sets integer parameter of LP */

set copy method of reader * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref *

returns unique index of given solution */

initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), * SCIPchgVarUbProbing(), SCIPfixVarProbing(),

gets focus node of the tree */

gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */

returns the solution of the variable in the last root node's relaxation, if the root relaxation is not yet * completely solved, zero is returned */

gets original upper bound of original problem variable (i.e. the bound set in problem creation) */

codimension.

read a MPS format data line and parse the fields.

----------------------------------- @name Warnings and Errors */ @{

analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),

gets user data of Benders' decomposition */

gets array of active problem variables in the cliques */

copies limits from source SCIP to target SCIP * * @note time and memory limit are reduced by the amount already spent in the source SCIP before ins

creates and captures a set packing constraint * * @note the constraint gets captured, hence at one point you have to release it using the method SC

creates constant value expression */

gets current primal feasibility tolerance of LP */

gets the left hand side of a nonlinear constraint */

gets number of active problem variables with a non-zero objective coefficient * * @note In case of the original problem the number of variables is

gets number of branching candidates for pseudo solution branching (non-fixed variables) * * @return the number branching candidates for pseudo solu

gets the right hand side of a nonlinear constraint */

gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case * if the problem stage is in SCIP

increases age of constraint by 1.0; * should be called * - in constraint separation, if no cut was found for this constraint, * - in constrain

creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental * (or optional) callbacks as, e.g., init and ex

frees the constraint matrix */

get row based start pointer of column indices */

gives handler data of nonlinear handler */

returns name of parameter */

returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present * in the LP, and FALSE, if there a

sets presolving method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed

gets the root node of the tree */

gets array of cliques, the active variable is contained in */

gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and updates the given * negation status (this means you

returns whether there is a clique that contains both given variable/value pairs; * the variables must be active binary variables; * if regardimpli

----------------------------------------------------------------- ! Add one element to a set. \param i is the index for this set in the vector of

returns whether the constraint updates of the constraint handler are currently delayed */

checks whether the parameter is specified */

------------------------------------ @name Variables and Covariables * Class SPxLP introduces \ref soplex::SPxId "SPxIds" to identify * row

----------------------------------------------------------------------------- Norm

issues an error message and marks the PIP data to have errors */

adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1; * if a variable appears twice in the same

adds constraint to the given node (and all of its subnodes), even if it is a global constraint; * It is sometimes desirable to add the constraint to

undoes all changes to the problem applied in probing up to the given probing depth; * the changes of the probing node of the given probing depth are

gets user data of the Benders' decomposition cut */

calculates the branching score out of the gain predictions for a binary branching */

gets array of values of active problem variables in the cliques, i.e. whether the variable is fixed to FALSE or * to TRUE in the clique */

returns whether the associated variable is of integral type (binary, integer, implicit integer) */

for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables * * This local bo

returns the primal heuristic of the given name, or NULL if not existing */

returns the expression of the given nonlinear constraint */

gets solution status of current NLP * * @pre This method can be called if SCIP is in one of the following stages: * - \ref SCIP_STAGE_INITSO

gets array of variables in AND-constraint */

removes element from the hash table, if it exists */

gets name and version of LP solver */

get column based start pointer of values */

flag indicating if right-hand-side of row is infinity */

gets user data of node selector */

decreases usage counter of a nonlinear row, and frees memory if necessary * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a

sets method of constraint handler to free specific constraint data * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitabl

gets objective value of primal CIP solution which lives in the original problem space */

returns value of variable in primal CIP solution */

initializes solving data structures and transforms problem * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error

returns, whether the LP was or is to be solved in the current node */

if a bool parameter exits with the given parameter name it is set to the new value */

output two strings in columns 1 and 2 with computed widths */

----------------------------------- @name Verbosity */ @{

adds a term coef*var to a rowprep */

frees an expression iterator */

calculates the branching score out of the gain predictions for a binary branching * * @return the branching score out of the gain predictions for a

gets current LP rows * * @return the current LP rows. * * @pre This method can be called if @p scip is in one of the following stages: *

gets the number of cliques in the clique table * * @return number of cliques in the clique table * * @note cliques do not get automatically clea

gets array of variables in set partitioning / packing / covering constraint */

removes origin->image pair from the hash map, if it exists */

returns whether the current node is already solved and only propagated again * * @return TRUE is returned if \SCIP performance repropagation, other

returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater * than the minimal cut efficacy

gets the number of columns in the LP */

get number of rows of the matrix */

get row based start pointer of values */

gets data of an NLPI */

gets the unique id to identify the node during reoptimization; the id is 0 if the node is the root or not part of * the reoptimization tree */

sets constraint display method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code i

sets method of constraint handler to transform constraint data into data belonging to the transformed problem * * @return \ref SCIP_OKAY is returne

set read method of reader * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref *

extract the next token as a double value if it is one; in case no value is parsed the endptr is set to @p str * * @return Returns TRUE if a value c

if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound * to the new value * * @return \ref SC

gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x; * the variable bounds are sorted by increasi

returns whether a variable has been introduced to define a relaxation * * These variables are only valid for the current SCIP solve round, * they a

is it possible, to round variable down and stay feasible? * * @note This method will always check w.r.t variable locks of type model */

is it possible, to round variable up and stay feasible? * * @note This method will always check w.r.t. variable locks of type model */

free memory and set number of elements to zero

Is \p k a valid DataKey of an element in DataSet?

marks the current LP to be unsolved */

returns the IsList's last element.