returns \c true iff relDiff(a,b) <= -eps

adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage * with the additional informati

adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage * with the additional informati

adds variable to SOS1 constraint, the position is determined by the given weight */

calculates the node selection priority for moving the given variable's LP value to the given target value; * this node selection priority can be giv

changes variable's lower bound in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is pass

changes variable's upper bound in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is pass

cuts off node and whole sub tree from branch and bound tree * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error

returns TRUE if decomposition is in the original space */

returns the tag associated with the activity of the expression * * It can depend on the owner of the expression how to interpret this tag. * SCIPev

returns whether an expression is integral */

set the expression handler callbacks to copy and free an expression handler */

set the curvature detection callback of an expression handler */

set differentiation callbacks of an expression handler */

set the hash callback of an expression handler */

set the monotonicity detection callback of an expression handler */

gets array with nonlinear rows of the NLP * * @pre This method can be called if SCIP is in one of the following stages: * - \ref SCIP_STAGE_

gets current number of nonlinear rows in NLP * * @pre This method can be called if SCIP is in one of the following stages: * - \ref SCIP_STA

gets number of all problem variables created during creation and solving of problem; * this includes also variables that were deleted in the meantim

gets array with original problem variables; data may become invalid after * a call to SCIPchgVarType() * * @return an array with original problem

gets depth of current scip instance (increased by each copy call) * * @return Depth of subscip of SCIP is returned. * * @pre This method can be

gets bounded variable x of variable bound constraint lhs <= x + c*y <= rhs */

gets bounding variable y of variable bound constraint lhs <= x + c*y <= rhs */

sets image for given origin in the hash map, either by modifying existing origin->image pair * or by appending a new origin->image pair */

creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. * Optional callbacks can be set v

creates the handler for an expression handler and includes it into SCIP */

adds operand1 and scalar operand2 and stores result in resultant */

intersection of two intervals */

checks, if val1 is (more than sumepsilon) greater than val2 */

Checks, if an iteratively updated value is reliable or should be recomputed from scratch. * This is useful, if the value, e.g., the activity of a li

increases the number of occurrences of a specific type of linear constraint */

calls dual simplex to solve the LP */

returns the curvature of a nonlinear row */

creates a child node of the focus node */

returns value of SCIP_Real parameter */

prints a rowprep */

gets rank of row */

sets branching execution method for fractional LP solutions */

sets solving process initialization method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable

returns feasibility tolerance for constraints */

increases usage counter of variable */

gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable * e.g. obj(x) = 1 this method returns fo

gets the branch factor of the variable; this value can be used in the branching methods to scale the score * values of the variables; higher factor

returns whether variable's column is removable from the LP (due to aging or cleanup) */

decreases usage counter of variable, and frees memory if necessary */

ends the given line with '\\0' and prints it to the given file stream, with a newline at the end */

constructs an inference information out of a propagation rule and a position number, returns info as int */

returns scaling factor for row \p i todo pass the LP?!

! Initializes the viewer OpenGL context. This method is called before the first drawing and should be overloaded to initialize some of the OpenGL

! Returns the world transform of the vector whose coordinates in the Frame coordinate system is \p src (converts vectors from Frame to world). tr

sets parameter of type SCIP_Real in LP solver, ignoring unknown parameters */

read a mps format data line and parse the fields. */

Fetch number of parameters in the recording.

solving process deinitialization method of transformed data (called before the branch and bound data is freed) * * This method is called befo

solving process initialization method of transformed data (called before the branch and bound process begins) * * This method is called befor

sets all CPLEX parameters used in LPI */

return the current value of field 0 */

swaps the current token with the token buffer */

return name of node */

returns left child which can be NULL if the given node is a leaf */

changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any * inference information in the bou

changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any * inference information in the bou

adds locks to (dis-)allow upgrading of constraint */

adds a solution value for a new variable in the transformed problem that has no original counterpart * a value can only be set if no value has been s

decode a packed dual bit vector into unpacked format */

queries labels for an array of variables */

encode a dual bit vector into packed format */

releases an expression (decrements usage count and possibly frees expression) */

set the interval evaluation callback of an expression handler */

gets the child expression that the expression iterator considers when in DFS mode and stage \ref SCIP_EXPRITER_VISITINGCHILD or \ref SCIP_EXPRITER_VIS

get total number of conflict constraints added to the problem * * @return the total number of conflict constraints added to the problem * * @pre

gets termination status of last NLP solve * * @pre This method can be called if SCIP is in one of the following stages: * - \ref SCIP_STAGE_

gets total number of constraints in the original problem * * @return total number of constraints in the original problem * * @pre This method ca

transforms given variable, scalar and constant to the corresponding active, fixed, or * multi-aggregated variable, scalar and constant; if the varia

gets corresponding transformed variables for an array of variables; * stores NULL in a transvars slot, if the transformed variable is not yet existi

returns the expected dual gain for moving the corresponding variable by "solvaldelta" */

subtracts operand2 from operand1 and stores result in resultant */

returns whether the solution process should be probably correct * * @note This feature is not supported yet! * * @return Returns TRUE if \SCIP i

returns whether the current LP solution passed the dual feasibility check * * @returns whether the current LP solution passed the dual feasibility

returns whether the presolving process would be finished given no more presolving reductions are found in this * presolving round * * Checks whet

solves the LP with simplex algorithm, and copy the solution into the column's data */

changes lower and upper bounds of columns */

copies characters from 'src' to 'dest', copying is stopped when either the 'stop' character is reached or after * 'cnt' characters have been copied,

gets NLP solver name */

returns whether parameter is fixed */

returns the internal value of the given external objective value */