returns whether the global relaxation solution is valid */

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

gets the number of times, the separator was called at the current node */

sets copy method of branching rule */

sets the check flag of the given constraint * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed.

returns the maximal number of cuts separated per round */

returns value treated as zero for sums of floating point values */

gets node number, where this solution was found */

updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the * variable's solution value and re

gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem * variable x, there are no impli

gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem * variable x (SCIP_BOUNDTYPE_UPPER

transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable * values */

gets current LP or pseudo solution value of variable */

! Returns the Camera aspect ratio defined by screenWidth() / screenHeight(). When the Camera is attached to a QGLViewer, these values and hence the

fills in matrix elements into coefficient arrays */

calculates activity bounds for constraint after setting variable to zero */

adds constraint to constraint handler's update constraint array and captures it */

returns whether the debug solution is worse than the best known solution or if the debug solution was found */

calculate all not artificial linear variables and all artificial and-resultants which will be ordered like the * 'consanddatas' such that the and-re

Import and return a module or throws `error_already_set`.

returns whether two vertices are adjacent in the conflict graph */

specifies whether an optimal solution has already been unsimplified.

get pointer to internal memory.

method post a ignore message */

Returns the row identifier for row \p n.

releases all variables or constraints from given hash map */

! Rotates the Frame by \p q (defined in the Frame coordinate system): R = R*q. The rotation actually applied to the Frame may differ from \p q sinc

sets a single integer parameter value */

sets the solution time, nodenum, runnum, and depth stamp to the current values */

get data */

gets the number of non-zeros in the aggregation row */

returns the auxiliary variable for the given subproblem */

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

creates a clock using the default clock type * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed

creates directed graph structure */

creates an exponential expression */

creates a SCIP_ROWPREP datastructure * * Initial row represents 0 &le; 0. */

gets user data of cut selector */

checks whether SCIP data structure is the main SCIP (the one for which debugging is enabled) */

add (directed) arc and a related data to the directed graph structure * * @note if the arc is already contained, it is added a second time */

gets user data of display column */

get the total number of LP iterations used by this dive set */

returns the random number generator of this \p diveset for tie-breaking */

returns the derivative stored in an expression (or SCIP_INVALID if there was an evaluation error) * * @see SCIPevalExprGradient */

set the simplify callback of an expression handler */

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

gets the current stage that the expression iterator is in when using DFS * * If the iterator has finished (SCIPexpriterIsEnd() is TRUE), then the st

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

gives the index stored in a varidx expression */

gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes) * * @return the maximal depth of all processed

gets total number of simplex iterations used so far for node relaxations * * @return the total number of simplex iterations used so far for node re

gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates * * @return \ref SCIP_OKAY is ret

gets the root node of the tree * * @return the root node of the search tree * * @pre This method can be called if @p scip is in one of the follo

returns the activity of a row in the last LP or pseudo solution * * @return the activity of a row in the last LP or pseudo solution * * @pre thi

returns minimal absolute value of row vector's non-zero coefficients * * @return minimal absolute value of row vector's non-zero coefficients * *

returns the feasibility of a row for the given primal solution * * @return the feasibility of a row for the given primal solution * * @pre this

Gets the parallel interface to execute processes concurrently. * * @return the \ref SCIP_SYNCSTORE parallel interface pointer to submit jobs for co

returns the reduced costs of the variable in the current node's LP relaxation; * the current node has to have a feasible LP. * * returns SCIP_INV

gives the number of slots of a hash set */

returns the number of divesets of this primal heuristic */

returns the average number of cutoffs per branching */

returns whether the LP is in diving mode and the objective value of at least one column was changed */

gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the * objective function) local bound

returns TRUE iff the objective limit was reached */

returns TRUE iff current LP solution is stable * * This function should return true if the solution is reliable, i.e., feasible and optimal (or pro

get constraint pointer for constraint representing row */

returns default value of int parameter */

gets name of variable pricer */

gets name of relaxation handler */

checks, if value is greater than feasibility tolerance */

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

rounds value to the nearest integer in epsilon tolerance */

copies the first size characters between a start and end character of str into token, if no error occurred endptr * will point to the position after

safe version of strncpy * * Copies string in s to t using at most @a size-1 nonzero characters (strncpy copies size characters). It always adds *

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

checks the solutions from the subscip and adds the first one that is found feasible to the master SCIP * * Variables that are relaxation-only in the

returns the depth of the effective root node (i.e. the first depth level of a node with at least two children) */

deletes a clique from the list of cliques the binary variable is member of, but does not change the clique * itself */

returns the average number of inferences found after branching on the variable in given direction */

gets type (lower or upper) of best bound of variable with respect to the objective function */

gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active * problem variable x, there are no im

gets lower bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own * data due to diving or conf

gets upper bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own * data due to diving or conf

Returns the column identifier for column \p n.