gets number of original problem variables * * @return the number of original problem variables * * @pre This method can be called if @p scip is

returns infimum of interval */

gets user data of presolver */

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

appends extension to line and prints it to the give file stream if the * line exceeded the length given in the define GMS_PRINTLEN */

get accounted user time.

returns the user data pointer stored in that node */

creates a power expression */

searches the dialog for entries corresponding to the given name; * If a complete match is found, the entry is returned as "subdialog" and * the re

gets the value of an existing int parameter * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed.

gets the array of coefficient values in the linear constraint; the user must not modify this array! */

returns whether an expression is a power expression */

get number of columns of the matrix */

get number of non-zeros of this row */

gets name of presolver */

sets presolving parameters to * * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters * - SCIP_PARAMSETTING_FAS

retransforms given variable, scalar and constant to the corresponding original variable, scalar * and constant, if possible; if the retransformation

returns the position of element \p elem within IsList.

returns depth level of given bound change information */

gets array with rows of nonzero entries */

returns TRUE iff constraint is enabled in the current node */

creates and initializes a random number generator * * @note The initial seed is changed using SCIPinitializeRandomSeed() */

checks, if relative difference of values is in range of epsilon */

gets the basis status of a row in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL * and with SCIPisLPSolBasic(scip) == TRUE;

sets deinitialization method of primal heuristic */

checks, if value is integral within epsilon */

returns \c true iff |a-b| > eps

informs row, that all subsequent additions of variables to the row should be cached and not directly applied; * after all additions were applied, SC

flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with * equal columns into a single coefficient *

gets number of branching candidates for LP solution branching (number of fractional variables) * * @return the number of branching candidates for L

gets number of branch and bound runs performed, including the current run * * @return the number of branch and bound runs performed, including the

prints a error message, acting like the printf() command */

returns the name of the given parameter type */

gets current LP rows along with the current number of LP rows * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable err

-------------------------- @name Access */ @{ returns the IsList's first element.

check if the current token is equal to give char */

creates and captures a linear constraint * in its most basic version, i. e., all constraint flags are set to their basic value as explained for the

gets number of implicit integer active problem variables * * @return the number of implicit integer active problem variables * * @pre This metho

gets number of variables in logic or constraint */

gets type of set partitioning / packing / covering constraint */

creates a statistics table and includes it in SCIP */

returns TRUE iff row is modifiable during node processing (subject to column generation) */

appends extension to line and prints it to the give file stream if the line buffer get full */

* returns true if queue is empty */

captures an expression (increments usage count) */

creates a variable expression */

returns copy of the source variable; if there already is a copy of the source variable in the variable hash map, * it is just returned as target var

creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path * with a call to SCIPbacktrackProbi

returns the right hand side of a nonlinear row */

outputs solving statistics * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref *

applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; * the propagated domains of the variabl

returns whether the solving process will be / was stopped before proving optimality; * if the solving process was stopped, stores the reason as stat

checks primal solution; if feasible, adds it to storage; solution is freed afterwards * * @return \ref SCIP_OKAY is returned if everything worked.

Returns the non-zero epsilon used.

quits probing and resets bounds and constraints to the focus node's environment * * @return \ref SCIP_OKAY is returned if everything worked. Otherw

returns the branching rule of the given name, or NULL if not existing */

gets values of multiple variables in primal CIP solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error co

returns whether an expression is a product expression */

gets name of node selector */

updates the flags of the first constraint according to the ones of the second constraint * * @return \ref SCIP_OKAY is returned if everything worke

---------------------------------------------------------------------- ! Remove all the elements from this vector but leave the capacity and data po

does \p stat describe a basic index ?

return the current value of field 3 */

safe version of snprintf

number of independent variables

calculates the greatest common divisor of the two given values */

possibly reevaluates and then returns the activity of the expression * * Reevaluate activity if currently stored is no longer uptodate (some bound w

gets branching candidates for LP solution branching (fractional variables) along with solution values, * fractionalities, and number of branching ca

gets objective value of current LP * * @note This method returns the objective value of the current LP solution, which might be primal or dual infe

get right-hand-side of row */

returns value treated as zero */

frees primal CIP solution */

returns number of columns

Similar to Python `warnings.warn()`

returns \c true iff a <= b + eps

number of dependent variables

increases usage counter of constraint * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \

returns the node data, or NULL if no data exist */

specifies in which stages to stop a DFS iterator * * Parameter `stopstages` should be a bitwise OR of different \ref SCIP_EXPRITER_STAGE values *

gets global dual bound * * @return the global dual bound * * @pre This method can be called if SCIP is in one of the following stages: *

returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value * * @return transformed objective valu

gets the value of a constant value expression */

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the