default constructor sets capacity_ = length_ = data_ = 0

find node with bound on the depth */

returns clean buffer memory for short living temporary objects initialized to all zero * * @return the buffer memory for short living temporary obj

gets name of conflict handler */

sets user data of constraint handler; user has to free old data in advance! */

creates and captures a nonlinear row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \r

gets number of blocks of this decomposition */

returns the number of nodes of the given digraph */

method to collect the variables of a constraint * * If the number of variables is greater than the available slots in the variable array, nothing h

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

returns the average number of inferences per branching */

sets interval to entire [-infinity, +infinity] */

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

cuts off node and whole sub tree from branch and bound tree */

returns locally defined parameter specific data */

outputs variable information to file stream via the message system * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitabl

returns whether the given solution is defined on original variables and containes unknown solution values */

informs the solution that it now belongs to the given primal heuristic. For convenience and backwards compatibility, * the method accepts NULL as in

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

stores solution values of variables in solution's own array * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error

changes current local lower bound of variable; if possible, adjusts bound to integral value; stores inference * information in variable */

changes current local upper bound of variable; if possible, adjusts bound to integral value; stores inference * information in variable */

gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */

returns whether variable's column should be present in the initial root LP */

deletes coefficient at given position from constraint data */

returns the dive set statistics for the given context */

gets variables and coefficients of linear constraint */

Current maximum number of SVectorBase%s.

returns predecessor of \p elem or 0, if \p elem is the first element.

print first len-1 characters of name to string s and replace '#', '*', '+', '/', and '-' by '_' if necessary */

----------------------------------------------------------------- ! process post entries for a specific set. \param i index of the set for which w

puts the current token on the token stack, such that it is read at the next call to getNextToken() */

check allocated memory of a node within the reoptimization tree and if necessary reallocate */

----------------------------------- @name Access */ @{

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

adds a nonlinear row to the NLP. This row is captured by the NLP. * * @pre This method can be called if SCIP is in one of the following stages: *

resolves variables to columns and adds them with the coefficients to the row; * this method caches the row extensions and flushes them afterwards to

appends an expression to a sum expression */

changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound, * if the global bound is better

changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound, * if the global bound is better

gets age of constraint */

creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked * if it should stay unaffected fr

add (directed) arc to the directed graph structure, if it is not contained, yet * * @note if there already exists an arc from startnode to endnode,

displays an integer in decimal form fitting in a given width */

gets new bound for a bound change event */

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

returns an expression handler of a given name (or NULL if not found) */

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

gets array of globally valid constraints currently in the problem * * @return array of globally valid constraints currently in the problem * * @

returns bounds on the expression * * This gives an intersection of bounds from * - activity calculation (SCIPexprGetActivity()), if valid, * - aux

returns the activity of a row for the given primal solution * * @return the activitiy of a row for the given primal solution * * @pre this metho

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

get number of branchings counter */

includes default SCIP plugins into SCIP */

returns whether the objective value is known to be integral in every feasible solution * * @return TRUE, if objective value is known to be always i

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

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

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

sets parameters to * * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams()) * - \ref SCIP_PARAMEMPHASIS_COUNTER t

sets solving process deinitialization method of primal heuristic */

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

checks, if value is greater than dual feasibility tolerance */

sets copy method of presolver */

update statistical information when a new solution was found */

gets depth of focus node in the tree */

returns whether the LP of the focus node is already constructed */

converts variable into fixed variable */

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

gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */

marks constraint handler to delay all constraint updates until the next conshdlrProcessUpdates() call */

marks constraint handler to perform all constraint updates immediately; * all delayed constraint updates will be processed */

! @name Constraint on the displacement */ @{ ! Returns the current constraint applied to the Frame. A \c nullptr value (default) means that no Cons

! Returns the Frame coordinates of a point \p src defined in the world coordinate system (converts from world to Frame). inverseCoordinatesOf() per

Dimension of vector.

gets finite part of objective value of current LP that results from LOOSE variables only */

the halfedge points to this vertex

returns the name of the given LP algorithm */

gets the negation of a double * Do this in a way that the compiler does not "optimize" it away, which usually does not considers rounding modes. * H

----------------------------------------------------------------------------- Normalization Private method to do normalization (using Norm() method of

Fetch number of vecad load operations

Fetch number of VecAD indices in the recording.

set row and column for a possibly non-zero element