## Expand description

This crate exposes automatically generated raw bindings to SCIP’s C-API. The documentation is automatically generated from the C-API docs, for further info please refer to SCIP’s original documentation.

## Re-exports§

`pub use self::SCIP_Retcode as SCIP_RETCODE;`

`pub use self::SCIP_VerbLevel as SCIP_VERBLEVEL;`

`pub use self::SCIP_Result as SCIP_RESULT;`

`pub use self::SCIP_ClockType as SCIP_CLOCKTYPE;`

`pub use self::SCIP_Confidencelevel as SCIP_CONFIDENCELEVEL;`

`pub use self::SCIP_Hashmaptype as SCIP_HASHMAPTYPE;`

`pub use self::SCIP_ParamType as SCIP_PARAMTYPE;`

`pub use self::SCIP_ParamSetting as SCIP_PARAMSETTING;`

`pub use self::SCIP_ParamEmphasis as SCIP_PARAMEMPHASIS;`

`pub use self::SCIP_LPSolStat as SCIP_LPSOLSTAT;`

`pub use self::SCIP_BoundType as SCIP_BOUNDTYPE;`

`pub use self::SCIP_SideType as SCIP_SIDETYPE;`

`pub use self::SCIP_RowOriginType as SCIP_ROWORIGINTYPE;`

`pub use self::SCIP_LPAlgo as SCIP_LPALGO;`

`pub use self::SCIP_Varstatus as SCIP_VARSTATUS;`

`pub use self::SCIP_Vartype as SCIP_VARTYPE;`

`pub use self::SCIP_DomchgType as SCIP_DOMCHGTYPE;`

`pub use self::SCIP_BoundchgType as SCIP_BOUNDCHGTYPE;`

`pub use self::SCIP_LockType as SCIP_LOCKTYPE;`

`pub use self::SCIP_Objsense as SCIP_OBJSENSE;`

`pub use self::SCIP_NodeType as SCIP_NODETYPE;`

`pub use self::SCIP_ConflictType as SCIP_CONFTYPE;`

`pub use self::SCIP_ConflictPresolStrat as SCIP_CONFPRES;`

`pub use self::SCIP_SolOrigin as SCIP_SOLORIGIN;`

`pub use self::SCIP_SolType as SCIP_SOLTYPE;`

`pub use self::SCIP_DiveContext as SCIP_DIVECONTEXT;`

`pub use self::SCIP_LinConstype as SCIP_LINCONSTYPE;`

`pub use self::SCIP_DispStatus as SCIP_DISPSTATUS;`

`pub use self::SCIP_DispMode as SCIP_DISPMODE;`

`pub use self::SCIP_BranchDir as SCIP_BRANCHDIR;`

`pub use self::SCIP_ReoptType as SCIP_REOPTTYPE;`

`pub use self::Reopt_ConsType as REOPT_CONSTYPE;`

`pub use self::SCIP_NlpParam_FastFail as SCIP_NLPPARAM_FASTFAIL;`

`pub use self::SCIP_NlpSolStat as SCIP_NLPSOLSTAT;`

`pub use self::SCIP_NlpTermStat as SCIP_NLPTERMSTAT;`

`pub use self::SCIP_Status as SCIP_STATUS;`

`pub use self::SCIP_Parallelmode as SCIP_PARALLELMODE;`

`pub use self::SCIP_BendersEnfoType as SCIP_BENDERSENFOTYPE;`

`pub use self::SCIP_BendersSolveLoop as SCIP_BENDERSSOLVELOOP;`

`pub use self::SCIP_BendersSubStatus as SCIP_BENDERSSUBSTATUS;`

`pub use self::SCIP_BendersSubType as SCIP_BENDERSSUBTYPE;`

`pub use self::SCIP_ObjSen as SCIP_OBJSEN;`

`pub use self::SCIP_LPParam as SCIP_LPPARAM;`

`pub use self::SCIP_Pricing as SCIP_PRICING;`

`pub use self::SCIP_BaseStat as SCIP_BASESTAT;`

`pub use self::SCIP_LPSolQuality as SCIP_LPSOLQUALITY;`

`pub use self::SCIP_Stage as SCIP_STAGE;`

`pub use self::SCIP_Setting as SCIP_SETTING;`

`pub use self::SYM_Rhssense as SYM_RHSSENSE;`

`pub use self::SCIP_LeaderRule as SCIP_LEADERRULE;`

`pub use self::SCIP_SSTType as SCIP_SSTTYPE;`

`pub use self::SCIP_OrbitopeType as SCIP_ORBITOPETYPE;`

`pub use self::SCIP_RecomputesymType as SCIP_RECOMPUTESYMTYPE;`

`pub use self::SCIP_LinearConsType as SCIP_LINEARCONSTYPE;`

`pub use self::SCIP_SetppcType as SCIP_SETPPCTYPE;`

## Structs§

- linear auxiliary expression of the form xy {≤,≥,=} coefs[0]w + coefs[1]x + coefs[2]y + cst
- bilinear term structure
- interval given by infimum and supremum
- parameters for NLP solve
- Statistics from an NLP solve

## Constants§

- < constraint representing a cut, e.g., to separate a solution
- < constraint reconstructs dual reductions
- < constraint cutoffs an LP infeasible subtree
- < constraint was added by SCIP, e.g., a (local) conflict
- < (slack) variable is basic
- < (slack) variable is at its lower bound
- < (slack) variable is at its upper bound
- < free variable is non-basic and set to zero
- < the Benders’ subproblems are solved during the checking of a solution for feasibility
- < the Benders’ subproblems are solved during the enforcement of an LP solution
- < the Benders’ subproblems are solved during the enforcement of a pseudo solution
- < the Benders’ subproblems are solved during the enforcement of a relaxation solution
- < the CIP is solved in this iteration of the loop
- < the relaxation is solved in this iteration of the loop
- < the user defined solve function is called
- < the user defined solve function is called
- < the subproblem is optimal, but the auxiliary variable is violated
- < the subproblem is solved to be infeasible
- < the subsystem is solved to be optimal
- < the subsystem status is unknown
- < the subproblem has convex constraints and continuous variables
- < the subproblem has convex constraints and discrete variables
- < the subproblem has non-convex constraints and continuous variables
- < the subproblem has non-convex constraints and discrete variables
- < the default type before the type is known
- < lower bound
- < upper bound
- < bound change was due to a branching decision
- < bound change was due to an inference of a constraint (domain propagation)
- < bound change was due to an inference of a domain propagator
- < automatic setting for choosing bound changes
- < downwards branching: decreasing upper bound
- < fixed branching: both bounds changed
- < upwards branching: increasing lower bound
- < use CPU clock
- < use default clock type
- < use wall clock
- < (one-sided) confidence level 95 %, two-sided 90 %
- < (one-sided) confidence level 87.5 %, two-sided 75 %
- < (one-sided) confidence level 97.5 %, two-sided 95 %
- < (one-sided) confidence level 90 %, two-sided 80 %
- < one-sided confidence level 75 %, two-sided 50 %
- < keep variables contributing with its global bound and add a few variables contributing with its local bound such that the constraint is not globally redundant
- < no presolving
- < keep variables contributing with its global bound
- < keep variables contributing with its local bound
- < alternative proof of a boundexceeding LP relaxation
- < alternative proof of an infeasible LP relaxation
- < conflict results from a boundexceeding LP relaxation
- < conflict results from an infeasible LP relaxation
- < conflict results from propagation
- < unknown type
- < display column is displayed in concurrent and sequential mode
- < display column is displayed only in concurrent mode
- < display column is displayed only in sequential mode
- < display column is switched on and off automatically
- < display column is not displayed
- < display column is displayed
- < within adaptive diving
- < single heuristic context
- < all contexts combined
- < static domain changes: number of entries equals size of arrays
- < static domain changes without any hole changes
- < dynamic bound changes with size information of arrays
- < concave
- < convex
- < linear = convex and concave
- < unknown or indefinite curvature
- < breadth-first search
- < depth-first search
- < reverse topological order
- < the hashmap stores ints
- < the hashmap stores pointers %
- < the hashmap stores reals
- < the hashmap did not store a single element yet, type unknown
- < barrier algorithm
- < barrier algorithm with crossover
- < dual simplex
- < primal simplex
- < convergence tolerance used in barrier algorithm
- < maximum condition number of LP basis counted as stable
- < feasibility tolerance for dual variables and reduced costs, strictly positive
- < fast mip setting of LP solver
- < feasibility tolerance for primal variables and slacks, strictly positive
- < solver should start from scratch at next call?
- < should LP solver output information to the screen?
- < LP iteration limit, greater than or equal 0
- < LP time limit, positive
- < Markowitz tolerance
- < objective limit (stop if objective is known be larger/smaller than limit for min/max-imization)
- < set solution polishing (0 - disable, 1 - enable)
- < should LP solver use presolving?
- < pricing strategy
- < inital random seed, e.g. for perturbations in the simplex (0: LP default)
- < set refactorization interval (0 - automatic)
- < simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (0 <= value or -1 = valu ; if negative, this change never occurs)
- < should LP solver use scaling?
- < number of threads used to solve the LP
- < type of timer (1 - cpu, 2 - wallclock, 0 - off)
- < estimated condition number of (scaled) basis matrix (SCIP_Real)
- < exact condition number of (scaled) basis matrix (SCIP_Real)
- < an error occured during optimization
- < LP is primal infeasible
- < iteration limit was reached during optimization
- < LP was not solved, no solution exists
- < objective limit was reached during optimization
- < LP was solved to optimality
- < time limit was reached during optimization
- < LP has a primal unbounded ray
- < first var in orbit
- < last var in orbit
- < var with most conflicting vars in problem
- < var with most conflicting vars in its orbit
- < orbit with maximum number of vars in conflict with leader
- < orbit of maximum size
- < orbit of minimum size
- < linear constraints of the type \f$ ax + by = c\f$
- < linear constraints of the form \f$ \sum a_i x_i + a x \leq a, x, x_i \in {0,1} \forall i, , a\in \mathbb{n} \geq 2 \f$
- < linear constraints of the form \f$ \sum x_i = k, x_i \in {0,1} \forall i, , k\geq 2 \f$
- < linear constraints with no variables
- < linear constraints of the form \f$ \sum a_i x_i = b, x_i \in {0,1} \forall i, , b\in \mathbb{n} \geq 2 \f$
- < linear constraints with no finite side
- < general linear constraints with no special structure
- < linear constraints of the form \f$ \sum a_k x_k \leq b, x_i \in \mathbb{Z} \forall i, , b\in \mathbb{n} \f$
- < linear constraints of the form \f$ \sum x_i \leq b, x_i \in {0,1} \forall i, , b\in \mathbb{n} \geq 2 \f$
- < linear constraints of the form \f$ \sum a_k x_k \leq b, x_i \in {0,1} \forall i, , b\in \mathbb{n} \geq 2 \f$
- < linear constraints of the form \f$ \sum a_k x_k + \sum p_j s_j \leq/= b, x_i \in {0,1} \forall i, s_j \in \text{ cont. } \forall j\f$
- < linear constraints of the type \f$ a x - a y \leq b\f$ where \f$x\f$ and \f$y\f$ must have the same type
- < linear constraints of the form \f$ \sum x_i \geq 1, x_i \in {0,1} \forall i \f$
- < linear constraints of the form \f$ \sum x_i \leq 1, x_i \in {0,1} \forall i \f$
- < linear constraints of the form \f$ \sum x_i = 1, x_i \in {0,1} \forall i \f$
- < linear constraints with a single variable
- < linear constraints of the form \f$ ax + by \leq c , x \in {0,1} \f$
- < this is no valid linear constraint type
- < this is a knapsack constraint
- < this is the common linear constraint
- < this is a logicor constraint
- < this is a setppc constraint
- < variable locks for conflict constraints
- < variable locks for model and check constraints
- < constant = increasing and decreasing
- < decreasing
- < increasing
- < unknown or non-monotone
- < stop if convergence rate is low
- < stop if it seems unlikely that an improving point can be found
- < never stop if progress is still possible
- < feasible solution found
- < problem is proven infeasible
- < solved to global optimality
- < solution found is local infeasible
- < solved to local optimality
- < problem is unbounded
- < unknown solution status (e.g., problem not solved yet)
- < stopped on function evaluation error
- < SCIP has been asked to stop (SCIPinterruptSolve() called)
- < iteration limit exceeded
- < problems with license of NLP solver
- < lower objective limit reached
- < stopped on numerical error
- < terminated successfully
- < other error (= this should never happen)
- < memory exceeded
- < time limit exceeded
- < unsolved child of the focus node
- < temporary type of focus node, if it was solved completely
- < the focus node, whose data is stored in the tree data structure
- < fork with solved LP and added rows and columns
- < fork without LP solution
- < unsolved leaf of the tree, stored in the tree’s queue
- < temporary child node of the focus or refocused node used for probing
- < fork without LP solution and added rows and columns
- < junction, fork, or subroot that was refocused for domain propagation
- < unsolved sibling of the focus node
- < fork with solved LP and arbitrarily changed rows and columns
- < maximize objective function
- < minimize objective function
- < maximization of objective function
- < minimization of objective function (the default)
- < constraint is a full orbitope constraint: rowsum(x) unrestricted
- < constraint is a packing orbitope constraint: rowsum(x) <= 1
- < constraint is a partitioning orbitope constraint: rowsum(x) == 1
- < do not try to avoid running into memory limit
- < get a feasible and “fast” counting process
- < get CP like search (e.g. no LP relaxation)
- < use default values
- < solve easy problems fast
- < detect feasibility fast
- < be capable to handle hard LPs
- < emphasis parameters for increased numerical safety
- < prove optimality fast
- < feasibility phase settings during 3-phase solving approach
- < improvement phase settings during 3-phase solving approach
- < proof phase settings during 3-phase solving approach
- < set to aggressive settings
- < use default values
- < set to fast settings
- < turn off
- < bool values: TRUE or FALSE
- < characters
- < integer values
- < long integer values
- < real values
- < strings: arrays of characters
- < the LP solver should use its preferred strategy
- < devex pricing
- < full pricing
- < the SCIP/LP interface should use its preferred strategy
- < partial pricing
- < steepest edge pricing
- < steepest edge pricing without initial dual norms
- < always recompute symmetries
- < never recompute symmetries
- < only if orbital fixing found a reduction in previous run
- < node is a leaf node and has an integral optimal LP solution
- < node contains dual reductions which leed to LP infeasibility
- < node is a leaf node
- < node contains additional constraints
- < node is not part of the reoptimizationtree
- < node is a leaf node and pruned by boudning
- < node contains dual reductions
- < node is only needed for reconstructing the tree
- < the method created a branching
- < the method added a constraint
- < the method changed a constraint
- < the current node is infeasible and can be cut off
- < the method was not executed, but should be called again later
- < the processing of the branch-and-bound node should stopped and continued later
- < the method was executed, but failed finding anything
- < the method was not executed
- < no infeasibility could be found
- < the method found a feasible primal solution
- < an infeasibility was detected
- < the method added a cutting plane and a new separation round should immediately start
- < the method reduced the domain of a variable
- < the method added a cutting plane
- < the current node’s LP must be solved
- < the method was successfully executed
- < the method interrupted its execution, but can continue if needed
- < an unboundedness was detected
- < no branching could be created
- < unspecified error
- < cannot create file
- < method cannot be called at this time in solution process
- < error in input data
- < method returned an invalid result code
- < the given key is already existing in table
- < error in LP solver
- < maximal branching depth level exceeded
- < file not found error
- < insufficient memory error
- < no problem exists
- < function not implemented
- < normal termination
- < the parameter with the given name was not found
- < the parameter is not of the expected type
- < the value is invalid for the given parameter
- < a required plugin was not found
- < read error
- < write error
- < row created by a constraint
- < row created by a constraint handler
- < row created by reoptimization
- < row created by separator
- < unspecified origin of row
- < binary variables
- < continuous variables
- < implicitly integer variables
- < integer variables
- < constraint is a set covering constraint: sum(x) >= 1
- < constraint is a set packing constraint: sum(x) <= 1
- < constraint is a set partitioning constraint: sum(x) == 1
- < feature is set to automatic mode
- < feature is disabled
- < feature is enabled
- < undefined setting
- < left hand side
- < right hand side
- < all non-cached elements in solution are equal to current LP solution
- < all non-cached elements in solution are equal to current NLP solution
- < solution describes original variables; non-cached elements are zero
- < solution describes original solution; all non-cached elements in solution are treated as being an arbitrary value in the variable’s bounds
- < all non-cached elements in solution are equal to current pseudo solution
- < all non-cached elements in solution are equal to current relaxation solution
- < all non-cached elements in solution are unknown; they have to be treated as being an arbitrary value in the variable’s bounds
- < all non-cached elements in solution are equal to zero
- < solution was found by a heuristic
- < solution was found by the LP relaxation
- < solution originates from a pseudo solution
- < solution was found by a relaxation
- < solution was found during strong branching
- < type of solution unspecified (the default)
- < presolving is exited
- < the solving process data is being freed
- < SCIP data structures are being freed
- < the transformed problem is being freed
- < SCIP data structures are initialized, no problem exists
- < presolving is initialized
- < the solving process data is being initialized
- < the problem was presolved
- < the problem is being presolved
- < the problem is being created and modified
- < the problem was solved
- < the problem is being solved
- < the problem was transformed into solving data space
- < the problem is being transformed into solving data space
- < the solving process was interrupted because the solution improvement limit was reached
- < the solving process was interrupted because the gap limit was reached
- < the problem was proven to be infeasible
- < the problem was proven to be either infeasible or unbounded
- < the solving process was interrupted because the memory limit was reached
- < the solving process was interrupted because the node limit was reached
- < the problem was solved to optimality, an optimal solution is available
- < the solving process was interrupted because the restart limit was reached
- < the solving process was interrupted because the solution limit was reached
- < the solving process was interrupted because the stalling node limit was reached (no inprovement w.r.t. primal bound)
- < status if the process received a SIGTERM signal
- < the solving process was interrupted because the time limit was reached
- < the solving process was interrupted because the total node limit was reached (incl. restarts)
- < the problem was proven to be unbounded
- < the solving status is not yet known
- < the user interrupted the solving process (by pressing CTRL-C)
- < variable is aggregated to x = a*y + c in the transformed problem
- < variable is a column of the transformed problem
- < variable is fixed to specific value in the transformed problem
- < variable is a loose variable of the transformed problem
- < variable is aggregated to x = a_1
*y_1 + … + a_k*y_k + c - < variable is the negation of an original or transformed variable
- < variable belongs to original problem
- < binary variable: \f$ x \in {0,1} \f$
- < continuous variable: \f$ lb \leq x \leq ub \f$
- < implicit integer variable: Integrality of this variable is implied for every optimal solution of the remaining problem after any fixing all integer and binary variables, without the explicit need to enforce integrality further
- < integer variable: \f$ x in {lb, \dots, ub} \f$
- < only interactive dialogs, errors, and warnings are displayed
- < all messages are displayed
- < a lot of information is displayed
- < only important messages are displayed
- < only error and warning messages are displayed
- < standard messages are displayed
- < AND constraint
- < bounddisjunction type 1
- < bounddisjunction type 2
- < linear equation
- < linear inequality
- < OR constrant
- < unknown sense
- < XOR constraint

## Statics§

## Functions§

- BMSalignMemsize
^{⚠}aligns the given byte size corresponding to the minimal alignment for chunk and block memory - allocates array in the block memory pool
- allocates memory in the block memory pool
- allocates the next unused buffer array
- allocates the next unused buffer
- allocates a memory element of the given chunk block
- allocates array in the block memory pool and clears it
- allocates memory in the block memory pool and clears it
- allocates the next unused buffer and clears it
- allocates array and initializes it with 0; returns NULL if memory allocation failed
- allocates array; returns NULL if memory allocation failed
- allocates memory; returns NULL if memory allocation failed
- outputs error messages, if there are allocated elements in the block memory and returns number of unfreed bytes
- displays a warning message on the screen, if allocated memory exists
- frees all chunk blocks in the block memory
- clears a chunk block data structure
- clears a memory element (i.e. fills it with zeros)
- copies the contents of one memory element into another memory element
- creates a block memory allocation data structure
- creates memory buffer storage
- creates a new chunk block data structure
- clears and deletes block memory
- destroys buffer memory
- destroys and frees a chunk block data structure
- outputs allocation diagnostics of block memory
- outputs information about currently allocated memory to the screen
- duplicates array in the block memory pool and copies the data
- duplicates memory element in the block memory pool and copies the data
- allocates an array in the next unused buffer and copies the given memory into the buffer
- allocates the next unused buffer and copies the given memory into the buffer
- duplicates a given memory element by allocating a new element of the same chunk block and copying the data
- allocates array and copies the contents of the given source array into the new array
- allocates memory and copies the contents of the given memory element into the new memory element
- frees memory element in the block memory pool if pointer is not NULL and sets pointer to NULL
- frees memory element in the block memory pool and sets pointer to NULL
- frees a buffer if pointer is not NULL and sets pointer to NULL
- frees a buffer and sets pointer to NULL
- frees a memory element of the given chunk block if pointer is not NULL and sets pointer to NULL
- frees a memory element of the given chunk block and sets pointer to NULL
- frees an allocated memory element if pointer is not NULL and sets pointer to NULL
- frees an allocated memory element and sets pointer to NULL
- calls garbage collection of block memory, frees chunks without allocated memory elements, and frees chunk blocks without any chunks
- calls garbage collection of chunk block and frees chunks without allocated memory elements
- returns the maximal number of allocated bytes in the block memory
- returns the number of allocated bytes in the block memory
- returns the maximal number of allocated but not used bytes in the block memory
- returns the number of allocated but not used bytes in the block memory
- returns the maximal number of used bytes in the block memory
- returns the number of used bytes in the block memory
- returns the size of the given memory element; returns 0, if the element is not member of the block memory
- returns the number of allocated bytes in the buffer memory
- returns the number of allocated bytes in the chunk block
- returns total number of allocated bytes
- gets number of used buffers
- returns the size of an allocated memory element
- BMSisAligned
^{⚠}checks whether the given size meets the alignment conditions for chunk and block memory - moves the contents of one memory element into another memory element, should be used if both elements overlap, otherwise BMScopyMemory is faster
- outputs statistics about currently allocated buffers to the screen
- resizes array in the block memory pool and copies the data
- resizes memory element in the block memory pool and copies the data
- reallocates an array in the buffer to at least the given size
- reallocates the buffer to at least the given size
- reallocates array; returns NULL if memory allocation failed
- allocates memory; returns NULL if memory allocation failed
- set arraygrowfac
- set arraygrowinit
- activates the Benders’ decomposition to be used for the current problem
- activates pricer to be used for the current problem This method should be called during the problem creation stage for all pricers that are necessary to solve the problem model. The pricers are automatically deactivated when the problem is freed.
- allow violation updates
- SCIPactiveCons
^{⚠}calls constraint activation notification method of single constraint - create a resource activity
- SCIPactivityFree
^{⚠}frees a resource activity - returns the demand of the resource activity
- returns the duration of the resource activity
- returns the energy of the resource activity
- returns the start time variable of the resource activity
- registers the Benders’ decomposition subproblem with the Benders’ decomposition struct.
- computes coefficients of linearization of a bilinear term in a reference point
- computes coefficients of McCormick under- or overestimation of a bilinear term
- SCIPaddBoolParam
^{⚠}creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set - SCIPaddCharParam
^{⚠}creates a char parameter, sets it to its default value, and adds it to the parameter set - SCIPaddClique
^{⚠}adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1; if a variable appears twice in the same clique, the corresponding implications are performed - adds new item to knapsack constraint
- adds coefficient to linear constraint (if it is not zero)
- adds coefficient in logic or constraint
- adds linear term pseudo boolean constraint (if it is not zero)
- adds coefficient in set partitioning / packing / covering constraint
- SCIPaddConflict
^{⚠}adds a conflict to a given node or globally to the problem if @p node == NULL. - adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage; this method should be called in one of the following two cases:
- adds changed bound of fixed binary variable to the conflict analysis’ candidate storage; this method should be called in one of the following two cases:
- adds lower bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage; this method should be called in one of the following two cases:
- adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:
- adds lower bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:
- adds upper bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:
- adds upper bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage; this method should be called in one of the following two cases:
- SCIPaddCons
^{⚠}adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the current node (and all of its subnodes); otherwise it is added to the global problem; if a local constraint is added at the root node, it is automatically upgraded into a global constraint - SCIPaddConsAge
^{⚠}adds given value to age of constraint, but age can never become negative; should be called - adds constraint to the conjunction of constraints
- adds constraint to the disjunction of constraints
- SCIPaddConsLocal
^{⚠}adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint; It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is only active in a small part of the tree although it is valid in a larger part. - SCIPaddConsLocks
^{⚠}adds given values to lock status of the constraint and updates the rounding locks of the involved variables - adds given values to lock status of type @p locktype of the constraint and updates the rounding locks of the involved variables
- SCIPaddConsNode
^{⚠}adds constraint to the given node (and all of its subnodes), even if it is a global constraint; It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is only active in a small part of the tree although it is valid in a larger part. In this case, one should pass the more global node where the constraint is valid as “validnode”. Note that the same constraint cannot be added twice to the branching tree with different “validnode” parameters. If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as “validnode”. If the “validnode” is the root node, it is automatically upgraded into a global constraint, but still only added to the given node. If a local constraint is added to the root node, it is added to the global problem instead. - adds current LP/pseudo solution to solution storage
- SCIPaddCut
^{⚠}adds cut to separation storage - SCIPaddDecomp
^{⚠}adds decomposition to SCIP - if not already existing, adds row to the delayed global cut pool
- adds a sub dialog to the given dialog as menu entry and captures it
- adds a single line of input to the command history which can be accessed with the cursor keys
- adds a single line of input which is treated as if the user entered the command line
- adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a bound change for the preferred direction or not
- adds coef * expr to nonlinear constraint
- adds violation-branching score to an expression
- adds violation-branching score to a set of expressions, distributing the score among all the expressions
- insert variable, its score and its solution value into the external branching candidate storage the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
- adds a globally valid inequality of the form \f$\text{xcoef}\cdot x \leq \text{ycoef} \cdot y + \text{constant}\f$ to a product expression of the form \f$x\cdot y\f$
- SCIPaddIntParam
^{⚠}creates a int parameter, sets it to its default value, and adds it to the parameter set - adds variable with a linear coefficient to a nonlinear row
- adds variables with linear coefficients to a row
- adds additional linear constraint that is not connected with an indicator constraint, but can be used for separation
- adds coef * var to nonlinear constraint
- creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
- SCIPaddNNodes
^{⚠}add given number to the number of processed nodes in current run and in all runs, including the focus node - adds row to a cut pool and captures it; doesn’t check for multiple cuts
- SCIPaddNlRow
^{⚠}adds a nonlinear row to the NLP. This row is captured by the NLP. - adds SCIP_NLROWs to a NLPI problem
- adds SCIP_ROWs to a NLPI problem
- SCIPaddNlpiVars
^{⚠} - SCIPaddObjoffset
^{⚠}adds offset of objective function - adds offset of objective function to original problem and to all existing solution in original space
- SCIPaddPoolCut
^{⚠}if not already existing, adds row to global cut pool - SCIPaddPricedVar
^{⚠}adds variable to the problem and uses it as pricing candidate to enter the LP - SCIPaddRealParam
^{⚠}creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set - save bound change based on dual information in the reoptimization tree
- add a variable bound change to a given reoptnode
- add stored constraint to a reoptimization node
- SCIPaddRow
^{⚠}adds row to separation storage - if not already existing, adds row to a cut pool and captures it
- SCIPaddRowDive
^{⚠}adds a row to the LP in current dive - adds additional globally valid row that is not connected with an indicator constraint, but can be used for separation
- adds a row to the LP in the current probing node
- adds a term coef*var to a rowprep
- adds several terms coef*var to a rowprep
- SCIPaddSol
^{⚠}adds feasible primal solution to solution storage by copying it - SCIPaddSolFree
^{⚠}adds primal solution to solution storage, frees the solution afterwards - computes coefficients of linearization of a square term in a reference point
- computes coefficients of secant of a square term
- creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
- adds nonlinear term to pseudo boolean constraint (if it is not zero)
- adds a trust region neighborhood constraint to the @p targetscip
- SCIPaddVar
^{⚠}adds variable to the problem - adds the given value to the branch factor of the variable
- adds the given value to the branch priority of the variable
- adds variable to cardinality constraint, the position is determined by the given weight
- informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b; also adds the corresponding implication or variable bound to the implied variable; if the implication is conflicting, the variable is fixed to the opposite value; if the variable is already fixed to the given value, the implication is performed immediately; if the implication is redundant with respect to the variables’ global bounds, it is ignored
- adds variable to the inequality of the indicator constraint
- SCIPaddVarLocks
^{⚠}adds given values to lock numbers of variable for rounding - adds given values to lock numbers of type @p locktype of variable for rounding
- SCIPaddVarObj
^{⚠}adds value to variable’s objective value - SCIPaddVarSOS1
^{⚠}adds variable to SOS1 constraint, the position is determined by the given weight - SCIPaddVarSOS2
^{⚠}adds variable to SOS2 constraint, the position is determined by the given weight - SCIPaddVarToRow
^{⚠}resolves variable to columns and adds them with the coefficient to the row - SCIPaddVarVlb
^{⚠}informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible - SCIPaddVarVub
^{⚠}informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible - SCIPaddVarsToRow
^{⚠}resolves variables to columns and adds them with the coefficients to the row; this method caches the row extensions and flushes them afterwards to gain better performance - resolves variables to columns and adds them with the same single coefficient to the row; this method caches the row extensions and flushes them afterwards to gain better performance
- adjusts solution values of implicit integer variables in handed solution. Solution objective value is not deteriorated by this method.
- returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value; does not change the bounds of the variable
- returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value; does not change the bounds of the variable
- add weighted constraint to the aggregation row
- add the objective function with right-hand side @p rhs and scaled by @p scale to the aggregation row
- add weighted row to the aggregation row
- calculates the efficacy norm of the given aggregation row, which depends on the “separating/efficacynorm” parameter
- Removes a given variable @p var from position @p pos the aggregation row and updates the right-hand side according to sign of the coefficient, i.e., rhs -= coef * bound, where bound = lb if coef >= 0 and bound = ub, otherwise.
- SCIPaggrRowClear
^{⚠}clear all entries in the aggregation row but do not free the internal memory - SCIPaggrRowCopy
^{⚠}copy the aggregation row - create an empty the aggregation row
- SCIPaggrRowFree
^{⚠}free a the aggregation row - gets the min and max absolute value of the weights used to aggregate the rows; must not be called for empty aggregation rows
- gets the array of corresponding variable problem indices for each non-zero in the aggregation row
- gets the number of non-zeros in the aggregation row
- gets the number of row aggregations
- gets the rank of the aggregation row
- gets the right hand side of the aggregation row
- get array with lp positions of aggregated rows
- get array with weights of aggregated rows
- checks whether a given row has been added to the aggregation row
- checks if the aggregation row is only valid locally
- SCIPaggrRowPrint
^{⚠}output aggregation row to file stream - removes all (close enough to) zero entries in the aggregation row
- aggregate rows using the given weights; the current content of the aggregation row, \p aggrrow, gets overwritten
- From a given equality a
*x + b*y == c, aggregates one of the variables and removes it from the set of active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders the arrays returned from the SCIPvarGetImpl…() methods for the two variables invalid. In the first step, the equality is transformed into an equality with active problem variables a’*x’ + b’*y’ == c’. If x’ == y’, this leads to the detection of redundancy if a’ == -b’ and c’ == 0, of infeasibility, if a’ == -b’ and c’ != 0, or to a variable fixing x’ == c’/(a’+b’) (and possible infeasibility) otherwise. In the second step, the variable to be aggregated is chosen among x’ and y’, prefering a less strict variable type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer aggregation (i.e. integral coefficients a’’ and b’‘, such that a’‘*x’ + b’‘*y’ == c’‘). This can lead to the detection of infeasibility (e.g. if c’’ is fractional), or to a rejection of the aggregation (denoted by aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable. - SCIPallColsInLP
^{⚠}returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing - returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables, that will be added in pricing and improve the objective value
- returns whether dual reductions are allowed during propagation and presolving
- SCIPallowObjProp
^{⚠}returns whether propagation w.r.t. current objective is allowed - returns whether strong dual reductions are allowed during propagation and presolving
- returns whether weak dual reductions are allowed during propagation and presolving
- analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons() instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
- analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
- analyses boundchanges resulting from probing on a variable and performs deduced fixations, aggregations, and domain tightenings
- appends child to the children list of expr
- appends an expression to a sum expression
- appends variable to cardinality constraint
- appends variable to SOS1 constraint
- appends variable to SOS2 constraint
- applies a Benders’ decomposition to the selected decomposition from the decomposition store
- applies the Benders’ decomposition cuts in storage to the input SCIP instance
- applies the cuts in the separation storage to the LP and clears the storage afterwards; this method can only be applied during probing; the user should resolve the probing LP afterwards in order to get a new solution
- main procedure of the dualval heuristic
- main procedure of the subNLP heuristic
- apply fix-and-propagate scheme based on variable locks
- applies and evaluates probing of a single variable in the given direction and bound
- main procedure of the proximity heuristic, creates and solves a sub-SCIP
- SCIPapplyRens
^{⚠}main procedure of the RNS heuristic, creates and solves a sub-SCIP - SCIPapplyReopt
^{⚠}reactivate the given @p reoptnode and split them into several nodes if necessary - SCIPapplyZeroobj
^{⚠}main procedure of the zeroobj heuristic, creates and solves a sub-SCIP - SCIPareSolsEqual
^{⚠}returns whether two given solutions are exactly equal - assigns linking constraints to blocks
- returns whether all nonlinear constraints are assumed to be convex
- automatically selects display columns for being shown w.r.t. the display width parameter
- undoes all changes to the problem applied in probing up to the given probing depth; the changes of the probing node of the given probing depth are the last ones that remain active; changes that were applied before calling SCIPnewProbingNode() cannot be undone
- return number of actions of this bandit algorithm
- return the random number generator of a bandit algorithm
- SCIPbanditSelect
^{⚠}select the next action - SCIPbanditUpdate
^{⚠}update the score of the selected action - return the name of this bandit virtual function table
- returns convergence tolerance used in barrier algorithm
- returns whether first bound change index belongs to an earlier applied bound change than second one; if a bound change index is NULL, the bound change index represents the current time, i.e. the time after the last bound change was applied to the current node
- returns whether first bound change index belongs to an earlier applied bound change than second one
- returns whether the bound change information belongs to a lower or upper bound change
- returns whether the bound change information belongs to a branching decision or a deduction
- returns depth level of given bound change information
- returns bound change index of given bound change information
- returns inference bound of inference variable of given bound change information
- returns inference constraint of given bound change information
- returns inference user information of given bound change information
- returns inference propagator of given bound change information, or NULL if no propagator was responsible
- returns inference variable of given bound change information
- returns new bound installed for given bound change information
- returns old bound that was overwritten for given bound change information
- returns bound change position in its depth level of given bound change information
- returns variable that belongs to the given bound change information
- returns whether the bound change has an inference reason (constraint or propagator), that can be resolved
- returns whether the bound change information belongs to a redundant bound change
- for two bound change informations belonging to the same variable and bound, returns whether the first bound change has a tighter new bound as the second bound change
- SCIPbendersComp
^{⚠} - SCIPbendersCutLP
^{⚠}Are Benders’ cuts generated from the LP solutions? - Are Benders’ cuts generated from the pseudo solutions?
- Are Benders’ cuts generated from the relaxation solutions?
- returns the auxiliary variable for the given subproblem
- returns all auxiliary variables
- returns the array of currently available Benders’ cuts; active Benders’ decomposition are in the first slots of the array
- gets user data of Benders’ decomposition
- gets description of Benders’ decomposition
- returns the number of currently available Benders’ cuts
- gets the number of times, the Bender’ decomposition was called and tried to find a violated second stage constraint
- returns the number of subproblems that are convex
- gets the number of optimality cuts found by the collection of Benders’ decomposition subproblems
- returns the number of subproblems that contain non-linear constraints
- returns the number of cuts that have been added for storage
- gets the number of calls to the strengthening round
- gets the number of cuts found from the strengthening round
- gets the number of calls to the strengthening round that fail
- gets the number of subproblems for the Benders’ decomposition
- returns the number of cuts that have been transferred from sub SCIPs to the master SCIP
- gets name of Benders’ decomposition
- gets priority of Benders’ decomposition
- gets time in seconds used in this Benders’ decomposition for setting up for next stages
- returns the data for the cuts that have been added by the Benders’ cut plugin
- returns the original problem data for the cuts that have been added by the Benders’ cut plugin. The stored variables and values will populate the input vars and vals arrays. Thus, memory must be allocated for the vars and vals arrays
- returns the stored lower bound for the given subproblem
- returns the objective function value of the subproblem for use in cut generation
- returns the type of the subproblem
- gets execution time in seconds used in this Benders’ decomposition
- returns the flag indicating that Benders’ decomposition is in a cut strengthening round
- returns whether the given Benders’ decomposition is in use in the current problem
- Is Benders’ decomposition initialized?
- returns whether the master problem contains non-linear constraints.
- Returns whether only the convex relaxations will be checked in this solve loop when Benders’ is used in the LNS heuristics, only the convex relaxations of the master/subproblems are checked, i.e. no integer cuts are generated. In this case, then Benders’ decomposition is performed under the assumption that all subproblems are convex relaxations.
- sets the priority of a Benders’ decomposition
- sets user data of Benders’ decomposition; user has to free old data in advance!
- sets the flag indicating whether the master problem contains non-linear constraints
- sets the flag indicating whether a subproblem is convex
- sets the independent subproblem flag
- sets the flag indicating whether a subproblem contains non-linear constraints
- sets the subproblem setup flag
- stores the objective function value of the subproblem for use in cut generation
- sets the subproblem type
- Should this Benders’ use the auxiliary variables from the highest priority Benders’?
- returns whether the solution has non-zero slack variables
- solves the Benders’ decomposition subproblem
- solves the LP of the Benders’ decomposition subproblem
- returns the SCIP instance for a given subproblem
- returns whether the subproblem is convex
- returns whether the subproblem is enabled, i.e. the subproblem is still solved in the solving loop.
- returns whether the subproblem is independent
- returns whether the subproblem contains non-linear constraints.
- returns the subproblem setup flag
- updates the lower bound for the subproblem. If the lower bound is not greater than the previously stored lowerbound, then no update occurs.
- gets user data of the Benders’ decomposition cut
- gets description of the Benders’ decomposition cut
- gets the number of times, the Benders’ decomposition cut was called and tried to find a violated cut
- gets the number of the cuts found by this Benders’ decomposition cut
- gets name of the Benders’ decomposition cut
- gets priority of the Benders’ decomposition cut
- gets time in seconds used in this Benders’ decomposition cut for setting up for next stages
- gets time in seconds used in this Benders’ decomposition cut
- is the Benders’ decomposition cut initialized?
- returns whether the Benders’ cut uses the LP information
- sets user data of the Benders’ decomposition cut; user has to free old data in advance!
- sets the enabled flag of the Benders’ decomposition cut method
- SCIPblkmem
^{⚠}returns block memory to use at the current time - returns the bound change type of the bound change in the bound change data
- returns the bound type of the bound change in the bound change data
- returns the new value of the bound in the bound change data
- returns the variable of the bound change in the bound change data
- returns whether the bound change is redundant due to a more global bound that is at least as strong
- gets opposite bound type of given bound type
- SCIPbranchExtern
^{⚠}calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN - SCIPbranchLP
^{⚠}calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN; if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority - SCIPbranchPseudo
^{⚠}calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN - SCIPbranchVar
^{⚠}branches on a non-continuous variable v using the current LP or pseudo solution; if solution value x’ is fractional, two child nodes will be created (x <= floor(x’), x >= ceil(x’)), if solution value is integral, the x’ is equal to lower or upper bound of the branching variable and the bounds of v are finite, then two child nodes will be created (x <= x’‘, x >= x’‘+1 with x’’ = floor((lb + ub)/2)), otherwise (up to) three child nodes will be created (x <= x’-1, x == x’, x >= x’+1) - branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
- SCIPbranchVarVal
^{⚠}branches on a variable x using a given value x’; for continuous variables with relative domain width larger epsilon, x’ must not be one of the bounds; two child nodes (x <= x’, x >= x’) are created; for integer variables, if solution value x’ is fractional, two child nodes are created (x <= floor(x’), x >= ceil(x’)), if x’ is integral, three child nodes are created (x <= x’-1, x == x’, x >= x’+1) - n-ary branching on a variable x using a given value
- gets user data of branching rule
- gets description of branching rule
- gets maximal relative distance from current node’s dual bound to primal bound for applying branching rule
- gets maximal depth level, up to which this branching rule should be used (-1 for no limit)
- gets the total number of children, the branching rule created
- gets the total number of constraints, the branching rule added to the respective local nodes (not counting constraints that were added to the child nodes as branching decisions)
- gets the total number of times, the branching rule detected a cutoff
- gets the total number of cuts, the branching rule separated
- gets the total number of domain reductions, the branching rule found
- gets the total number of times, the branching rule was called on external candidates
- gets the total number of times, the branching rule was called on an LP solution
- gets the total number of times, the branching rule was called on a pseudo solution
- gets name of branching rule
- gets priority of branching rule
- gets time in seconds used in this branching rule for setting up for next stages
- gets time in seconds used in this branching rule
- is branching rule initialized?
- sets user data of branching rule; user has to free old data in advance!
- SCIPbtCreate
^{⚠}creates an binary tree - SCIPbtFree
^{⚠}frees binary tree - SCIPbtGetRoot
^{⚠}returns the root node of the binary tree or NULL if the binary tree is empty - SCIPbtIsEmpty
^{⚠}returns whether the binary tree is empty (has no nodes) - SCIPbtPrintGml
^{⚠}prints the binary tree in GML format into the given file - SCIPbtSetRoot
^{⚠}sets root node - SCIPbtnodeCreate
^{⚠}creates a binary tree node with sorting value and user data - SCIPbtnodeFree
^{⚠}frees the binary node including the rooted subtree - returns the user data pointer stored in that node
- returns left child which can be NULL if the given node is a leaf
- returns the parent which can be NULL if the given node is the root
- returns right child which can be NULL if the given node is a leaf
- returns the sibling of the node or NULL if does not exist
- SCIPbtnodeIsLeaf
^{⚠}returns whether the node is a leaf - returns TRUE if the given node is left child
- returns TRUE if the given node is right child
- SCIPbtnodeIsRoot
^{⚠}returns whether the node is a root node - sets the give node data
- sets left child
- sets parent node
- sets right child
- SCIPbuffer
^{⚠}returns buffer memory for short living temporary objects - informs row, that all subsequent additions of variables to the row should be cached and not directly applied; after all additions were applied, SCIPflushRowExtensions() must be called; while the caching of row extensions is activated, information methods of the row give invalid results; caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase the performance
- calculates a binomial coefficient n over m, choose m elements out of n, maximal value will be 33 over 16 (because the n=33 is the last line in the Pascal’s triangle where each entry fits in a 4 byte value), an error occurs due to big numbers or an negative value m (and m < n) and -1 will be returned
- calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given branching; this estimate can be given to the SCIPcreateChild() call
- calculates the increase of the estimate for the objective of the best feasible solution contained in the subtree after applying the given branching
- calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
- calculates the cumulative distribution P(-infinity <= x <= value) that a normally distributed random variable x takes a value between -infinity and parameter \p value.
- SCIPcalcFibHash
^{⚠}calculates hash for floating-point number by using Fibonacci hashing - calculates a lifted simple generalized flow cover cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in the cut. For further details we refer to:
- calculates the greatest common divisor of the two given values
- tries to find a value, such that all given values, if scaled with this value become integral in relative allowed difference in between mindelta and maxdelta
- calculates a lifted knapsack cover cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in the cut. For further details we refer to:
- SCIPcalcMIR
^{⚠}calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in an MIR cut. - returns the machine epsilon: the smallest number eps > 0, for which 1.0 + eps > 1.0
- calculate memory size for dynamically allocated arrays
- returns a reasonable hash table size (a prime number) that is at least as large as the specified value
- calculates a partition of the given set of binary variables into negated cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same negated clique; the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
- calculates the node selection priority for moving the given variable’s LP value to the given target value; this node selection priority can be given to the SCIPcreateChild() call
- Performs the Newton Procedure from a given starting point to compute a root of the given function with specified precision and maximum number of iterations. If the procedure fails, SCIP_INVALID is returned.
- tries to find a value, such that all row coefficients, if scaled with this value become integral
- calculates the smallest common multiple of the two given values
- SCIPcalcStrongCG
^{⚠}calculates a strong CG cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in a strongcg cut - calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
- SCIPcallExprEval
^{⚠}calls the eval callback for an expression with given values for children - calls the eval and fwdiff callback of an expression with given values for children
- Calls Lapacks Dsyev routine to compute eigenvalues and eigenvectors of a dense matrix.
- SCIPcaptureCons
^{⚠}increases usage counter of constraint - captures a dialog
- SCIPcaptureExpr
^{⚠}captures an expression (increments usage count) - SCIPcaptureNlRow
^{⚠}increases usage counter of a nonlinear row - SCIPcaptureRow
^{⚠}increases usage counter of LP row - SCIPcaptureVar
^{⚠}increases usage counter of variable - SCIPcatchEvent
^{⚠}catches a global (not variable or row dependent) event - catches a row coefficient, constant, or side change event on the given row
- catches an objective value or domain change event on the given transformed variable
- SCIPceil
^{⚠}rounds value - epsilon up to the next integer - checks the optimality of a Benders’ decomposition subproblem by comparing the objective function value against the value of the corresponding auxiliary variable
- SCIPcheckCons
^{⚠}checks single constraint for feasibility of the given solution - checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP
- check for the given starting time variables with their demands and durations if the cumulative conditions for the given solution is satisfied
- checks whether an expression is quadratic
- checks whether expression of constraint can be represented as quadratic form
- check if the reoptimization process should be restarted
- SCIPcheckSol
^{⚠}checks solution for feasibility without adding it to the solution store - SCIPcheckSolOrig
^{⚠}checks solution for feasibility in original problem without adding it to the solution store; this method is used to double check a solution in order to validate the presolving process - checks whether a given binary solution is feasible for the orbisack
- when ‘upgrading’ the given AND-constraint, should the check flag for the upgraded constraint be set to TRUE, even if the check flag of this AND-constraint is set to FALSE?
- when ‘upgrading’ the given AND-constraint, should the removable flag for the upgraded constraint be set to FALSE, even if the removable flag of this AND-constraint is set to TRUE?
- sets the convergence tolerance used in barrier algorithm
- SCIPchgBoolParam
^{⚠}changes the value of an existing SCIP_Bool parameter - changes capacity of the knapsack constraint
- changes cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)
- SCIPchgCharParam
^{⚠}changes the value of an existing char parameter - SCIPchgChildPrio
^{⚠}change the node selection priority of the given child - changes coefficient of variable in linear constraint; deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint
- SCIPchgConsName
^{⚠}change constraint name - changes cutoffbound in current dive
- SCIPchgDispMode
^{⚠}changes the display column mode - sets the feasibility tolerance for reduced costs
- changes expression of a nonlinear constraint
- SCIPchgFeastol
^{⚠}sets the feasibility tolerance for constraints - SCIPchgIntParam
^{⚠}changes the value of an existing int parameter - SCIPchgLhsLinear
^{⚠}changes left hand side of linear constraint - changes left-hand-side of a nonlinear constraint
- changes left hand side of pseudoboolean constraint
- changes the value of an existing SCIP_Longint parameter
- SCIPchgLpfeastol
^{⚠}sets the primal feasibility tolerance of LP solver - changes constant of a nonlinear row
- SCIPchgNlRowLhs
^{⚠}changes left hand side of a nonlinear row - changes linear coefficient of a variables in a nonlinear row
- SCIPchgNlRowRhs
^{⚠}changes right hand side of a nonlinear row - SCIPchgNlpiExpr
^{⚠} - SCIPchgRealParam
^{⚠}changes the value of an existing SCIP_Real parameter - sets the primal feasibility tolerance of relaxations
- changes the objective function
- SCIPchgRhsLinear
^{⚠}changes right hand side of linear constraint - changes right-hand-side of a nonlinear constraint
- changes right hand side of pseudoboolean constraint
- SCIPchgRowLhs
^{⚠}changes left hand side of LP row - changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
- SCIPchgRowRhs
^{⚠}changes right hand side of LP row - changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
- changes the value of an existing string(char*) parameter
- changes bounds of a variable in diving NLP
- sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards branch)
- sets the branch factor of the variable; this value can be used in the branching methods to scale the score values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
- sets the branch priority of the variable; variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable
- SCIPchgVarLb
^{⚠}depending on SCIP’s stage, changes lower bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision - SCIPchgVarLbDive
^{⚠}changes variable’s lower bound in current dive - changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound, if the global bound is better than the local bound
- SCIPchgVarLbLazy
^{⚠}changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet - SCIPchgVarLbNode
^{⚠}changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision - 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 case, the bound change would be treated like a deduction instead of a branching decision
- SCIPchgVarName
^{⚠}changes the name of a variable - SCIPchgVarObj
^{⚠}changes variable’s objective value - changes variable’s objective value in current dive
- changes linear objective coefficient of a variable in diving NLP
- changes (column) variable’s objective value during probing mode
- SCIPchgVarType
^{⚠}changes type of variable in the problem; - SCIPchgVarUb
^{⚠}depending on SCIP’s stage, changes upper bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision - SCIPchgVarUbDive
^{⚠}changes variable’s upper bound in current dive - changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound, if the global bound is better than the local bound
- SCIPchgVarUbLazy
^{⚠}changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet - SCIPchgVarUbNode
^{⚠}changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision - 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 case, the bound change would be treated like a deduction instead of a branching decision
- changes bounds of a set of variables in diving NLP
- performs linear constraint type classification as used for MIPLIB
- SCIPcleanbuffer
^{⚠}returns clean buffer memory for short living temporary objects initialized to all zero - force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
- cleans up (multi-)aggregations and fixings from knapsack constraints
- cleans up (multi-)aggregations and fixings from linear constraints
- cleans up (multi-)aggregations and fixings from logicor constraints
- cleans up (multi-)aggregations and fixings from setppc constraints
- cleans up (multi-)aggregations and fixings from varbound constraints
- Cleans up and attempts to improve rowprep
- Cleans up and attempts to improve rowprep without regard for violation
- clears a dynamic bool array
- removes all conflicts depending on an old cutoff bound if the improvement of the incumbent is good enough
- SCIPclearCuts
^{⚠}clears the separation storage - clear the dive bound change data structures
- removes all external candidates from the storage for external branching
- clears a dynamic int array
- clears a dynamic pointer array
- clears a dynamic real array
- sets the solution value of all variables in the global relaxation solution to zero
- SCIPclearSol
^{⚠}clears a primal solution - SCIPcliqueGetId
^{⚠}gets unique identifier of the clique - gets index of the clique in the clique table
- gets number of variables in the cliques
- gets array of values of active problem variables in the cliques, i.e. whether the variable is fixed to FALSE or to TRUE in the clique
- gets array of active problem variables in the cliques
- SCIPcliqueHasVar
^{⚠}returns whether the given variable/value pair is member of the given clique - returns whether the given clique is cleaned up
- return whether the given clique is an equation
- returns the position of the given variable/value pair in the clique; returns -1 if variable/value pair is not member of the clique
- SCIPcolGetAge
^{⚠}gets the age of a column, i.e., the total number of successive times a column was in the LP and was 0.0 in the solution - gets the basis status of a column in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_ZERO for columns not in the current SCIP_LP
- gets best bound of column with respect to the objective function
- SCIPcolGetIndex
^{⚠}gets unique index of col - gets depth in the tree where the column entered the LP, or -1 if it is not in LP
- SCIPcolGetLPPos
^{⚠}gets position of column in current LP, or -1 if it is not in LP - SCIPcolGetLb
^{⚠}gets lower bound of column - gets the maximal LP solution value, this column ever assumed
- gets the minimal LP solution value, this column ever assumed
- get number of nonzero entries in column vector, that correspond to rows currently in the SCIP_LP;
- SCIPcolGetNNonz
^{⚠}get number of nonzero entries in column vector - gets number of times, strong branching was applied in current run on the given column
- SCIPcolGetObj
^{⚠}gets objective value of column - gets the primal LP solution of a column
- SCIPcolGetRows
^{⚠}gets array with rows of nonzero entries - gets node number of the last node in current branch and bound run, where strong branching was used on the given column, or -1 if strong branching was never applied to the column in current run
- SCIPcolGetUb
^{⚠}gets upper bound of column - SCIPcolGetVals
^{⚠}gets array with coefficients of nonzero entries - SCIPcolGetVar
^{⚠}gets variable this column represents - gets probindex of corresponding variable
- SCIPcolIsInLP
^{⚠}returns TRUE iff column is member of current LP - returns whether the associated variable is of integral type (binary, integer, implicit integer)
- returns TRUE iff column is removable from the LP (due to aging or cleanup)
- SCIPcolSort
^{⚠}sorts column entries such that LP rows precede non-LP rows and inside both parts lower row indices precede higher ones - collects all bilinear terms for a given set of constraints
- SCIPcompareExpr
^{⚠}compare expressions @return -1, 0 or 1 if expr1 <, =, > expr2, respectively @note The given expressions are assumed to be simplified. - SCIPcomprComp
^{⚠} - SCIPcomprGetData
^{⚠}gets user data of tree compression - SCIPcomprGetDesc
^{⚠}gets description of tree compression - gets minimal number of nodes for calling tree compression (returns -1, if no node threshold exists)
- gets the number of times, the compression was called and tried to find a compression
- gets the number of tree compressions found by this compression
- SCIPcomprGetName
^{⚠}gets name of tree compression - gets priority of tree compression
- gets time in seconds used in this compression for setting up for next stages
- SCIPcomprGetTime
^{⚠}gets time in seconds used in this compression - is tree compression initialized?
- SCIPcomprSetData
^{⚠}sets user data of tree compression; user has to free old data in advance! - computes set intersection (duplicates removed) of two integer arrays that are ordered ascendingly
- computes set intersection (duplicates removed) of two integer arrays that are ordered ascendingly
- computes set intersection (duplicates removed) of two void-pointer arrays that are ordered ascendingly
- computes set difference (duplicates removed) of two integer arrays that are ordered ascendingly
- computes set difference (duplicates removed) of two integer arrays that are ordered ascendingly
- solves an independent subproblem to identify its lower bound and updates the lower bound of the corresponding auxiliary variable
- computes coefficients of linearization of a bilinear term in a reference point when given a linear inequality involving only the variables of the bilinear term
- computes coefficients of linearization of a bilinear term in a reference point when given two linear inequalities involving only the variables of the bilinear term
- compute components of symmetry group
- computes a minimal set of covering variables
- computes constraint labels from variable labels
- computes decomposition statistics and store them in the decomposition object
- creates a decomposition of the variables from a labeling of the constraints
- computes the curvature of a given expression and all its subexpressions
- computes integrality information of a given expression and all its subexpressions
- checks the curvature of the quadratic expression
- computes a facet of the convex or concave envelope of a vertex polyhedral function
- SCIPcomputeGap
^{⚠}computes the gap from the primal and the dual bound - SCIPcomputeHmax
^{⚠}computes w.r.t. the given worst case resource profile the first time point where the given capacity is satisfied for sure - SCIPcomputeHmin
^{⚠}computes w.r.t. the given worst case resource profile the first time point where the given capacity can be violated - compute relative interior point to current LP @see SCIPlpComputeRelIntPoint
- Compute orbit of a given variable and store it in @p orbit. The first entry of the orbit will be the given variable index and the rest is filled with the remaining variables excluding the ones specified in @p ignoredvars.
- compute non-trivial orbits of symmetry group
- compute non-trivial orbits of symmetry group using filtered generators
- compute non-trivial orbits of symmetry group
- compute a t-value for the hypothesis that x and y are from the same population; Assuming that x and y represent normally distributed random samples with equal variance, the returned value comes from a Student-T distribution with countx + county - 2 degrees of freedom; this value can be compared with a critical value (see also SCIPstudentTGetCriticalValue()) at a predefined confidence level for checking if x and y significantly differ in location
- for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
- for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
- for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
- for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
- gets user data of conflict handler
- gets description of conflict handler
- gets name of conflict handler
- gets priority of conflict handler
- gets time in seconds used in this conflict handler for setting up for next stages
- gets time in seconds used in this conflict handler
- is conflict handler initialized?
- sets user data of conflict handler; user has to free old data in advance!
- SCIPconsAddCoef
^{⚠}adds the given variable to the input constraint. If the constraint is setppc or logicor the value is ignored. If the constraint is knapsack, then the value is converted to an int. A warning is passed if the SCIP_Real is not an integer. TODO: Allow val to be a pointer. - adds locks to (dis-)allow upgrading of constraint
- enforces Benders’ constraints for given solution
- for an active constraint, returns the depth in the tree at which the constraint was activated
- SCIPconsGetAge
^{⚠}gets age of constraint - SCIPconsGetData
^{⚠}returns the constraint data field of the constraint - returns the dual farkas solution of an arbitrary SCIP constraint that can be represented as a single linear constraint
- returns the dual solution of an arbitrary SCIP constraint that can be represented as a single linear constraint
- SCIPconsGetHdlr
^{⚠}returns the constraint handler of the constraint - SCIPconsGetLhs
^{⚠}returns the left-hand side of an arbitrary SCIP constraint that can be represented as a single linear constraint - get number of times the roundings for variables in constraint’s negation are locked
- get number of times the roundings for variables in constraint are locked
- get number of times the roundings of given locktype for variables in constraint’s negation are locked
- get number of times the roundings of given locktype for variables in constraint are locked
- gets number of locks against upgrading the constraint, 0 means this constraint can be upgraded
- SCIPconsGetNUses
^{⚠}gets number of times, the constraint is currently captured - SCIPconsGetName
^{⚠}returns the name of the constraint - SCIPconsGetPos
^{⚠}returns the position of constraint in the corresponding handler’s conss array - SCIPconsGetRhs
^{⚠}returns the right-hand side of an arbitrary SCIP constraint that can be represented as a single linear constraint - SCIPconsGetRow
^{⚠}returns the row of an arbitrary SCIP constraint that can be represented as a single linear constraint or NULL of no row is awailable - returns the depth in the tree at which the constraint is valid; returns INT_MAX, if the constraint is local and currently not active
- SCIPconsIsActive
^{⚠}returns TRUE iff constraint is active in the current node - SCIPconsIsAdded
^{⚠}returns if the constraint was already added to a SCIP instance - returns TRUE iff constraint should be checked for feasibility
- returns TRUE iff constraint is marked as a conflict
- returns TRUE iff constraint is deleted or marked to be deleted
- returns TRUE iff constraint is subject to aging
- returns TRUE iff constraint is enabled in the current node
- returns TRUE iff constraint should be enforced during node processing
- SCIPconsIsGlobal
^{⚠}returns TRUE iff constraint is globally valid - SCIPconsIsInProb
^{⚠}returns TRUE iff constraint belongs to the global problem - returns TRUE iff the LP relaxation of constraint should be in the initial LP
- SCIPconsIsLocal
^{⚠}returns TRUE iff constraint is only locally valid or not added to any (sub)problem - SCIPconsIsLocked
^{⚠}returns TRUE iff roundings for variables in constraint or in constraint’s negation are locked - returns TRUE iff roundings for variables in constraint’s negation are locked
- returns TRUE iff roundings for variables in constraint are locked
- returns TRUE iff roundings of the given locktype for variables in constraint or in constraint’s negation are locked
- returns TRUE iff roundings of the given locktype for variables in constraint are locked
- returns TRUE iff roundings of the given locktype for variables in constraint are locked
- returns whether the constraint is marked for propagation
- returns TRUE iff constraint is modifiable (subject to column generation)
- returns TRUE iff constraint is marked obsolete
- returns TRUE iff constraint is belonging to original space
- returns TRUE iff constraint should be propagated during node processing
- returns TRUE iff constraint’s propagation is enabled in the current node
- returns TRUE iff constraint’s relaxation should be removed from the LP due to aging or cleanup
- returns TRUE iff constraint should be separated during LP processing
- returns TRUE iff constraint’s separation is enabled in the current node
- 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
- returns TRUE iff constraint has to be deactivated in update phase
- does the constraint handler perform presolving?
- gets array with checked constraints of constraint handler; this is local information
- gets checking priority of constraint handler
- gets time in seconds used for feasibility checking in this constraint handler
- gets array with constraints of constraint handler; the first SCIPconshdlrGetNActiveConss() entries are the active constraints, the last SCIPconshdlrGetNConss() - SCIPconshdlrGetNActiveConss() constraints are deactivated
- gets user data of constraint handler
- gets description of constraint handler
- gets frequency of constraint handler for eager evaluations in separation, propagation and enforcement
- gets array with enforced constraints of constraint handler; this is local information
- gets time in seconds used for LP enforcement in this constraint handler
- gets time in seconds used for pseudo enforcement in this constraint handler
- gets enforcing priority of constraint handler
- gets time in seconds used for relaxation enforcement in this constraint handler
- gets maximum number of active constraints of constraint handler existing at the same time
- gets number of active constraints of constraint handler
- gets number of constraints added in presolving method of constraint handler
- gets number of holes added to domains of variables in presolving method of constraint handler
- gets number of variables aggregated in presolving method of constraint handler
- gets number of calls to the constraint handler’s checking method
- gets number of checked constraints of constraint handler; this is local information
- gets number of bounds changed in presolving method of constraint handler
- gets number of coefficients changed in presolving method of constraint handler
- gets number of constraint sides changed in presolving method of constraint handler
- gets number of variable types changed in presolving method of constraint handler
- gets number of children created by this constraint handler
- gets total number of existing transformed constraints of constraint handler
- gets total number of additional constraints added by this constraint handler
- gets total number of times, this constraint handler detected a cutoff
- gets total number of cuts found by this constraint handler applied to lp
- gets total number of cuts found by this constraint handler
- gets number of constraints deleted in presolving method of constraint handler
- gets total number of domain reductions found by this constraint handler
- gets number of enabled constraints of constraint handler
- gets number of enforced constraints of constraint handler; this is local information
- gets number of calls to the constraint handler’s LP enforcing method
- gets number of calls to the constraint handler’s pseudo enforcing method
- gets number of calls to the constraint handler’s relaxation enforcing method
- gets number of variables fixed in presolving method of constraint handler
- gets number of times the presolving method of the constraint handler was called and tried to find reductions
- gets number of calls to the constraint handler’s propagation method
- gets number of calls to the constraint handler’s resolve propagation method
- gets number of calls to the constraint handler’s separation method
- gets number of constraints that have delayed updates
- gets number of constraints upgraded in presolving method of constraint handler
- gets name of constraint handler
- gets time in seconds used for presolving in this constraint handler
- returns the timing mask of the presolving method of the constraint handler
- gets propagation frequency of constraint handler
- gets time in seconds used for propagation in this constraint handler
- returns the timing mask of the propagation method of the constraint handler
- gets time in seconds used for resolving propagation in this constraint handler
- gets separation frequency of constraint handler
- gets separation priority of constraint handler
- gets time in seconds used for separation in this constraint handler
- gets time in seconds used for setting up this constraint handler for new stages
- gets initial number of active constraints of constraint handler
- gets time in seconds used for propagation in this constraint handler during strong branching
- gets array with delayed update constraints
- does the constraint handler have a copy function?
- is constraint handler initialized?
- should propagation method be delayed, if other propagators found reductions?
- should separation method be delayed, if other separators found cuts?
- needs constraint handler a constraint to be called?
- sets user data of constraint handler; user has to free old data in advance!
- sets the relaxation enforcement method of the constraint handler
- sets the timing mask of the presolving method of the constraint handler
- sets both the propagation callback and the propagation frequency of the constraint handler
- sets the timing mask of the propagation method of the constraint handler
- sets all separation related callbacks of the constraint handler
- was LP separation method delayed at the last call?
- was propagation method delayed at the last call?
- was primal solution separation method delayed at the last call?
- gets added constraints data for a constraint set change
- SCIPconstructLP
^{⚠}makes sure that the LP of the current node is loaded and may be accessed through the LP information methods - Constructs the parallel interface to execute processes concurrently.
- checks whether the given variable is contained in the candidate storage for external branching
- convert all active cuts from cutpool to linear constraints
- converts the given real number representing an integer to an int; in optimized mode the function gets inlined for performance; in debug mode we check some additional conditions
- converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for performance; in debug mode we check some additional conditions
- SCIPcopy
^{⚠}copies source SCIP to target SCIP; the copying process is done in the following order: - SCIPcopyBenders
^{⚠}copies all Benders’ decomposition plugins - copies all active conflicts from the conflict pool of sourcescip and adds them as linear constraints to targetscip
- copies source SCIP to target SCIP but compresses constraints
- creates by copying and captures a linear constraint
- SCIPcopyConss
^{⚠}copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the variables between the source and the target SCIP a hash map can be given; if the variable hash map is NULL or necessary variable mapping is missing, the required variables are created in the target-SCIP and added to the hash map, if not NULL; all variables which are created are added to the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping between the constraints of the source and target-SCIP is stored - SCIPcopyCuts
^{⚠}copies all active cuts from cutpool of sourcescip to linear constraints in targetscip - SCIPcopyDigraph
^{⚠}copies directed graph structure - SCIPcopyExpr
^{⚠}copies an expression including children to use in a (possibly different) SCIP instance - copies implications and cliques of sourcescip to targetscip
- get a sub-SCIP copy of the transformed problem
- SCIPcopyLimits
^{⚠}copies limits from source SCIP to target SCIP - SCIPcopyOrig
^{⚠}copies source SCIP original problem to target SCIP; the copying process is done in the following order: - copies source SCIP original problem to target SCIP but compresses constraints
- copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the variables between the source and the target SCIP a hash map can be given; if the variable hash map is NULL or necessary variable mapping is missing, the required variables are created in the target-SCIP and added to the hash map, if not NULL; all variables which are created are added to the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping between the constraints of the source and target-SCIP is stored
- SCIPcopyOrigProb
^{⚠}create a problem by copying the original problem data of the source SCIP - SCIPcopyOrigVars
^{⚠}copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated variables do not get copied - copies parameter settings from sourcescip to targetscip
- SCIPcopyPlugins
^{⚠}copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the copied SCIP instance might not represent the same problem semantics as the original. Note that in this case dual reductions might be invalid. - SCIPcopyProb
^{⚠}create a problem by copying the problem data of the source SCIP - SCIPcopyRowprep
^{⚠}creates a copy of a SCIP_ROWPREP datastructure - SCIPcopyVars
^{⚠}Copies all active (thus unfixed) variables from source-SCIP, except those that are marked as relaxation only, and adds these variable to the target-SCIP. - returns the constraint name for the given index
- returns the number of constraint names in the COR problem
- returns the number of variable names in the COR problem
- returns the variable name for the given index
- SCIPcorHasRead
^{⚠}returns whether the COR file has been successfully read. This is used by the TIM and STO readers. - SCIPcount
^{⚠}execute counting - SCIPcreate
^{⚠}creates and initializes SCIP data structures - create and resets an epsilon greedy bandit algorithm
- creates and resets an Exp.3 bandit algorithm using \p scip pointer
- create and reset UCB bandit algorithm
- Creates a default Benders’ decomposition algorithm and activates it in SCIP
- creates a dynamic array of bool values
- creates a clock counting the CPU user seconds
- SCIPcreateChild
^{⚠}creates a child node of the focus node - SCIPcreateClock
^{⚠}creates a clock using the default clock type - SCIPcreateCons
^{⚠}creates and captures a constraint of the given constraint handler - creates and captures an and constraint
- creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsAnd(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an and constraint with possibly redundant literals in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an cardinality constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsConjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an absolute power constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsCumulative(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a cumulative constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsDisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an indicator constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsIndicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an indicator constraint with given linear constraint and slack variable in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsIndicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a knapsack constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsKnapsack(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- 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 method SCIPcreateConsLinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a linking constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLinking(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a logicor constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLogicor(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a nonlinear constraint with all its constraint flags set to their default values
- creates and captures an or constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsNonlinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an orbisack constraint in its most basic variant
- creates and captures an orbitope constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a pseudoboolean constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a quadratic nonlinear constraint with all its constraint flags set to their default values
- creates and captures a nonlinear constraint that is a second-order cone constraint with all its constraint flags set to their default values
- creates and captures an SOS1 constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a SOS2 constraint with all constraint flags set to their default values.
- creates and captures a set packing constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a set packing constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a set partitioning constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a signpower nonlinear constraint with all its constraint flags set to their default values
- creates and captures a superindicator constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsSuperindicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a symresack constraint in its most basic variant, i.e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h
- creates and captures a varbound constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsVarbound(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures an xor constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsXor(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
- creates and captures a bound disjunction constraint
- creates and captures a bound disjunction constraint with possibly redundant literals
- creates and captures an cardinality constraint
- creates and captures a conjunction constraint
- creates and captures a cumulative constraint
- creates and captures a disjunction constraint
- creates and captures an indicator constraint
- creates and captures a indicator constraint in a more generic version.
- creates and captures an indicator constraint with given linear constraint and slack variable in a generic version, i. e., with a flag activeone indicating whether the constraint is active on value 1 or 0 of the binary variable.
- creates and captures an indicator constraint with given linear constraint and slack variable
- creates and captures a knapsack constraint
- creates and captures a linear constraint
- creates and captures a linking constraint
- creates and captures a logic or constraint
- creates and captures a nonlinear constraint
- SCIPcreateConsOr
^{⚠}creates and captures an or constraint - creates and captures a orbisack constraint
- creates and captures a orbitope constraint
- creates and captures a pseudoboolean constraint
- creates and captures a pseudoboolean constraint, with given linear and and-constraints
- creates and captures a quadratic nonlinear constraint
- creates and captures an SOS1 constraint
- creates and captures an SOS2 constraint
- creates and captures a set covering constraint
- creates and captures a set packing constraint
- creates and captures a set partitioning constraint
- creates and captures a superindicator constraint
- creates and captures a symresack constraint
- creates and captures a variable bound constraint: lhs <= x + c*y <= rhs
- creates and captures an xor constraint
- creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved at the current node
- creates a cut pool
- SCIPcreateDecomp
^{⚠}creates a decomposition - creates directed graph structure
- creates a disjoint set (union find) structure \p djset for \p ncomponents many components (of size one)
- create a diving set associated with a primal heuristic. The primal heuristic needs to be included before this method can be called. The diveset is installed in the array of divesets of the heuristic and can be retrieved later by accessing SCIPheurGetDivesets()
- creates and captures a nonlinear row without any coefficients
- creates and captures an LP row without any coefficients
- creates and captures an LP row without any coefficients from a constraint
- creates and captures an LP row without any coefficients from a constraint handler
- creates and captures an LP row without any coefficients from a separator
- creates and captures an LP row without any coefficients from an unspecified source
- SCIPcreateExpr
^{⚠}creates and captures an expression with given expression data and children - SCIPcreateExpr2
^{⚠}creates and captures an expression with given expression data and up to two children - creates an absolute value expression
- creates a cos expression
- creates an entropy expression
- creates an exponential expression
- creates a logarithmic expression
- creates and captures an expression representing a monomial
- creates a power expression
- creates a product expression
- creates and captures an expression representing a quadratic function
- creates a signpower expression
- creates a sin expression
- creates a sum expression
- creates constant value expression
- creates a variable expression
- creates a variable index expression
- creates an expression iterator
- creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values; the copy is always defined in the original variable space; success indicates whether the objective value of the solution was changed by removing infinite values
- creates a dynamic array of int values
- SCIPcreateLPSol
^{⚠}creates a primal solution, initialized to the current LP solution - SCIPcreateNLPSol
^{⚠}creates a primal solution, initialized to the current NLP solution - SCIPcreateNlRow
^{⚠}creates and captures a nonlinear row - creates and captures a nonlinear row from a linear row
- creates a NLPI problem from given nonlinear rows
- creates a primal solution living in the original problem space, initialized to zero; a solution in original space allows to set original variables to values that would be invalid in the transformed problem due to preprocessing fixings or aggregations
- creates a partial primal solution, initialized to unknown values
- SCIPcreateProb
^{⚠}creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE) If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed. - creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE) all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(), SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and SCIPsetProbCopy() If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
- creates a primal solution, initialized to the current pseudo solution
- creates a dynamic array of pointers
- SCIPcreateRandom
^{⚠}creates and initializes a random number generator - creates a dynamic array of real values
- creates a primal solution, initialized to the current relaxation solution
- creates a root dialog
- SCIPcreateRow
^{⚠}creates and captures an LP row - creates and captures an LP row from a constraint
- creates and captures an LP row from a constraint handler
- creates and captures an LP row from a separator
- creates and captures an LP row from an unspecified source
- creates a SCIP_ROWPREP datastructure
- SCIPcreateSol
^{⚠}creates a primal solution, initialized to zero - 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 from changes in the LP or pseudo solution
- creates a copy of a solution in the original primal solution space
- creates a symmetry breaking constraint
- creates a primal solution, initialized to unknown values
- SCIPcreateVar
^{⚠}creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable; - creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(), SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable;
- creates a clock counting the wall clock seconds
- creates the worst case resource profile, that is, all jobs are inserted with the earliest start and latest completion time
- calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in an MIR cut. The function uses a cut generation heuristic which tries different scaling factors and complementations of the variables to improve the cut’s efficacy. For further details we refer to:
- SCIPcutGetAge
^{⚠}gets the age of the cut: the number of consecutive cut pool separation rounds where the cut was neither in the LP nor violated - returns the ratio of LPs where the row belonging to this cut was active in an LP solution, i.e. where the age of its row has not been increased
- SCIPcutGetRow
^{⚠}gets the row of the cut - SCIPcutoffNode
^{⚠}marks node and whole sub tree to be cut off from branch and bound tree - return the cutoff bound delta
- gets array of cuts in the cut pool
- get maximum number of cuts that were stored in the cut pool at the same time
- get number of times the cut pool was separated
- get number of cuts in the cut pool
- get total number of cuts that were added from the cut pool to sepastore
- get total number of cuts that were separated from the cut pool
- get number of times the cut pool was separated at the root
- gets time in seconds used for separating cuts from the pool
- perform activity based coefficient tigthening on the given cut; returns TRUE if the cut was detected to be redundant due to acitivity bounds
- SCIPcutselComp
^{⚠} - gets user data of cut selector
- gets description of cut selector
- get number of times the cutselector was called
- get total number of local cuts that were selected
- get total number of local cuts that were filtered
- get total number of forced local cuts that were selected
- get number of times the cutselector was called at the root
- get total number of cuts that were selected at the root
- get total number of root cuts that were filtered
- get total number of forced cuts that were selected at the root
- gets name of cut selector
- gets priority of cut selector
- gets time in seconds used in this cut selector for setting up for next stages
- gets time in seconds used in this cut selector
- is cut selector initialized?
- sets user data of cut selector; user has to free old data in advance!
- deactivates the Benders’ decomposition
- deactivates pricer
- disallow violation updates
- SCIPdeactiveCons
^{⚠}calls constraint deactivation notification method of single constraint - SCIPdecompClear
^{⚠}clears the corresponding labeling (constraints, variables, or both) of this decomposition - SCIPdecompCreate
^{⚠}creates a decomposition - SCIPdecompFree
^{⚠}frees a decomposition - gets area score of this decomposition
- gets the maximum degree of the block-decomposition graph of this decomposition
- gets the minimum degree of the block-decomposition graph of this decomposition
- queries labels for an array of constraints
- gets constraint size for each block, sorted by increasing block label
- gets modularity of this decomposition
- gets number of articulation points in the block-decomposition graph of this decomposition
- gets number of connected components in the block-decomposition graph of this decomposition
- gets number of edges in the block-decomposition graph of this decomposition
- gets number of blocks of this decomposition
- gets number of border constraints of this decomposition
- gets number of border variables of this decomposition
- queries labels for an array of variables
- gets variable size for each block, sorted by increasing block label
- returns TRUE if decomposition is in the original space
- prints decomposition statistics into string buffer
- sets labels for an array of constraints
- sets the parameter that indicates whether the variables must be labeled for the application of Benders’ decomposition
- sets labels for an array of variables
- returns TRUE if the variables must be labeled for the application of Benders’ decomposition
- deletes variable from linear constraint
- SCIPdelCons
^{⚠}globally removes constraint from all subproblems; removes constraint from the constraint set change data of the node, where it was added, or from the problem, if it was a problem constraint - SCIPdelConsLocal
^{⚠}disables constraint’s separation, enforcing, and propagation capabilities at the current node (and all subnodes); if the method is called during problem modification or at the root node, the constraint is globally deleted from the problem; the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the constraint is automatically enabled again, and after reentering the current node’s subtree, it is automatically disabled again; this may improve performance because redundant checks on this constraint are avoided, but it consumes memory; alternatively, use SCIPdisableCons() - SCIPdelConsNode
^{⚠}disables constraint’s separation, enforcing, and propagation capabilities at the given node (and all subnodes); if the method is called at the root node, the constraint is globally deleted from the problem; the constraint deletion is being remembered at the given node, s.t. after leaving the node’s subtree, the constraint is automatically enabled again, and after entering the node’s subtree, it is automatically disabled; this may improve performance because redundant checks on this constraint are avoided, but it consumes memory; alternatively, use SCIPdisableCons() - removes the row from the delayed global cut pool
- SCIPdelNlRow
^{⚠}removes a nonlinear row from the NLP - SCIPdelPoolCut
^{⚠}removes the row from the global cut pool - removes the LP row from a cut pool
- SCIPdelVar
^{⚠}removes variable from the problem - deletes the given reoptimization node
- frees the sub-MIP created by proximity
- determine number of variables affected by symmetry group
- displays all dialog entries with names starting with the given “entryname”
- displays the dialog’s menu
- displays the entry for the dialog in it’s parent’s menu
- searches the dialog for entries corresponding to the given name; If a complete match is found, the entry is returned as “subdialog” and the return value is 1. If no dialog entry completely matches the given “entryname”, the number of entries with names beginning with “entryname” is returned. If this number is 1, the single match is returned as “subdialog”. Otherwise, “subdialog” is set to NULL.
- gets the user defined data associated with the given dialog
- gets the description of the dialog
- gets the number of sub-dialogs associated with the given dialog
- gets the command name of the dialog
- gets the parent dialog of the given dialog
- gets the name of the current path in the dialog tree, separated by the given character
- gets the array of sub-dialogs associated with the given dialog
- returns TRUE iff a dialog entry matching exactly the given name is existing in the given dialog
- returns whether the dialog is a sub menu
- sets user data of dialog; user has to free old data in advance!
- writes command history to specified filename
- 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 command is given, only the path to the dialog is added to the command history
- adds a single line of input to the dialog handler which is treated as if the user entered the command line
- clears the input command buffer of the dialog handler
- returns the next line in the handler’s command buffer; if the buffer is empty, displays the given prompt or the current dialog’s path and asks the user for further input; the user must not free or modify the returned string
- @addtogroup PublicDialogMethods
- returns the next word in the handler’s command buffer; if the buffer is empty, displays the given prompt or the current dialog’s path and asks the user for further input; the user must not free or modify the returned string
- returns TRUE iff input command buffer is empty
- add (directed) arc and a related data to the directed graph structure
- add (directed) arc to the directed graph structure, if it is not contained, yet
- Computes all strongly connected components of an undirected connected component with Tarjan’s Algorithm. The resulting strongly connected components are sorted topologically (starting from the end of the strongcomponents array).
- Compute undirected connected components on the given graph.
- SCIPdigraphFree
^{⚠}frees given directed graph structure - frees the component information for the given directed graph
- identifies the articulation points in a given directed graph uses the helper recursive function findArticulationPointsUtil
- Returns the previously computed undirected component of the given number for the given directed graph. If the components were sorted using SCIPdigraphTopoSortComponents(), the component is (almost) topologically sorted.
- returns the total number of arcs in the given digraph
- returns the number of previously computed undirected components for the given directed graph
- returns the number of nodes of the given digraph
- returns the number of successor nodes of the given node
- returns the node data, or NULL if no data exist
- returns the array of indices of the successor nodes; this array must not be changed from outside
- returns the array of data corresponding to the arcs originating at the given node, or NULL if no data exist; this array must not be changed from outside
- SCIPdigraphPrint
^{⚠}output of the given directed graph via the given message handler - output of the given directed graph via the given message handler
- prints the given directed graph structure in GML format into the given file
- resize directed graph structure
- sets the number of successors to a given value
- sets the node data
- sets the sizes of the successor lists for the nodes in a directed graph and allocates memory for the lists
- Performes an (almost) topological sort on the undirected components of the given directed graph. The undirected components should be computed before using SCIPdigraphComputeUndirectedComponents().
- SCIPdisableCons
^{⚠}disables constraint’s separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated, separated, and enforced anymore until it is enabled again with a call to SCIPenableCons(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again; note that the constraints enforcing capabilities are necessary for the solution’s feasibility, if the constraint is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree, and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using an appropriate event handler that watches the corresponding variables’ domain changes) - disables constraint’s propagation capabilities s.t. the constraint is not propagated anymore until the propagation is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
- disables constraint’s separation capabilities s.t. the constraint is not propagated anymore until the separation is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
- disable solution debugging mechanism
- disables the collection of any statistic for a variable
- clears the disjoint set (union find) structure \p djset
- finds and returns the component identifier of this \p element
- returns the number of independent components in this disjoint set (union find) data structure
- returns the size (number of nodes) of this disjoint set (union find) data structure
- merges the components containing the elements \p p and \p q
- prints structure of an expression a la Maple’s dismantle
- SCIPdispGetData
^{⚠}gets user data of display column - SCIPdispGetDesc
^{⚠}gets description of display column - gets head line of display column
- SCIPdispGetName
^{⚠}gets name of display column - gets position of display column
- gets priority of display column
- gets status of display column
- SCIPdispGetWidth
^{⚠}gets width of display column - SCIPdispInt
^{⚠}displays an integer in decimal form fitting in a given width - is display column initialized?
- SCIPdispLongint
^{⚠}displays a long integer in decimal form fitting in a given width - SCIPdispSetData
^{⚠}sets user data of display column; user has to free old data in advance! - SCIPdispTime
^{⚠}displays a time value fitting in a given width - get the average depth this dive set reached during execution
- get the average upper bound quotient parameter of the diving settings if an incumbent solution exists
- get the average quotient parameter of the diving settings if no solution is available
- get the average depth at which this dive set found a solution
- get the heuristic to which this diving setting belongs
- returns the domain reduction quotient for triggering an immediate resolve of the diving LP (0.0: always resolve)
- returns the LP solve frequency for diving LPs (0: dynamically based on number of intermediate domain reductions)
- get the maximum depth reached by this dive set
- get the maximum LP iterations offset of the diving settings
- get the maximum LP iterations quotient of the diving settings
- get the maximum relative depth of the diving settings
- get the maximum depth at which this dive set found a solution
- get the minimum depth reached by this dive set
- get the minimum relative depth of the diving settings
- get the minimum depth at which this dive set found a solution
- get the total number of backtracks performed by this dive set
- get the number of calls to this dive set
- get the total number of conflicts found by this dive set
- get the total number of LP iterations used by this dive set
- get the total number of probing nodes used by this dive set
- get the total number of solutions (leaf and rounded solutions) found by the dive set
- get the number of calls successfully terminated at a feasible leaf node
- get the name of the dive set
- returns the random number generator of this \p diveset for tie-breaking
- get the number of successful runs of the diving settings
- get the maximum upper bound quotient parameter of the diving settings if an incumbent solution exists
- get the maximum upper bound quotient parameter of the diving settings if no solution is available
- get the working solution of this dive set
- is this dive set publicly available (ie., can be used by other primal heuristics?)
- set the working solution for this dive set
- returns TRUE if dive set supports diving of the specified type
- should backtracking be applied?
- should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
- SCIPdoNotAggr
^{⚠}returns whether aggregation of variables is not allowed - SCIPdoNotAggrVar
^{⚠}returns whether variable is not allowed to be aggregated - returns whether multi-aggregation is disabled
- returns whether variable is not allowed to be multi-aggregated
- returns a particular bound change in the domain change data
- returns the number of bound changes in the domain change data
- SCIPdropEvent
^{⚠}drops a global event (stops to track event) - SCIPdropRowEvent
^{⚠}drops a row coefficient, constant, or side change event (stops to track event) on the given row - SCIPdropVarEvent
^{⚠}drops an objective value or domain change event (stops to track event) on the given transformed variable - SCIPdualfeasCeil
^{⚠}rounds value - dual feasibility tolerance up to the next integer - rounds value + dual feasibility tolerance down to the next integer
- SCIPdualfeasFrac
^{⚠}returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance - rounds value to the nearest integer in dual feasibility tolerance
- SCIPdualfeastol
^{⚠} - duplicates the given expression and its children
- duplicates the given expression, but reuses its children
- SCIPenableCons
^{⚠}enables constraint’s separation, propagation, and enforcing capabilities - enables constraint compression.
- enables constraint’s propagation capabilities
- enables constraint’s separation capabilities
- enable debug solution mechanism
- SCIPenableNLP
^{⚠}notifies SCIP that the NLP relaxation should be initialized in INITSOLVE - enables or disables all statistic clocks of SCIP concerning plugin statistics, LP execution time, strong branching time, etc.
- include specific heuristics and branching rules for reoptimization
- enables the collection of statistics for a variable
- SCIPendDive
^{⚠}quits LP diving and resets bounds and objective values of columns to the current node’s values - SCIPendDiveNLP
^{⚠}ends NLP diving - SCIPendProbing
^{⚠}quits probing and resets bounds and constraints to the focus node’s environment - end strong branching - call after any strong branching
- SCIPenfolpCons
^{⚠}enforces single constraint for a given LP solution - SCIPenfopsCons
^{⚠}enforces single constraint for a given pseudo solution - enforces single constraint for a given relaxation solution
- extends a dynamically allocated block memory array to be able to store at least the given number of elements; use SCIPensureBlockMemoryArray() define to call this method!
- ensures that rowprep has space for at least given number of additional terms
- SCIPepsilon
^{⚠}returns value treated as zero - SCIPerf
^{⚠}returns the value of the Gauss error function evaluated at a given point - SCIPescapeString
^{⚠}translates the given string into a string where symbols “, ’, and spaces are escaped with a \ prefix - evaluates an auxiliary expression for a bilinear term
- SCIPevalExpr
^{⚠}evaluate an expression in a point - possibly reevaluates and then returns the activity of the expression
- evaluates gradient of an expression for a given point
- evaluates Hessian-vector product of an expression for a given point and direction
- evaluates quadratic term in a solution
- evaluates quadratic term in a solution w.r.t. auxiliary variables
- gets the left bound of open interval in the hole
- gets the right bound of open interval in the hole
- gets new bound for a bound change event
- gets new objective value for an objective value change event
- gets new variable type for a variable type change event
- SCIPeventGetNode
^{⚠}gets node for a node or LP event - gets old bound for a bound change event
- gets old objective value for an objective value change event
- gets old variable type for a variable type change event
- SCIPeventGetRow
^{⚠}gets row for a row event - gets column for a row change coefficient event
- gets new coefficient value for a row change coefficient event
- gets new constant value for a row change constant event
- gets new side value for a row change side event
- gets old coefficient value for a row change coefficient event
- gets old constant value for a row change constant event
- gets old side value for a row change side event
- gets side for a row change side event
- SCIPeventGetSol
^{⚠}gets solution for a primal solution event - SCIPeventGetType
^{⚠}gets type of event - SCIPeventGetVar
^{⚠}gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed) - gets user data of event handler
- gets name of event handler
- gets time in seconds used in this event handler for setting up for next stages
- gets time in seconds used in this event handler
- is event handler initialized?
- sets user data of event handler; user has to free old data in advance!
- performs propagation of variables lower and upper bounds
- execution reliability pseudo cost branching with the given branching candidates
- checks if for the given linking variable (continuous or integer) a linking constraint exists
- SCIPexistsDialog
^{⚠}returns if the dialog already exists - returns whether all expressions that are used in a quadratic expression are variable expressions
- returns the activity that is currently stored for an expression
- returns the tag associated with the activity of the expression
- gives the value of directional derivative from the last evaluation of a directional derivative of derivative of root (or SCIP_INVALID if there was an error)
- gives the children of an expression (can be NULL if no children)
- returns the curvature of an expression
- SCIPexprGetData
^{⚠}gets the expression data of an expression - returns the derivative stored in an expression (or SCIP_INVALID if there was an evaluation error)
- returns the difftag stored in an expression
- SCIPexprGetDot
^{⚠}gives the value of directional derivative from the last evaluation of a directional derivative of expression (or SCIP_INVALID if there was an error) - gives the evaluation tag from the last evaluation, or 0
- gives the value from the last evaluation of an expression (or SCIP_INVALID if there was an eval error)
- SCIPexprGetHdlr
^{⚠}gets the expression handler of an expression - gives the number of children of an expression
- SCIPexprGetNUses
^{⚠}gets the number of times the expression is currently captured - gets the data that the owner of an expression has stored in an expression
- gives the data of a bilinear expression term
- gives the coefficients and expressions that define a quadratic expression
- gives the data of a quadratic expression term
- returns whether an expression is integral
- set the activity with tag for an expression
- sets the curvature of an expression
- SCIPexprSetData
^{⚠}sets the expression data of an expression - sets the integrality flag of an expression
- SCIPexprcurvAdd
^{⚠}gives curvature for a sum of two functions with given curvature - gives name as string for a curvature
- gives curvature for a monomial with given curvatures and bounds for each factor
- for a monomial with given bounds for each factor, gives condition on the curvature of each factor, so that monomial has a requested curvature, if possible
- gives curvature for a functions with given curvature multiplied by a constant factor
- gives the curvature for the negation of a function with given curvature
- gives curvature for base^exponent for given bounds and curvature of base-function and constant exponent
- gives required curvature for base so that base^exponent has given curvature under given bounds on base and constant exponent
- SCIPexprhdlrComp
^{⚠} - gives the data of an expression handler
- gives the description of an expression handler (can be NULL)
- gets time spend in estimation callback
- gets time spend in interval evaluation callback
- gets number of times branching candidates reported by of this expression handler were used to assemble branching candidates
- gets number of times an expression has been created with given expression handler
- gets number of times an empty interval was found in reverse propagation
- gets number of times a bound reduction was found in reverse propagation (and accepted by caller)
- gets number of times the estimation callback was called
- gets number of times the interval evaluation callback was called
- gets number of times the reverse propagation callback was called
- gets number of times the simplify callback found a simplification
- gets number of times the simplify callback was called
- gives the name of an expression handler
- gives the precedence of an expression handler
- gets time spend in reverse propagation callback
- gets time spend in simplify callback
- returns whether expression handler implements the backward differentiation callback
- returns whether expression handler implements the curvature callback
- returns whether expression handler implements the estimator callback
- returns whether expression handler implements the forward differentiation callback
- returns whether expression handler implements the initial estimators callback
- returns whether expression handler implements the interval evaluation callback
- returns whether expression handler implements the monotonicity callback
- returns whether expression handler implements the print callback
- returns whether expression handler implements the reverse propagation callback
- returns whether expression handler implements the simplification callback
- increments the branching candidates count of an expression handler
- increments the domain reductions count of an expression handler
- set the compare callback of an expression handler
- set the expression handler callbacks to copy and free expression data
- set the expression handler callbacks to copy and free an expression handler
- set the curvature detection callback of an expression handler
- set differentiation callbacks of an expression handler
- set the estimation callbacks of an expression handler
- set the hash callback of an expression handler
- set the interval evaluation callback of an expression handler
- set the integrality detection callback of an expression handler
- set the monotonicity detection callback of an expression handler
- set the parse callback of an expression handler
- set the print callback of an expression handler
- set the reverse propagation callback of an expression handler
- set the simplify callback of an expression handler
- gets the child expression that the expression iterator considers when in DFS mode and stage \ref SCIP_EXPRITER_VISITINGCHILD or \ref SCIP_EXPRITER_VISITEDCHILD
- 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_VISITEDCHILD
- gives the iterator specific user data of the current expressions current child
- gets the current expression that the expression iterator points to
- gives the iterator specific user data of the current expression
- gives the iterator specific user data of a given expression
- moves the iterator to the next expression according to the mode of the expression iterator
- gives the parent of the current expression of an expression iteration if in DFS mode
- gets the current stage that the expression iterator is in when using DFS
- SCIPexpriterInit
^{⚠}initializes an expression iterator - returns whether the iterator visited all expressions already
- returns whether expression iterator is currently initialized
- restarts an already initialized expression iterator in DFS mode
- sets the iterator specific user data of the current expressions current child
- sets the iterator specific user data of the current expression for an expression iteration if in DFS mode
- sets the iterator specific user data of a given expression
- specifies in which stages to stop a DFS iterator
- moves a DFS iterator to one of the next expressions
- extends dynamic array to be able to store indices from minidx to maxidx
- extends dynamic array to be able to store indices from minidx to maxidx
- extends dynamic array to be able to store indices from minidx to maxidx
- extends dynamic array to be able to store indices from minidx to maxidx
- Given a matrix with nrows and #perms + 1 columns whose first nfilledcols columns contain entries of variables, this routine checks whether the 2-cycles of perm intersect each row of column coltoextend in exactly one position. In this case, we add one column to the suborbitope of the first nfilledcols columns.
- SCIPfclose
^{⚠} - SCIPfdopen
^{⚠} - SCIPfeasCeil
^{⚠}rounds value - feasibility tolerance up to the next integer - SCIPfeasFloor
^{⚠}rounds value + feasibility tolerance down to the next integer - SCIPfeasFrac
^{⚠}returns fractional part of value, i.e. x - floor(x) - SCIPfeasRound
^{⚠}rounds value to the nearest integer in feasibility tolerance - SCIPfeastol
^{⚠} - SCIPfeof
^{⚠} - SCIPfflush
^{⚠} - SCIPfgetc
^{⚠} - SCIPfgets
^{⚠} - SCIPfileExists
^{⚠}returns, whether the given file exists - returns the bandit virtual function table of the given name, or NULL if not existing
- SCIPfindBenders
^{⚠}returns the Benders’ decomposition of the given name, or NULL if not existing - returns the Benders’ cut of the given name, or NULL if not existing
- returns the branching rule of the given name, or NULL if not existing
- SCIPfindCompr
^{⚠}returns the tree compression of the given name, or NULL if not existing - returns the concurrent solver type with the given name, or NULL if not existing
- returns the conflict handler of the given name, or NULL if not existing
- SCIPfindCons
^{⚠}returns constraint of given name in the problem, or NULL if not existing - SCIPfindConshdlr
^{⚠}returns the constraint handler of the given name, or NULL if not existing - SCIPfindCutsel
^{⚠}returns the cut selector of the given name, or NULL if not existing - SCIPfindDisp
^{⚠}returns the display column of the given name, or NULL if not existing - returns the event handler of the given name, or NULL if not existing
- SCIPfindExprhdlr
^{⚠}returns an expression handler of a given name (or NULL if not found) - SCIPfindHeur
^{⚠}returns the primal heuristic of the given name, or NULL if not existing - returns a nonlinear handler of a given name (or NULL if not found)
- SCIPfindNlpi
^{⚠}returns the NLPI of the given name, or NULL if not existing - SCIPfindNodesel
^{⚠}returns the node selector of the given name, or NULL if not existing - SCIPfindOrigCons
^{⚠}returns original constraint of given name in the problem, or NULL if not existing - SCIPfindPresol
^{⚠}returns the presolver of the given name, or NULL if not existing - SCIPfindPricer
^{⚠}returns the variable pricer of the given name, or NULL if not existing - SCIPfindProp
^{⚠}returns the propagator of the given name, or NULL if not existing - SCIPfindReader
^{⚠}returns the reader of the given name, or NULL if not existing - SCIPfindRelax
^{⚠}returns the relaxation handler of the given name, or NULL if not existing - SCIPfindSepa
^{⚠}returns the separator of the given name, or NULL if not existing - given a (usually very small) interval, tries to find a rational number with simple denominator (i.e. a small number, probably multiplied with powers of 10) out of this interval; returns TRUE iff a valid rational number inside the interval was found
- SCIPfindTable
^{⚠}returns the statistics table of the given name, or NULL if not existing - SCIPfindVar
^{⚠}returns variable of given name in the problem, or NULL if not existing - SCIPfixParam
^{⚠}fixes the value of an existing parameter - SCIPfixVar
^{⚠}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 a fixed variable, and bounds are changed respectively; conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders arrays returned from the SCIPvarGetImpl…() methods invalid - injects a change of variable’s bounds into current probing node to fix the variable to the specified value; the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated like deductions instead of branching decisions
- flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
- SCIPfloor
^{⚠}rounds value + epsilon down to the next integer - SCIPflushLP
^{⚠}makes sure that the LP of the current node is flushed - SCIPflushNLP
^{⚠}makes sure that the NLP of the current node is flushed - flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with equal columns into a single coefficient
- SCIPfopen
^{⚠} - SCIPfprintf
^{⚠} - SCIPfputc
^{⚠} - SCIPfputs
^{⚠} - SCIPfrac
^{⚠}returns fractional part of value, i.e. x - floor(x) in epsilon tolerance - SCIPfread
^{⚠} - SCIPfree
^{⚠}frees SCIP data structures - SCIPfreeBandit
^{⚠}calls destructor and frees memory of bandit algorithm - frees the subproblem after calling the solve subproblem method
- frees a dynamic array of bool values
- SCIPfreeClock
^{⚠}frees a clock - SCIPfreeCutpool
^{⚠}frees a cut pool - SCIPfreeDecomp
^{⚠}frees a decomposition - frees the disjoint set (union find) data structure
- frees information on quadratic representation of an expression
- SCIPfreeExpriter
^{⚠}frees an expression iterator - SCIPfreeIntarray
^{⚠}frees a dynamic array of int values - frees memory allocated when parsing a signomial from a string
- SCIPfreeProb
^{⚠}frees problem and solution process data - SCIPfreePtrarray
^{⚠}frees a dynamic array of pointers - SCIPfreeRandom
^{⚠}frees a random number generator - frees a dynamic array of real values
- frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is preserved
- free a set of initialized reoptimization nodes
- SCIPfreeRowprep
^{⚠}frees a SCIP_ROWPREP datastructure - frees arrays created by SCIPisSOCNonlinear()
- SCIPfreeSol
^{⚠}frees primal CIP solution - SCIPfreeSolve
^{⚠}frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is preserved - releases the current synchronization store
- frees all solution process data including presolving and transformed problem, only original problem is kept
- SCIPfseek
^{⚠} - SCIPftell
^{⚠} - SCIPfwrite
^{⚠} - SCIPgenVBoundAdd
^{⚠}adds a generalized variable bound to the genvbounds propagator; if there is already a genvbound for the bound “boundtype” of variable “var”, it will be replaced - generate variable matrix for orbitope constraint handler
- gets absolute violation of nonlinear constraint
- gets activation value of an indicator constraint, TRUE for active on 1, FALSE for active on 0
- return for given variables all their active counterparts; all active variables will be pairwise different @note It does not hold that the first output variable is the active variable for the first input variable.
- gets the activity of the linear constraint in the given solution
- gets and-constraints of pseudoboolean constraint
- gets the average conflict score value over all variables
- gets the average conflict score value over all variables, only using the conflict information of the current run
- gets the average inference score value over all variables
- gets the average conflictlength score value over all variables, only using the conflictlength information of the current run
- gets the average cutoff score value over all variables
- gets the average cutoff score value over all variables, only using the cutoff information of the current run
- returns the average number of cutoffs found after branching in given direction over all variables
- returns the average number of cutoffs found after branching in given direction over all variables, only using the cutoff information of the current run
- gets average dual bound of all unprocessed nodes for original problem
- gets the average inference score value over all variables
- gets the average inference score value over all variables, only using the inference information of the current run
- returns the average number of inferences found after branching in given direction over all variables
- returns the average number of inferences found after branching in given direction over all variables, only using the inference information of the current run
- gets average lower (dual) bound of all unprocessed nodes in transformed problem
- gets the average pseudo cost value for the given direction over all variables
- gets the average number of pseudo cost updates for the given direction over all variables
- gets the average number of pseudo cost updates for the given direction over all variables, only using the pseudo cost information of the current run
- gets the average pseudo cost value for the given direction over all variables, only using the pseudo cost information of the current run
- gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
- gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5, only using the pseudo cost information of the current run
- SCIPgetBenders
^{⚠}returns the array of currently available Benders’ decomposition; active Benders’ decomposition are in the first slots of the array - returns the value of the auxiliary variable for a given subproblem
- returns the master problem variable for the given subproblem variable
- returns the number of subproblems that are stored in the given Benders’ decomposition
- returns the subproblem problem variable for the given master variable
- SCIPgetBestChild
^{⚠}gets the best child of the focus node w.r.t. the node selection strategy - SCIPgetBestLeaf
^{⚠}gets the best leaf from the node queue w.r.t. the node selection strategy - SCIPgetBestNode
^{⚠}gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy - gets the best sibling of the focus node w.r.t. the node selection strategy
- SCIPgetBestSol
^{⚠}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 solution candidate, or NULL if no solution has been found or the candidate store is empty; - gets the node with smallest lower bound from the tree (child, sibling, or leaf)
- returns the index of the bilinear term representing the product of the two given variables
- returns the bilinear term that represents the product of two given variables
- returns all bilinear terms that are contained in all nonlinear constraints
- gets binary variable corresponding to indicator constraint. Returns the negative of the original binary variable if activeone was set to false
- similar to SCIPgetBinaryVarIndicator but returns the original binary variable passed by the user.
- gets binary variable corresponding to the superindicator constraint
- gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
- gets binary variables that are equal to the given binary variables, and which are either active, fixed, or multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
- return all binary variable information of the linking constraint
- returns the binary variables of the linking constraint
- SCIPgetBoolParam
^{⚠}gets the value of an existing SCIP_Bool parameter - returns the maximal index of all stored non-zero elements
- returns the minimal index of all stored non-zero elements
- gets value of entry in dynamic array
- gets array of bounds in bound disjunction constraint
- gets array of bound types in bound disjunction constraint
- calculates the branching score out of the gain predictions for a binary branching
- calculates the branching score out of the gain predictions for a branching with arbitrary many children
- computes a branching point for a continuous or discrete variable
- returns the array of currently available branching rules
- returns the capacity of the cumulative constraint
- gets the capacity of the knapsack constraint
- gets cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)
- SCIPgetCharParam
^{⚠}gets the value of an existing char parameter - SCIPgetChildren
^{⚠}gets children of focus node along with the number of children - SCIPgetCliques
^{⚠}gets the array of cliques in the clique table - SCIPgetClockTime
^{⚠}gets the measured time of a clock in seconds - gets the constant coefficient of a product expression
- gets the coefficients of a summation expression
- returns the Farkas coefficient of a column in the last (infeasible) LP
- returns the reduced costs of a column in the last (feasible) LP
- SCIPgetComprs
^{⚠}returns the array of currently available tree compression - returns the array of included concurrent solver types
- returns the upper confidence bound of a selected action
- returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower bound
- returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global upper bound
- gets conflict graph of SOS1 constraints (or NULL if not existent)
- returns the array of currently available conflict handlers
- SCIPgetConsCopy
^{⚠}returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of the source SCIP to the variables of the target SCIP - returns the linking constraint belonging the given linking variable (continuous or integer) or NULL if it does not exist yet
- SCIPgetConsNVars
^{⚠}method to collect the number of variables of a constraint - SCIPgetConsVals
^{⚠}returns the value array of an arbitrary SCIP constraint that can be represented as a single linear constraint - SCIPgetConsVars
^{⚠}method to collect the variables of a constraint - SCIPgetConshdlrs
^{⚠}returns the array of currently available constraint handlers - SCIPgetConss
^{⚠}gets array of globally valid constraints currently in the problem - gets the constant of a summation expression
- Method to get the sparse solution.
- gets tag indicating current local variable bounds
- gets current node in the tree
- returns the curvature of the expression of a given nonlinear constraint
- returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm
- returns row’s cutoff distance in the direction of the given primal solution
- gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the objective value is always integral, the cutoff bound is (nearly) one less than the upper bound; additionally, due to objective function domain propagation, the cutoff bound can be further reduced
- returns depth of first node in active path that is marked being cutoff
- SCIPgetCuts
^{⚠}gets the array of cuts currently stored in the separation storage - SCIPgetCutsels
^{⚠}returns the array of currently available cut selectors - SCIPgetDecomps
^{⚠}gets available user decompositions for either the original or transformed problem - gets the delayed global cut pool used by SCIP
- gets current cuts in the delayed global cut pool
- returns the demands of the cumulative constraint
- SCIPgetDepth
^{⚠}gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node, such that the depth includes the probing path - gets deterministic time number of LPs solved so far
- SCIPgetDisps
^{⚠}returns the array of currently available display columns - get the dive bound change data for the preferred or the alternative direction
- enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
- stores the candidate score and preferred rounding direction for a candidate variable
- returns dual solution value of a constraint
- SCIPgetDualbound
^{⚠}gets global dual bound - gets dual bound of the root node for the original problem
- gets the dual Farkas value of the knapsack constraint in the current infeasible LP
- gets the dual Farkas value of the linear constraint in the current infeasible LP
- gets the dual Farkas value of the logic or constraint in the current infeasible LP
- gets the dual Farkas value of the set partitioning / packing / covering constraint in the current infeasible LP
- gets the dual Farkas value of the variable bound constraint in the current infeasible LP
- gets the dual solution of the knapsack constraint in the current LP
- gets the dual solution of the linear constraint in the current LP
- gets the dual solution of the logic or constraint in the current LP
- gets the dual solution of the set partitioning / packing / covering constraint in the current LP
- gets the dual solution of the variable bound constraint in the current LP
- returns the durations of the cumulative constraint
- gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node to the unprocessed nodes.
- returns the array of currently available event handlers
- gets the exponent of a power or signed power expression
- computes absolute violation for auxvar relation in an expression w.r.t. auxiliary variables
- computes absolute violation for auxvar relation in an expression w.r.t. original variables
- returns the variable used for linearizing a given expression (return value might be NULL)
- returns bounds on the expression
- returns the data for one of the enforcements of an expression
- number of nonlinear handlers whose separation methods (estimate or enforcement) use auxiliary variable of the expression
- returns the number of enforcements for an expression
- returns the number of negative rounding locks of an expression
- returns the number of positive rounding locks of an expression
- number of nonlinear handlers whose activity computation and propagation methods depend on the activity of the expression
- number of nonlinear handlers whose separation methods (estimate or enforcement) depend on the activity of the expression
- SCIPgetExprNVars
^{⚠}returns the total number of variable expressions in an expression - returns a previously unused solution tag for expression evaluation
- returns the expression of the given nonlinear constraint
- returns the var’s coordinate of Hu partial derivative of an expression w.r.t. a variable (or SCIP_INVALID if there was an evaluation error)
- returns the partial derivative of an expression w.r.t. a variable (or SCIP_INVALID if there was an evaluation error)
- computes relative violation for auxvar relation in an expression w.r.t. auxiliary variables
- returns all variable expressions contained in a given expression
- gives violation-branching score stored in expression, or 0.0 if no valid score has been stored
- returns expression handler for power expressions (or NULL if not included)
- returns expression handler for product expressions (or NULL if not included)
- returns expression handler for sum expressions (or NULL if not included)
- returns expression handler for constant value expressions (or NULL if not included)
- returns expression handler for variable expressions (or NULL if not included)
- SCIPgetExprhdlrs
^{⚠}gives expression handlers - returns an array of expressions that have been detected by the bilinear nonlinear handler
- returns an array of nonlinear handler expressions data of expressions that have been detected by the bilinear nonlinear handler
- gets external branching candidates along with solution values, scores, and number of branching candidates; these branching candidates can be used by relaxations or nonlinear constraint handlers; branching rules should always select the branching candidate among the first nprioexterncands of the candidate list
- returns an array of the descriptions of currently included external codes
- returns an array of names of currently included external codes
- gets the feasibility of the linear constraint in the given solution
- gets dual bound for the original problem obtained by the first LP solve at the root node
- gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
- gets the time need to solve the first LP in the root node
- the primal bound of the very first solution
- SCIPgetFixedVars
^{⚠}gets array with fixed and aggregated problem variables; data may become invalid after calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar() - gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the branching tree, excluding the nodes of the probing path
- SCIPgetFocusNode
^{⚠}gets focus node in the tree - SCIPgetGap
^{⚠}gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign, or infinity, if they have opposite sign - gets the global cut pool used by SCIP
- gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) global bound
- SCIPgetHeurs
^{⚠}returns the array of currently available primal heuristics - returns the right bound of effective horizon
- returns the left bound of the effective horizon
- SCIPgetHugeValue
^{⚠}returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity computation) - gets indicator variable of pseudoboolean constraint, or NULL if there is no
- gives the index stored in a varidx expression
- SCIPgetIntParam
^{⚠}gets the value of an existing int parameter - SCIPgetIntVarXor
^{⚠}gets integer variable in xor constraint - returns the maximal index of all stored non-zero elements
- returns the minimal index of all stored non-zero elements
- gets value of entry in dynamic array
- gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A), i.e., it computes B^-1 * A_c with A_c being the c’th column of A
- gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
- SCIPgetLPBInvCol
^{⚠}gets a column from the inverse basis matrix B^-1 - SCIPgetLPBInvRow
^{⚠}gets a row from the inverse basis matrix B^-1 - gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
- gets branching candidates for LP solution branching (fractional variables) along with solution values, fractionalities, and number of branching candidates; The number of branching candidates does NOT account for fractional implicit integer variables which should not be used for branching decisions.
- SCIPgetLPCols
^{⚠}gets current LP columns - gets current LP columns along with the current number of LP columns
- gets part of objective value of current LP that results from COLUMN variables only
- computes two measures for dual degeneracy (dual degeneracy rate and variable-constraint ratio) based on the changes applied when reducing the problem to the optimal face
- SCIPgetLPFeastol
^{⚠}gets current primal feasibility tolerance of LP - SCIPgetLPI
^{⚠}gets the LP interface of SCIP; with the LPI you can use all of the methods defined in lpi/lpi.h; - gets part of objective value of current LP that results from LOOSE variables only
- SCIPgetLPObjval
^{⚠}gets objective value of current LP (which is the sum of column and loose objective value) - gets part of the objective value of the root node LP that results from COLUMN variables only; returns SCIP_INVALID if the root node LP was not (yet) solved
- gets part of the objective value of the root node LP that results from LOOSE variables only; returns SCIP_INVALID if the root node LP was not (yet) solved
- gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
- SCIPgetLPRows
^{⚠}gets current LP rows - gets current LP rows along with the current number of LP rows
- SCIPgetLPSolstat
^{⚠}gets solution status of current LP - gets the
`curboundstag`

from the last time where variable bounds were relaxed - returns the number of the node in the current branch and bound run, where the last LP was solved in diving or probing mode
- get LP solution status of last strong branching call (currently only works for strong branching with propagation)
- SCIPgetLeaves
^{⚠}gets leaves of the tree along with the number of leaves - SCIPgetLhsLinear
^{⚠}gets left hand side of linear constraint - gets the left hand side of a nonlinear constraint
- get left hand side of pseudoboolean constraint
- gets left hand side of variable bound constraint lhs <= x + c*y <= rhs
- gets linear constraint of pseudoboolean constraint
- gets the linear constraint corresponding to the indicator constraint (may be NULL)
- gets linear constraint of pseudoboolean constraint
- gets type of linear constraint of pseudoboolean constraint
- returns the linking variable (continuous or integer) of the linking constraint
- returns a variable that appears linearly that may be decreased without making any other constraint infeasible
- returns a variable that appears linearly that may be increased without making any other constraint infeasible
- gets dual bound of current node
- gets lower bound of current node in transformed problem
- gets estimate of best primal solution w.r.t. original problem contained in current subtree
- gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
- gets the value of an existing SCIP_Longint parameter
- gets global lower (dual) bound in transformed problem
- gets lower (dual) bound in transformed problem of the root node
- SCIPgetMaxDepth
^{⚠}gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes) - gets maximal depth of all processed nodes over all branch and bound runs
- returns the estimated number of bytes used by external software, e.g., the LP solver
- SCIPgetMemTotal
^{⚠}returns the total number of bytes in block and buffer memory - SCIPgetMemUsed
^{⚠}returns the total number of bytes used in block and buffer memory - returns the currently installed message handler
- returns the number of currently active Benders’ decomposition
- gets total number of active constraints at the current node
- returns the number of currently active variable pricers, that are used in the LP solving loop
- gets number of and constraints of pseudoboolean constraint
- gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
- gets total number of iterations used so far in barrier algorithm
- gets total number of barrier LPs solved so far
- SCIPgetNBenders
^{⚠}returns the number of currently available Benders’ decomposition - gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
- returns the total number of bilinear terms that are contained in all nonlinear constraints
- SCIPgetNBinVars
^{⚠}gets number of binary active problem variables - returns the number of binary variables of the linking constraint
- returns the number of currently available branching rules
- computes the number of check constraint in the current node (loop over all constraint handler and cumulates the number of check constraints)
- SCIPgetNChildren
^{⚠}gets number of children of focus node - SCIPgetNCliques
^{⚠}gets the number of cliques in the clique table - gets the number of cliques created so far by the cliquetable
- SCIPgetNCompr
^{⚠}returns the number of currently available tree compression - returns the number of included concurrent solver types
- get total number of conflict constraints added to the problem
- get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
- get number of conflict constraints found so far at the current node
- get total number of dual proof constraints added to the problem
- returns the number of currently available conflict handlers
- returns the number of currently available constraint handlers
- SCIPgetNConss
^{⚠}gets total number of globally valid constraints currently in the problem - SCIPgetNContVars
^{⚠}gets number of continuous active problem variables - returns number of counted feasible subtrees
- returns number of feasible solutions found as SCIP_Longint; if the number does not fit into a SCIP_Longint the valid flag is set to FALSE
- returns number of counted solutions as string
- SCIPgetNCuts
^{⚠}get current number of cuts in the separation storage - get total number of cuts applied to the LPs
- get total number of cuts found so far; this includes global cuts from the cut pool as often as they are separated
- get number of cuts found so far in current separation round
- SCIPgetNCutsels
^{⚠}returns the number of currently available cut selectors - gets number of times a selected node was from a cut off subtree
- gets current number of rows in the delayed global cut pool
- SCIPgetNDisps
^{⚠}returns the number of currently available display columns - gets total number of simplex iterations used so far during diving and probing
- gets total number of LPs solved so far during diving and probing
- gets total number of iterations used so far in dual simplex
- SCIPgetNDualLPs
^{⚠}gets total number of dual LPs solved so far - gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis was available
- gets total number of dual LPs solved so far that were resolved from an advanced start basis
- gets total number of enabled constraints at the current node
- returns the number of currently available event handlers
- gives number of expression handlers
- returns the total number of expressions that have been detected by the bilinear nonlinear handler
- gets number of external branching candidates
- returns the number of currently included information on external codes
- gets number of leaf nodes processed with feasible relaxation solution
- gets number of fixed or aggregated problem variables
- returns current number of variables fixed to one in the constraint
- returns current number of variables fixed to zero in the constraint
- SCIPgetNHeurs
^{⚠}returns the number of currently available primal heuristics - SCIPgetNImplVars
^{⚠}gets number of implicit integer active problem variables - gets total number of implications between variables that are stored in the implication graph
- gets number of infeasible leaf nodes processed
- SCIPgetNIntVars
^{⚠}gets number of integer active problem variables - gets number of branching candidates for LP solution branching (number of fractional variables)
- SCIPgetNLPCols
^{⚠}gets current number of LP columns - gets fractional variables of last NLP solution along with solution values and fractionalities
- SCIPgetNLPI
^{⚠}gets the NLP interface and problem used by the SCIP NLP - gets total number of iterations used so far in primal and dual simplex and barrier algorithm
- SCIPgetNLPNlRows
^{⚠}gets array with nonlinear rows of the NLP - gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
- SCIPgetNLPObjval
^{⚠}gets objective value of current NLP - SCIPgetNLPRows
^{⚠}gets current number of LP rows - gets solution status of current NLP
- gives statistics (number of iterations, solving time, …) of last NLP solve
- gets termination status of last NLP solve
- SCIPgetNLPVars
^{⚠}gets array with variables of the NLP - gets current NLP variables along with the current number of NLP variables
- returns dual solution values associated with lower bounds of NLP variables
- computes for each variables the number of NLP rows in which the variable appears in the nonlinear part
- returns dual solution values associated with upper bounds of NLP variables
- SCIPgetNLPs
^{⚠}gets total number of LPs solved so far - SCIPgetNLeaves
^{⚠}gets number of leaves in the tree - gets number of feasible primal solutions respecting the objective limit found so far
- gets number of linear variables without artificial terms variables of pseudoboolean constraint
- gets current number of nonlinear rows in NLP
- SCIPgetNNLPVars
^{⚠}gets current number of variables in NLP - SCIPgetNNZs
^{⚠}gets number of active non-zeros in the current transformed problem - get number of nonlinear handler
- SCIPgetNNlpis
^{⚠}returns the number of currently available NLPIs - gets total number of simplex iterations used so far for initial LP in node relaxations
- gets total number of LPs solved so far for initial LP in node relaxations
- gets total number of simplex iterations used so far for node relaxations
- SCIPgetNNodeLPs
^{⚠}gets total number of LPs solved so far for node relaxations - gets total number of LPs solved in 0 iterations for node relaxations
- SCIPgetNNodes
^{⚠}gets number of processed nodes in current run, including the focus node - gets number of nodes left in the tree (children + siblings + leaves)
- SCIPgetNNodesels
^{⚠}returns the number of currently available node selectors - SCIPgetNObjVars
^{⚠}gets number of active problem variables with a non-zero objective coefficient - gets number of processed leaf nodes that hit LP objective limit
- gets number of binary variables in the original problem
- gets total number of constraints in the original problem
- gets number of continuous variables in the original problem
- gets number of implicit integer variables in the original problem
- gets the number of integer variables in the original problem
- SCIPgetNOrigVars
^{⚠}gets number of original problem variables - SCIPgetNParams
^{⚠}returns the total number of all available SCIP parameters - returns number of partial solutions
- SCIPgetNPoolCuts
^{⚠}gets current number of rows in the global cut pool - returns the number of presolve rounds (current or last presolve)
- SCIPgetNPresols
^{⚠}returns the number of currently available presolvers - gets number of pricing rounds performed so far at the current node
- SCIPgetNPricers
^{⚠}returns the number of currently available variable pricers - get current number of variables in the pricing store
- get total number of pricing variables applied to the LPs
- get total number of pricing variables found so far
- gets total number of iterations used so far in primal simplex
- gets total number of primal LPs solved so far
- gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis was available
- gets total number of primal LPs solved so far that were resolved from an advanced start basis
- gets number of binary external branching candidates with maximal branch priority
- gets number of external branching candidates with maximal branch priority
- gets number of continuous external branching candidates with maximal branch priority
- gets number of implicit integer external branching candidates with maximal branch priority
- gets number of integer external branching candidates with maximal branch priority
- gets number of branching candidates with maximal priority for LP solution branching
- gets number of binary branching candidates with maximal branch priority for pseudo solution branching
- gets number of branching candidates with maximal branch priority for pseudo solution branching
- gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
- gets number of integer branching candidates with maximal branch priority for pseudo solution branching
- SCIPgetNProps
^{⚠}returns the number of currently available propagators - gets number of branching candidates for pseudo solution branching (non-fixed variables)
- SCIPgetNReaders
^{⚠}returns the number of currently available readers - SCIPgetNRelaxs
^{⚠}returns the number of currently available relaxation handlers - returns the number of leave nodes of the subtree induced by @p node; if @p node == NULL, the method returns the number of leaf nodes of the whole reoptimization tree.
- gets number of reoptimization runs performed, including the current run
- returns the number of nodes in the reoptimization tree induced by @p node; if @p node == NULL, the method returns the number of nodes of the whole reoptimization tree.
- gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis was available
- gets total number of LPs solved so far that were resolved from an advanced start basis
- gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root node
- gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
- gets total number of simplex iterations used so far in strong branching at the root node
- gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
- gets number of global bound changes
- gets number of global bound changes applied in the current run
- SCIPgetNRuns
^{⚠}gets number of branch and bound runs performed, including the current run - SCIPgetNSOS1Vars
^{⚠}gets number of problem variables that are part of the SOS1 conflict graph - gets number of separation rounds performed so far at the current node
- SCIPgetNSepas
^{⚠}returns the number of currently available separators - SCIPgetNSiblings
^{⚠}gets number of siblings of focus node - SCIPgetNSols
^{⚠}gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate storage is returned - gets number of feasible primal solutions found so far
- gets total number of simplex iterations used so far in strong branching
- gets total number of times, strong branching was called (each call represents solving two LPs)
- SCIPgetNTables
^{⚠}returns the number of currently available statistics tables - gets total number of processed nodes in all runs, including the focus node
- gets number of all problem variables created during creation and solving of problem; this includes also variables that were deleted in the meantime
- gets current number of unfixed LP columns
- gets number of upgraded constraints
- SCIPgetNVars
^{⚠}gets number of active problem variables - SCIPgetNVarsAnd
^{⚠}gets number of variables in and constraint - gets number of variables in bound disjunction constraint
- gets number of variables in cardinality constraint
- returns the number of start time variables of the cumulative constraint
- gets the number of items in the knapsack constraint
- gets the number of variables in the linear constraint
- gets number of variables in logic or constraint
- SCIPgetNVarsOr
^{⚠}gets number of variables in or constraint - SCIPgetNVarsSOS1
^{⚠}gets number of variables in SOS1 constraint - SCIPgetNVarsSOS2
^{⚠}gets number of variables in SOS2 constraint - gets number of variables in set partitioning / packing / covering constraint
- SCIPgetNVarsXor
^{⚠}gets number of variables in xor constraint - gets negated variable x’ = lb + ub - x of variable x; negated variable is created, if not yet existing
- gets negated variables x’ = lb + ub - x of variables x; negated variables are created, if not yet existing; in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
- gives the activity of a nonlinear row in the last NLP or pseudo solution
- gives the minimal and maximal activity of a nonlinear row w.r.t. the variable’s bounds
- gives the feasibility of a nonlinear row in the last NLP or pseudo solution
- returns the activity of a nonlinear row in the last NLP solution
- gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
- gets the nonlinear constraint as a nonlinear row representation.
- gives the activity of a nonlinear row for the current pseudo solution
- gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
- gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
- gives the feasibility of a nonlinear row for the given primal solution
- gives expression data that a given nonlinear handler stored in an expression
- get nonlinear handlers
- gives a pointer to the NLPIORACLE object stored in Ipopt-NLPI’s NLPI problem data structure
- SCIPgetNlpis
^{⚠}returns the array of currently available NLPIs (sorted by priority) - gets dual bound of given node
- gets lower bound of given node in transformed problem
- SCIPgetNodesel
^{⚠}returns the currently used node selector - SCIPgetNodesels
^{⚠}returns the array of currently available node selectors - SCIPgetObjNorm
^{⚠}returns the Euclidean norm of the objective function vector (available only for transformed problem) - SCIPgetObjlimit
^{⚠}returns current limit on objective function - SCIPgetObjsense
^{⚠}returns objective sense of original problem - access to all data of open nodes (leaves, children, and siblings)
- SCIPgetOrigConss
^{⚠}gets array of constraints in the original problem - returns the objective offset of the original problem
- returns the objective scale of the original problem
- SCIPgetOrigVars
^{⚠}gets array with original problem variables; data may become invalid after a call to SCIPchgVarType() - gets variables of the original problem along with the numbers of different variable types; data may become invalid after a call to SCIPchgVarType()
- SCIPgetParam
^{⚠}returns the pointer to the SCIP parameter with the given name - SCIPgetParams
^{⚠}returns the array of all available SCIP parameters - returns all partial solutions
- gets current plunging depth (successive times, a child was selected as next node)
- SCIPgetPoolCuts
^{⚠}gets current cuts in the global cut pool - SCIPgetPresols
^{⚠}returns the array of currently available presolvers - gets the current presolving time in seconds
- SCIPgetPricers
^{⚠}returns the array of currently available variable pricers; active pricers are in the first slots of the array - gets value of given variable in primal ray causing unboundedness of the LP relaxation; should only be called if such a ray is stored (check with SCIPhasPrimalRay())
- gets global primal bound (objective value of best solution or user objective limit) for the original problem
- SCIPgetPrioChild
^{⚠}gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule - gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
- SCIPgetProbData
^{⚠}gets user problem data - SCIPgetProbName
^{⚠}returns name of the current problem instance - returns probability to play an action
- returns the current probing depth
- Transforms a given linear sum of variables, that is a_1
*x_1 + … + a_n*x_n + c into a corresponding linear sum of active variables, that is b_1*y_1 + … + b_m*y_m + d. - transforms given variable, scalar and constant to the corresponding active, fixed, or multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable, “scalar” will be 0.0 and the value of the sum will be stored in “constant”; a multi-aggregation with only one active variable (this can happen due to fixings after the multi-aggregation), is treated like an aggregation; if the multi-aggregation constant is infinite, “scalar” will be 0.0
- SCIPgetProps
^{⚠}returns the array of currently available propagators - gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
- 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
- gets the number of pseudo cost updates for the given direction over all variables
- returns the variance of pseudo costs for all variables in the requested direction
- returns the maximal index of all stored non-zero elements
- returns the minimal index of all stored non-zero elements
- gets value of entry in dynamic array
- SCIPgetRandomInt
^{⚠}returns a random integer between minrandval and maxrandval - returns a random real between minrandval and maxrandval
- draws a random subset of disjoint elements from a given set of disjoint elements; this implementation is suited for the case that nsubelems is considerably smaller then nelems
- SCIPgetReaders
^{⚠}returns the array of currently available readers - gets the current reading time in seconds
- SCIPgetRealParam
^{⚠}gets the value of an existing SCIP_Real parameter - returns the maximal index of all stored non-zero elements
- returns the minimal index of all stored non-zero elements
- gets value of entry in dynamic array
- gets scaled violation of nonlinear constraint
- gets the relaxation solution objective value
- gets the relaxation solution value of the given variable
- SCIPgetRelaxs
^{⚠}returns the array of currently available relaxation handlers - return the ids of child nodes stored in the reoptimization tree
- returns the optimal solution of the last iteration or NULL of none exists
- return the ids of all leave nodes store in the reoptimization tree induced by the given node
- returns the objective coefficent of a given variable in a previous iteration
- return the similarity between two objective functions
- returns the stored solutions corresponding to a given run
- SCIPgetReoptnode
^{⚠}gets the node of the reoptimization tree corresponding to the unique @p id - return the branching path stored in the reoptree at ID id
- returns depth of first node in active path that has to be propagated again
- gets the resultant variable in and constraint
- gets the resultant variable in or constraint
- SCIPgetRhsLinear
^{⚠}gets right hand side of linear constraint - gets the right hand side of a nonlinear constraint
- get right hand side of pseudoboolean constraint
- gets right hand side of variable bound constraint lhs <= x + c*y <= rhs
- SCIPgetRhsXor
^{⚠}gets the right hand side of the xor constraint - returns the root dialog of SCIP’s interactive user shell
- SCIPgetRootNode
^{⚠}gets the root node of the tree - returns the activity of a row in the last LP or pseudo solution
- returns the feasibility of a row in the last LP or pseudo solution
- returns the linear relaxation of the given knapsack constraint; may return NULL if no LP row was yet created; the user must not modify the row!
- returns the activity of a row in the last LP solution
- returns the feasibility of a row in the last LP solution
- SCIPgetRowLinear
^{⚠}returns the linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row! - returns the linear relaxation of the given logic or constraint; may return NULL if no LP row was yet created; the user must not modify the row!
- returns the maximal activity of a row w.r.t. the column’s bounds
- returns maximal absolute value of row vector’s non-zero coefficients
- returns the minimal activity of a row w.r.t. the column’s bounds
- returns minimal absolute value of row vector’s non-zero coefficients
- returns number of integral columns in the row
- returns the parallelism of row with objective function
- returns the activity of a row for the current pseudo solution
- returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
- SCIPgetRowSetppc
^{⚠}returns the linear relaxation of the given set partitioning / packing / covering constraint; may return NULL if no LP row was yet created; the user must not modify the row! - returns the activity of a row for the given primal solution
- returns the feasibility of a row for the given primal solution
- returns the linear relaxation of the given variable bound constraint; may return NULL if no LP row was yet created; the user must not modify the row!
- generates a SCIP_ROW from a rowprep, setting its origin to given constraint
- generates a SCIP_ROW from a rowprep, setting its origin to given constraint handler
- generates a SCIP_ROW from a rowprep, setting its origin to given separator
- computes violation of rowprep in a given solution
- gets value of minimal efficacy for a cut to enter the LP
- SCIPgetSepas
^{⚠}returns the array of currently available separators - SCIPgetSiblings
^{⚠}gets siblings of focus node along with the number of siblings - gets the slack constraint corresponding to the superindicator constraint
- gets slack variable corresponding to indicator constraint
- SCIPgetSolHeur
^{⚠}gets heuristic, that found this solution (or NULL if it’s from the tree) - gets node number of the specific branch and bound run, where this solution was found
- returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
- SCIPgetSolRunnum
^{⚠}gets branch and bound run number, where this solution was found - SCIPgetSolTime
^{⚠}gets clock time, when this solution was found - returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
- SCIPgetSolVal
^{⚠}returns value of variable in primal CIP solution, or in current LP/pseudo solution - SCIPgetSolVals
^{⚠}gets values of multiple variables in primal CIP solution - gets variables of the original or transformed problem along with the numbers of different variable types; the returned problem space (original or transformed) corresponds to the given solution; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
- SCIPgetSols
^{⚠}gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored - gets string that describes filterSQP
- gets string that describes Ipopt
- gets string that describes Worhp (version number)
- gets string that identifies filterSQP
- gets string that identifies Ipopt (version number)
- gets string that identifies Worhp (version number)
- gets the current solving time in seconds
- SCIPgetStage
^{⚠}returns current stage of SCIP - gets startpoint candidate to be used in next call to NLP heuristic, or NULL if none
- return start permutation of the UCB bandit algorithm
- SCIPgetStatus
^{⚠}gets solution status - gets the value of an existing string(char*) parameter
- gets depth of current scip instance (increased by each copy call)
- returns whether plugins with sub-SCIPs that could cause recursion have been disabled
- SCIPgetSymmetry
^{⚠}return currently available symmetry group information - return number of the symmetry group’s generators
- SCIPgetSyncstore
^{⚠}Gets the synchronization store. - SCIPgetTables
^{⚠}returns the array of currently available statistics tables - SCIPgetTimeOfDay
^{⚠}gets current time of day in seconds (standard time zone) - SCIPgetTotalTime
^{⚠}gets the current total SCIP time in seconds, possibly accumulated over several problems. - SCIPgetTransGap
^{⚠}gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds have same sign, or infinity, if they have opposite sign - returns the objective offset of the transformed problem
- returns the objective scale of the transformed problem
- gets corresponding transformed constraint of a given constraint; returns NULL as transcons, if transformed constraint is not yet existing
- gets corresponding transformed constraints for an array of constraints; stores NULL in a transconss slot, if the transformed constraint is not yet existing; it is possible to call this method with conss == transconss, but remember that constraints that are not yet transformed will be replaced with NULL
- gets corresponding transformed variable of a given variable; returns NULL as transvar, if transformed variable is not yet existing
- gets corresponding transformed variables for an array of variables; stores NULL in a transvars slot, if the transformed variable is not yet existing; it is possible to call this method with vars == transvars, but remember that variables that are not yet transformed will be replaced with NULL
- gets type of set partitioning / packing / covering constraint
- gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
- gets the array of coefficient values in the linear constraint; the user must not modify this array!
- returns the coefficients of the binary variables
- gets the value of a constant value expression
- recovers candidate variables and their scores from last vanilla full strong branching call
- returns the variable’s average conflict length
- returns the variable’s average conflict length only using conflicts of the current run
- returns the variable’s average cutoff score value
- returns the variable’s average cutoff score value, only using cutoffs of the current run
- returns the average number of cutoffs found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned
- returns the average number of cutoffs found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned
- returns the variable’s average inference/cutoff score value, weighting the cutoffs of the variable with the given factor
- returns the variable’s average inference/cutoff score value, weighting the cutoffs of the variable with the given factor, only using inferences and cutoffs of the current run
- returns the variable’s average inference score value
- returns the variable’s average inference score value only using inferences of the current run
- returns the average number of inferences found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned
- returns the average number of inferences found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned
- returns lower or upper bound of variable directly before or after the bound change given by the bound change index was applied
- returns solution value and index of variable lower bound that is closest to the variable’s value in the given primal solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is available
- returns solution value and index of variable upper bound that is closest to the variable’s value in the given primal solution; or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
- check the changes of the variable coefficient in the objective function
- returns the variable’s conflict score value
- returns the variable’s conflict score value only using conflicts of the current run
- returns the variable’s conflict length score
- returns the variable’s conflict length score only using conflicts of the current run
- SCIPgetVarCopy
^{⚠}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 variable; otherwise, if the variables it not marked as relaxation-only, a new variable will be created and added to the target SCIP; this created variable is added to the variable hash map and returned as target variable; relaxation-only variables are not copied and FALSE is returned in *success - returns the hashmap that is internally used to map variables to their corresponding variable expressions
- gets the variable of a variable expression
- returns the Farkas coefficient of the variable in the current node’s LP relaxation; the current node has to have an infeasible LP.
- returns the implied reduced costs of the variable in the current node’s LP relaxation; the current node has to have a feasible LP.
- returns lower bound of variable directly before or after the bound change given by the bound change index was applied
- SCIPgetVarLbDive
^{⚠}gets variable’s lower bound in current dive - for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing
- for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing
- for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing
- for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
- gets number of times, strong branching was applied in current run on the given variable
- gets variable’s objective value in current dive
- gets variable’s objective value in current probing
- gets the variable’s pseudo cost value for the given direction
- gets the variable’s (possible fractional) number of pseudo cost updates for the given direction
- gets the variable’s (possible fractional) number of pseudo cost updates for the given direction, only using the pseudo cost information of the current run
- gets the variable’s pseudo cost value for the given direction, only using the pseudo cost information of the current run
- gets the variable’s pseudo cost score value for the given LP solution value
- gets the variable’s pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run
- gets the variable’s pseudo cost value for the given change of the variable’s LP value
- gets the variable’s pseudo cost value for the given change of the variable’s LP value, only using the pseudo cost information of the current run
- get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
- returns the reduced costs of the variable in the current node’s LP relaxation; the current node has to have a feasible LP.
- SCIPgetVarSol
^{⚠}gets solution value for variable in current node - SCIPgetVarSols
^{⚠}gets solution values of multiple variables in current node - gets strong branching information on column variable with fractional value
- gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch is (val -1.0) and the up brach ins (val +1.0)
- if strong branching was already applied on the variable at the current node, returns the number of LPs solved after the LP where the strong branching on this variable was applied; if strong branching was not yet applied on the variable at the current node, returns INT_MAX
- gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call; returns values of SCIP_INVALID, if strong branching was not yet called on the given variable; keep in mind, that the returned old values may have nothing to do with the current LP solution
- gets node number of the last node in current branch and bound run, where strong branching was used on the given variable, or -1 if strong branching was never applied to the variable in current run
- gets strong branching information with previous domain propagation on column variable
- returns upper bound of variable directly before or after the bound change given by the bound change index was applied
- SCIPgetVarUbDive
^{⚠}gets variable’s upper bound in current dive - SCIPgetVarVSIDS
^{⚠}returns the variable’s VSIDS value - returns the variable’s VSIDS value only using conflicts of the current run
- gets bounded variable x of variable bound constraint lhs <= x + c*y <= rhs
- returns whether the binary variable was fixed at the time given by the bound change index
- SCIPgetVars
^{⚠}gets array with active problem variables - SCIPgetVarsAnd
^{⚠}gets array of variables in and constraint - gets array of variables in bound disjunction constraint
- gets array of variables in cardinality constraint
- returns the start time variables of the cumulative constraint
- SCIPgetVarsData
^{⚠}gets variables of the problem along with the numbers of different variable types; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar() - gets the array of variables in the knapsack constraint; the user must not modify this array!
- gets the array of variables in the linear constraint; the user must not modify this array!
- gets array of variables in logic or constraint
- SCIPgetVarsOr
^{⚠}gets array of variables in or constraint - SCIPgetVarsSOS1
^{⚠}gets array of variables in SOS1 constraint - SCIPgetVarsSOS2
^{⚠}gets array of variables in SOS2 constraint - gets array of variables in set partitioning / packing / covering constraint
- gets strong branching information on column variables with fractional values
- gets strong branching information on column variables with integral values
- SCIPgetVarsXor
^{⚠}gets array of variables in xor constraint - gets bound coefficient c of variable bound constraint lhs <= x + c*y <= rhs
- gets bounding variable y of variable bound constraint lhs <= x + c*y <= rhs
- calculates the efficacy norm of the given vector, which depends on the “separating/efficacynorm” parameter
- SCIPgetVerbLevel
^{⚠}returns the current message verbosity level - gets array of weights in cardinality constraint (or NULL if not existent)
- get weights array of epsilon greedy bandit algorithm
- gets the array of weights in the knapsack constraint; the user must not modify this array!
- gets array of weights in SOS1 constraint (or NULL if not existent)
- gets array of weights in SOS2 constraint (or NULL if not existent)
- SCIPgmlWriteArc
^{⚠}writes an arc section to the given graph file - writes the ending lines to a GML graph file, does not close a file
- SCIPgmlWriteEdge
^{⚠}writes an edge section to the given graph file - SCIPgmlWriteNode
^{⚠}writes a node section to the given graph file - writes a node section including weight to the given graph file
- writes the starting line to a GML graph file, does not open a file
- returns TRUE if the constraint \p cons contains only linking variables in decomposition \p decomp
- returns, whether the LP was or is to be solved in the current node
- checks whether a given expression is convex or concave w.r.t. the original variables
- checks whether the NLP has a continuous variable in a nonlinear term
- indicates whether a solution for the current NLP is available
- returns whether SCIP has performed presolving during the last solve
- SCIPhasPrimalRay
^{⚠}return whether a primal ray is stored that proves unboundedness of the LP relaxation - SCIPhashExpr
^{⚠}compute the hash value of an expression - SCIPhashKeyEqPtr
^{⚠} - creates a hash map mapping pointers to pointers
- gives the image of the hashmap entry
- gives the image of the hashmap entry
- gives the image of the hashmap entry
- gives the origin of the hashmap entry
- sets pointer image of a hashmap entry
- sets integer image of a hashmap entry
- sets real image of a hashmap entry
- checks whether an image to the given origin exists in the hash map
- SCIPhashmapFree
^{⚠}frees the hash map - gives the hashmap entry at the given index or NULL if entry has no element
- retrieves image of given origin from the hash map, or NULL if no image exists
- retrieves image of given origin from the hash map, or INT_MAX if no image exists
- retrieves image of given origin from the hash map, or SCIP_INVALID if no image exists
- gives the number of elements in a hash map
- gives the number of entries in the internal arrays of a hash map
- inserts new origin->image pair in hash map (must not be called for already existing origins!)
- inserts new origin->image pair in hash map (must not be called for already existing origins!)
- inserts new origin->image pair in hash map (must not be called for already existing origins!)
- indicates whether a hash map has no entries
- prints statistics about hash map usage
- removes origin->image pair from the hash map, if it exists
- removes all entries in a hash map.
- sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair
- sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair
- sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair
- creates a hash set of pointers
- checks whether an element exists in the hash set
- SCIPhashsetFree
^{⚠}frees the hash set - gives the number of elements in a hash set
- gives the number of slots of a hash set
- gives the array of hash set slots; contains all elements in indetermined order and may contain NULL values
- inserts new element into the hash set
- indicates whether a hash set has no entries
- prints statistics about hash set usage
- removes an element from the hash set, if it exists
- removes all entries in a hash set.
- removes all elements of the hash table
- creates a hash table
- returns whether the given element exists in the table
- frees the hash table
- gives the element at the given index or NULL if entry at that index has no element
- returns the load of the given hash table in percentage
- returns number of hash table elements
- gives the number of entries in the internal arrays of a hash table
- inserts element in hash table (multiple inserts of same element override the previous entry)
- prints statistics about hash table usage
- removes element from the hash table, if it exists
- removes all elements of the hash table
- retrieve element with key from hash table, returns NULL if not existing
- inserts element in hash table (multiple insertion of same element is checked and results in an error)
- returns whether there is a clique that contains both given variable/value pairs; the variables must be active binary variables; if regardimplics is FALSE, only the cliques in the clique table are looked at; if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
- SCIPheurComp
^{⚠} - SCIPheurCompName
^{⚠} - SCIPheurGetData
^{⚠}gets user data of primal heuristic - SCIPheurGetDesc
^{⚠}gets description of primal heuristic - gets display character of primal heuristic
- returns array of divesets of this primal heuristic, or NULL if it has no divesets
- SCIPheurGetFreq
^{⚠}gets frequency of primal heuristic - gets frequency offset of primal heuristic
- gets maximal depth level for calling primal heuristic (returns -1, if no depth limit exists)
- gets the number of new best primal feasible solutions found by this heuristic
- gets the number of times, the heuristic was called and tried to find a solution
- returns the number of divesets of this primal heuristic
- gets the number of primal feasible solutions found by this heuristic
- SCIPheurGetName
^{⚠}gets name of primal heuristic - gets priority of primal heuristic
- gets time in seconds used in this heuristic for setting up for next stages
- SCIPheurGetTime
^{⚠}gets time in seconds used in this heuristic - returns the timing mask of the heuristic
- is primal heuristic initialized?
- pass partial solution for indicator variables to heuristic
- pass solution to trysol heuristic which just gets added (without checking feasibility
- pass solution to trysol heuristic
- SCIPheurSetData
^{⚠}sets user data of primal heuristic; user has to free old data in advance! - SCIPheurSetFreq
^{⚠}sets frequency of primal heuristic - sets new timing mask for heuristic
- does the heuristic use a secondary SCIP instance?
- gets the average conflict length of the history entry
- get number of cutoffs counter
- get number of inferences counter
- gets the conflict score of the history entry
- returns left bound of open interval in hole
- returns next hole in list or NULL
- returns right bound of open interval in hole
- SCIPinDive
^{⚠}returns whether we are in diving mode - SCIPinProbing
^{⚠}returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped via SCIPendProbing() - returns whether the current node is already solved and only propagated again
- SCIPincConsAge
^{⚠}increases age of constraint by 1.0; should be called - increases value of entry in dynamic array
- increases value of entry in dynamic array
- SCIPincSolVal
^{⚠}increases value of variable in primal CIP solution - includes a bandit algorithm virtual function table
- creates a Benders’ decomposition and includes it in SCIP
- creates a Benders’ decomposition and includes it in SCIP with all non-fundamental callbacks set to NULL
- creates the default Benders’ decomposition and includes it in SCIP
- creates a Benders’ cut algorithms and includes it in the associated Benders’ decomposition
- creates a Benders’ cut and includes it an associated Benders’ decomposition with all non-fundamental callbacks set to NULL
- creates a branching rule and includes it in SCIP
- creates the all variables full strong LP branching rule and includes it in SCIP
- creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(), SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(), SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
- creates the cloud branching rule and includes it in SCIP
- creates the distribution branching rule and includes it in SCIP
- creates the full strong LP branching rule and includes it in SCIP
- creates the inference history branching rule and includes it in SCIP
- creates the least infeasible LP branching rule and includes it in SCIP
- creates the lookahead branching rule and includes it in SCIP
- creates the most infeasible LP branching rule and includes it in SCIP
- creates the multi-aggregated branching rule and includes it in SCIP
- creates the nodereopt branching rule and includes it in SCIP
- creates the pseudo cost branching rule and includes it in SCIP
- creates the random branching rule and includes it in SCIP
- creates the reliable pseudo cost branching rule and includes it in SCIP
- creates the vanilla full strong branching rule and includes it in SCIP
- SCIPincludeCompr
^{⚠}@addtogroup PublicCompressionMethods - creates a tree compression and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e. g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(), SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
- creates the largestrepr tree compression and includes it in SCIP
- creates the weakcompr tree compression and includes it in SCIP
- creates a concurrent solver type and includes it in SCIP.
- creates the concurrent SCIP solver plugins and includes them in SCIP
- creates a conflict handler and includes it in SCIP
- creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(), SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(), and SCIPsetConflicthdlrExitsol()
- includes a nonlinear constraint upgrade method into the nonlinear constraint handler
- creates a constraint handler and includes it in SCIP.
- creates the handler for and constraints and includes it in SCIP
- creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(), SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(), SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(), SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(), SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(), SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and SCIPsetConshdlrGetDiveBdChgs().
- creates the handler for Benders’ decomposition and includes it in SCIP
- creates the handler for benderslp constraints and includes it in SCIP
- creates the handler for bound disjunction constraints and includes it in SCIP
- creates the handler for cardinality constraints and includes it in SCIP
- creates the components constraint handler and includes it in SCIP
- creates the handler for conjunction constraints and includes it in SCIP
- creates the handler for countsol constraints and includes it in SCIP
- creates the constraint handler for cumulative constraints and includes it in SCIP
- creates the handler for disjunction constraints and includes it in SCIP
- creates the handler for indicator constraints and includes it in SCIP
- creates the handler for the integrality constraint and includes it in SCIP
- creates the handler for knapsack constraints and includes it in SCIP
- creates the handler for linear constraints and includes it in SCIP
- creates the handler for linking constraints and includes it in SCIP
- creates the handler for logic or constraints and includes it in SCIP
- creates the handler for nonlinear constraints and includes it in SCIP
- creates the handler for or constraints and includes it in SCIP
- creates the handler for orbisack constraints and includes it in SCIP
- creates the handler for orbitope constraints and includes it in SCIP
- creates the handler for pseudoboolean constraints and includes it in SCIP
- creates the handler for SOS1 constraints and includes it in SCIP
- creates the handler for SOS2 constraints and includes it in SCIP
- creates the handler for set partitioning / packing / covering constraints and includes it in SCIP
- creates the handler for superindicator constraints and includes it in SCIP
- creates the handler for symresack constraints and includes it in SCIP
- creates the handler for variable bound constraints and includes it in SCIP
- creates the handler for xor constraints and includes it in SCIP
- creates a cut selector and includes it in SCIP
- Creates a cut selector and includes it in SCIP with its most fundamental callbacks.
- creates the hybrid separator and includes it in SCIP
- includes default SCIP plugins into SCIP
- creates and includes dialog
- includes or updates the default dialog menus in SCIP except for menus “fix” and “set”
- includes or updates the “fix” menu for each available parameter setting
- includes or updates the “set” menu for each available parameter setting
- SCIPincludeDisp
^{⚠}creates a display column and includes it in SCIP - includes the default display columns in SCIP
- creates event handler for tree size estimation
- includes event handler for soft time limit
- creates event handler for solving phase event
- creates an event handler and includes it in SCIP
- creates an event handler and includes it in SCIP with all its non-fundamental callbacks set to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(), SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
- creates the handler for an expression handler and includes it into SCIP
- creates the handler for absolute expression and includes it into SCIP
- creates the handler for cos expressions and includes it into SCIP
- creates the handler for entropy expressions and includes it into SCIP
- creates the handler for exponential expressions and includes it into SCIP
- creates the handler for logarithmic expression and includes it into SCIP
- creates the handler for power expression and includes it into SCIP
- creates the handler for product expressions and includes it into SCIP
- creates the handler for signed power expression and includes it into SCIP
- creates the handler for sin expressions and includes it into SCIP
- creates the handler for sum expressions and includes it into SCIP
- creates the handler for constant value expression and includes it into SCIP
- creates the handler for variable expression and includes it into SCIP
- creates the handler for variable index expressions and includes it into SCIP
- includes information about an external code linked into the SCIP library
- SCIPincludeHeur
^{⚠}creates a primal heuristic and includes it in SCIP. - creates the actconsdiving heuristic and includes it in SCIP
- creates the adaptivediving heuristic and includes it in SCIP
- creates the alns primal heuristic and includes it in SCIP
- creates a primal heuristic and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e. g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(), SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
- creates the bound primal heuristic and includes it in SCIP
- creates the clique primal heuristic and includes it in SCIP
- creates the coefdiving heuristic and includes it in SCIP
- creates the completesol primal heuristic and includes it in SCIP
- creates the conflictdiving heuristic and includes it in SCIP
- creates the crossover primal heuristic and includes it in SCIP
- creates the DINS primal heuristic and includes it in SCIP
- creates the distributiondiving heuristic and includes it in SCIP
- creates the dps primal heuristic and includes it in SCIP
- creates the dualVal primal heuristic and includes it in SCIP
- creates the farkasdiving heuristic and includes it in SCIP
- creates the feaspump primal heuristic and includes it in SCIP
- creates the fix-and-infer primal heuristic and includes it in SCIP
- creates the fracdiving heuristic and includes it in SCIP
- creates the gins primal heuristic and includes it in SCIP
- creates the guideddiving heuristic and includes it in SCIP
- creates the indicator primal heuristic and includes it in SCIP
- creates the intdiving heuristic and includes it in SCIP
- creates the intshifting heuristic and includes it in SCIP
- creates the linesearchdiving primal heuristic and includes it in SCIP
- creates local branching primal heuristic and includes it in SCIP
- creates the locks primal heuristic and includes it in SCIP
- creates the lpface primal heuristic and includes it in SCIP
- creates the mpec primal heuristic and includes it in SCIP
- creates the multistart primal heuristic and includes it in SCIP
- creates the mutation primal heuristic and includes it in SCIP
- creates the fracdiving heuristic and includes it in SCIP
- creates the objpscostdiving heuristic and includes it in SCIP
- creates the octane primal heuristic and includes it in SCIP
- creates the ofins primal heuristic and includes it in SCIP
- creates the oneopt primal heuristic and includes it in SCIP
- creates the PADM primal heuristic and includes it in SCIP
- creates the proximity primal heuristic and includes it in SCIP
- creates the pscostdiving heuristic and includes it in SCIP
- creates the rand rounding heuristic and includes it in SCIP
- creates RENS primal heuristic and includes it in SCIP
- creates the reoptsols primal heuristic and includes it in SCIP
- creates the repair primal heuristic and includes it in SCIP
- creates RINS primal heuristic and includes it in SCIP
- creates the rootsoldiving heuristic and includes it in SCIP
- creates the rounding heuristic with infeasibility recovering and includes it in SCIP
- creates the shiftandpropagate primal heuristic and includes it in SCIP
- creates the shifting heuristic and includes it in SCIP
- creates the simple rounding heuristic and includes it in SCIP
- creates the NLP local search primal heuristic and includes it in SCIP
- creates the trivial primal heuristic and includes it in SCIP
- creates the trivialnegation primal heuristic and includes it in SCIP
- creates local branching primal heuristic and includes it in SCIP
- creates the trysol primal heuristic and includes it in SCIP
- creates the twoopt primal heuristic and includes it in SCIP
- creates the undercover primal heuristic and includes it in SCIP
- creates the variable bounds primal heuristic and includes it in SCIP
- creates the veclendiving heuristic and includes it in SCIP
- creates the zeroobj primal heuristic and includes it in SCIP
- creates the zirounding primal heuristic and includes it in SCIP
- includes a linear constraint update method into the linear constraint handler
- includes bilinear nonlinear handler in nonlinear constraint handler
- includes concave nonlinear handler in nonlinear constraint handler
- includes convex nonlinear handler in nonlinear constraint handler
- includes default nonlinear handler in nonlinear constraint handler
- creates a nonlinear handler and includes it into the nonlinear constraint handler
- includes perspective nonlinear handler in nonlinear constraint handler
- includes quadratic nonlinear handler in nonlinear constraint handler
- includes quotient nonlinear handler in nonlinear constraint handler
- includes SOC nonlinear handler in nonlinear constraint handler
- create solver interface for the solver “All” and includes it into SCIP, if at least 2 NLPIs have already been included
- create solver interface for filterSQP solver and include it into SCIP, if filterSQP is available
- create solver interface for Ipopt solver and includes it into SCIP, if Ipopt is available
- create solver interface for Worhp solver and includes it into SCIP, if Worhp is available
- SCIPincludeNlpi
^{⚠}creates an NLPI and includes it into SCIP - creates a node selector and includes it in SCIP.
- Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(), SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
- creates the node selector for best first search and includes it in SCIP
- creates the node selector for breadth first search and includes it in SCIP
- creates the node selector for depth first search and includes it in SCIP
- creates the node selector for best estimate search and includes it in SCIP
- creates the node selector for hybrid best estim / best bound search and includes it in SCIP
- creates the node selector for restarting depth first search and includes it in SCIP
- creates the uct node selector and includes it in SCIP
- creates a presolver and includes it in SCIP
- Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(), SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
- creates the boundshift presolver and includes it in SCIP
- creates the convertinttobin presolver and includes it in SCIP
- creates the dominated column presolver and includes it in SCIP
- creates the dualagg presolver and includes it in SCIP
- creates the dualcomp presolver and includes it in SCIP
- creates the dual inference presolver and includes it in SCIP
- creates the dual sparsify presolver and includes it in SCIP
- creates the gateextraction presolver and includes it in SCIP
- creates the implics presolver and includes it in SCIP
- creates the inttobinary presolver and includes it in SCIP
- creates the MILP presolver and includes it in SCIP if the presolve library is available
- creates the QP KKT reformulation presolver and includes it in SCIP
- creates the redvub presolver and includes it in SCIP
- creates the sparsify presolver and includes it in SCIP
- creates the stuffing presolver and includes it in SCIP
- creates the trivial presolver and includes it in SCIP
- creates the tworowbnd presolver and includes it in SCIP
- creates a variable pricer and includes it in SCIP To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer(). This should be done during the problem creation stage.
- creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL; if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(), SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(), SCIPsetPricerFarkas();
- SCIPincludeProp
^{⚠}creates a propagator and includes it in SCIP. - creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(), SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(), SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
- creates the dual fixing propagator and includes it in SCIP
- creates the genvbounds propagator and includes it in SCIP
- creates the nlobbt propagator and includes it in SCIP
- creates the obbt propagator and includes it in SCIP
- creates the probing propagator and includes it in SCIP
- creates the pseudo objective function propagator and includes it in SCIP
- creates the redcost propagator and includes it in SCIP
- creates the root node reduced cost strengthening propagator and includes it in SCIP
- include symmetry propagator
- creates the vbounds propagator and includes it in SCIP
- creates a reader and includes it in SCIP
- creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
- includes the bnd file reader into SCIP
- includes the ccg file reader into SCIP
- includes the cip file reader into SCIP
- includes the cnf file reader into SCIP
- includes the cor file reader into SCIP
- includes the decomposition file reader into SCIP
- includes the diff file reader into SCIP
- includes the fix file reader into SCIP
- includes the FlatZinc file reader into SCIP
- includes the gms file reader into SCIP
- includes the lp file reader into SCIP
- includes the mps file reader into SCIP
- includes the mst file reader into SCIP
- includes the .nl file reader into SCIP
- includes the opb file reader into SCIP
- includes the osil file reader into SCIP
- includes the pbm file reader into SCIP
- includes the pip file reader into SCIP
- includes the ppm file reader into SCIP
- includes the rlp file reader into SCIP
- includes the smps file reader into SCIP
- includes the sol file reader into SCIP
- includes the sto file reader into SCIP
- includes the tim file reader into SCIP
- includes the wbo file reader into SCIP
- includes the zpl file reader into SCIP
- SCIPincludeRelax
^{⚠}creates a relaxation handler and includes it in SCIP - creates a relaxation handler and includes it in SCIP. All non fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(), SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
- SCIPincludeSepa
^{⚠}creates a separator and includes it in SCIP. - creates the aggregation separator and includes it in SCIP
- creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(), SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
- creates the Chvatal-Gomory-MIP cut separator and includes it in SCIP
- creates the clique separator and includes it in SCIP
- creates the closecuts separator and includes it in SCIP
- creates the convexproj separator and includes it in SCIP
- creates the disjunctive cut separator and includes it in SCIP
- creates the edge-concave separator and includes it in SCIP
- creates the gauge separator and includes it in SCIP
- creates the Gomory MIR cut separator and includes it in SCIP
- creates the impliedbounds separator and includes it in SCIP
- creates the interminor separator and includes it in SCIP
- creates the integer objective value separator and includes it in SCIP
- creates the mcf separator and includes it in SCIP
- creates the minor separator and includes it in SCIP
- creates the mixing separator and includes it in SCIP
- creates the oddcycle separator and includes it in SCIP
- creates the rapidlearning separator and includes it in SCIP
- creates the RLT separator and includes it in SCIP
- creates the {0,1/2}-cut separator and includes it in SCIP
- SCIPincludeTable
^{⚠}creates a statistics table and includes it in SCIP - creates the default statistics tables and includes them in SCIP
- increments
`curboundstag`

and resets`lastboundrelax`

in constraint handler data - depending on SCIP’s stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing
- depending on SCIP’s stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing
- fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- 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 current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- 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 current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
- SCIPinfinity
^{⚠}returns value treated as infinity - SCIPinfoMessage
^{⚠} - initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
- initialize a set of empty reoptimization nodes
- initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores of a variable to the given values
- initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
- modifies an initial seed value with the global shift of random seeds
- SCIPinitlpCons
^{⚠}calls LP initialization method for single constraint - stores the variables of a bilinear term in the data of the constraint handler
- stores the variables of a bilinear term in the data of the constraint handler
- SCIPinterruptLP
^{⚠}interrupts or disables the interrupt of the currently ongoing lp solve; if the lp is not currently constructed just returns with no effect - informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has been solved)
- SCIPintervalAbs
^{⚠}stores absolute value of operand in resultant - SCIPintervalAdd
^{⚠}adds operand1 and operand2 and stores result in resultant - adds operand1 and operand2 and stores infimum of result in infimum of resultant
- adds operand1 and scalar operand2 and stores result in resultant
- adds operand1 and operand2 and stores supremum of result in supremum of resultant
- adds vector operand1 and vector operand2 and stores result in vector resultant
- indicates whether operand1 and operand2 are disjoint
- indicates whether operand1 and operand2 are disjoint with epsilon tolerance
- SCIPintervalCos
^{⚠}stores cosine value of operand in resultant - SCIPintervalDiv
^{⚠}divides operand1 by operand2 and stores result in resultant - divides operand1 by scalar operand2 and stores result in resultant
- stores entropy of operand in resultant
- SCIPintervalExp
^{⚠}stores exponential of operand in resultant @attention we assume a correctly rounded exp(double) function when rounding is to nearest - returns infimum of interval
- gets current rounding mode of floating point operations
- returns supremum of interval
- returns whether rounding mode control is available
- intersection of two intervals
- intersection of two intervals with epsilon tolerance
- indicates whether interval is empty, i.e., whether inf > sup
- indicates whether interval is entire, i.e., whether inf ≤ -infinity and sup ≥ infinity