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_1y_1 + … + a_ky_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§
- 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
- 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
- calls constraint activation notification method of single constraint
- create a resource activity
- 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
- creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
- creates a char parameter, sets it to its default value, and adds it to the parameter set
- 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
- 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:
- 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
- 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
- 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.
- 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
- 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
- adds cut to separation storage
- 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$
- 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
- 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
- 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
- adds offset of objective function
- adds offset of objective function to original problem and to all existing solution in original space
- if not already existing, adds row to global cut pool
- adds variable to the problem and uses it as pricing candidate to enter the LP
- 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
- adds row to separation storage
- if not already existing, adds row to a cut pool and captures it
- 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
- adds feasible primal solution to solution storage by copying it
- 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
- 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
- adds given values to lock numbers of variable for rounding
- adds given values to lock numbers of type @p locktype of variable for rounding
- adds value to variable’s objective value
- adds variable to SOS1 constraint, the position is determined by the given weight
- adds variable to SOS2 constraint, the position is determined by the given weight
- resolves variable to columns and adds them with the coefficient to the row
- 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
- 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
- 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.
- clear all entries in the aggregation row but do not free the internal memory
- copy the aggregation row
- create an empty the aggregation row
- 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
- 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 ax + by == 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.
- 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
- 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
- main procedure of the RNS heuristic, creates and solves a sub-SCIP
- reactivate the given @p reoptnode and split them into several nodes if necessary
- main procedure of the zeroobj heuristic, creates and solves a sub-SCIP
- 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
- select the next action
- 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
- 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
- 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
- calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
- 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
- calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
- 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
- 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!
- creates an binary tree
- frees binary tree
- returns the root node of the binary tree or NULL if the binary tree is empty
- returns whether the binary tree is empty (has no nodes)
- prints the binary tree in GML format into the given file
- sets root node
- creates a binary tree node with sorting value and user data
- 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
- 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
- returns whether the node is a root node
- sets the give node data
- sets left child
- sets parent node
- sets right child
- 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.
- 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:
- 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
- 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
- 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.
- increases usage counter of constraint
- captures a dialog
- captures an expression (increments usage count)
- increases usage counter of a nonlinear row
- increases usage counter of LP row
- increases usage counter of variable
- 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
- 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
- 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
- checks solution for feasibility without adding it to the solution store
- 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
- 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)
- changes the value of an existing char parameter
- 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
- change constraint name
- changes cutoffbound in current dive
- changes the display column mode
- sets the feasibility tolerance for reduced costs
- changes expression of a nonlinear constraint
- sets the feasibility tolerance for constraints
- changes the value of an existing int parameter
- 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
- sets the primal feasibility tolerance of LP solver
- changes constant of a nonlinear row
- changes left hand side of a nonlinear row
- changes linear coefficient of a variables in a nonlinear row
- changes right hand side of a nonlinear row
- changes the value of an existing SCIP_Real parameter
- sets the primal feasibility tolerance of relaxations
- changes the objective function
- changes right hand side of linear constraint
- changes right-hand-side of a nonlinear constraint
- changes right hand side of pseudoboolean constraint
- 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()
- 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
- 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
- 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
- changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
- 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
- changes the name of a variable
- 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
- changes type of variable in the problem;
- 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
- 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
- changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
- 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
- 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
- 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
- clears a primal solution
- 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
- 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
- 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
- gets unique index of col
- gets depth in the tree where the column entered the LP, or -1 if it is not in LP
- gets position of column in current LP, or -1 if it is not in LP
- 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;
- get number of nonzero entries in column vector
- gets number of times, strong branching was applied in current run on the given column
- gets objective value of column
- gets the primal LP solution of a column
- 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
- gets upper bound of column
- gets array with coefficients of nonzero entries
- gets variable this column represents
- gets probindex of corresponding variable
- 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)
- 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
- compare expressions @return -1, 0 or 1 if expr1 <, =, > expr2, respectively @note The given expressions are assumed to be simplified.
- gets user data of tree compression
- 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
- gets name of tree compression
- gets priority of tree compression
- gets time in seconds used in this compression for setting up for next stages
- gets time in seconds used in this compression
- is tree compression initialized?
- 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
- computes the gap from the primal and the dual bound
- computes w.r.t. the given worst case resource profile the first time point where the given capacity is satisfied for sure
- 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!
- 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
- gets age of constraint
- 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
- returns the constraint handler of the constraint
- 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
- gets number of times, the constraint is currently captured
- returns the name of the constraint
- returns the position of constraint in the corresponding handler’s conss array
- returns the right-hand side of an arbitrary SCIP constraint that can be represented as a single linear constraint
- 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
- returns TRUE iff constraint is active in the current node
- 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
- returns TRUE iff constraint is globally valid
- returns TRUE iff constraint belongs to the global problem
- returns TRUE iff the LP relaxation of constraint should be in the initial LP
- returns TRUE iff constraint is only locally valid or not added to any (sub)problem
- 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
- 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
- copies source SCIP to target SCIP; the copying process is done in the following order:
- 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
- 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
- copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
- copies directed graph structure
- 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
- copies limits from source SCIP to target SCIP
- 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
- create a problem by copying the original problem data of the source SCIP
- 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
- 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.
- create a problem by copying the problem data of the source SCIP
- creates a copy of a SCIP_ROWPREP datastructure
- 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
- returns whether the COR file has been successfully read. This is used by the TIM and STO readers.
- execute counting
- 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
- creates a child node of the focus node
- creates a clock using the default clock type
- 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
- 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
- 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
- creates and captures an expression with given expression data and children
- 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
- creates a primal solution, initialized to the current LP solution
- creates a primal solution, initialized to the current NLP solution
- 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
- 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
- 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
- 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
- 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
- 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:
- 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
- gets the row of the cut
- 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
- 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
- calls constraint deactivation notification method of single constraint
- clears the corresponding labeling (constraints, variables, or both) of this decomposition
- creates a decomposition
- 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
- 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
- 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()
- 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
- removes a nonlinear row from the NLP
- removes the row from the global cut pool
- removes the LP row from a cut pool
- 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.
- 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
- 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().
- 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
- gets user data of display column
- gets description of display column
- gets head line of display column
- gets name of display column
- gets position of display column
- gets priority of display column
- gets status of display column
- gets width of display column
- displays an integer in decimal form fitting in a given width
- is display column initialized?
- displays a long integer in decimal form fitting in a given width
- sets user data of display column; user has to free old data in advance!
- 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?
- returns whether aggregation of variables is not allowed
- 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
- drops a global event (stops to track event)
- drops a row coefficient, constant, or side change event (stops to track event) on the given row
- drops an objective value or domain change event (stops to track event) on the given transformed variable
- rounds value - dual feasibility tolerance up to the next integer
- rounds value + dual feasibility tolerance down to the next integer
- returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance
- rounds value to the nearest integer in dual feasibility tolerance
- duplicates the given expression and its children
- duplicates the given expression, but reuses its children
- 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
- 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
- quits LP diving and resets bounds and objective values of columns to the current node’s values
- ends NLP diving
- quits probing and resets bounds and constraints to the focus node’s environment
- end strong branching - call after any strong branching
- enforces single constraint for a given LP solution
- 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
- returns value treated as zero
- returns the value of the Gauss error function evaluated at a given point
- translates the given string into a string where symbols “, ’, and spaces are escaped with a \ prefix
- evaluates an auxiliary expression for a bilinear term
- 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
- 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
- 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
- gets solution for a primal solution event
- gets type of event
- 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
- 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
- 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
- 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)
- gets the expression handler of an expression
- gives the number of children of an expression
- 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
- sets the expression data of an expression
- sets the integrality flag of an expression
- 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
- 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
- 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.
- rounds value - feasibility tolerance up to the next integer
- rounds value + feasibility tolerance down to the next integer
- returns fractional part of value, i.e. x - floor(x)
- rounds value to the nearest integer in feasibility tolerance
- returns, whether the given file exists
- returns the bandit virtual function table of the given name, or NULL if not existing
- 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
- 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
- returns constraint of given name in the problem, or NULL if not existing
- returns the constraint handler of the given name, or NULL if not existing
- returns the cut selector of the given name, or NULL if not existing
- 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
- returns an expression handler of a given name (or NULL if not found)
- 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)
- returns the NLPI of the given name, or NULL if not existing
- returns the node selector of the given name, or NULL if not existing
- returns original constraint of given name in the problem, or NULL if not existing
- returns the presolver of the given name, or NULL if not existing
- returns the variable pricer of the given name, or NULL if not existing
- returns the propagator of the given name, or NULL if not existing
- returns the reader of the given name, or NULL if not existing
- returns the relaxation handler of the given name, or NULL if not existing
- 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
- returns the statistics table of the given name, or NULL if not existing
- returns variable of given name in the problem, or NULL if not existing
- fixes the value of an existing parameter
- 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
- rounds value + epsilon down to the next integer
- makes sure that the LP of the current node is flushed
- 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
- returns fractional part of value, i.e. x - floor(x) in epsilon tolerance
- frees SCIP data structures
- calls destructor and frees memory of bandit algorithm
- frees the subproblem after calling the solve subproblem method
- frees a dynamic array of bool values
- frees a clock
- frees a cut pool
- frees a decomposition
- frees the disjoint set (union find) data structure
- frees information on quadratic representation of an expression
- frees an expression iterator
- frees a dynamic array of int values
- frees memory allocated when parsing a signomial from a string
- frees problem and solution process data
- frees a dynamic array of pointers
- 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
- frees a SCIP_ROWPREP datastructure
- frees arrays created by SCIPisSOCNonlinear()
- frees primal CIP solution
- 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
- 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
- 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
- gets the best child of the focus node w.r.t. the node selection strategy
- gets the best leaf from the node queue w.r.t. the node selection strategy
- 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
- 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
- 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)
- gets the value of an existing char parameter
- gets children of focus node along with the number of children
- gets the array of cliques in the clique table
- 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
- 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
- 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
- method to collect the number of variables of a constraint
- returns the value array of an arbitrary SCIP constraint that can be represented as a single linear constraint
- method to collect the variables of a constraint
- returns the array of currently available constraint handlers
- 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
- gets the array of cuts currently stored in the separation storage
- returns the array of currently available cut selectors
- 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
- 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
- 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
- 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
- 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)
- 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
- 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
- gets focus node in the tree
- 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
- returns the array of currently available primal heuristics
- returns the right bound of effective horizon
- returns the left bound of the effective horizon
- 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
- gets the value of an existing int parameter
- 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)
- gets a column from the inverse basis matrix B^-1
- 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.
- 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
- gets current primal feasibility tolerance of LP
- 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
- 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
- gets current LP rows
- gets current LP rows along with the current number of LP rows
- gets solution status of current LP
- gets the
curboundstagfrom 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)
- gets leaves of the tree along with the number of leaves
- 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
- 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
- returns the total number of bytes in block and buffer memory
- 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
- 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
- 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)
- gets number of children of focus node
- gets the number of cliques in the clique table
- gets the number of cliques created so far by the cliquetable
- 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
- gets total number of globally valid constraints currently in the problem
- 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
- 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
- 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
- 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
- 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
- returns the number of currently available primal heuristics
- 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
- gets number of integer active problem variables
- gets number of branching candidates for LP solution branching (number of fractional variables)
- gets current number of LP columns
- gets fractional variables of last NLP solution along with solution values and fractionalities
- 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
- gets array with nonlinear rows of the NLP
- gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
- gets objective value of current NLP
- 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
- 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
- gets total number of LPs solved so far
- 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
- gets current number of variables in NLP
- gets number of active non-zeros in the current transformed problem
- get number of nonlinear handler
- 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
- gets total number of LPs solved so far for node relaxations
- gets total number of LPs solved in 0 iterations for node relaxations
- gets number of processed nodes in current run, including the focus node
- gets number of nodes left in the tree (children + siblings + leaves)
- returns the number of currently available node selectors
- 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
- gets number of original problem variables
- returns the total number of all available SCIP parameters
- returns number of partial solutions
- gets current number of rows in the global cut pool
- returns the number of presolve rounds (current or last presolve)
- returns the number of currently available presolvers
- gets number of pricing rounds performed so far at the current node
- 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
- returns the number of currently available propagators
- gets number of branching candidates for pseudo solution branching (non-fixed variables)
- returns the number of currently available readers
- 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
- gets number of branch and bound runs performed, including the current run
- 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
- returns the number of currently available separators
- gets number of siblings of focus node
- 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)
- 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
- gets number of active problem variables
- 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
- gets number of variables in or constraint
- gets number of variables in SOS1 constraint
- gets number of variables in SOS2 constraint
- gets number of variables in set partitioning / packing / covering constraint
- 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
- 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
- returns the currently used node selector
- returns the array of currently available node selectors
- returns the Euclidean norm of the objective function vector (available only for transformed problem)
- returns current limit on objective function
- returns objective sense of original problem
- access to all data of open nodes (leaves, children, and siblings)
- gets array of constraints in the original problem
- returns the objective offset of the original problem
- returns the objective scale of the original problem
- 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()
- returns the pointer to the SCIP parameter with the given name
- 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)
- gets current cuts in the global cut pool
- returns the array of currently available presolvers
- gets the current presolving time in seconds
- 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
- 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
- gets user problem data
- 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_1x_1 + … + a_nx_n + c into a corresponding linear sum of active variables, that is b_1y_1 + … + b_my_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
- 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
- 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
- returns the array of currently available readers
- gets the current reading time in seconds
- 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
- 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
- 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
- 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
- gets the right hand side of the xor constraint
- returns the root dialog of SCIP’s interactive user shell
- 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
- 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
- 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
- returns the array of currently available separators
- 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
- 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
- gets branch and bound run number, where this solution was found
- gets clock time, when this solution was found
- returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
- returns value of variable in primal CIP solution, or in current LP/pseudo solution
- 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()
- 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
- 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
- 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
- return currently available symmetry group information
- return number of the symmetry group’s generators
- Gets the synchronization store.
- returns the array of currently available statistics tables
- gets current time of day in seconds (standard time zone)
- gets the current total SCIP time in seconds, possibly accumulated over several problems.
- 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
- 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
- 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.
- gets solution value for variable in current node
- 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
- gets variable’s upper bound in current dive
- 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
- gets array with active problem variables
- 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
- 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
- gets array of variables in or constraint
- gets array of variables in SOS1 constraint
- 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
- 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
- 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)
- writes an arc section to the given graph file
- writes the ending lines to a GML graph file, does not close a file
- writes an edge section to the given graph file
- 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
- return whether a primal ray is stored that proves unboundedness of the LP relaxation
- compute the hash value of an expression
- 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
- 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
- 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
- gets user data of primal heuristic
- 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
- 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
- gets name of primal heuristic
- gets priority of primal heuristic
- gets time in seconds used in this heuristic for setting up for next stages
- 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
- sets user data of primal heuristic; user has to free old data in advance!
- 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
- returns whether we are in diving mode
- 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
- increases age of constraint by 1.0; should be called
- increases value of entry in dynamic array
- increases value of entry in dynamic array
- 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
- @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
- 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
- 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
- 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();
- 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
- 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()
- 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
- creates a statistics table and includes it in SCIP
- creates the default statistics tables and includes them in SCIP
- increments
curboundstagand resetslastboundrelaxin 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
- returns value treated as infinity
- 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
- 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
- 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)
- stores absolute value of operand in resultant
- 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
- stores cosine value of operand in resultant
- 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
- 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
- indicates whether interval is negative infinity, i.e., [-infinity, -infinity]
- indicates whether interval is positive infinity, i.e., [infinity, infinity]
- indicates whether operand1 is contained in operand2
- stores natural logarithm of operand in resultant @attention we assume a correctly rounded log(double) function when rounding is to nearest
- stores maximum of operands in resultant
- stores minimum of operands in resultant
- multiplies operand1 with operand2 and stores result in resultant
- multiplies operand1 with operand2 and stores infimum of result in infimum of resultant
- multiplies operand1 with scalar operand2 and stores result in resultant
- multiplies operand1 with scalar operand2 and stores infimum of result in infimum of resultant
- multiplies operand1 with scalar operand2 and stores supremum of result in supremum of resultant
- multiplies operand1 with operand2 and stores supremum of result in supremum of resultant
- negates a number in a way that the compiler does not optimize it away
- stores operand1 to the power of operand2 in resultant
- stores operand1 to the power of the scalar operand2 in resultant @attention we assume a correctly rounded pow(double) function when rounding is to nearest
- computes bounds on power of a scalar operand1 to an integer operand2
- computes lower bound on power of a scalar operand1 to an integer operand2
- computes upper bound on power of a scalar operand1 to an integer operand2
- given an interval for the image of a power operation, computes an interval for the origin
- stores bounds on the power of a scalar operand1 to a scalar operand2 in resultant
- propagates a weighted sum of intervals in a given interval
- stores range of quadratic term in resultant
- stores range of bivariate quadratic term in resultant
- computes exact upper bound on \f$ a x^2 + b x \f$ for x in [xlb, xub], b an interval, and a scalar
- computes the reciprocal of an interval
- computes the scalar product of two vectors of intervals and stores result in resultant
- computes the scalar product of a vector of intervals and a vector of scalars and stores result in resultant
- computes the scalar product of a vector of intervals and a vector of scalars and stores infimum of result in infimum of resultant
- computes the scalar product of a vector of intervals and a vector of scalars and stores supremum of result in supremum of resultant
- stores given value as interval
- stores given infimum and supremum as interval
- sets interval to empty interval, which will be [1.0, -1.0]
- sets interval to entire [-infinity, +infinity]
- sets rounding mode of floating point operations
- sets rounding mode of floating point operations to downwards rounding
- sets rounding mode of floating point operations to nearest rounding
- sets rounding mode of floating point operations to towards zero rounding
- sets rounding mode of floating point operations to upwards rounding
- stores sign of operand in resultant
- stores operand1 to the signed power of the scalar positive operand2 in resultant
- stores sine value of operand in resultant
- solves a bivariate quadratic equation for the first variable
- solves a quadratic equation with interval coefficients
- computes interval with negative solutions of a quadratic equation with interval coefficients
- computes interval with positive solutions of a quadratic equation with interval coefficients
- computes positive solutions of a quadratic equation with scalar coefficients
- squares operand and stores result in resultant
- stores (positive part of) square root of operand in resultant @attention we assume a correctly rounded sqrt(double) function when rounding is to nearest
- subtracts operand2 from operand1 and stores result in resultant
- subtracts scalar operand2 from operand1 and stores result in resultant
- interval enclosure of the union of two intervals
- return if the variables of the AND-constraint are sorted with respect to their indices
- checks whether the value of an existing SCIP_Bool parameter is valid
- checks whether parameter value for a given SCIP_Real parameter is valid
- return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied
- checks if the given variable is already part of the current conflict set or queued for resolving with the same or even stronger bound
- is constraint compression enabled?
- indicates whether a cut is applicable
- returns whether the cut’s efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy
- checks if cut is already existing in global cutpool
- check specific preconditions for diving, e.g., if an incumbent solution is available
- check whether the dual solution is available
- checks, if relative difference of values is in range of dual feasibility tolerance
- checks, if given fractional part is smaller than dual feasibility tolerance
- checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance
- checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance
- checks, if value is integral within the LP dual feasibility tolerance
- checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance
- checks, if relative difference val1 and val2 is lower than dual feasibility tolerance
- checks, if value is lower than -dual feasibility tolerance
- checks, if value is greater than dual feasibility tolerance
- checks, if value is in range dual feasibility tolerance of 0.0
- checks, if values are in range of epsilon
- checks, if the given cut’s efficacy is larger than the minimal cut efficacy
- returns whether the solution process is arithmetically exact, i.e., not subject to roundoff errors
- indicates whether expression is of abs-type
- indicates whether expression is of cosine-type
- indicates whether expression is of entropy-type
- indicates whether expression is of exp-type
- indicates whether expression is of log-type
- returns whether an expression is a power expression
- returns whether an expression is a product expression
- indicates whether expression is of signpower-type
- indicates whether expression is of sine-type
- returns whether an expression is a sum expression
- returns whether an expression is a value expression
- returns whether an expression is a variable expression
- indicates whether expression is varidx expression
- checks, if relative difference of values is in range of feasibility tolerance
- checks, if given fractional part is smaller than feastol
- checks, if relative difference of val1 and val2 is not lower than -feastol
- checks, if relative difference of val1 and val2 is greater than feastol
- checks, if value is integral within the LP feasibility bounds
- checks, if relative difference of val1 and val2 is not greater than feasibility tolerance
- checks, if relative difference val1 and val2 is lower than feasibility tolerance
- checks, if value is lower than -feasibility tolerance
- checks, if value is greater than feasibility tolerance
- checks, if value is in range feasibility tolerance of 0.0
- returns whether filterSQP is available, i.e., whether it has been linked in
- checks, if given fractional part is smaller than epsilon
- checks, if val1 is not (more than epsilon) lower than val2
- checks, if val1 is (more than epsilon) greater than val2
- checks, if value is huge and should be handled separately (e.g., in activity computation)
- returns whether we are in the restarting phase
- checks, if value is (positive) infinite
- checks whether the value of an existing int parameter is valid
- checks, if value is integral within epsilon
- Checks whether a permutation is a composition of 2-cycles and in this case determine the number of overall 2-cycles and binary 2-cycles. It is a composition of 2-cycles iff @p ntwocyclesperm > 0 upon termination.
- returns whether Ipopt is available, i.e., whether it has been linked in
- checks, if val1 is not (more than epsilon) greater than val2
- returns, whether the LP of the current node is already constructed
- returns whether the current LP solution passed the dual feasibility check
- returns whether the current LP solution passed the primal feasibility check
- returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
- returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
- checks, if val1 is (more than epsilon) lower than val2
- checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one
- checks whether parameter value of an existing SCIP_Longint paramter is valid
- returns, whether an NLP has been constructed
- returns whether the NLP relaxation has been enabled
- checks, if value is lower than -epsilon
- returns whether the objective function has changed during probing mode
- returns whether the objective value is known to be integral in every feasible solution
- return whether orbital fixing is enabled
- checks whether an orbitope is a packing or partitioning orbitope
- gets the fixing status of an existing parameter
- checks, if value is greater than epsilon
- returns whether the presolving process would be finished given no more presolving reductions are found in this presolving round
- returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound was set from the user as objective limit
- returns TRUE if the propagator has the status that all variable lower and upper bounds are propagated
- checks whether parameter value of an existing SCIP_Real paramter is valid
- checks, if relative difference of values is in range of epsilon
- checks, if relative difference of val1 and val2 is not lower than -epsilon
- checks, if relative difference of val1 and val2 is greater than epsilon
- checks, if relative difference of val1 and val2 is not greater than epsilon
- checks, if relative difference of val1 and val2 is lower than epsilon
- returns whether the relaxation solution is valid
- returns whether reoptimization is enabled or not
- returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
- computes violation of rowprep in a given solution and reports whether that value seem numerically reliable
- checks whether constraint is SOC representable in original variables and returns the SOC representation
- checks whether the product val * scalar is integral in epsilon scaled by scalar
- indicates whether \SCIP has been informed that the solving process should be interrupted as soon as possible
- returns whether the solving process should be / was stopped before proving optimality; if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields the reason for the premature abort
- checks whether parameter value for a given string parameter is valid
- determine which branching direction should be evaluated first by strong branching
- checks, if values are in range of sumepsilon
- checks, if val1 is not (more than sumepsilon) lower than val2
- checks, if val1 is (more than sumepsilon) greater than val2
- checks, if val1 is not (more than sumepsilon) greater than val2
- checks, if val1 is (more than sumepsilon) lower than val2
- checks, if value is lower than -sumepsilon
- checks, if value is greater than sumepsilon
- checks, if relative difference of values is in range of sumepsilon
- checks, if relative difference of val1 and val2 is not lower than -sumepsilon
- checks, if relative difference of val1 and val2 is greater than sumepsilon
- checks, if relative difference of val1 and val2 is not greater than sumepsilon
- checks, if relative difference of val1 and val2 is lower than sumepsilon
- checks, if value is in range sumepsilon of 0.0
- returns whether the current stage belongs to the transformed problem space
- checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one
- Checks, if an iteratively updated value is reliable or should be recomputed from scratch. This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high absolute value during the optimization process which is later reduced significantly. In this case, the last digits were canceled out when increasing the value and are random after decreasing it. We do not consider the cancellations which can occur during increasing the absolute value because they just cannot be expressed using fixed precision floating point arithmetic, anymore. In order to get more reliable values, the idea is to always store the last reliable value, where increasing the absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared against the last reliable one with this method, checking whether it was decreased by a factor of at least “lp/recompfac” and should be recomputed.
- check if the current pseudo cost relative error in a direction violates the given threshold. The Relative Error is calculated at a specific confidence level
- checks whether indicator constraint is violated w.r.t. sol
- returns whether Worhp is available, i.e., whether it has been linked in
- checks, if value is in range epsilon of 0.0
- create linear constraint statistics
- free linear constraint statistics
- returns the total number of classified constraints
- returns the number of occurrences of a specific type of linear constraint
- increases the number of occurrences of a specific type of linear constraint
- resets linear constraint statistics
- links a primal solution to the current LP or pseudo solution
- links a primal solution to the current LP solution
- links a primal solution to the current NLP solution
- links a primal solution to the current pseudo solution
- links a primal solution to the current relaxation solution
- add locks of type @p locktype of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed
- returns primal feasibility tolerance of LP solver
- adds columns to the LP
- adds rows to the LP
- changes lower and upper bounds of columns
- changes a single coefficient
- changes objective values of columns in the LP
- changes the objective sense
- changes left and right hand sides of rows
- clears the whole LP
- clears current LPi state (like basis information) of the solver
- creates an LP problem object
- deletes all columns in the given range from LP
- deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position
- deletes all rows in the given range from LP
- deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position
- end strong branching - call after any strong branching
- returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point); this does not necessarily mean, that the solver knows and can return the dual ray
- returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point); this does not necessarily mean, that the solver knows and can return the primal ray
- deletes an LP problem object
- frees LPi pricing norms information
- frees LPi state information
- get column of inverse basis matrix times constraint matrix B^-1 * A
- get row of inverse basis matrix times constraint matrix B^-1 * A
- get column of inverse basis matrix B^-1
- get row of inverse basis matrix B^-1
- gets current basis status for columns and rows; arrays must be large enough to store the basis status
- returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m
- gets current bounds from LP problem object
- gets a single coefficient
- gets column names
- gets columns from LP problem object; the arrays have to be large enough to store all values; Either both, lb and ub, have to be NULL, or both have to be non-NULL, either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
- gets dual Farkas proof for infeasibility
- returns the internal solution status of the solver
- gets integer parameter of LP
- gets the number of LP iterations of the last solve call
- gets the number of columns in the LP
- gets the number of nonzero elements in the LP constraint matrix
- gets the number of rows in the LP
- stores LPi pricing norms into lpinorms object
- gets objective coefficients from LP problem object
- gets the objective sense of the LP
- gets objective value of solution
- gets primal ray for unbounded LPs
- gets information about the quality of an LP solution
- gets floating point parameter of LP
- gets row names
- gets rows from LP problem object; the arrays have to be large enough to store all values. Either both, lhs and rhs, have to be NULL, or both have to be non-NULL, either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
- gets current row sides from LP problem object
- gets primal and dual solution vectors for feasible LPs
- gets information about primal and dual feasibility of the current LP solution
- gets description of LP solver (developer, webpage, …)
- gets name and version of LP solver
- gets pointer for LP solver - use only with great care
- stores LPi state (like basis information) into lpistate object
- informs about availability of a barrier solving method
- returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point), and the solver knows and can return the dual ray
- informs about availability of a dual simplex solving method
- returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point), and the solver knows and can return the primal ray
- informs about availability of a primal simplex solving method
- checks, whether the given LPi state contains simplex basis information
- tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call
- returns value treated as infinity in the LP solver
- interrupts the currently ongoing lp solve or disables the interrupt
- returns TRUE iff LP is proven to be dual feasible
- returns TRUE iff LP is proven to be dual infeasible
- returns TRUE iff LP is proven to be dual unbounded
- checks if given value is treated as infinity in the LP solver
- returns TRUE iff the iteration limit was reached
- returns TRUE iff the objective limit was reached
- returns TRUE iff LP was solved to optimality
- returns TRUE iff LP is proven to be primal feasible
- returns TRUE iff LP is proven to be primal infeasible
- returns TRUE iff LP is proven to be primal unbounded
- returns TRUE iff current LP solution is stable
- returns TRUE iff the time limit was reached
- copies LP data with column matrix into LP solver
- reads LP from a file
- reads LPi state (like basis information from a file
- multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds are divided by the scalar; for negative scalars, the column’s bounds are switched
- multiplies a row with a non-zero scalar; for negative scalars, the row’s sense is switched accordingly
- sets current basis status for columns and rows
- pass integrality information about variables to the solver
- sets integer parameter of LP
- loads LPi pricing norms into solver; note that the LP might have been extended with additional columns and rows since the norms were stored with SCIPlpiGetNorms()
- sets floating point parameter of LP
- loads LPi state (like basis information) into solver; note that the LP might have been extended with additional columns and rows since the state was stored with SCIPlpiGetState()
- calls barrier or interior point algorithm to solve the LP with crossover to simplex basis
- calls dual simplex to solve the LP
- calls primal simplex to solve the LP
- start strong branching - call before any strong branching
- performs strong branching iterations on one @b fractional candidate
- performs strong branching iterations on one candidate with @b integral value
- performs strong branching iterations on given @b fractional candidates
- performs strong branching iterations on given candidates with @b integral values
- returns whether a solve method was called after the last modification of the LP
- writes LP to a file
- writes LPi state (i.e. basis information) to a file
- returns SCIP major version
- based on values of other variables, computes slack and binary variable to turn constraint feasible
- based on values of other variables, computes slack and binary variable to turn all constraints feasible
- tries to scale row, s.t. all coefficients (of integer variables) become integral
- based on solution values of the variables, fixes variables to zero to turn all SOS1 constraints feasible
- marks a column to be not removable from the LP in the current node
- marks constraint to be propagated
- marks the variable that it must not be aggregated
- marks the variable that it must not be multi-aggregated
- mark constraints that include this expression to be propagated again
- marks that some limit parameter was changed
- informs SCIP, that the relaxation solution is invalid
- informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
- marks a row to be not removable from the LP in the current node
- initialize matrix by copying all check constraints
- get if conflicting downlocks of variable present
- frees the constraint matrix
- get column based start pointer of row indices
- get lower bound of column
- get number of downlocks of column
- get the number of non-zero entries of this column
- get number of uplocks of column
- get name of column/variable
- get upper bound of column
- get column based start pointer of values
- get constraint pointer for constraint representing row
- get number of columns of the matrix
- get number of non-zeros of matrix
- get number of rows of the matrix
- detect parallel columns, obj ignored
- detect parallel rows, rhs/lhs are ignored
- get row based start pointer of column indices
- get left-hand-side of row
- get maximal activity of row
- get minimal activity of row
- get number of negative infinities present within maximal activity
- get number of positive infinities present within maximal activity
- get number of negative infinities present within minimal activity
- get number of positive infinities present within minimal activity
- get number of non-zeros of this row
- get name of row
- get right-hand-side of row
- get row based start pointer of values
- get variable pointer of column
- flag indicating if right-hand-side of row is infinity
- print one row of the MIP matrix
- removes the bounds of a column and updates the activities accordingly
- get if conflicting uplocks of variable present
- copies characters from ‘src’ to ‘dest’, copying is stopped when either the ‘stop’ character is reached or after ‘cnt’ characters have been copied, whichever comes first.
- merges a subproblem into the master problem.
- merges the statistics of NLPIs from a source SCIP into a target SCIP
- Merge terms that use same variable and eliminate zero coefficients.
- merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to different SCIP instances.
- prints the header with source file location for an error message using the static message handler
- Method to set the error printing method. Setting the error printing method to NULL will suspend all error methods.
- Method to set the error printing method to default version prints everything the stderr.
- prints a dialog message that requests user interaction into a file, acting like the vfprintf() command
- prints a message into a file, acting like the vfprintf() command
- prints a message into a file depending on the verbosity level, acting like the vfprintf() command
- prints a warning message into a file, acting like the vfprintf() command
- prints a dialog message that requests user interaction, acting like the vprintf() command
- prints an error message, acting like the vprintf() command using the static message handler
- prints a message, acting like the vprintf() command
- prints a message depending on the verbosity level, acting like the vprintf() command
- prints a warning message, acting like the vprintf() command
- captures message handler
- Creates and captures a message handler which deals with warning, information, and dialog (interactive shell) methods.
- returns the user data of the message handler
- returns the log file or NULL for stdout
- returns TRUE if the message handler is set to be quiet
- releases message handler
- sets the user data of the message handler
- sets the log file name for the message handler
- sets the messages handler to be quiet
- returns SCIP minor version
- converts variable into multi-aggregated variable; this changes the variable array returned from SCIPgetVars() and SCIPgetVarsData();
- creates a multihash table
- returns whether the given element exists in the multihash table
- frees the multihash table
- returns the load of the given multihash table in percentage
- returns number of multihash table elements
- inserts element in multihash table (multiple inserts of same element possible)
- prints statistics about multihash table usage
- removes element from the multihash table, if it exists
- removes all elements of the multihash table
- retrieve element with key from multihash table, returns NULL if not existing
- retrieve element with key from multihash table, returns NULL if not existing can be used to retrieve all entries with the same key (one-by-one)
- inserts element in multihash table (multiple insertion of same element is checked and results in an error)
- multiplies given sum expression by a constant
- creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path with a call to SCIPbacktrackProbing(); using a sub node for each set of probing bound changes can improve conflict analysis
- returns the next representable value of from in the direction of to
- gives handler data of nonlinear handler
- gives description of nonlinear handler, can be NULL
- gives detection priority of nonlinear handler
- gives enforcement priority of nonlinear handler
- gives name of nonlinear handler
- returns whether nonlinear handler implements the enforcement callback
- returns whether nonlinear handler implements the estimator callback
- returns whether nonlinear handler implements the separation deinitialization callback
- returns whether nonlinear handler implements the separation initialization callback
- returns whether nonlinear handler implements the interval evaluation callback
- returns whether nonlinear handler implements the reverse propagation callback
- returns whether nonlinear handler is enabled
- sets the copy handler callback of a nonlinear handler
- sets the nonlinear handler callback to free expression specific data of nonlinear handler
- sets the nonlinear handler callback to free the nonlinear handler data
- sets the initialization and deinitialization callback of a nonlinear handler
- sets the propagation callbacks of a nonlinear handler
- sets the enforcement callbacks of a nonlinear handler
- gets data of an NLPI
- gets NLP solver description
- gives total time spend in function evaluation during NLP solves
- gives total number of iterations spend by NLP solver so far
- gives number of problems created for NLP solver so far
- gives number of times a solve ended with a specific solution status
- total number of NLP solves so far
- gives number of times a solve ended with a specific termination status
- gets NLP solver name
- gets NLP solver priority
- gives total time spend in problem creation/modification/freeing
- gives total time spend in NLP solves (as reported by solver)
- adds statistics from one NLPI to another
- gets constant
- returns the curvature of a nonlinear row
- gets the dual NLP solution of a nlrow
- gets expression
- returns the left hand side of a nonlinear row
- gets array with coefficients in linear part
- gets array with variables of linear part
- gets position of a nonlinear row in current NLP, or -1 if not in NLP
- gets number of variables of linear part
- returns the name of a nonlinear row
- returns the right hand side of a nonlinear row
- returns TRUE iff row is member of current NLP
- sets the curvature of a nonlinear row
- returns all constraints added to a given node
- returns the set of variable branchings that were performed in all ancestor nodes (nodes on the path to the root) to create this node sorted by the nodes, starting from the current node going up to the root
- returns the set of variable branchings that were performed in all ancestor nodes (nodes on the path to the root) to create this node
- returns the set of variable branchings that were performed between the given @p node and the given @p parent node.
- gets the depth of the node
- gets the domain change information of the node, i.e., the information about the differences in the variables domains to the parent node
- gets the estimated value of the best feasible solution in subtree of the node
- gets the lower bound of the node
- returns the number of added constraints to the given node
- counts the number of bound changes due to branching, constraint propagation, and propagation
- gets successively assigned number of the node
- gets the parent node of a node in the branch-and-bound tree, if any
- returns the set of variable branchings that were performed in the parent node to create this node
- gets the unique id to identify the node during reoptimization; id is 0 if the node is the root or not part of the reoptimization tree
- gets the reoptimization type of a node
- gets the type of the node
- returns variable that belongs to a given node from the conflict graph
- returns whether node is in the path to the current node
- returns whether the node is marked to be propagated again
- outputs the path into given file stream in GML format
- sets a unique id to identify the node during reoptimization
- sets the reoptimization type of the node
- finds the common ancestor node of two given nodes
- checks for two nodes whether they share the same root path, i.e., whether one is an ancestor of the other
- gets user data of node selector
- gets description of node selector
- gets priority of node selector in memory saving mode
- gets name of node selector
- gets time in seconds used in this node selector for setting up for next stages
- gets priority of node selector in standard mode
- gets time in seconds used in this node selector
- is node selector initialized?
- sets user data of node selector; user has to free old data in advance!
- calculates the cumulative distribution P(-infinity <= x <= value) that a normally distributed random variable x takes a value between -infinity and parameter \p value.
- get critical value of a standard normal distribution at a given confidence level
- normalize cumulative condition
- returns value of SCIP_Bool parameter
- returns default value of SCIP_Bool parameter
- returns value of char parameter
- returns allowed values of char parameter, or NULL if everything is allowed
- returns default value of char parameter
- returns locally defined parameter specific data
- returns description of parameter
- returns value of int parameter
- returns default value of int parameter
- returns maximal value of int parameter
- returns minimal value of int parameter
- returns value of SCIP_Longint parameter
- returns default value of SCIP_Longint parameter
- returns maximal value of longint parameter
- returns minimal value of longint parameter
- returns name of parameter
- returns value of SCIP_Real parameter
- returns default value of SCIP_Real parameter
- returns maximal value of real parameter
- returns minimal value of real parameter
- returns value of string parameter
- returns default value of String parameter
- returns type of parameter
- returns whether parameter is advanced
- returns whether the parameter is on its default setting
- returns whether parameter is fixed
- sets fixing status of given parameter
- parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is creates and captures;
- creates an expression from a string
- parse a real value that was written with SCIPprintReal()
- parses variable information (in cip format) out of a string; if the parsing process was successful a variable is created and captured; 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
- parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable exits and returns the position where the parsing stopped
- parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + … + cn <xn>) (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
- parse the given string as variable list (here ‘,’ is the delimiter)) (<x1>, <x2>, …, <xn>) (see SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
- parse the given string as signomial of variables and coefficients (c1 <x11>^e11 <x12>^e12 … <x1n>^e1n + c2 <x21>^e21 <x22>^e22 … + … + cn <xn1>^en1 …) (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
- performs a diving within the limits of the @p diveset parameters
- randomly shuffles parts of an array using the Fisher-Yates algorithm
- randomly shuffles parts of an integer array using the Fisher-Yates algorithm
- permutes parts of the problem data structure
- clears the priority queue, but doesn’t free the data elements themselves
- creates priority queue
- delete element at specified position, maintaining the heap property
- returns the elements of the queue; changing the returned array may destroy the queue’s ordering!
- return the position of @p elem in the priority queue, or -1 if element is not found
- returns the best element of the queue without removing it
- frees priority queue, but not the data elements themselves
- inserts element into priority queue
- returns the number of elements in the queue
- removes and returns best element from the priority queue
- presolves of single constraint
- gets user data of presolver
- gets description of presolver
- gets round limit of presolver
- gets number of constraints added in presolver
- gets number of holes added to domains of variables in presolver
- gets number of variables aggregated in presolver
- gets number of times the presolver was called and tried to find reductions
- gets number of bounds changed in presolver
- gets number of coefficients changed in presolver
- gets number of constraint sides changed in presolver
- gets number of variable types changed in presolver
- gets number of constraints deleted in presolver
- gets number of variables fixed in presolver
- gets number of constraints upgraded in presolver
- gets name of presolver
- gets priority of presolver
- gets time in seconds used in this presolver for setting up for next stages
- gets time in seconds used in this presolver
- gets the timing mask of the presolver
- is presolver initialized?
- sets user data of presolver; user has to free old data in advance!
- sets the timing mask of the presolver
- transforms and presolves problem
- presolve cumulative condition w.r.t. effective horizon by detecting irrelevant variables
- returns whether the user pressed CTRL-C to interrupt the solving process
- gets user data of variable pricer
- gets description of variable pricer
- gets the number of times, the pricer was called and tried to find a variable with negative reduced costs
- gets the number of variables with negative reduced costs found by this pricer
- gets name of variable pricer
- gets priority of variable pricer
- gets time in seconds used in this pricer for setting up for next stages
- gets time in seconds used in this pricer
- returns whether the given pricer is in use in the current problem
- returns whether the pricer should be delayed until no other pricer finds a new variable
- is variable pricer initialized?
- sets user data of variable pricer; user has to free old data in advance!
- outputs Benders’ decomposition statistics
- outputs best feasible primal solution found so far to file stream
- outputs best feasible primal solution found so far in transformed variables to file stream
- outputs history statistics about branchings on variables
- outputs branching rule statistics
- prints detailed information on the compile-time flags
- outputs compression statistics
- outputs concurrent solver statistics
- outputs conflict statistics
- outputs constraint information to file stream via the message handler system
- outputs constraint statistics
- outputs constraint timing statistics
- outputs cutselector statistics
- outputs node information display line
- outputs dual solution from LP solver to file stream
- prints error message for the given SCIP_RETCODE via the error prints method
- print an expression as info-message
- main part of printing an expression in dot format
- finishes printing of expressions in dot format
- initializes printing of expressions in dot format to a give FILE* pointer
- initializes printing of expressions in dot format to a file with given filename
- prints quadratic expression
- outputs expression handler statistics
- prints information on external codes to a file stream via the message handler system
- outputs heuristics statistics
- Displays quality information about the current LP solution. An LP solution need to be available. Information printed is subject to what the LP solver supports
- outputs LP statistics
- print linear constraint classification statistics
- outputs discrete variables of solution in original problem space to the given file stream
- prints output about used memory
- outputs NLPI statistics
- outputs NLP statistics
- prints a nonlinear row to file stream
- prints all branching decisions on variables from the root to the given node
- outputs original problem to file stream
- outputs statistics for original problem
- outputs presolver statistics
- outputs pricer statistics
- outputs propagator statistics
- outputs non-zero variables of solution representing a ray in original problem space to file stream
- outputs a real number, or “+infinity”, or “-infinity” to a file
- outputs relaxator statistics
- outputs reoptimization statistics
- outputs root statistics
- output row to file stream via the message handler system
- prints a rowprep
- prints a rowprep and values in solution
- outputs separator statistics
- outputs non-zero variables of solution in original problem space to the given file stream
- print given solution in Flatzinc format w.r.t. the output annotation
- outputs solution statistics
- outputs SCIP stage and solution status if applicable via the message handler
- outputs solving statistics
- outputs solution status
- outputs status statistics
- prints an error message containing of the given string followed by a string describing the current system error; prefers to use the strerror_r method, which is threadsafe; on systems where this method does not exist, NO_STRERROR_R should be defined (see INSTALL), in this case, srerror is used which is not guaranteed to be threadsafe (on SUN-systems, it actually is)
- outputs timing statistics
- outputs transformed problem of the current node to file stream
- outputs statistics for transformed problem
- outputs non-zero variables of solution in transformed problem space to file stream
- outputs tree statistics
- outputs variable information to file stream via the message system
- prints a version information line to a file stream via the message handler system
- processes a rowprep for cut addition and maybe report branchscores
- evaluates command line parameters and runs SCIP appropriately in the given SCIP instance
- creates resource profile
- subtracts the height from the resource profile during core time
- returns if the given time point exists in the resource profile and stores the position of the given time point if it exists; otherwise the position of the next smaller existing time point is stored
- frees given resource profile
- returns the capacity of the resource profile
- return the earliest possible starting point within the time interval [lb,ub] for a given core (given by its height and duration)
- return the latest possible starting point within the time interval [lb,ub] for a given core (given by its height and duration)
- returns the loads of the resource profile at the given position
- returns the loads of the resource profile
- returns the number time points of the resource profile
- returns the time point for given position of the resource profile
- returns the time points of the resource profile
- insert a core into resource profile; if the core is non-empty the resource profile will be updated otherwise nothing happens
- output of the given resource profile
- calls domain propagation method of single constraint
- propagate the given cumulative condition
- does the propagator perform presolving?
- gets user data of propagator
- gets description of propagator
- gets frequency of propagator
- gets number of constraints added during presolving of propagator
- gets number of holes added to domains of variables during presolving of propagator
- gets number of variables aggregated during presolving of propagator
- gets the total number of times, the propagator was called
- gets number of bounds changed during presolving of propagator
- gets number of coefficients changed during presolving of propagator
- gets number of constraint sides changed during presolving of propagator
- gets number of variable types changed during presolving of propagator
- gets total number of times, this propagator detected a cutoff
- gets number of constraints deleted during presolving of propagator
- gets total number of domain reductions found by this propagator
- gets number of variables fixed during presolving of propagator
- gets number of times the propagator was called in presolving and tried to find reductions
- gets the total number of times, the propagator was called for resolving a propagation
- gets number of constraints upgraded during presolving of propagator
- gets name of propagator
- gets presolving priority of propagator
- gets time in seconds used in this propagator for presolving
- returns the timing mask of the presolving method of the propagator
- gets priority of propagator
- gets time in seconds used in this propagator for resolve propagation
- gets time in seconds used for setting up this propagator for new stages
- gets time in seconds used in this propagator during strong branching
- gets time in seconds used in this propagator
- returns the timing mask of the propagator
- should propagator be delayed, if other propagators found reductions?
- is propagator initialized?
- sets user data of propagator; user has to free old data in advance!
- sets frequency of propagator
- sets the timing mask of the presolving method of the propagator
- was propagator delayed at the last call?
- propagates the cutoff bound for the given variables
- applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
- applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; only propagations of the binary variables fixed at the current probing node that are triggered by the implication graph and the clique table are applied; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
- removes all nodes from branch and bound tree that were marked to be cut off via SCIPcutoffNode()
- tests at a given confidence level whether the variable pseudo-costs only have a small probability to exceed a \p threshold. This is useful to determine if past observations provide enough evidence to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement of at least \p threshold.
- clears the queue, but doesn’t free the data elements themselves
- creates a (circular) queue, best used if the size will be fixed or will not be increased that much
- returns the first element of the queue without removing it, or NULL if no element exists
- returns the first unsigned integer element of the queue without removing it, or UINT_MAX if no element exists
- frees queue, but not the data elements themselves
- inserts pointer element at the end of the queue
- inserts unsigned integer element at the end of the queue
- returns whether the queue is empty
- returns the number of elements in the queue
- removes and returns the first element of the queue, or NULL if no element exists
- removes and returns the first unsigned integer element of the queue, or UNIT_MAX if no element exists
- 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
- randomly shuffles parts of an array using the Fisher-Yates algorithm
- randomly shuffles parts of an integer array using the Fisher-Yates algorithm
- reads problem from file
- reads problem from file
- reads problem from file
- reads problem from file
- reads problem from file
- reads parameters from a file
- reads problem from file
- reads problem from file and initializes all solving data structures
- reads a given solution file
- reads a given solution file and store the solution values in the given solution pointer
- reads the stochastic information for a stochastic program that is in SMPS format
- reads the stage information for a stochastic programming instance in SMPS format
- return whether the reader can read files
- return whether the reader can write files
- gets user data of reader
- gets description of reader
- gets file extension of reader
- gets name of reader
- sets user data of reader; user has to free old data in advance!
- converts a real number into a (approximate) rational representation, and returns TRUE iff the conversion was successful
- recalculates the activity of a nonlinear row in the last NLP or pseudo solution
- recalculates the activity of a nonlinear row in the last NLP solution
- recalculates the activity of a nonlinear row for the current pseudo solution
- recalculates the activity of a row in the last LP or pseudo solution
- recalculates the activity of a row in the last LP solution
- recalculates the activity of a row for the current pseudo solution
- recomputes the objective value of an original solution, e.g., when transferring solutions from the solution pool (objective coefficients might have changed in the meantime)
- method to be called by a nlhdlr during NLHDLRDETECT to notify an expression that it will be used
- update regression by a new observation (x,y)
- creates and resets a regression
- frees a regression
- get the current y-intercept of the regression
- returns the number of observations of this regression
- return the current slope of the regression
- removes an observation (x,y) from the regression
- reset regression data structure
- returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0)
- gets user data of relaxation handler
- gets description of relaxation handler
- gets frequency of relaxation handler
- gets the time in seconds spent for the execution of the relaxation handler when a node’s lower bound could be improved (or a cutoff was found)
- gets the total number of times the relaxation handler added constraints
- gets the total number of times the relaxation handler was called
- gets the total number of times the relaxation handler cut off a node
- gets the total number of times the relaxation handler improved a node’s lower bound
- gets the total number of times the relaxation handler reduced variable domains
- gets the total number of times the relaxation handler separated cutting planes
- gets name of relaxation handler
- gets priority of relaxation handler
- gets time in seconds used in this relaxator for setting up for next stages
- gets time in seconds used in this relaxation handler
- is relaxation handler initialized?
- marks the current relaxation unsolved, s.t. the relaxation handler is called again in the next solving round
- sets user data of relaxation handler; user has to free old data in advance!
- return the relaxation primal feasibility tolerance
- decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
- releases a dialog
- releases an expression (decrements usage count and possibly frees expression)
- decreases usage counter of a nonlinear row, and frees memory if necessary
- decreases usage counter of LP row, and frees memory if necessary
- decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
- remove all children of expr
- removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
- Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds. This is an advanced method which should be used with care.
- returns the number of iteration with the first global restarts
- returns the number of iteration with the last global restarts
- returns the number of reoptimized nodes that were cut off in the current run
- returns the number of nodes providing an improving feasible LP solution in the current run
- returns the number of stored nodes with an infeasible LP in the current run
- returns the number of nodes that exceeded the cutoff bound in the current run
- returns the number of global restarts
- returns the number of local restarts in the current run
- returns the number of reoptimized nodes that were cut off over all runs
- returns the number of nodes providing an improving feasible LP solution over all runs
- returns the number of stored nodes with an infeasible LP over all runs
- returns the number of nodes that exceeded the cutoff bound over all runs
- returns the number of local restarts over all runs
- returns if a node should be reoptimized
- returns all added constraints at ID id
- returns the number of child nodes of @p reoptnode
- returns the number of bound changes at the node stored at ID id
- returns the number of stored bound changes based on dual information in the reopttree at ID id
- returns the number of bound changes stored in the reoptnode
- create the constraint which splits the node stored at ID id on the basis of the stored dual information.
- returns the type of the @p reoptnode
- set the parent id
- @addtogroup PRIMALHEURISTICS
- replaces common sub-expressions in a given expression graph by using a hash key for each expression
- overwrites/replaces a child of an expressions
- marks the given node to be propagated again the next time a node of its subtree is processed
- reset the bandit algorithm
- resets the time measurement of a clock to zero and completely stops the clock
- resets age of constraint to zero; should be called
- resets primal feasibility tolerance of LP
- resets a single parameter to its default value
- resets all parameters to their default values
- mark all stored solutions as not updated
- remove the stored information about bound changes based in dual information
- reset a set of initialized reoptimization nodes
- resolves propagation conflict of single constraint
- resolve propagation w.r.t. the cumulative condition
- informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has been solved)
- maps transformed objective value into original space
- retransforms solution to original problem space
- rounds value to the nearest integer with epsilon tolerance
- try to round given solution
- calculates the probability of satisfying an LP-row under the assumption of uniformly distributed variable values.
- changes the rank of LP row
- returns the number of times that this row has been sharp in an optimal LP solution
- gets age of row
- gets the basis status of a row in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_BASIC for rows not in the current SCIP_LP
- gets array with columns of nonzero entries
- gets constant shift of row
- gets the dual Farkas coefficient of a row in an infeasible LP
- gets the dual LP solution of a row
- gets unique index of row
- gets depth in the tree where the row entered the LP, or -1 if it is not in LP
- gets position of row in current LP, or -1 if it is not in LP
- returns the left hand side of the row
- get number of nonzero entries in row vector, that correspond to columns currently in the SCIP_LP;
- returns the number of LPs since this row has been created
- get number of nonzero entries in row vector
- returns the name of the row
- gets Euclidean norm of row vector
- returns origin constraint that created the row (NULL if not available)
- returns origin constraint handler that created the row (NULL if not available)
- returns origin separator that created the row (NULL if not available)
- returns type of origin that created the row
- returns the degree of orthogonality between the hyperplanes defined by the two row vectors v, w: o = 1 - |vw|/(|v||w|); the hyperplanes are orthogonal, iff p = 1, they are parallel, iff p = 0
- returns the degree of parallelism between the hyperplanes defined by the two row vectors v, w: p = |vw|/(|v||w|); the hyperplanes are parallel, iff p = 1, they are orthogonal, iff p = 0
- gets rank of row
- returns the right hand side of the row
- returns the scalar product of the coefficient vectors of the two given rows
- gets sum norm of row vector (sum of absolute values of coefficients)
- gets array with coefficients of nonzero entries
- returns TRUE iff row is member of the global cut pool
- returns TRUE iff row is member of current LP
- returns TRUE iff the activity of the row (without the row’s constant) is always integral in a feasible solution
- returns TRUE iff row is only valid locally
- returns TRUE iff row is modifiable during node processing (subject to column generation)
- returns TRUE iff row is removable from the LP (due to aging or cleanup)
- locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows
- sorts row entries such that LP columns precede non-LP columns and inside both parts lower column indices precede higher ones
- unlocks a lock of an unmodifiable row; a row with no sealed lock may be modified; has no effect on modifiable rows
- adds constant term to rowprep
- adds constant value to side of rowprep
- gives coefficients of rowprep (feel free to modify)
- returns variables which coefficients were modified in cleanup
- returns number of variables which coefficients were modified in cleanup
- gives number of terms in rowprep
- returns name of rowprep (feel free to modify)
- gives side of rowprep
- gives kind of inequality of rowprep
- gives variables of rowprep (feel free to modify)
- returns whether rowprep is locally valid only
- enables recording for where modifications were done in cleanup
- resets rowprep to have 0 terms and side 0.0
- sets whether rowprep is local
- sets side type of rowprep
- creates a SCIP instance with default plugins, evaluates command line parameters, runs SCIP appropriately, and frees the SCIP instance
- scales a rowprep by given factor (after some rounding)
- scales the branch factor of the variable with the given value
- Scales up a rowprep to increase coefficients/sides that are within epsilon to an integer value, if possible.
- selects a branching variable, due to pseudo cost, from the given candidate array and returns this variable together with a branching point
- perform a cut selection algorithm for the given array of cuts
- partial sort an index array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort array of ints in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort an array of Longints in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of an array of pointers in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort an array of Reals in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order around the \p k-th element
- partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort an index array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort array of ints in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort an array of Longints in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of an array of pointers in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort an array of Reals in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
- given a (usually very small) interval, selects a value inside this interval; it is tried to select a rational number with simple denominator (i.e. a small number, probably multiplied with powers of 10); if no valid rational number inside the interval was found, selects the central value of the interval
- Selects a variable from a set of candidates by strong branching
- Selects a variable from a set of candidates by strong branching
- partial sort an index array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort array of ints in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort an array of Longints in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of an array of pointers in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort an array of Reals in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity
- partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort an index array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort array of ints in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort an array of Longints in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of an array of pointers in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort an array of Reals in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity, see \ref SelectionAlgorithms for more information.
- gets user data of separator
- gets description of separator
- gets frequency of separator
- get maximal bound distance at which the separator is called
- gets the total number of times the separator was called
- gets the number of times, the separator was called at the current node
- gets total number of additional constraints added by this separator
- gets total number of times, the separator detected a cutoff
- gets the total number of cutting planes added from the separator to the sepastore; equal to the sum of added cuts directly and via the pool.
- gets the number of cutting planes from the separator added directly to the sepastore
- gets the number of cutting planes from the separator added from the cut pool
- gets the total number of cutting planes from the separator applied to the LP
- gets the total number of cutting planes from the separator applied directly to the LP
- gets the total number of cutting planes from the separator applied to the LP from the cutpool
- gets the total number of cutting planes added from the separator to the cut pool and to the sepastore directly
- gets the number of cutting planes found by this separator at the current node
- gets total number of domain reductions found by this separator
- gets the total number of times the separator was called at the root
- gets name of separator
- gets parent separator (or NULL)
- gets priority of separator
- gets time in seconds used in this separator for setting up for next stages
- gets time in seconds used in this separator
- should separator be delayed, if other separators found cuts?
- is separator initialized?
- gets whether separator is a parent separator
- sets user data of separator; user has to free old data in advance!
- sets frequency of separator
- does the separator use a secondary SCIP instance?
- was separation of the LP solution delayed at the last call?
- was separation of the primal solution delayed at the last call?
- calls separation method of single constraint for LP solution
- separates cuts from a cut pool
- separates different classes of valid inequalities for the 0-1 knapsack problem
- separates the given primal solution or the current LP solution by calling the separators and constraint handlers’ separation methods; the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and SCIPgetNCuts(); after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the separation storage; it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts afterwards
- separates cuts w.r.t. given solution from a cut pool
- calls separation method of single constraint for given primal solution
- sets point to be used as base point for computing the point to be separated
- sets copy method of benders
- sets deinitialization method of benders
- sets presolving deinitialization method of benders
- sets solving process deinitialization method of benders
- sets destructor method of benders
- sets initialization method of benders
- sets presolving initialization method of benders
- sets solving process initialization method of benders
- sets the post solving methods for benders
- sets the method called prior to solving the subproblems for benders
- sets the priority of a Benders’ decomposition
- sets the subproblem solving and freeing methods for Benders’ decomposition
- sets the subproblem comparison method for determining the solving order in Benders’ decomposition
- sets copy method of Benders’ decomposition cut
- sets deinitialization method of benderscut
- sets solving process deinitialization method of benderscut
- sets destructor method of benderscut
- sets initialization method of benderscut
- sets solving process initialization method of benderscut
- sets the priority of a Benders’ decomposition cut algorithm
- set beta parameter of Exp.3 bandit algorithm to increase gain offset for actions that were not played
- sets binary indicator variable for indicator constraint
- changes the value of an existing SCIP_Bool parameter
- sets value of entry in dynamic array
- sets copy method of branching rule
- sets branching execution method for external candidates
- sets branching execution method for fractional LP solutions
- sets branching execution method for not completely fixed pseudo solutions
- sets deinitialization method of branching rule
- sets solving process deinitialization method of branching rule
- sets destructor method of branching rule
- sets initialization method of branching rule
- sets solving process initialization method of branching rule
- sets maximal relative distance from current node’s dual bound to primal bound for applying branching rule
- sets maximal depth level, up to which this branching rule should be used (-1 for no limit)
- sets the priority of a branching rule
- changes the value of an existing char parameter
- enables or disables \p clck
- sets the measured time of a clock to the given value in seconds
- sets the working limits as well as common search parameters for the auxiliary problem
- sets copy method of tree compression
- sets deinitialization method of tree compression
- sets solving process deinitialization method of tree compression
- sets destructor method of tree compression
- sets initialization method of tree compression
- sets solving process initialization method of tree compression
- set the priority of a tree compression method
- set copy method of conflict handler
- set deinitialization method of conflict handler
- set solving process deinitialization method of conflict handler
- set destructor of conflict handler
- set initialization method of conflict handler
- set solving process initialization method of conflict handler
- sets the priority of a conflict handler
- sets the check flag of the given constraint
- sets the dynamic flag of the given constraint
- sets the enforce flag of the given constraint
- sets the initial flag of the given constraint
- sets the local flag of the given constraint
- sets the modifiable flag of the given constraint
- sets the propagate flag of the given constraint
- sets the removable flag of the given constraint
- sets the separate flag of the given constraint
- sets the stickingatnode flag of the given constraint
- sets activation notification method of constraint handler
- sets copy method of both the constraint handler and each associated constraint
- sets deactivation notification method of constraint handler
- sets method of constraint handler to free specific constraint data
- sets variable deletion method of constraint handler
- sets disabling notification method of constraint handler
- sets enabling notification method of constraint handler
- sets relaxation enforcement method of the constraint handler
- sets deinitialization method of constraint handler
- sets preprocessing deinitialization method of constraint handler
- sets solving process deinitialization method of constraint handler
- sets destructor method of constraint handler
- sets diving enforcement method of constraint handler
- sets constraint variable number getter method of constraint handler
- sets constraint variable getter method of constraint handler
- sets initialization method of constraint handler
- sets method of constraint handler to initialize LP with relaxations of “initial” constraints
- sets preprocessing initialization method of constraint handler
- sets solving process initialization method of constraint handler
- sets constraint parsing method of constraint handler
- sets presolving method of constraint handler
- sets constraint display method of constraint handler
- sets both the propagation callback and the propagation frequency of the constraint handler
- sets propagation conflict resolving method of constraint handler
- sets all separation related callbacks/parameters of the constraint handler
- sets method of constraint handler to transform constraint data into data belonging to the transformed problem
- sets the constant of a summation expression
- sets copy method of cut selector
- sets deinitialization method of cut selector
- sets solving process deinitialization method of cut selector
- sets destructor method of cut selector
- sets initialization method of cut selector
- sets solving process initialization method of cut selector
- sets the priority of a cut selector
- sets parameters to
- set epsilon parameter of epsilon greedy bandit algorithm
- sets copy callback of the event handler
- sets callback of the event handler to free specific event data
- sets deinitialization callback of the event handler
- sets solving process deinitialization callback of the event handler
- sets deinitialization callback of the event handler
- sets initialization callback of the event handler
- sets solving process initialization callback of the event handler
- sets the auxiliary value of expression for one of the enforcements of an expression
- sets whether the LP should be solved at the focus node
- set gamma parameter of Exp.3 bandit algorithm to increase weight of uniform distribution
- sets copy method of primal heuristic
- sets deinitialization method of primal heuristic
- sets solving process deinitialization method of primal heuristic
- sets destructor method of primal heuristic
- sets initialization method of primal heuristic
- sets solving process initialization method of primal heuristic
- sets the priority of a primal heuristic
- sets heuristic parameters values to
- set the right bound of the effective horizon
- set the left bound of effective horizon
- sets the index stored in a varidx expression
- changes the value of an existing int parameter
- sets value of entry in dynamic array
- sets primal feasibility tolerance of LP
- sets the linear constraint corresponding to the indicator constraint (may be NULL)
- changes the value of an existing SCIP_Longint parameter
- installs the given message handler, such that all messages are passed to this handler. A messages handler can be created via SCIPmessagehdlrCreate().
- sets the log file name for the currently installed message handler
- sets the currently installed message handler to be quiet (or not)
- sets or clears initial primal guess for NLP solution (start point for NLP solver)
- sets initial primal guess for NLP solution (start point for NLP solver)
- sets or deletes expression in a nonlinear row
- sets the priority of an NLPI
- sets copy method of node selector
- sets deinitialization method of node selector
- sets solving process deinitialization method of node selector
- sets destructor method of node selector
- sets initialization method of node selector
- sets solving process initialization method of node selector
- sets the priority of a node selector in memory saving mode
- sets the priority of a node selector in standard mode
- informs SCIP, that the objective value is always integral in every feasible solution
- sets limit on objective function, such that only solutions better than this limit are accepted
- sets objective sense of problem
- setting SCIP parameters for such that a valid counting process is possible
- sets copy method of presolver
- sets deinitialization method of presolver
- sets solving process deinitialization method of presolver
- sets destructor method of presolver
- sets initialization method of presolver
- sets solving process initialization method of presolver
- sets the priority of a presolver
- sets presolving parameters to
- sets copy method of pricer
- sets deinitialization method of pricer
- sets solving process deinitialization method of pricer
- sets destructor method of pricer
- sets initialization method of pricer
- sets solving process initialization method of pricer
- sets the priority of a variable pricer
- sets callback to copy user data to a subscip
- sets user problem data
- sets callback to free user data of original problem
- sets callback to free user data of transformed problem
- sets solving process deinitialization callback of transformed data
- sets solving process initialization callback of transformed data
- sets name of the current problem instance
- sets callback to create user data of transformed problem by transforming original user data
- sets the LP state for the current probing node
- sets copy method of propagator
- sets deinitialization method of propagator
- sets preprocessing deinitialization method of propagator
- sets solving process deinitialization method of propagator
- sets destructor method of propagator
- sets initialization method of propagator
- sets preprocessing initialization method of propagator
- sets solving process initialization method of propagator
- sets presolving method of propagator
- sets the presolving priority of a propagator
- sets the priority of a propagator
- sets propagation conflict resolving callback of propagator
- sets value of entry in dynamic array
- initializes a random number generator with a given seed
- set copy method of reader
- set deinitialization method of reader
- set read method of reader
- set write method of reader
- changes the value of an existing SCIP_Real parameter
- sets value of entry in dynamic array
- sets copy method of relaxation handler
- sets deinitialization method of relaxation handler
- sets solving process deinitialization method of relaxation handler
- sets destructor method of relaxation handler
- sets initialization method of relaxation handler
- sets solving process initialization method of relaxation handler
- sets the priority of a relaxation handler
- sets the value of the given variable in the global relaxation solution; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; You can use SCIPclearRelaxSolVals() to set all values to zero, initially; after setting all solution values, you have to call SCIPmarkRelaxSolValid() to inform SCIP that the stored solution is valid
- sets the values of the given variables in the global relaxation solution and informs SCIP about the validity and whether the solution can be enforced via linear cuts; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; the solution is automatically cleared, s.t. all other variables get value 0.0
- sets the values of the variables in the global relaxation solution to the values in the given primal solution and informs SCIP about the validity and whether the solution can be enforced via linear cuts; the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
- set the @p representation as the new search frontier
- makes given dialog the root dialog of SCIP’s interactive user shell; captures dialog and releases former root dialog
- sets copy method of separator
- sets deinitialization method of separator
- sets solving process deinitialization method of separator
- sets destructor method of separator
- sets initialization method of separator
- sets solving process initialization method of separator
- declares separator to be a parent separator
- sets the parent separator
- sets the priority of a separator
- sets separating parameters to
- sets upper bound for slack variable corresponding to indicator constraint
- sets value of variable in primal CIP solution
- sets values of multiple variables in primal CIP solution
- sets method to solve an individual cumulative condition
- changes the value of an existing string(char*) parameter
- sets depth of scip instance
- sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for auxiliary SCIP instances to avoid recursion
- sets strong branching information for a column variable
- calls the generic subproblem setup method for a Benders’ decomposition subproblem
- shows a single expression by use of dot and gv
- @defgroup PublicSpecialPresolveMethods Special Methods @ingroup PublicPresolverMethods @brief methods commonly used for presolving
- check if variable pseudo-costs have a significant difference in location. The significance depends on the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the unknown location means of the underlying pseudo-cost distributions of x and y.
- simplifies an expression
- safe version of snprintf
- print statistics of probing
- get maximum absolute bound violation of solution
- get maximum absolute constraint violation of solution
- get maximum absolute integrality violation of solution
- get maximum absolute LP row violation of solution
- gets node’s depth, where this solution was found
- gets heuristic that found this solution, or NULL if solution has type different than SCIP_SOLTYPE_HEUR
- returns unique index of given solution
- gets node number of the specific branch and bound run, where this solution was found
- gets objective value of primal CIP solution which lives in the original problem space
- gets origin of solution
- get maximum relative bound violation of solution
- get maximum relative constraint violation of solution
- get maximum relative LP row violation of solution
- gets relaxation handler that found this solution, or NULL if solution has different type than SCIP_SOLTYPE_RELAX
- gets branch and bound run number, where this solution was found
- gets clock time, when this solution was found
- gets information if solution was found by the LP, a primal heuristic, or a custom relaxator
- returns whether the given solution is defined on original variables
- returns whether the given solution is partial
- informs the solution that it now belongs to the given primal heuristic. For convenience and backwards compatibility, the method accepts NULL as input for \p heur, in which case the solution type is set to SCIP_SOLTYPE_LPRELAX.
- informs the solution that it is an LP relaxation solution
- informs the solution that it originates from a pseudo solution
- informs the solution that it now belongs to the given relaxation handler
- informs the solution that it is a solution found during strong branching
- transforms, presolves, and solves problem
- calls the solving method for a single Benders’ decomposition subproblem
- calls the exec method of Benders’ decomposition to solve the subproblems
- transforms, presolves, and solves problem using additional solvers which emphasize on finding solutions.
- solves given cumulative condition as independent sub problem
- solves the LP of the current dive; no separation or pricing is applied
- solves knapsack problem in maximization form approximately by solving the LP-relaxation of the problem using Dantzig’s method and rounding down the solution; if needed, one can provide arrays to store all selected items and all not selected items
- solves knapsack problem in maximization form exactly using dynamic programming; if needed, one can provide arrays to store all selected items and all not selected items
- solves a linear problem of the form Ax = b for a regular matrix A
- solves the current NLP (or diving NLP if in diving mode) with given parameters
- transforms, presolves, and solves problem using additional solvers which emphasize on finding solutions.
- solves the LP at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied
- solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing until the LP is solved to optimality; no separation is applied
- solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied
- sort an indexed element set in non-decreasing order, resulting in a permutation index array
- sort the variables of the AND-constraint with respect to their indices
- sort an indexed element set in non-increasing order, resulting in a permutation index array
- sort an index array in non-increasing order
- sort array of ints in non-increasing order
- sort of two joint arrays of ints/ints, sorted by first array in non-increasing order
- sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order
- sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order
- sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order
- sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order
- sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order
- sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order
- sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order
- sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order
- sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order
- sort of two joint arrays of ints/reals, sorted by first array in non-increasing order
- sort an array of Longints in non-increasing order
- sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order
- sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order
- sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order
- sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order
- sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order
- sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order
- sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order
- sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order
- sort of an array of pointers in non-increasing order
- sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order
- sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order
- sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order
- sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order
- sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order
- sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order
- sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order
- sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order
- sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order
- sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order
- sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order
- sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order
- sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order
- sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order
- sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order
- sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order
- sort an array of Reals in non-increasing order
- sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order
- sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order
- sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order
- sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order
- sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order
- sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order
- sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order
- sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order
- sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order
- sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order
- sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order
- sort an index array in non-decreasing order
- sort array of ints in non-decreasing order
- sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order
- sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order
- sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order
- sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order
- sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order
- sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order
- sort an array of Longints in non-decreasing order
- sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order
- sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order
- sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order
- sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order
- sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order
- sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order
- sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order
- sort of an array of pointers in non-decreasing order
- sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order
- sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order
- sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order
- sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order
- sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order
- sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order
- sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order
- sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order
- sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order
- sort an array of Reals in non-decreasing order
- sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order
- sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order
- sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order
- sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order
- sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order
- sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order
- sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order
- sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order
- sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from an index array in non-increasing order
- delete the element at the given position from an array of ints in non-increasing order
- delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order
- delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order
- delete the element at the given position from an array of Longints, sorted in non-increasing order
- delete the element at the given position from two arrays of Long/pointer, sorted by the first array in non-increasing order
- delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order
- delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order
- delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order
- delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order
- delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order
- delete the element at the given position from an array of pointers in non-increasing order
- delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order
- deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from an array of Reals, sorted in non-increasing order
- delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order
- delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order
- delete the element at the given position from three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order
- delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order
- delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order
- delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order
- delete the element at the given position from an index array in non-decreasing order
- delete the element at the given position from an array of ints in non-decreasing order
- delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order
- delete the element at the given position from an array of Longints, sorted by in non-decreasing order
- delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order
- delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order
- delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order
- delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order
- delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order
- delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order
- delete the element at the given position from an array of pointers in non-decreasing order
- delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order
- deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order
- deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of pointers/RealsReals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of pointers/RealsReals//ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of pointers/RealsReals/ints/SCIP_Bools, sorted by first array in non-decreasing order
- delete the element at the given position from an arrays of Reals, sorted in non-decreasing order
- delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order
- delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order
- delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order
- delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order
- delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- Finds the position at which ‘val’ is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in ‘*pos’. If the element does not exist, the method returns FALSE and stores the position of the element that follows ‘val’ in the ordering in ‘*pos’, i.e., ‘*pos’ is the position at which ‘val’ would be inserted. Note that if the element is not found, ‘*pos’ may be equal to len if all existing elements are smaller than ‘val’.
- insert a new element into an index array in non-increasing order
- insert a new element into an array of ints in non-increasing order
- insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order
- insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order
- insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order
- insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order
- insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order
- insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order
- insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order
- insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order
- insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order
- insert a new element into an array of Longints, sorted in non-increasing order
- insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order
- insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order
- insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order
- insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order
- insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order
- insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order
- insert a new element into an array of pointers in non-increasing order
- insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order
- insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order
- insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order
- insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order
- insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order
- insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order
- insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order
- insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order
- insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order
- insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order
- insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order
- insert a new element into an array of Reals, sorted in non-increasing order
- insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order
- insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order
- insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order
- insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order
- insert a new element into three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order
- insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order
- insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order
- insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order
- insert a new element into an index array in non-decreasing order
- insert a new element into an array of ints in non-decreasing order
- insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order
- insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order
- insert a new element into an array of Longints, sorted in non-decreasing order
- insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order
- insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order
- insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order
- insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order
- insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order
- insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order
- insert a new element into an array of pointers in non-decreasing order
- insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order
- insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order
- insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order
- insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order
- insert a new element into an arrays of Reals, sorted in non-decreasing order
- insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order
- insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order
- insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order
- insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order
- insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order
- insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order
- insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order
- creates a sparse solution
- frees sparse solution
- constructs the first solution of sparse solution (all variables are set to their lower bound value
- returns the the lower bound array for all variables for a given sparse solution
- returns the number of variables in the given sparse solution
- constructs the next solution of the sparse solution and return whether there was one more or not
- returns the the upper bound array for all variables for a given sparse solution
- returns the variables in the given sparse solution
- searches for a time point within the cumulative condition were the cumulative condition can be split
- splits filename into path, name, and extension
- splits the root into several nodes and moves the child nodes of the root to one of the created nodes
- starts the time measurement of a clock
- initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
- initiates NLP diving
- starts interactive mode of SCIP by executing the root dialog
- initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
- starts the current solving time
- start strong branching - call before any strong branching
- returns the total number of scenarios added to the problem
- stops the time measurement of a clock
- stops the current solving time in seconds
- adds the generated cuts to the Benders’ cut storage
- update statistical information when a new solution was found
- checks whether a given string t appears at the beginning of the string s (up to spaces at beginning)
- copies the first size characters between a start and end character of str into token, if no error occurred endptr will point to the position after the read part, otherwise it will point to @p str
- extract the next token as a integer value if it is one; in case no value is parsed the endptr is set to @p str
- extract the next token as a double value if it is one; in case a value is parsed the endptr is set to @p str
- safe version of strncpy
- extracts tokens from strings - wrapper method for strtok_r()
- get critical value of a Student-T distribution for a given number of degrees of freedom at a confidence level
- returns SCIP sub version number
- calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding LP row are swapped in the summation
- returns value treated as zero for sums of floating point values
- swaps two ints
- swaps the addresses of two pointers
- swaps two real values
- gets user data of statistics table
- gets description of statistics table
- gets earliest stage of statistics table
- gets name of statistics table
- gets position of statistics table
- is statistics table currently active?
- is statistics table initialized?
- sets user data of statistics table; user has to free old data in advance!
- returns SCIP technical version
- informs the expression about new bounds that can be used for reverse-propagation and to tighten bounds of corresponding (auxiliary) variable (if any)
- 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; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision
- changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound
- 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; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision
- changes global 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 global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound
- @}
- gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed, a new transformed constraint for this constraint is created
- gets and captures transformed constraints for an array of constraints; if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created; it is possible to call this method with conss == transconss
- transforms the current problem into a MinUC problem (minimizing the number of unsatisfied constraints), a CIP generalization of the MinULR (min. unsatisfied linear relations) problem
- maps original space objective value into transformed objective value
- initializes solving data structures and transforms problem
- gets and captures transformed variable of a given variable; if the variable is not yet transformed, a new transformed variable for this variable is created
- gets and captures transformed variables for an array of variables; if a variable of the array is not yet transformed, a new transformed variable for this variable is created; it is possible to call this method with vars == transvars
- translates a solution from a subscip to the main scip
- checks the solutions from the subscip and adds the first one that is found feasible to the master SCIP
- checks current LP/pseudo solution for feasibility; if possible, adds it to storage
- checks solution for feasibility; if possible, adds it to storage by copying
- checks primal solution; if feasible, adds it to storage; solution is freed afterwards
- rounds the current solution and tries it afterwards; if feasible, adds it to storage
- unfixes the value of an existing parameter
- stores solution values of variables in solution’s own array
- remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed
- unmarks the constraint to be propagated
- updates the flags of the first constraint according to the ones of the second constraint
- updates the cutoff bound
- update the up- and downscore of a single variable after calculating the impact of branching on a particular row, depending on the chosen score parameter
- update diveset LP statistics, should be called after every LP solved by this diving heuristic
- update diveset statistics and global diveset statistics
- if given value is tighter (larger for minimization, smaller for maximization) than the current node’s dual bound (in original problem space), sets the current node’s dual bound to the new value
- if given value is larger than the current node’s lower bound (in transformed problem), sets the current node’s lower bound to the new value
- updates variable bounds and the cutoff row in a NLPI problem
- if given value is tighter (larger for minimization, smaller for maximization) than the node’s dual bound, sets the node’s dual bound to the new value
- if given value is larger than the node’s lower bound (in transformed problem), sets the node’s lower bound to the new value
- updates the primal ray thats proves unboundedness
- update bound violation of a solution
- update constraint violation of a solution
- update integrality violation of a solution
- update LP row and constraint violations of a solution
- update LP row violation of a solution
- updates the starting point for the NLP heuristic
- changes the branch priority of the variable to the given value, if it is larger than the current priority
- updates the pseudo costs of the given variable and the global pseudo costs after a change of “solvaldelta” in the variable’s solution value and resulting change of “objdelta” in the in the LP’s objective value; the update is ignored, if the objective value difference is infinite
- tries to automatically convert a linear constraint into a more specific and more specialized constraint
- validate the result of the solve
- return the array containing the histories for the individual (domain) values
- return the number of (domain) values for which a history exists
- return the array containing the (domain) values for which a history exists
- calculate the variable’s distribution parameters (mean and variance) for the bounds specified in the arguments. special treatment of infinite bounds necessary
- compares the index of two variables, returns -1 if first is smaller than, and +1 if first is greater than second variable index; returns 0 if both indices are equal, which means both variables are equal
- compares the index of two variables, only active or negated variables are allowed, if a variable is negated then the index of the corresponding active variable is taken, returns -1 if first is smaller than, and +1 if first is greater than second variable index; returns 0 if both indices are equal, which means both variables are equal
- gets aggregation constant c of an aggregated variable x = a*y + c
- gets aggregation scalar a of an aggregated variable x = a*y + c
- gets aggregation variable y of an aggregated variable x = a*y + c
- gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable e.g. obj(x) = 1 this method returns for ~x the value -1
- returns the average depth of bound changes in given direction due to branching on the variable
- returns the average depth of bound changes in given direction due to branching on the variable in the current run
- returns a weighted average solution value of the variable in all feasible primal solutions found so far
- returns lower or upper bound of variable directly before or after the bound change given by the bound change index was applied
- returns the bound change information for the last lower or upper bound change on given active problem variable before or after the bound change with the given index was applied; returns NULL, if no change to the lower/upper bound was applied up to this point of time
- return lower bound change info at requested position
- return upper bound change info at requested position
- gets best global bound of variable with respect to the objective function
- gets best local bound of variable with respect to the objective function
- gets type (lower or upper) of best bound of variable with respect to the objective function
- returns the best objective value (w.r.t. root reduced cost propagation) of the root LP which belongs the root reduced cost which is accessible via SCIPvarGetRootRedcost() or the variable was no column of the root LP, SCIP_INVALID is returned
- returns the best reduced costs (w.r.t. root reduced cost propagation) of the variable in the root node’s relaxation, if the root relaxation is not yet completely solved, or the variable was no column of the root LP, SCIP_INVALID is returned
- returns the best solution (w.r.t. root reduced cost propagation) of the variable in the root node’s relaxation, if the root relaxation is not yet completely solved, zero is returned
- gets the preferred branch direction of the variable (downwards, upwards, or auto)
- gets 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
- gets the branch priority of the variable; variables with higher priority should always be preferred to variables with lower priority
- gets array of cliques, the active variable is contained in
- gets column of COLUMN variable
- returns the number of cutoffs branching on this variable in given direction produced
- returns the number of cutoffs branching on this variable in given direction produced in the current run
- returns the user data of the variable
- gets the global hole list of an active variable
- gets the current hole list of an active variable
- gets the original hole list of an original variable
- gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x, there are no implications for nonbinary variable x
- Gets array with unique ids of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x, there are no implications for nonbinary variable x. If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication, its id is negative, otherwise it is nonnegative.
- gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x (SCIP_BOUNDTYPE_UPPER if y <= b, SCIP_BOUNDTYPE_LOWER if y >= b), there are no implications for nonbinary variable x
- gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x, there are no implications for nonbinary variable x; the implications are sorted such that implications with binary implied variables precede the ones with non-binary implied variables, and as a second criteria, the implied variables are sorted by increasing variable index (see SCIPvarGetIndex())
- gets the values of b in implications x == varfixing -> y <= b or y >= b in the implication graph; the values are set to SCIP_INVALID if there is no implied bound
- gets unique index of variable
- returns the number of inferences branching on this variable in given direction triggered
- returns the number of inferences branching on this variable in given direction triggered in the current run
- gets primal LP solution value of variable
- gets primal LP solution value of variable
- returns the last depth level, at which the bounds of the given variable were tightened; returns -2, if the variable’s bounds are still the global bounds returns -1, if the variable was fixed in presolving
- returns the last bound change index, at which the bounds of the given variable were tightened
- returns lower bound of variable directly before or after the bound change given by the bound change index was applied
- gets global lower bound of variable
- gets lazy lower bound of variable
- gets current lower bound of variable
- gets original lower bound of original problem variable (i.e. the bound set in problem creation)
- returns the bound change information for the last lower bound change on given active problem variable before or after the bound change with the given index was applied; returns NULL, if no change to the lower bound was applied up to this point of time
- gets aggregation constant c of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c
- gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c
- gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c
- gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c
- gets the number of lower bound change info array
- gets the number upper bound change info array
- returns the number of times, a bound of the variable was changed in given direction due to branching
- returns the number of times, a bound of the variable was changed in given direction due to branching in the current run
- gets number of cliques, the active variable is contained in
- gets number of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x, there are no implications for nonbinary variable x
- gets primal NLP solution value of variable
- gets primal NLP solution value of variable
- gets number of locks for rounding down
- gets number of locks for rounding down of a special type
- gets number of locks for rounding up
- gets number of locks for rounding up of a special type
- gets number of times, the variable is currently captured
- gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x
- gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x
- returns the name of the variable
- gets the negation of the given variable; may return NULL, if no negation is existing yet
- gets the negation offset of a negated variable x’ = offset - x
- gets the negation variable x of a negated variable x’ = offset - x
- returns node of variable in the conflict graph or -1 if variable is not part of the SOS1 conflict graph
- gets objective function value of variable
- retransforms given variable, scalar and constant to the corresponding original variable, scalar and constant, if possible; if the retransformation is impossible, NULL is returned as variable
- gets position of variable in problem, or -1 if variable is not active
- gets corresponding active, fixed, or multi-aggregated problem variable of a variable
- gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and updates the given negation status
- transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable values
- transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable values
- gets pseudo solution value of variable at current node
- returns the solution of the variable in the last root node’s relaxation, if the root relaxation is not yet completely solved, zero is returned
- gets current LP or pseudo solution value of variable
- gets status of variable
- gets transformed variable of ORIGINAL variable
- gets type of variable
- returns upper bound of variable directly before or after the bound change given by the bound change index was applied
- gets global upper bound of variable
- gets lazy upper bound of variable
- gets current upper bound of variable
- gets original upper bound of original problem variable (i.e. the bound set in problem creation)
- returns the bound change information for the last upper bound change on given active problem variable before or after the bound change with the given index was applied; returns NULL, if no change to the upper bound was applied up to this point of time
- gets the unchanged objective function value of variable (ignoring temproray changes performed in probing mode)
- returns the value based history for the variable
- gets array with bounding coefficients b_i in variable lower bounds x >= b_i*z_i + d_i of given variable x
- gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x
- gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x; the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
- gets array with bounding coefficients b_i in variable upper bounds x <= b_i*z_i + d_i of given variable x
- gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x
- gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x; the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
- gets worst global bound of variable with respect to the objective function
- gets worst local bound of variable with respect to the objective function
- gets type (lower or upper) of worst bound of variable with respect to the objective function
- returns whether there is an implication x == varfixing -> y == implvarfixing in the implication graph; implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique()); both variables must be active binary variables
- returns whether there is an implication x == varfixing -> y <= b or y >= b in the implication graph; implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique()); both variables must be active, variable x must be binary
- returns whether variable is an active (neither fixed nor aggregated) variable
- returns TRUE if the variable is of binary type; this is the case if: (1) variable type is binary (2) variable type is integer or implicit integer and (i) the global lower bound is greater than or equal to zero (ii) the global upper bound is less than or equal to one
- returns whether variable is allowed to be deleted completely from the problem
- returns whether the variable was deleted from the problem
- returns whether the variable is a COLUMN variable that is member of the current LP
- returns whether variable’s column should be present in the initial root LP
- returns whether variable is of integral type (binary, integer, or implicit integer)
- returns whether the variable was created by negation of a different variable
- returns whether the variable belongs to the original problem
- returns whether a variable has been introduced to define a relaxation
- returns whether variable’s column is removable from the LP (due to aging or cleanup)
- returns whether variable is part of the SOS1 conflict graph
- returns whether the variable belongs to the transformed problem
- returns whether the given variable is the direct counterpart of an original problem variable
- marks the variable to be deletable, i.e., it may be deleted completely from the problem; method can only be called before the variable is added to the problem by SCIPaddVar() or SCIPaddPricedVar()
- marks variable to be deleted from global structures (cliques etc.) when cleaning up
- marks the variable to be not deletable from the problem
- marks that this variable has only been introduced to define a relaxation
- is it possible, to round variable down and stay feasible?
- is it possible, to round variable up and stay feasible?
- set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables
- sets method to copy this variable into sub-SCIPs
- sets the user data for the variable
- sets method to free user data for the original variable
- sets method to free transformed user data for the variable
- sets the initial flag of a variable; only possible for original or loose variables
- sets the removable flag of a variable; only possible for original or loose variables
- sets method to transform user data of the variable
- returns whether the binary variable was fixed at the time given by the bound change index
- returns whether the first binary variable was fixed earlier than the second one; returns FALSE, if the first variable is not fixed, and returns TRUE, if the first variable is fixed, but the second one is not fixed
- initialization method of variable graph data structure
- deinitialization method of variable graph data structure
- Perform breadth-first (BFS) search on the variable constraint graph.
- gets corresponding active, fixed, or multi-aggregated problem variables of given variables, @note the content of the given array will/might change
- gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and updates the given negation status of each variable
- 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
- returns complete SCIP version number in the format “major . minor tech”
- this method visualizes the cumulative structure in GML format
- query if node was the last parent of a branching of the tree
- writes problem to file
- writes the clique graph to a gml file
- writes problem to file
- writes problem to file
- stores conflict graph of binary variables’ implications into a file, which can be used as input for the DOT tool
- writes current LP to a file
- writes problem to file
- writes MIP relaxation of the current branch-and-bound node to a file
- writes problem to file
- writes current NLP to a file
- writes problem to file
- writes original problem to file
- writes a single parameter to a file
- writes all parameters in the parameter set to a file
- @addtogroup FILEREADERS
- writes problem to file
- writes problem to file
- writes AMPL solution file
- writes problem to file
- writes transformed problem which are valid in the current node to file
- outputs the variable name to the file stream
- print the given variables and coefficients as linear sum in the following form c1 <x1> + c2 <x2> … + cn <xn>
- print the given list of variables to output stream separated by the given delimiter character;
- print the given terms as signomial in the following form c1 <x11>^e11 <x12>^e12 … <x1n>^e1n + c2 <x21>^e21 <x22>^e22 … + … + cn <xn1>^en1 …
- __j0⚠
- __j1⚠
- __jn⚠
- __y0⚠
- __y1⚠
- __yn⚠
- a64l⚠
- abs⚠
- acos⚠
- asin⚠
- atan⚠
- atof⚠
- atoi⚠
- atol⚠
- bcmp⚠
- cbrt⚠
- ceil⚠
- cos⚠
- cosf⚠
- cosh⚠
- cosl⚠
- div⚠
- drem⚠
- ecvt⚠
- erf⚠
- erfc⚠
- erff⚠
- erfl⚠
- exit⚠
- exp⚠
- exp2⚠
- expf⚠
- expl⚠
- fabs⚠
- fcvt⚠
- fdim⚠
- feof⚠
- ffs⚠
- ffsl⚠
- fma⚠
- fmaf⚠
- fmal⚠
- fmax⚠
- fmin⚠
- fmod⚠
- free⚠
- gcvt⚠
- getc⚠
- getw⚠
- j0⚠
- j0f⚠
- j0l⚠
- j1⚠
- j1f⚠
- j1l⚠
- jn⚠
- jnf⚠
- jnl⚠
- l64a⚠
- labs⚠
- ldiv⚠
- log⚠
- log2⚠
- logb⚠
- logf⚠
- logl⚠
- modf⚠
- nan⚠
- nanf⚠
- nanl⚠
- pow⚠
- powf⚠
- powl⚠
- putc⚠
- puts⚠
- putw⚠
- rand⚠
- rint⚠
- sin⚠
- sinf⚠
- sinh⚠
- sinl⚠
- sqrt⚠
- tan⚠
- tanf⚠
- tanh⚠
- tanl⚠
- y0⚠
- y0f⚠
- y0l⚠
- y1⚠
- y1f⚠
- y1l⚠
- yn⚠
- ynf⚠
- ynl⚠
Type Aliases§
- Block Memory Management
- Buffer Memory Management
- Chunk Memory Management
- data structure for bandit algorithms
- data structure for specific bandit algorithm implementation
- virtual function table for bandit callbacks
- dynamic array for storing SCIP_Bool values
- Binary tree data structure
- search node of \ref SCIP_BT “binary tree”
- basis status for columns and rows
- type of variable bound: lower or upper bound
- bound change type
- branching direction for branching on variables
- column of an LP
- linear auxiliary expression of the form xy {≤,≥,=} coefs[0]w + coefs[1]x + coefs[2]y + cst
- bilinear term structure
- represents different confidence levels for (one-sided) hypothesis testing; in order to obtain two-sided confidence levels, calculate 2 * c - 1, i.e., if the one-sided confidence level is 90 %, the two-sided level is 80 %
- dualray presolving strategy
- types of conflicts
- Directed graph data structure (stored as adjacency list)
- disjoint set (disjoint set (union find)) data structure for querying and updating connectedness of a graph with integer vertices 0,…,n - 1
- display activation status of display column
- display activation status of display column
- context for diving statistics
- domain change data type
- curvature types
- @name Expression Handler */ /**@{
- stage of DFS iterator
- mode for expression iterator
- @name Expression Owner */ /**@{
- Hash map data structure
- Hash map entry
- Hash set data structure
- Hash table data structure
- type of hashmap: are pointers, reals or ints stored, or unknown
- dynamic array for storing int values
- interval given by infimum and supremum
- @addtogroup CONSHDLRS
- LP structure
- type of LP algorithm
- LP solver parameters
- LP solution quality quantities
- solution status after solving LP
- selection rules for leaders in SST cuts
- tie breaks for leader rule based on the leader’s orbit
- linear constraint types recognizable
- solution status after solving LP
- monotonicity
- Hash table data structure which allows multiple occurences of an element
- Hash table element list to store single elements of a multi hash table
- parameters for NLP solve
- Statistics from an NLP solve
- NLP solver fast-fail levels
- NLP solution status
- NLP solver termination status
- objective sense
- objective sense: minimization or maximization
- type of orbitope constraint: full, packing, or partitioning orbitope
- Priority queue data structure
- Resource profile data structure
- dynamic array for storing pointers
- The parallel mode
- possible parameter emphases - used to determine the general SCIP behavior
- possible parameter settings - used to determine the behavior of different SCIP components, e.g., heuristics, separators, …
- possible parameter types
- LP pricing strategy
- (circular) Queue data structure
- random number generator
- dynamic array for storing SCIP_Real values
- regression data structure to compute an incremental linear regression of paired observations
- Resource activity data structure
- rounding mode of floating point operations (upwards, downwards, nearest, …)
- row of an LP
- a linear inequality row in preparation to become a SCIP_ROW
- conditions to recompute symmetries after a restart
- result codes for SCIP callback methods
- return codes for SCIP methods: non-positive return codes are errors
- type of origin of row
- Sparse solution data structure
- variable types for leader in Schreier Sims cuts
- type of setppc constraint: set partitioning, set packing, or set covering
- possible settings for enabling/disabling algorithms and other features
- type of row side: left hand or right hand side
- origin of solution: where to retrieve uncached elements
- type of solution: heuristic or (LP) relaxation solution, or unspecified origin
- SCIP operation stage
- SCIP solving status
- Value history data structure
- status of problem variables
- variable type
- verbosity levels of output
- define sense of rhs
Unions§
- user data storage type for expression iteration