checks, if value is greater than feasibility tolerance */

creates a hash map mapping pointers to pointers */

checks, if relative difference val1 and val2 is lower than feasibility tolerance */

checks, if value is lower than -feasibility tolerance */

gets array with active problem variables * * @return array with active problem variables * * @pre This method can be called if @p scip is in one

returns whether the solving process should be / was stopped before proving optimality; * if the solving process should be / was stopped, the status

decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed * * @return \ref SCIP_OKAY is returned if everything

checks, if value is in range epsilon of 0.0 */

stops measurement of time in the given clock */

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

guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() and opttol(), i.e., the less tight tolerance.

starts measurement of time in the given clock */

gets solution status of current LP */

gets the variable of a variable expression */

returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */

gets best feasible primal solution found so far if the problem is transformed; in case the problem is in * SCIP_STAGE_PROBLEM it returns the best so

returns TRUE iff constraint is only locally valid or not added to any (sub)problem */

retrieves image of given origin from the hash map, or INT_MAX if no image exists */

! Returns the associated Camera. Set using the CameraConstraint constructor. */

checks, if value is lower than -epsilon */

gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit) * * @return the global upper (pr

returns TRUE iff the LP relaxation of constraint should be in the initial LP */

--------------------------------------------------------------------------- @name Access methods @{

checks, if relative difference of val1 and val2 is greater than feastol */

checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */

converts the given real number representing an integer to an int; in optimized mode the function gets inlined for * performance; in debug mode we ch

in problem creation and solving stage, both bounds of the variable are set to the given value; * in presolving stage, the variable is converted into

returns TRUE iff constraint is deleted or marked to be deleted */

changes the value of an existing SCIP_Bool parameter * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code i

gets number of locks for rounding down of a special type */

gets number of locks for rounding up of a special type */

rounds value + feasibility tolerance down to the next integer */

returns status of column \p i.

gets solution status of current LP * * @return the solution status of current LP. * * @pre This method can be called if @p scip is in one of the

returns the right hand side of the row */

creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */

returns feasibility tolerance for constraints * * @return feasibility tolerance for constraints */

gets the negation variable x of a negated variable x' = offset - x */

gets number of binary active problem variables * * @return the number of binary active problem variables * * @pre This method can be called if @

gets number of processed nodes in current run, including the focus node * * @return the number of processed nodes in current run, including the foc

returns the left hand side of the row */

returns TRUE iff constraint should be separated during LP processing */

frees primal CIP solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref *

get variable pointer of column */

returns TRUE iff constraint should be enforced during node processing */

gets the used time of this clock in seconds */

gets the fixing status of an existing parameter * * @return TRUE if the parameter is fixed to a value, otherwise FALSE. */

----------------------------------------------------------------- ! Fetch end for this vector of sets object. \return is the maximum element value

sets value of variable in primal CIP solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passe

returns TRUE iff constraint is subject to aging */

adds variable to the problem * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref *

gets successively assigned number of the node */

returns the variable used for linearizing a given expression (return value might be NULL) * * @note for variable expression it returns the correspon

gets variable this column represents */

returns TRUE iff constraint should be propagated during node processing */

returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped * via SCIPendProbing() * * @return TRUE, if

gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff * cannot contain a better feasible solution;

gets variables of the problem along with the numbers of different variable types; data may become invalid after * calls to SCIPchgVarType(), SCIPfix

returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */

returns TRUE iff constraint is belonging to transformed space */

checks, if relative difference of val1 and val2 is not lower than -feastol */

creates an int parameter, sets it to its default value, and adds it to the parameter set */

resets age of constraint to zero; * should be called * - in constraint separation, if a cut was found for this constraint, * - in constraint e

resolves variable to columns and adds them with the coefficient to the row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a

retrieve element with key from hash table, returns NULL if not existing */

calculate memory size for dynamically allocated arrays * * @return the memory size for dynamically allocated arrays. */

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

gets column of COLUMN variable */

adds coefficient to linear constraint (if it is not zero) */

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

adds a command to the command history of the dialog handler; if a dialog is given, the command is preceeded * by the dialog's command path; if no co

gets the lower bound of the node */

rounds value + epsilon down to the next integer */

number of elements in the vector

gets the expression handler of an expression * * This identifies the type of the expression (sum, variable, ...). */

prints a message depending on the verbosity level, acting like the printf() command */

indicates whether interval is empty, i.e., whether inf > sup */

returns whether the variable belongs to the transformed problem */

calculate memory size for dynamically allocated arrays */

returns the root dialog of the dialog handler */

gives the value from the last evaluation of an expression (or SCIP_INVALID if there was an eval error) * * @see SCIPevalExpr to evaluate the express

----------------------------------------------------------------- ! Fetch n_set for vector of sets object. \return Number of from sets for this vec

returns x * 2^exp

gets solution status * * @return SCIP solution status * * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.

returns whether an expression is a variable expression */

rounds value - feasibility tolerance up to the next integer */

checks, if val1 is (more than epsilon) lower than val2 */

convert rational number to string