returns max(|a|,|b|)

! Returns the orientation of the Frame, defined in the world coordinate system. See also position(), setOrientation() and rotation(). */

----------------------------------------------------------------------- ! set sizes for this object (the default sizes are zero) \param n_ind numb

Sets \p i 'th element to \p x.

CppAD callback function that returns the number of the current thread * * assigns a new number to the thread if new */

get number of nonzero entries in column vector */

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

creates and captures an LP row without any coefficients from a separator * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a s

creates a product expression */

check if solution debugging mechanism is enabled */

returns the curvature of an expression * * @note Call SCIPcomputeExprCurvature() before calling this function. */

gets binary variable corresponding to indicator constraint */

gets estimate of best primal solution w.r.t. transformed problem contained in current subtree * * @return estimate of best primal solution w.r.t. t

returns the activity of a row in the last LP solution * * @return activity of a row in the last LP solution * * @pre this method can be called i

returns array of divesets of this primal heuristic, or NULL if it has no divesets */

sets new timing mask for heuristic */

gets the parent node of a node in the branch-and-bound tree, if any */

returns type of parameter */

method to be called by a nlhdlr during NLHDLRDETECT to notify an expression that it will be used * * - if `useauxvar` is enabled, then ensures that

sets constraint parsing method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code i

sets both the propagation callback and the propagation frequency of the constraint handler * * @return \ref SCIP_OKAY is returned if everything wor

sets limit on objective function, such that only solutions better than this limit are accepted * * @note SCIP will only look for solutions with a s

gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */

gets transformed variable of ORIGINAL variable */

gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x; * the variable bounds are sorted by increasi

sets left hand side of linear constraint */

sets right hand side of linear constraint */

gets a single double parameter value */

return the current value of field 1 */

Makes SSVectorBase not setup.

Is the \p keyword present in \p buf ? If yes, advance \p pos. \p keyword should be lower case. It can contain optional sections which are enclosed in

Is the \p keyword present in \p buf ? If yes, advance \p pos. \p keyword should be lower case. It can contain optional sections which are enclosed in

informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b; * also adds the corresponding implication

returns the type of the subproblem * * This type is used to determine whether the duals of the problem can be used to generate cuts */

gets the primal LP solution of a column */

for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables * * This local bo

creates an expression iterator */

restarts an already initialized expression iterator in DFS mode * * The expression iterator will continue from the given expression, not revisiting

returns fractional part of value, i.e. x - floor(x) in feasibility tolerance */

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

frees a SCIP_ROWPREP datastructure */

returns the total number of bytes used in block and buffer memory * * @return the total number of bytes used in block and buffer memory. */

gets number of fixed or aggregated problem variables * * @return the number of fixed or aggregated problem variables * * @pre This method can be

gets the variable's pseudo cost value for the given change of the variable's LP value * * @return the variable's pseudo cost value for the given ch

gets array of variables in logic or constraint */

adds operand1 and operand2 and stores result in resultant */

returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis * * @return whether the current LP solution is basic, i.

returns TRUE iff LP is proven to be primal infeasible */

marks the variable that it must not be multi-aggregated * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error cod

is the problem data transformed */

sets constraint variable number getter method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitab

sets constraint variable getter method of constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable erro

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

sets objective sense of problem * * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref *

gets aggregation variable y of an aggregated variable x = a*y + c */

returns adjusted lower bound value, which is rounded for integral variable types */

returns adjusted upper bound value, which is rounded for integral variable types */

disable old_atomic<Base>::clear(void)

clears the last solution information */

Fetch number of variables in the recording.

Testing all values of |pVec| against its bounds. If $i$, say, is violated the violation is saved as negative value in |theTest[i]|. */

Write loaded LP to \p filename.

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

gets the right hand side of the aggregation row */

checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP * * This is the case if the time a

injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to * SCIPchgVarLb(), but in this cas

injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to * SCIPchgVarUb(), but in this cas

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

gets the current expression that the expression iterator points to */

frees all solution process data including presolving and transformed problem, only original problem is kept * * @return \ref SCIP_OKAY is returned

returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity * computation) */

returns the number of currently active variable pricers, that are used in the LP solving loop */

gets number of feasible primal solutions found so far * * @return the number of feasible primal solutions found so far * * @pre This method can

gets the number of items in the knapsack constraint */

informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has * been solved) * * @return \r

multiplies operand1 with scalar operand2 and stores result in resultant */

gets current number of rows in LP */

get number of downlocks of column */

get number of uplocks of column */

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

checks, if value is in range feasibility tolerance of 0.0 */

sets destructor method of separator */

returns lower bound of variable directly before or after the bound change given by the bound change index * was applied * * @deprecated Please us

gets aggregation constant c of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */

returns upper bound of variable directly before or after the bound change given by the bound change index * was applied * * @deprecated Please us

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

sanity check for the constraint arrays of the constraint handler (only in debug mode) */