scip_var.h
Go to the documentation of this file.
38/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
79/** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
80 * an integer variable with bounds zero and one is automatically converted into a binary variable;
82 * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
83 * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
84 * original objective function value of variables created during the solving process has to be multiplied by
87 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
99 * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
113 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
114 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
119/** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
121 * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
122 * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
124 * an integer variable with bounds zero and one is automatically converted into a binary variable;
126 * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
127 * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
128 * original objective function value of variables created during the solving process has to be multiplied by
131 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
143 * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
158 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
183/** print the given list of variables to output stream separated by the given delimiter character;
185 * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
189 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
223 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
257 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
288/** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
289 * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
292 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
313 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
320/** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
323 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
343/** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
346 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
358 * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
360 * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
361 * except that the required size is stored in the corresponding integer; the reason for this approach is that we
362 * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
378/** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
381 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
393 * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
395 * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
396 * except that the required size is stored in the corresponding integer; the reason for this approach is that we
397 * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
418 * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
419 * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
422 * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
425 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
473 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
495/** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
497 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
524 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
538/** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
541 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
562 * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
565 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
589 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
614 * it is possible to call this method with vars == transvars, but remember that variables that are not
617 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
641/** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
643 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
667/** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
668 * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
670 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
695/** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
698 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
718 SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
721/** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
724 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
745 SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
748/** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
750 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
768/** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
771 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
772 * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
775 * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
778 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
793 * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
796 * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
818 SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
823 * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
825 * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
827 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
850/** return for given variables all their active counterparts; all active variables will be pairwise different
851 * @note It does not hold that the first output variable is the active variable for the first input variable.
853 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
887 * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
903 * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
926/** returns lower bound of variable directly before or after the bound change given by the bound change index
937/** returns upper bound of variable directly before or after the bound change given by the bound change index
948/** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
985 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1002 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1016 * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
1021 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1028 * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution
1029 * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting
1040/** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity
1042 * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
1045 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1062/** sets the values of the variables in the global relaxation solution to the values in the given primal solution
1063 * and informs SCIP about the validity and whether the solution can be enforced via linear cuts;
1064 * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
1066 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1094/** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
1096 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1112 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1164 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1171 * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
1177 SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
1182 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1196 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1208 SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */
1211 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1215 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1217 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1227 * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
1228 * after strong branching was done for all candidate variables, the strong branching mode must be ended by
1229 * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
1232 * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
1235 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1242 * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
1256 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1260 SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
1262 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1264 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1274/** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
1277 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1284 * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
1292 SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */
1295 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1299 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1301 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1311 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1326 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
1330 SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
1342 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1357 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
1361 SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
1371/** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
1378/** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
1379 * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
1380 * keep in mind, that the returned old values may have nothing to do with the current LP solution
1382 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1395 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1399 SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
1405 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1427 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1440/** gets node number of the last node in current branch and bound run, where strong branching was used on the
1443 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1464/** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
1468 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1491 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1514 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1542 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1569/** add locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
1570 * this method should be called whenever the lock status of a variable in a constraint changes, for example if
1571 * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
1574 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1597/** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
1598 * this method should be called whenever the lock status of a variable in a constraint changes, for example if
1599 * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
1602 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1627 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1644 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1661/** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
1664 * @return adjusted lower bound for the given variable; the bound of the variable is not changed
1687/** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
1690 * @return adjusted upper bound for the given variable; the bound of the variable is not changed
1713/** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
1714 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
1717 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1720 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1729 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1738/** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
1739 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
1742 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1745 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1754 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1763/** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
1764 * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
1767 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1780/** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
1781 * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
1784 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1797/** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
1800 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1803 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1813 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1822/** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
1825 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1828 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1838 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1847/** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
1850 * Setting a lazy lower bound has the consequence that for variables which lower bound equals the lazy lower bound,
1854 * @attention If the variable has a global lower bound below lazylb, then the global lower bound is tightened to
1857 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1874/** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
1877 * Setting a lazy upper bound has the consequence that for variables which upper bound equals the lazy upper bound,
1881 * @attention If the variable has a global upper bound above lazyub, then the global upper bound is tightened to
1884 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1901/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1902 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1903 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1906 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1909 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1917 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1929/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
1930 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1931 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1934 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1937 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1945 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1957/** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
1958 * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
1959 * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
1961 * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
1962 * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
1965 * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
1968 * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
1982/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1983 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1984 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
1987 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1990 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1998 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2012/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2013 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2014 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
2017 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2020 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2028 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2042/** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2043 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
2046 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2062 SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2065/** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
2066 * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
2067 * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
2069 * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
2070 * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
2073 * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
2076 * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
2090/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2091 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2092 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2095 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2098 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2106 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2120/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2121 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2122 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2125 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2128 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2136 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2150/** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2151 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
2154 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2171 SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2174/** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2175 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2178 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2181 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2190 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2202/** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2203 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2206 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2209 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2218 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2230/** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
2232 * This global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing
2233 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
2235 * @return the global lower bound computed by adding the global bounds from all aggregation variables
2243/** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
2245 * This global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing
2246 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
2248 * @return the global upper bound computed by adding the global bounds from all aggregation variables
2256/** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
2258 * This local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing
2259 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
2261 * @return the local lower bound computed by adding the global bounds from all aggregation variables
2269/** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
2271 * This local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
2272 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
2274 * @return the local upper bound computed by adding the global bounds from all aggregation variables
2282/** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
2283 * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
2294/** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
2295 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
2306/** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
2307 * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
2318/** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
2319 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
2332/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
2336#define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
2337#define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
2338#define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
2339#define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
2343/** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
2344 * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
2347 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2361/** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
2362 * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
2364 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2378/** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
2384 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2404/** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
2410 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2429/** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
2432 * if the variable is already fixed to the given value, the implication is performed immediately;
2435 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2448 SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
2457/** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
2460 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2473 SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
2480/** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
2487 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2489 * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
2493 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2506 SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2509 int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2513 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2515 * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
2517 * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
2519 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2532 SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2535 int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2538/** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
2623 * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
2625 * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
2653 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2669 * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
2679/** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
2701/** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
2702 * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
2704 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2726 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2748 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2768/** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
2771 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2793/** changes the branch priority of the variable to the given value, if it is larger than the current priority
2795 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2812 int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
2817 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2837/** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
2840 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2857 SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
2862 * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
2864 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2872 * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
2873 * corresponding transformed variable is changed; the type of the original variable does not change
2875 * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
2887/** in problem creation and solving stage, both bounds of the variable are set to the given value;
2888 * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
2889 * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2892 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2906 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
2909/** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
2910 * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2911 * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
2912 * In the first step, the equality is transformed into an equality with active problem variables
2913 * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
2914 * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
2916 * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
2917 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
2918 * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
2919 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
2920 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
2921 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
2926 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2928 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2946/** converts variable into multi-aggregated variable; this changes the variable array returned from
2949 * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
2950 * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
2955 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2957 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3011 * @note A reduction is called strong dual, if it may discard feasible/optimal solutions, but leaves at least one
3012 * optimal solution intact. Often such reductions are based on analyzing the objective function and variable
3031 * @note A reduction is called weak dual, if it may discard feasible solutions, but leaves at all optimal solutions
3032 * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
3041 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3053 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
3064 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3076 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
3115/** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
3116 * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
3119 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3219/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
3221 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
3239/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
3242 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
3261/** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
3282/** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
3284 * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
3285 * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
3299/** check if variable pseudo-costs have a significant difference in location. The significance depends on
3300 * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
3304 * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
3305 * better than x (despite the current information), meaning that y can be expected to yield branching
3306 * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
3307 * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
3312 * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
3329/** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
3330 * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
3331 * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
3334 * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
3337 * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
3340 * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
3353/** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
3564/** returns the average number of inferences found after branching on the variable in given direction;
3565 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3568 * @return the average number of inferences found after branching on the variable in given direction
3586/** returns the average number of inferences found after branching on the variable in given direction in the current run;
3587 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3590 * @return the average number of inferences found after branching on the variable in given direction in the current run
3627/** returns the variable's average inference score value only using inferences of the current run
3629 * @return the variable's average inference score value only using inferences of the current run
3646/** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
3649 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3665 SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
3666 SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
3667 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3668 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3669 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3670 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3671 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3672 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3673 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3674 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3677/** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
3680 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3697 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3698 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3699 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3700 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3701 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3702 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3703 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3704 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3707/** returns the average number of cutoffs found after branching on the variable in given direction;
3708 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3711 * @return the average number of cutoffs found after branching on the variable in given direction
3729/** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
3730 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3733 * @return the average number of cutoffs found after branching on the variable in given direction in the current run
3789/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3810/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3813 * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
3833 * @return the variable's average GMI efficacy score value (for when it was fractional and basic in the LP)
3852 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3873 * @return the variable's last GMI efficacy score value (for when it was fractional and basic in the LP)
3892 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3913 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:2919
SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9537
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: scip_var.c:1738
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5203
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2264
SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9608
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip_var.c:4317
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6546
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:9059
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4351
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:7859
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2282
SCIP_RETCODE SCIPincVarGMISumScore(SCIP *scip, SCIP_VAR *var, SCIP_Real gmieff)
Definition: scip_var.c:9904
SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5826
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6576
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6010
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6921
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7256
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_RELAX *relax, SCIP_VAR *var, SCIP_Real val)
Definition: scip_var.c:2414
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6348
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9504
SCIP_RETCODE SCIPgetVarStrongbranchInt(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3662
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8950
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9473
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip_var.c:7921
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4676
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6561
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1480
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8922
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7475
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8896
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7710
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip_var.c:1299
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6591
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:8021
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9365
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:9078
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip_var.c:1644
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8598
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8868
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
Definition: scip_var.c:610
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9758
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:8401
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5615
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4766
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4890
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9447
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5320
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip_var.c:533
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:474
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip_var.c:1794
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:8085
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6720
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4259
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6661
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7980
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4437
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1954
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip_var.c:6632
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9701
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip_var.c:5123
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2128
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4160
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1389
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:8535
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip_var.c:1157
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip_var.c:3988
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip_var.c:7949
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip_var.c:7532
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip_var.c:4645
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4194
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4943
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_RELAX *relax, SCIP_Bool includeslp)
Definition: scip_var.c:2557
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3773
SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
Definition: scip_var.c:4044
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8814
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:704
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9303
SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: scip_var.c:9029
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2603
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
Definition: scip_var.c:3352
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip_var.c:4613
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9673
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip_var.c:6609
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8176
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1693
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6463
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip_var.c:1527
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:9141
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip_var.c:7659
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6780
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, SCIP_RELAX *relax, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
Definition: scip_var.c:2447
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8998
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:5032
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6505
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
Definition: scip_var.c:404
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8842
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip_var.c:8780
SCIP_Real SCIPgetVarAvgGMIScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9877
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:114
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip_var.c:8054
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1349
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8715
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:8276
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9834
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5501
SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3884
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:1992
SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:813
SCIP_Real SCIPgetVarLastGMIScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9932
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9241
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9994
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9727
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4846
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
Definition: scip_var.c:194
SCIP_RETCODE SCIPsetVarLastGMIScore(SCIP *scip, SCIP_VAR *var, SCIP_Real gmieff)
Definition: scip_var.c:9958
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip_var.c:5164
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5723
SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
Definition: scip_var.c:4079
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip_var.c:230
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_var.c:2327
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4513
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip_var.c:1597
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9790
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip_var.c:292
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6484
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6526
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip_var.c:1830
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4226
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip_var.c:343
SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: scip_var.c:4010
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9177
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9334
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9209
SCIP_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2655
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip_var.c:1909
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_var.c:8976
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip_var.c:1560
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1439
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9272
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:9103
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip_var.c:2686
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip, SCIP_RELAX *relax)
Definition: scip_var.c:2364
SCIP_RETCODE SCIPmarkDoNotAggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8682
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9419
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6120
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5432
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9391
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_RELAX *relax, SCIP_SOL *sol, SCIP_Bool includeslp)
Definition: scip_var.c:2489
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip_var.c:7893
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6228
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5895
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip_var.c:4562
Definition: objbenders.h:44
public methods for problem variables
Definition: struct_var.h:109
Definition: struct_implics.h:76
Definition: struct_cons.h:47
Definition: struct_tree.h:142
Definition: struct_prop.h:47
Definition: struct_relax.h:47
Definition: struct_sol.h:74
Definition: struct_var.h:208
Definition: struct_scip.h:70
type definitions for constraints and constraint handlers
type definitions for branching and inference history
type definitions for implications, variable bounds, and cliques
type definitions for LP management
type definitions for miscellaneous datastructures
type definitions for propagators
type definitions for relaxators
result codes for SCIP callback methods
type definitions for return codes for SCIP methods
type definitions for SCIP's main datastructure
type definitions for storing primal CIP solutions
type definitions for branch and bound tree
type definitions for problem variables