Crate scip_sys

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

BMS_BlkMem

BMS_BufMem

BMS_ChkMem

SCIP_AggrRow

SCIP_Aggregate

SCIP_Bandit

SCIP_BanditData

SCIP_BanditVTable

SCIP_BdChgIdx

SCIP_BdChgInfo

SCIP_Benders

SCIP_BendersData

SCIP_Benderscut

SCIP_BenderscutData

SCIP_BoolArray

SCIP_BoundChg

SCIP_BoundStore

SCIP_BranchCand

SCIP_BranchingData

SCIP_Branchrule

SCIP_BranchruleData

SCIP_Bt

SCIP_BtNode

SCIP_CPUClock

SCIP_Child

SCIP_Clique

SCIP_CliqueList

SCIP_CliqueTable

SCIP_Clock

SCIP_Col

SCIP_ColSolVals

SCIP_Compr

SCIP_ComprData

SCIP_ConcSolver

SCIP_ConcSolverData

SCIP_ConcSolverType

SCIP_ConcSolverTypeData

SCIP_Conflict

SCIP_ConflictSet

SCIP_Conflicthdlr

SCIP_ConflicthdlrData

SCIP_Cons

SCIP_ConsData

SCIP_ConsNonlinear_Auxexpr

linear auxiliary expression of the form xy {≤,≥,=} coefs[0]w + coefs[1]x + coefs[2]y + cst

SCIP_ConsNonlinear_BilinTerm

bilinear term structure

SCIP_ConsSetChg

SCIP_Conshdlr

SCIP_ConshdlrData

SCIP_Cut

SCIP_Cutpool

SCIP_Cutsel

SCIP_CutselData

SCIP_Decomp

SCIP_DecompStore

SCIP_Dialog

SCIP_DialogData

SCIP_Dialoghdlr

SCIP_Digraph

SCIP_DisjointSet

SCIP_Disp

SCIP_DispData

SCIP_Diveset

SCIP_Dom

SCIP_DomChg

SCIP_DomChgBoth

SCIP_DomChgBound

SCIP_DomChgDyn

SCIP_Event

SCIP_EventBdChg

SCIP_EventData

SCIP_EventFilter

SCIP_EventHole

SCIP_EventImplAdd

SCIP_EventObjChg

SCIP_EventQueue

SCIP_EventRowAddedLP

SCIP_EventRowAddedSepa

SCIP_EventRowCoefChanged

SCIP_EventRowConstChanged

SCIP_EventRowDeletedLP

SCIP_EventRowDeletedSepa

SCIP_EventRowSideChanged

SCIP_EventTypeChg

SCIP_EventVarAdded

SCIP_EventVarDeleted

SCIP_EventVarFixed

SCIP_EventVarUnlocked

SCIP_Eventhdlr

SCIP_EventhdlrData

SCIP_Expr

SCIP_ExprData

SCIP_ExprIter

SCIP_ExprIterData

SCIP_ExprPrintData

SCIP_Expr_OwnerData

SCIP_Exprhdlr

SCIP_ExprhdlrData

SCIP_File

SCIP_Fork

SCIP_HashMap

SCIP_HashMapEntry

SCIP_HashSet

SCIP_HashTable

SCIP_Heur

SCIP_HeurData

SCIP_History

SCIP_Hole

SCIP_HoleChg

SCIP_Holelist

SCIP_Implics

SCIP_InferenceData

SCIP_IntArray

SCIP_Interval

interval given by infimum and supremum

SCIP_Junction

SCIP_LPBdChgs

SCIP_LPi

SCIP_LPiNorms

SCIP_LPiState

SCIP_Leaf

SCIP_LinConsStats

SCIP_LinConsUpgrade

SCIP_Linelist

SCIP_Lp

SCIP_LpSolVals

SCIP_Matrix

SCIP_Messagehdlr

SCIP_MessagehdlrData

SCIP_Multaggr

SCIP_MultiHash

SCIP_MultiHashList

SCIP_Negate

SCIP_NlRow

SCIP_Nlhdlr

SCIP_NlhdlrData

SCIP_NlhdlrExprData

SCIP_Nlp

SCIP_NlpParam

parameters for NLP solve

SCIP_NlpStatistics

Statistics from an NLP solve

SCIP_Nlpi

SCIP_NlpiData

SCIP_NlpiProblem

SCIP_Node

SCIP_NodePQ

SCIP_Nodesel

SCIP_NodeselData

SCIP_Original

SCIP_PQueue

SCIP_Param

SCIP_ParamData

SCIP_ParamSet

SCIP_PendingBdchg

SCIP_Presol

SCIP_PresolData

SCIP_Pricer

SCIP_PricerData

SCIP_Prob

SCIP_ProbData

SCIP_Probingnode

SCIP_Profile

SCIP_ProofSet

SCIP_Prop

SCIP_PropData

SCIP_Pseudofork

SCIP_PtrArray

SCIP_Queue

SCIP_RandNumGen

SCIP_Reader

SCIP_ReaderData

SCIP_RealArray

SCIP_Regression

SCIP_Relax

SCIP_RelaxData

SCIP_Relaxation

SCIP_Reopt

SCIP_ReoptConsData

SCIP_ReoptNode

SCIP_ReoptTree

SCIP_ResourceActivity

SCIP_Row

SCIP_RowPrep

SCIP_RowSolVals

SCIP_Sepa

SCIP_SepaData

SCIP_Set

SCIP_Sibling

SCIP_Sol

SCIP_SolNode

SCIP_SolTree

SCIP_SparseSol

SCIP_Stat

SCIP_SubproblemSolveStat

SCIP_Subroot

SCIP_SyncData

SCIP_SyncStore

SCIP_Table

SCIP_TableData

SCIP_Tree

SCIP_Treemodel

SCIP_VBounds

SCIP_VGraph

SCIP_ValueHistory

SCIP_Var

SCIP_VarData

SCIP_Viol

SCIP_WallClock

SYM_Consttype

SYM_Exprdata

SYM_Matrixdata

SYM_Optype

SYM_Rhstype

SYM_Vartype

Scip

_G_fpos64_t

_G_fpos_t

_IO_FILE

_IO_codecvt

_IO_cookie_io_functions_t

_IO_marker

_IO_wide_data

__atomic_wide_counter__bindgen_ty_1

__fsid_t

__locale_data

__locale_struct

__mbstate_t

__once_flag

__pthread_cond_s

__pthread_internal_list

__pthread_internal_slist

__pthread_mutex_s

__pthread_rwlock_arch_t

__sigset_t

__va_list_tag

div_t

drand48_data

fd_set

imaxdiv_t

ldiv_t

lldiv_t

max_align_t

random_data

timespec

timeval

Constants

AIO_PRIO_DELTA_MAX

ARG_MAX

ARTIFICIALVARNAMEPREFIX

BC_BASE_MAX

BC_DIM_MAX

BC_SCALE_MAX

BC_STRING_MAX

BIG_ENDIAN

BUFSIZ

BYTE_ORDER

CHARCLASS_NAME_MAX

CMAKE_BUILD_TYPE

COLL_WEIGHTS_MAX

DELAYTIMER_MAX

EOF

EXIT_FAILURE

EXIT_SUCCESS

EXPR_NEST_MAX

FALSE

FD_SETSIZE

FILENAME_MAX

FOPEN_MAX

FP_ILOGB0

FP_ILOGBNAN

FP_INFINITE

FP_NAN

FP_NORMAL

FP_SUBNORMAL

FP_ZERO

HOST_NAME_MAX

INT8_MAX

INT8_MIN

INT16_MAX

INT16_MIN

INT32_MAX

INT32_MIN

INTPTR_MAX

INTPTR_MIN

INT_FAST8_MAX

INT_FAST8_MIN

INT_FAST16_MAX

INT_FAST16_MIN

INT_FAST32_MAX

INT_FAST32_MIN

INT_LEAST8_MAX

INT_LEAST8_MIN

INT_LEAST16_MAX

INT_LEAST16_MIN

INT_LEAST32_MAX

INT_LEAST32_MIN

LINE_MAX

LINK_MAX

LITTLE_ENDIAN

LOGIN_NAME_MAX

L_ctermid

L_tmpnam

MATH_ERREXCEPT

MATH_ERRNO

MAX_CANON

MAX_INPUT

MB_LEN_MAX

MQ_PRIO_MAX

M_1_PI

M_2_PI

M_2_SQRTPI

M_E

M_LN2

M_LN10

M_LOG2E

M_LOG10E

M_PI

M_PI_2

M_PI_4

M_SQRT2

M_SQRT1_2

NAME_MAX

NGROUPS_MAX

NLOCKTYPES

NR_OPEN

PATH_MAX

PDP_ENDIAN

PIPE_BUF

PRIX8

PRIX16

PRIX32

PRIX64

PRIXFAST8

PRIXFAST16

PRIXFAST32

PRIXFAST64

PRIXLEAST8

PRIXLEAST16

PRIXLEAST32

PRIXLEAST64

PRIXMAX

PRIXPTR

PRId8

PRId16

PRId32

PRId64

PRIdFAST8

PRIdFAST16

PRIdFAST32

PRIdFAST64

PRIdLEAST8

PRIdLEAST16

PRIdLEAST32

PRIdLEAST64

PRIdMAX

PRIdPTR

PRIi8

PRIi16

PRIi32

PRIi64

PRIiFAST8

PRIiFAST16

PRIiFAST32

PRIiFAST64

PRIiLEAST8

PRIiLEAST16

PRIiLEAST32

PRIiLEAST64

PRIiMAX

PRIiPTR

PRIo8

PRIo16

PRIo32

PRIo64

PRIoFAST8

PRIoFAST16

PRIoFAST32

PRIoFAST64

PRIoLEAST8

PRIoLEAST16

PRIoLEAST32

PRIoLEAST64

PRIoMAX

PRIoPTR

PRIu8

PRIu16

PRIu32

PRIu64

PRIuFAST8

PRIuFAST16

PRIuFAST32

PRIuFAST64

PRIuLEAST8

PRIuLEAST16

PRIuLEAST32

PRIuLEAST64

PRIuMAX

PRIuPTR

PRIx8

PRIx16

PRIx32

PRIx64

PRIxFAST8

PRIxFAST16

PRIxFAST32

PRIxFAST64

PRIxLEAST8

PRIxLEAST16

PRIxLEAST32

PRIxLEAST64

PRIxMAX

PRIxPTR

PTHREAD_DESTRUCTOR_ITERATIONS

PTHREAD_KEYS_MAX

PTHREAD_STACK_MIN

PTRDIFF_MAX

PTRDIFF_MIN

P_tmpdir

QUAD_EPSILON

RAND_MAX

RE_DUP_MAX

RTSIG_MAX

Reopt_ConsType_REOPT_CONSTYPE_CUT

< constraint representing a cut, e.g., to separate a solution

Reopt_ConsType_REOPT_CONSTYPE_DUALREDS

< constraint reconstructs dual reductions

Reopt_ConsType_REOPT_CONSTYPE_INFSUBTREE

< constraint cutoffs an LP infeasible subtree

Reopt_ConsType_REOPT_CONSTYPE_UNKNOWN

< constraint was added by SCIP, e.g., a (local) conflict

SCIP_APIVERSION

SCIP_BaseStat_SCIP_BASESTAT_BASIC

< (slack) variable is basic

SCIP_BaseStat_SCIP_BASESTAT_LOWER

< (slack) variable is at its lower bound

SCIP_BaseStat_SCIP_BASESTAT_UPPER

< (slack) variable is at its upper bound

SCIP_BaseStat_SCIP_BASESTAT_ZERO

< free variable is non-basic and set to zero

SCIP_BendersEnfoType_SCIP_BENDERSENFOTYPE_CHECK

< the Benders’ subproblems are solved during the checking of a solution for feasibility

SCIP_BendersEnfoType_SCIP_BENDERSENFOTYPE_LP

< the Benders’ subproblems are solved during the enforcement of an LP solution

SCIP_BendersEnfoType_SCIP_BENDERSENFOTYPE_PSEUDO

< the Benders’ subproblems are solved during the enforcement of a pseudo solution

SCIP_BendersEnfoType_SCIP_BENDERSENFOTYPE_RELAX

< the Benders’ subproblems are solved during the enforcement of a relaxation solution

SCIP_BendersSolveLoop_SCIP_BENDERSSOLVELOOP_CIP

< the CIP is solved in this iteration of the loop

SCIP_BendersSolveLoop_SCIP_BENDERSSOLVELOOP_CONVEX

< the relaxation is solved in this iteration of the loop

SCIP_BendersSolveLoop_SCIP_BENDERSSOLVELOOP_USERCIP

< the user defined solve function is called

SCIP_BendersSolveLoop_SCIP_BENDERSSOLVELOOP_USERCONVEX

< the user defined solve function is called

SCIP_BendersSubStatus_SCIP_BENDERSSUBSTATUS_AUXVIOL

< the subproblem is optimal, but the auxiliary variable is violated

SCIP_BendersSubStatus_SCIP_BENDERSSUBSTATUS_INFEAS

< the subproblem is solved to be infeasible

SCIP_BendersSubStatus_SCIP_BENDERSSUBSTATUS_OPTIMAL

< the subsystem is solved to be optimal

SCIP_BendersSubStatus_SCIP_BENDERSSUBSTATUS_UNKNOWN

< the subsystem status is unknown

SCIP_BendersSubType_SCIP_BENDERSSUBTYPE_CONVEXCONT

< the subproblem has convex constraints and continuous variables

SCIP_BendersSubType_SCIP_BENDERSSUBTYPE_CONVEXDIS

< the subproblem has convex constraints and discrete variables

SCIP_BendersSubType_SCIP_BENDERSSUBTYPE_NONCONVEXCONT

< the subproblem has non-convex constraints and continuous variables

SCIP_BendersSubType_SCIP_BENDERSSUBTYPE_NONCONVEXDIS

< the subproblem has non-convex constraints and discrete variables

SCIP_BendersSubType_SCIP_BENDERSSUBTYPE_UNKNOWN

< the default type before the type is known

SCIP_BoundType_SCIP_BOUNDTYPE_LOWER

< lower bound

SCIP_BoundType_SCIP_BOUNDTYPE_UPPER

< upper bound

SCIP_BoundchgType_SCIP_BOUNDCHGTYPE_BRANCHING

< bound change was due to a branching decision

SCIP_BoundchgType_SCIP_BOUNDCHGTYPE_CONSINFER

< bound change was due to an inference of a constraint (domain propagation)

SCIP_BoundchgType_SCIP_BOUNDCHGTYPE_PROPINFER

< bound change was due to an inference of a domain propagator

SCIP_BranchDir_SCIP_BRANCHDIR_AUTO

< automatic setting for choosing bound changes

SCIP_BranchDir_SCIP_BRANCHDIR_DOWNWARDS

< downwards branching: decreasing upper bound

SCIP_BranchDir_SCIP_BRANCHDIR_FIXED

< fixed branching: both bounds changed

SCIP_BranchDir_SCIP_BRANCHDIR_UPWARDS

< upwards branching: increasing lower bound

SCIP_COPYRIGHT

SCIP_ClockType_SCIP_CLOCKTYPE_CPU

< use CPU clock

SCIP_ClockType_SCIP_CLOCKTYPE_DEFAULT

< use default clock type

SCIP_ClockType_SCIP_CLOCKTYPE_WALL

< use wall clock

SCIP_Confidencelevel_SCIP_CONFIDENCELEVEL_HIGH

< (one-sided) confidence level 95 %, two-sided 90 %

SCIP_Confidencelevel_SCIP_CONFIDENCELEVEL_LOW

< (one-sided) confidence level 87.5 %, two-sided 75 %

SCIP_Confidencelevel_SCIP_CONFIDENCELEVEL_MAX

< (one-sided) confidence level 97.5 %, two-sided 95 %

SCIP_Confidencelevel_SCIP_CONFIDENCELEVEL_MEDIUM

< (one-sided) confidence level 90 %, two-sided 80 %

SCIP_Confidencelevel_SCIP_CONFIDENCELEVEL_MIN

< one-sided confidence level 75 %, two-sided 50 %

SCIP_ConflictPresolStrat_SCIP_CONFPRES_BOTH

< 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

SCIP_ConflictPresolStrat_SCIP_CONFPRES_DISABLED

< no presolving

SCIP_ConflictPresolStrat_SCIP_CONFPRES_ONLYGLOBAL

< keep variables contributing with its global bound

SCIP_ConflictPresolStrat_SCIP_CONFPRES_ONLYLOCAL

< keep variables contributing with its local bound

SCIP_ConflictType_SCIP_CONFTYPE_ALTBNDPROOF

< alternative proof of a boundexceeding LP relaxation

SCIP_ConflictType_SCIP_CONFTYPE_ALTINFPROOF

< alternative proof of an infeasible LP relaxation

SCIP_ConflictType_SCIP_CONFTYPE_BNDEXCEEDING

< conflict results from a boundexceeding LP relaxation

SCIP_ConflictType_SCIP_CONFTYPE_INFEASLP

< conflict results from an infeasible LP relaxation

SCIP_ConflictType_SCIP_CONFTYPE_PROPAGATION

< conflict results from propagation

SCIP_ConflictType_SCIP_CONFTYPE_UNKNOWN

< unknown type

SCIP_DECOMP_LINKCONS

SCIP_DECOMP_LINKVAR

SCIP_DEFAULT_BARRIERCONVTOL

SCIP_DEFAULT_BOUNDSTREPS

SCIP_DEFAULT_CHECKFEASTOLFAC

SCIP_DEFAULT_DUALFEASTOL

SCIP_DEFAULT_EPSILON

SCIP_DEFAULT_FEASTOL

SCIP_DEFAULT_HUGEVAL

SCIP_DEFAULT_INFINITY

SCIP_DEFAULT_LPFEASTOLFACTOR

SCIP_DEFAULT_MEM_ARRAYGROWFAC

SCIP_DEFAULT_MEM_ARRAYGROWINIT

SCIP_DEFAULT_PSEUDOCOSTDELTA

SCIP_DEFAULT_PSEUDOCOSTEPS

SCIP_DEFAULT_RECOMPFAC

SCIP_DEFAULT_SUMEPSILON

SCIP_DIVETYPE_INTEGRALITY

SCIP_DIVETYPE_NONE

SCIP_DIVETYPE_SOS1VARIABLE

SCIP_DispMode_SCIP_DISPMODE_ALL

< display column is displayed in concurrent and sequential mode

SCIP_DispMode_SCIP_DISPMODE_CONCURRENT

< display column is displayed only in concurrent mode

SCIP_DispMode_SCIP_DISPMODE_DEFAULT

< display column is displayed only in sequential mode

SCIP_DispStatus_SCIP_DISPSTATUS_AUTO

< display column is switched on and off automatically

SCIP_DispStatus_SCIP_DISPSTATUS_OFF

< display column is not displayed

SCIP_DispStatus_SCIP_DISPSTATUS_ON

< display column is displayed

SCIP_DiveContext_SCIP_DIVECONTEXT_ADAPTIVE

< within adaptive diving

SCIP_DiveContext_SCIP_DIVECONTEXT_SINGLE

< single heuristic context

SCIP_DiveContext_SCIP_DIVECONTEXT_TOTAL

< all contexts combined

SCIP_DomchgType_SCIP_DOMCHGTYPE_BOTH

< static domain changes: number of entries equals size of arrays

SCIP_DomchgType_SCIP_DOMCHGTYPE_BOUND

< static domain changes without any hole changes

SCIP_DomchgType_SCIP_DOMCHGTYPE_DYNAMIC

< dynamic bound changes with size information of arrays

SCIP_EVENTTYPE_FORMAT

SCIP_EXPRCURV_SCIP_EXPRCURV_CONCAVE

< concave

SCIP_EXPRCURV_SCIP_EXPRCURV_CONVEX

< convex

SCIP_EXPRCURV_SCIP_EXPRCURV_LINEAR

< linear = convex and concave

SCIP_EXPRCURV_SCIP_EXPRCURV_UNKNOWN

< unknown or indefinite curvature

SCIP_EXPRITER_ALLSTAGES

SCIP_EXPRITER_ENTEREXPR

SCIP_EXPRITER_LEAVEEXPR

SCIP_EXPRITER_MAXNACTIVE

SCIP_EXPRITER_TYPE_SCIP_EXPRITER_BFS

< breadth-first search

SCIP_EXPRITER_TYPE_SCIP_EXPRITER_DFS

< depth-first search

SCIP_EXPRITER_TYPE_SCIP_EXPRITER_RTOPOLOGIC

< reverse topological order

SCIP_EXPRITER_VISITEDCHILD

SCIP_EXPRITER_VISITINGCHILD

SCIP_EXPRPRINT_ACTIVITY

SCIP_EXPRPRINT_ACTIVITYTAG

SCIP_EXPRPRINT_ALL

SCIP_EXPRPRINT_EVALTAG

SCIP_EXPRPRINT_EVALVALUE

SCIP_EXPRPRINT_EXPRHDLR

SCIP_EXPRPRINT_EXPRSTRING

SCIP_EXPRPRINT_NUSES

SCIP_EXPRPRINT_OWNER

SCIP_EXPR_MAXINITESTIMATES

SCIP_HASHSIZE_CLIQUES

SCIP_HASHSIZE_CLIQUES_SMALL

SCIP_HASHSIZE_CUTPOOLS

SCIP_HASHSIZE_CUTPOOLS_SMALL

SCIP_HASHSIZE_NAMES

SCIP_HASHSIZE_NAMES_SMALL

SCIP_HASHSIZE_PARAMS

SCIP_HASHSIZE_VBC

SCIP_HAVE_VARIADIC_MACROS

SCIP_HEURDISPCHAR_DIVING

SCIP_HEURDISPCHAR_ITERATIVE

SCIP_HEURDISPCHAR_LNS

SCIP_HEURDISPCHAR_OBJDIVING

SCIP_HEURDISPCHAR_PROP

SCIP_HEURDISPCHAR_ROUNDING

SCIP_HEURDISPCHAR_TRIVIAL

SCIP_HEURTIMING_AFTERLPLOOP

SCIP_HEURTIMING_AFTERLPNODE

SCIP_HEURTIMING_AFTERLPPLUNGE

SCIP_HEURTIMING_AFTERNODE

SCIP_HEURTIMING_AFTERPLUNGE

SCIP_HEURTIMING_AFTERPROPLOOP

SCIP_HEURTIMING_AFTERPSEUDONODE

SCIP_HEURTIMING_AFTERPSEUDOPLUNGE

SCIP_HEURTIMING_BEFORENODE

SCIP_HEURTIMING_BEFOREPRESOL

SCIP_HEURTIMING_DURINGLPLOOP

SCIP_HEURTIMING_DURINGPRESOLLOOP

SCIP_HEURTIMING_DURINGPRICINGLOOP

SCIP_Hashmaptype_SCIP_HASHMAPTYPE_INT

< the hashmap stores ints

SCIP_Hashmaptype_SCIP_HASHMAPTYPE_POINTER

< the hashmap stores pointers %

SCIP_Hashmaptype_SCIP_HASHMAPTYPE_REAL

< the hashmap stores reals

SCIP_Hashmaptype_SCIP_HASHMAPTYPE_UNKNOWN

< the hashmap did not store a single element yet, type unknown

SCIP_LONGINT_FORMAT

SCIP_LPAlgo_SCIP_LPALGO_BARRIER

< barrier algorithm

SCIP_LPAlgo_SCIP_LPALGO_BARRIERCROSSOVER

< barrier algorithm with crossover

SCIP_LPAlgo_SCIP_LPALGO_DUALSIMPLEX

< dual simplex

SCIP_LPAlgo_SCIP_LPALGO_PRIMALSIMPLEX

< primal simplex

SCIP_LPParam_SCIP_LPPAR_BARRIERCONVTOL

< convergence tolerance used in barrier algorithm

SCIP_LPParam_SCIP_LPPAR_CONDITIONLIMIT

< maximum condition number of LP basis counted as stable

SCIP_LPParam_SCIP_LPPAR_DUALFEASTOL

< feasibility tolerance for dual variables and reduced costs, strictly positive

SCIP_LPParam_SCIP_LPPAR_FASTMIP

< fast mip setting of LP solver

SCIP_LPParam_SCIP_LPPAR_FEASTOL

< feasibility tolerance for primal variables and slacks, strictly positive

SCIP_LPParam_SCIP_LPPAR_FROMSCRATCH

< solver should start from scratch at next call?

SCIP_LPParam_SCIP_LPPAR_LPINFO

< should LP solver output information to the screen?

SCIP_LPParam_SCIP_LPPAR_LPITLIM

< LP iteration limit, greater than or equal 0

SCIP_LPParam_SCIP_LPPAR_LPTILIM

< LP time limit, positive

SCIP_LPParam_SCIP_LPPAR_MARKOWITZ

< Markowitz tolerance

SCIP_LPParam_SCIP_LPPAR_OBJLIM

< objective limit (stop if objective is known be larger/smaller than limit for min/max-imization)

SCIP_LPParam_SCIP_LPPAR_POLISHING

< set solution polishing (0 - disable, 1 - enable)

SCIP_LPParam_SCIP_LPPAR_PRESOLVING

< should LP solver use presolving?

SCIP_LPParam_SCIP_LPPAR_PRICING

< pricing strategy

SCIP_LPParam_SCIP_LPPAR_RANDOMSEED

< inital random seed, e.g. for perturbations in the simplex (0: LP default)

SCIP_LPParam_SCIP_LPPAR_REFACTOR

< set refactorization interval (0 - automatic)

SCIP_LPParam_SCIP_LPPAR_ROWREPSWITCH

< 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)

SCIP_LPParam_SCIP_LPPAR_SCALING

< should LP solver use scaling?

SCIP_LPParam_SCIP_LPPAR_THREADS

< number of threads used to solve the LP

SCIP_LPParam_SCIP_LPPAR_TIMING

< type of timer (1 - cpu, 2 - wallclock, 0 - off)

SCIP_LPSolQuality_SCIP_LPSOLQUALITY_ESTIMCONDITION

< estimated condition number of (scaled) basis matrix (SCIP_Real)

SCIP_LPSolQuality_SCIP_LPSOLQUALITY_EXACTCONDITION

< exact condition number of (scaled) basis matrix (SCIP_Real)

SCIP_LPSolStat_SCIP_LPSOLSTAT_ERROR

< an error occured during optimization

SCIP_LPSolStat_SCIP_LPSOLSTAT_INFEASIBLE

< LP is primal infeasible

SCIP_LPSolStat_SCIP_LPSOLSTAT_ITERLIMIT

< iteration limit was reached during optimization

SCIP_LPSolStat_SCIP_LPSOLSTAT_NOTSOLVED

< LP was not solved, no solution exists

SCIP_LPSolStat_SCIP_LPSOLSTAT_OBJLIMIT

< objective limit was reached during optimization

SCIP_LPSolStat_SCIP_LPSOLSTAT_OPTIMAL

< LP was solved to optimality

SCIP_LPSolStat_SCIP_LPSOLSTAT_TIMELIMIT

< time limit was reached during optimization

SCIP_LPSolStat_SCIP_LPSOLSTAT_UNBOUNDEDRAY

< LP has a primal unbounded ray

SCIP_LeaderRule_SCIP_LEADERRULE_FIRSTINORBIT

< first var in orbit

SCIP_LeaderRule_SCIP_LEADERRULE_LASTINORBIT

< last var in orbit

SCIP_LeaderRule_SCIP_LEADERRULE_MAXCONFLICTS

< var with most conflicting vars in problem

SCIP_LeaderRule_SCIP_LEADERRULE_MAXCONFLICTSINORBIT

< var with most conflicting vars in its orbit

SCIP_LeaderTiebreakRule_SCIP_LEADERTIEBREAKRULE_MAXCONFLICTSINORBIT

< orbit with maximum number of vars in conflict with leader

SCIP_LeaderTiebreakRule_SCIP_LEADERTIEBREAKRULE_MAXORBIT

< orbit of maximum size

SCIP_LeaderTiebreakRule_SCIP_LEADERTIEBREAKRULE_MINORBIT

< orbit of minimum size

SCIP_LinConstype_SCIP_LINCONSTYPE_AGGREGATION

< linear constraints of the type \f$ ax + by = c\f$

SCIP_LinConstype_SCIP_LINCONSTYPE_BINPACKING

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_CARDINALITY

< linear constraints of the form \f$ \sum x_i = k, x_i \in {0,1} \forall i, , k\geq 2 \f$

SCIP_LinConstype_SCIP_LINCONSTYPE_EMPTY

< linear constraints with no variables

SCIP_LinConstype_SCIP_LINCONSTYPE_EQKNAPSACK

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_FREE

< linear constraints with no finite side

SCIP_LinConstype_SCIP_LINCONSTYPE_GENERAL

< general linear constraints with no special structure

SCIP_LinConstype_SCIP_LINCONSTYPE_INTKNAPSACK

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_INVKNAPSACK

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_KNAPSACK

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_MIXEDBINARY

< 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$

SCIP_LinConstype_SCIP_LINCONSTYPE_PRECEDENCE

< 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

SCIP_LinConstype_SCIP_LINCONSTYPE_SETCOVERING

< linear constraints of the form \f$ \sum x_i \geq 1, x_i \in {0,1} \forall i \f$

SCIP_LinConstype_SCIP_LINCONSTYPE_SETPACKING

< linear constraints of the form \f$ \sum x_i \leq 1, x_i \in {0,1} \forall i \f$

SCIP_LinConstype_SCIP_LINCONSTYPE_SETPARTITION

< linear constraints of the form \f$ \sum x_i = 1, x_i \in {0,1} \forall i \f$

SCIP_LinConstype_SCIP_LINCONSTYPE_SINGLETON

< linear constraints with a single variable

SCIP_LinConstype_SCIP_LINCONSTYPE_VARBOUND

< linear constraints of the form \f$ ax + by \leq c , x \in {0,1} \f$

SCIP_LinearConsType_SCIP_LINEARCONSTYPE_INVALIDCONS

< this is no valid linear constraint type

SCIP_LinearConsType_SCIP_LINEARCONSTYPE_KNAPSACK

< this is a knapsack constraint

SCIP_LinearConsType_SCIP_LINEARCONSTYPE_LINEAR

< this is the common linear constraint

SCIP_LinearConsType_SCIP_LINEARCONSTYPE_LOGICOR

< this is a logicor constraint

SCIP_LinearConsType_SCIP_LINEARCONSTYPE_SETPPC

< this is a setppc constraint

SCIP_LockType_SCIP_LOCKTYPE_CONFLICT

< variable locks for conflict constraints

SCIP_LockType_SCIP_LOCKTYPE_MODEL

< variable locks for model and check constraints

SCIP_MAXEPSILON

SCIP_MAXMEMSIZE

SCIP_MAXSTRLEN

SCIP_MAXTREEDEPTH

SCIP_MAXVERTEXPOLYDIM

SCIP_MINEPSILON

SCIP_MONOTONE_SCIP_MONOTONE_CONST

< constant = increasing and decreasing

SCIP_MONOTONE_SCIP_MONOTONE_DEC

< decreasing

SCIP_MONOTONE_SCIP_MONOTONE_INC

< increasing

SCIP_MONOTONE_SCIP_MONOTONE_UNKNOWN

< unknown or non-monotone

SCIP_NLHDLR_METHOD_ACTIVITY

SCIP_NLHDLR_METHOD_ALL

SCIP_NLHDLR_METHOD_NONE

SCIP_NLHDLR_METHOD_SEPAABOVE

SCIP_NLHDLR_METHOD_SEPABELOW

SCIP_NLHDLR_METHOD_SEPABOTH

SCIP_NLPPARAM_DEFAULT_VERBLEVEL

SCIP_NlpParam_FastFail_SCIP_NLPPARAM_FASTFAIL_AGGRESSIVE

< stop if convergence rate is low

SCIP_NlpParam_FastFail_SCIP_NLPPARAM_FASTFAIL_CONSERVATIVE

< stop if it seems unlikely that an improving point can be found

SCIP_NlpParam_FastFail_SCIP_NLPPARAM_FASTFAIL_OFF

< never stop if progress is still possible

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_FEASIBLE

< feasible solution found

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_GLOBINFEASIBLE

< problem is proven infeasible

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_GLOBOPT

< solved to global optimality

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_LOCINFEASIBLE

< solution found is local infeasible

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_LOCOPT

< solved to local optimality

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_UNBOUNDED

< problem is unbounded

SCIP_NlpSolStat_SCIP_NLPSOLSTAT_UNKNOWN

< unknown solution status (e.g., problem not solved yet)

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_EVALERROR

< stopped on function evaluation error

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_INTERRUPT

< SCIP has been asked to stop (SCIPinterruptSolve() called)

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_ITERLIMIT

< iteration limit exceeded

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_LICENSEERROR

< problems with license of NLP solver

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_LOBJLIMIT

< lower objective limit reached

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_NUMERICERROR

< stopped on numerical error

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_OKAY

< terminated successfully

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_OTHER

< other error (= this should never happen)

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_OUTOFMEMORY

< memory exceeded

SCIP_NlpTermStat_SCIP_NLPTERMSTAT_TIMELIMIT

< time limit exceeded

SCIP_NodeType_SCIP_NODETYPE_CHILD

< unsolved child of the focus node

SCIP_NodeType_SCIP_NODETYPE_DEADEND

< temporary type of focus node, if it was solved completely

SCIP_NodeType_SCIP_NODETYPE_FOCUSNODE

< the focus node, whose data is stored in the tree data structure

SCIP_NodeType_SCIP_NODETYPE_FORK

< fork with solved LP and added rows and columns

SCIP_NodeType_SCIP_NODETYPE_JUNCTION

< fork without LP solution

SCIP_NodeType_SCIP_NODETYPE_LEAF

< unsolved leaf of the tree, stored in the tree’s queue

SCIP_NodeType_SCIP_NODETYPE_PROBINGNODE

< temporary child node of the focus or refocused node used for probing

SCIP_NodeType_SCIP_NODETYPE_PSEUDOFORK

< fork without LP solution and added rows and columns

SCIP_NodeType_SCIP_NODETYPE_REFOCUSNODE

< junction, fork, or subroot that was refocused for domain propagation

SCIP_NodeType_SCIP_NODETYPE_SIBLING

< unsolved sibling of the focus node

SCIP_NodeType_SCIP_NODETYPE_SUBROOT

< fork with solved LP and arbitrarily changed rows and columns

SCIP_ObjSen_SCIP_OBJSEN_MAXIMIZE

< maximize objective function

SCIP_ObjSen_SCIP_OBJSEN_MINIMIZE

< minimize objective function

SCIP_Objsense_SCIP_OBJSENSE_MAXIMIZE

< maximization of objective function

SCIP_Objsense_SCIP_OBJSENSE_MINIMIZE

< minimization of objective function (the default)

SCIP_OrbitopeType_SCIP_ORBITOPETYPE_FULL

< constraint is a full orbitope constraint: rowsum(x) unrestricted

SCIP_OrbitopeType_SCIP_ORBITOPETYPE_PACKING

< constraint is a packing orbitope constraint: rowsum(x) <= 1

SCIP_OrbitopeType_SCIP_ORBITOPETYPE_PARTITIONING

< constraint is a partitioning orbitope constraint: rowsum(x) == 1

SCIP_PRESOLTIMING_ALWAYS

SCIP_PRESOLTIMING_EXHAUSTIVE

SCIP_PRESOLTIMING_FAST

SCIP_PRESOLTIMING_FINAL

SCIP_PRESOLTIMING_MAX

SCIP_PRESOLTIMING_MEDIUM

SCIP_PRESOLTIMING_NONE

SCIP_PROBINGSCORE_PENALTYRATIO

SCIP_PROPTIMING_AFTERLPLOOP

SCIP_PROPTIMING_AFTERLPNODE

SCIP_PROPTIMING_ALWAYS

SCIP_PROPTIMING_BEFORELP

SCIP_PROPTIMING_DURINGLPLOOP

SCIP_Parallelmode_SCIP_PARA_DETERMINISTIC

SCIP_Parallelmode_SCIP_PARA_OPPORTUNISTIC

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_BENCHMARK

< do not try to avoid running into memory limit

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_COUNTER

< get a feasible and “fast” counting process

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_CPSOLVER

< get CP like search (e.g. no LP relaxation)

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_DEFAULT

< use default values

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_EASYCIP

< solve easy problems fast

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_FEASIBILITY

< detect feasibility fast

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_HARDLP

< be capable to handle hard LPs

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_NUMERICS

< emphasis parameters for increased numerical safety

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_OPTIMALITY

< prove optimality fast

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_PHASEFEAS

< feasibility phase settings during 3-phase solving approach

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_PHASEIMPROVE

< improvement phase settings during 3-phase solving approach

SCIP_ParamEmphasis_SCIP_PARAMEMPHASIS_PHASEPROOF

< proof phase settings during 3-phase solving approach

SCIP_ParamSetting_SCIP_PARAMSETTING_AGGRESSIVE

< set to aggressive settings

SCIP_ParamSetting_SCIP_PARAMSETTING_DEFAULT

< use default values

SCIP_ParamSetting_SCIP_PARAMSETTING_FAST

< set to fast settings

SCIP_ParamSetting_SCIP_PARAMSETTING_OFF

< turn off

SCIP_ParamType_SCIP_PARAMTYPE_BOOL

< bool values: TRUE or FALSE

SCIP_ParamType_SCIP_PARAMTYPE_CHAR

< characters

SCIP_ParamType_SCIP_PARAMTYPE_INT

< integer values

SCIP_ParamType_SCIP_PARAMTYPE_LONGINT

< long integer values

SCIP_ParamType_SCIP_PARAMTYPE_REAL

< real values

SCIP_ParamType_SCIP_PARAMTYPE_STRING

< strings: arrays of characters

SCIP_Pricing_SCIP_PRICING_AUTO

< the LP solver should use its preferred strategy

SCIP_Pricing_SCIP_PRICING_DEVEX

< devex pricing

SCIP_Pricing_SCIP_PRICING_FULL

< full pricing

SCIP_Pricing_SCIP_PRICING_LPIDEFAULT

< the SCIP/LP interface should use its preferred strategy

SCIP_Pricing_SCIP_PRICING_PARTIAL

< partial pricing

SCIP_Pricing_SCIP_PRICING_STEEP

< steepest edge pricing

SCIP_Pricing_SCIP_PRICING_STEEPQSTART

< steepest edge pricing without initial dual norms

SCIP_REAL_FORMAT

SCIP_RecomputesymType_SCIP_RECOMPUTESYM_ALWAYS

< always recompute symmetries

SCIP_RecomputesymType_SCIP_RECOMPUTESYM_NEVER

< never recompute symmetries

SCIP_RecomputesymType_SCIP_RECOMPUTESYM_OFFOUNDRED

< only if orbital fixing found a reduction in previous run

SCIP_ReoptType_SCIP_REOPTTYPE_FEASIBLE

< node is a leaf node and has an integral optimal LP solution

SCIP_ReoptType_SCIP_REOPTTYPE_INFSUBTREE

< node contains dual reductions which leed to LP infeasibility

SCIP_ReoptType_SCIP_REOPTTYPE_LEAF

< node is a leaf node

SCIP_ReoptType_SCIP_REOPTTYPE_LOGICORNODE

< node contains additional constraints

SCIP_ReoptType_SCIP_REOPTTYPE_NONE

< node is not part of the reoptimizationtree

SCIP_ReoptType_SCIP_REOPTTYPE_PRUNED

< node is a leaf node and pruned by boudning

SCIP_ReoptType_SCIP_REOPTTYPE_STRBRANCHED

< node contains dual reductions

SCIP_ReoptType_SCIP_REOPTTYPE_TRANSIT

< node is only needed for reconstructing the tree

SCIP_Result_SCIP_BRANCHED

< the method created a branching

SCIP_Result_SCIP_CONSADDED

< the method added a constraint

SCIP_Result_SCIP_CONSCHANGED

< the method changed a constraint

SCIP_Result_SCIP_CUTOFF

< the current node is infeasible and can be cut off

SCIP_Result_SCIP_DELAYED

< the method was not executed, but should be called again later

SCIP_Result_SCIP_DELAYNODE

< the processing of the branch-and-bound node should stopped and continued later

SCIP_Result_SCIP_DIDNOTFIND

< the method was executed, but failed finding anything

SCIP_Result_SCIP_DIDNOTRUN

< the method was not executed

SCIP_Result_SCIP_FEASIBLE

< no infeasibility could be found

SCIP_Result_SCIP_FOUNDSOL

< the method found a feasible primal solution

SCIP_Result_SCIP_INFEASIBLE

< an infeasibility was detected

SCIP_Result_SCIP_NEWROUND

< the method added a cutting plane and a new separation round should immediately start

SCIP_Result_SCIP_REDUCEDDOM

< the method reduced the domain of a variable

SCIP_Result_SCIP_SEPARATED

< the method added a cutting plane

SCIP_Result_SCIP_SOLVELP

< the current node’s LP must be solved

SCIP_Result_SCIP_SUCCESS

< the method was successfully executed

SCIP_Result_SCIP_SUSPENDED

< the method interrupted its execution, but can continue if needed

SCIP_Result_SCIP_UNBOUNDED

< an unboundedness was detected

SCIP_Retcode_SCIP_BRANCHERROR

< no branching could be created

SCIP_Retcode_SCIP_ERROR

< unspecified error

SCIP_Retcode_SCIP_FILECREATEERROR

< cannot create file

SCIP_Retcode_SCIP_INVALIDCALL

< method cannot be called at this time in solution process

SCIP_Retcode_SCIP_INVALIDDATA

< error in input data

SCIP_Retcode_SCIP_INVALIDRESULT

< method returned an invalid result code

SCIP_Retcode_SCIP_KEYALREADYEXISTING

< the given key is already existing in table

SCIP_Retcode_SCIP_LPERROR

< error in LP solver

SCIP_Retcode_SCIP_MAXDEPTHLEVEL

< maximal branching depth level exceeded

SCIP_Retcode_SCIP_NOFILE

< file not found error

SCIP_Retcode_SCIP_NOMEMORY

< insufficient memory error

SCIP_Retcode_SCIP_NOPROBLEM

< no problem exists

SCIP_Retcode_SCIP_NOTIMPLEMENTED

< function not implemented

SCIP_Retcode_SCIP_OKAY

< normal termination

SCIP_Retcode_SCIP_PARAMETERUNKNOWN

< the parameter with the given name was not found

SCIP_Retcode_SCIP_PARAMETERWRONGTYPE

< the parameter is not of the expected type

SCIP_Retcode_SCIP_PARAMETERWRONGVAL

< the value is invalid for the given parameter

SCIP_Retcode_SCIP_PLUGINNOTFOUND

< a required plugin was not found

SCIP_Retcode_SCIP_READERROR

< read error

SCIP_Retcode_SCIP_WRITEERROR

< write error

SCIP_RowOriginType_SCIP_ROWORIGINTYPE_CONS

< row created by a constraint

SCIP_RowOriginType_SCIP_ROWORIGINTYPE_CONSHDLR

< row created by a constraint handler

SCIP_RowOriginType_SCIP_ROWORIGINTYPE_REOPT

< row created by reoptimization

SCIP_RowOriginType_SCIP_ROWORIGINTYPE_SEPA

< row created by separator

SCIP_RowOriginType_SCIP_ROWORIGINTYPE_UNSPEC

< unspecified origin of row

SCIP_SSTType_SCIP_SSTTYPE_BINARY

< binary variables

SCIP_SSTType_SCIP_SSTTYPE_CONTINUOUS

< continuous variables

SCIP_SSTType_SCIP_SSTTYPE_IMPLINT

< implicitly integer variables

SCIP_SSTType_SCIP_SSTTYPE_INTEGER

< integer variables

SCIP_SUBVERSION

SCIP_SetppcType_SCIP_SETPPCTYPE_COVERING

< constraint is a set covering constraint: sum(x) >= 1

SCIP_SetppcType_SCIP_SETPPCTYPE_PACKING

< constraint is a set packing constraint: sum(x) <= 1

SCIP_SetppcType_SCIP_SETPPCTYPE_PARTITIONING

< constraint is a set partitioning constraint: sum(x) == 1

SCIP_Setting_SCIP_AUTO

< feature is set to automatic mode

SCIP_Setting_SCIP_DISABLED

< feature is disabled

SCIP_Setting_SCIP_ENABLED

< feature is enabled

SCIP_Setting_SCIP_UNDEFINED

< undefined setting

SCIP_SideType_SCIP_SIDETYPE_LEFT

< left hand side

SCIP_SideType_SCIP_SIDETYPE_RIGHT

< right hand side

SCIP_SolOrigin_SCIP_SOLORIGIN_LPSOL

< all non-cached elements in solution are equal to current LP solution

SCIP_SolOrigin_SCIP_SOLORIGIN_NLPSOL

< all non-cached elements in solution are equal to current NLP solution

SCIP_SolOrigin_SCIP_SOLORIGIN_ORIGINAL

< solution describes original variables; non-cached elements are zero

SCIP_SolOrigin_SCIP_SOLORIGIN_PARTIAL

< solution describes original solution; all non-cached elements in solution are treated as being an arbitrary value in the variable’s bounds

SCIP_SolOrigin_SCIP_SOLORIGIN_PSEUDOSOL

< all non-cached elements in solution are equal to current pseudo solution

SCIP_SolOrigin_SCIP_SOLORIGIN_RELAXSOL

< all non-cached elements in solution are equal to current relaxation solution

SCIP_SolOrigin_SCIP_SOLORIGIN_UNKNOWN

< all non-cached elements in solution are unknown; they have to be treated as being an arbitrary value in the variable’s bounds

SCIP_SolOrigin_SCIP_SOLORIGIN_ZERO

< all non-cached elements in solution are equal to zero

SCIP_SolType_SCIP_SOLTYPE_HEUR

< solution was found by a heuristic

SCIP_SolType_SCIP_SOLTYPE_LPRELAX

< solution was found by the LP relaxation

SCIP_SolType_SCIP_SOLTYPE_PSEUDO

< solution originates from a pseudo solution

SCIP_SolType_SCIP_SOLTYPE_RELAX

< solution was found by a relaxation

SCIP_SolType_SCIP_SOLTYPE_STRONGBRANCH

< solution was found during strong branching

SCIP_SolType_SCIP_SOLTYPE_UNKNOWN

< type of solution unspecified (the default)

SCIP_Stage_SCIP_STAGE_EXITPRESOLVE

< presolving is exited

SCIP_Stage_SCIP_STAGE_EXITSOLVE

< the solving process data is being freed

SCIP_Stage_SCIP_STAGE_FREE

< SCIP data structures are being freed

SCIP_Stage_SCIP_STAGE_FREETRANS

< the transformed problem is being freed

SCIP_Stage_SCIP_STAGE_INIT

< SCIP data structures are initialized, no problem exists

SCIP_Stage_SCIP_STAGE_INITPRESOLVE

< presolving is initialized

SCIP_Stage_SCIP_STAGE_INITSOLVE

< the solving process data is being initialized

SCIP_Stage_SCIP_STAGE_PRESOLVED

< the problem was presolved

SCIP_Stage_SCIP_STAGE_PRESOLVING

< the problem is being presolved

SCIP_Stage_SCIP_STAGE_PROBLEM

< the problem is being created and modified

SCIP_Stage_SCIP_STAGE_SOLVED

< the problem was solved

SCIP_Stage_SCIP_STAGE_SOLVING

< the problem is being solved

SCIP_Stage_SCIP_STAGE_TRANSFORMED

< the problem was transformed into solving data space

SCIP_Stage_SCIP_STAGE_TRANSFORMING

< the problem is being transformed into solving data space

SCIP_Status_SCIP_STATUS_BESTSOLLIMIT

< the solving process was interrupted because the solution improvement limit was reached

SCIP_Status_SCIP_STATUS_GAPLIMIT

< the solving process was interrupted because the gap limit was reached

SCIP_Status_SCIP_STATUS_INFEASIBLE

< the problem was proven to be infeasible

SCIP_Status_SCIP_STATUS_INFORUNBD

< the problem was proven to be either infeasible or unbounded

SCIP_Status_SCIP_STATUS_MEMLIMIT

< the solving process was interrupted because the memory limit was reached

SCIP_Status_SCIP_STATUS_NODELIMIT

< the solving process was interrupted because the node limit was reached

SCIP_Status_SCIP_STATUS_OPTIMAL

< the problem was solved to optimality, an optimal solution is available

SCIP_Status_SCIP_STATUS_RESTARTLIMIT

< the solving process was interrupted because the restart limit was reached

SCIP_Status_SCIP_STATUS_SOLLIMIT

< the solving process was interrupted because the solution limit was reached

SCIP_Status_SCIP_STATUS_STALLNODELIMIT

< the solving process was interrupted because the stalling node limit was reached (no inprovement w.r.t. primal bound)

SCIP_Status_SCIP_STATUS_TERMINATE

< status if the process received a SIGTERM signal

SCIP_Status_SCIP_STATUS_TIMELIMIT

< the solving process was interrupted because the time limit was reached

SCIP_Status_SCIP_STATUS_TOTALNODELIMIT

< the solving process was interrupted because the total node limit was reached (incl. restarts)

SCIP_Status_SCIP_STATUS_UNBOUNDED

< the problem was proven to be unbounded

SCIP_Status_SCIP_STATUS_UNKNOWN

< the solving status is not yet known

SCIP_Status_SCIP_STATUS_USERINTERRUPT

< the user interrupted the solving process (by pressing CTRL-C)

SCIP_VARTYPE_BINARY_CHAR

SCIP_VARTYPE_CONTINUOUS_CHAR

SCIP_VARTYPE_IMPLINT_CHAR

SCIP_VARTYPE_INTEGER_CHAR

SCIP_VERSION

SCIP_VERSION_API

SCIP_VERSION_MAJOR

SCIP_VERSION_MINOR

SCIP_VERSION_PATCH

SCIP_VERSION_SUB

SCIP_Varstatus_SCIP_VARSTATUS_AGGREGATED

< variable is aggregated to x = a*y + c in the transformed problem

SCIP_Varstatus_SCIP_VARSTATUS_COLUMN

< variable is a column of the transformed problem

SCIP_Varstatus_SCIP_VARSTATUS_FIXED

< variable is fixed to specific value in the transformed problem

SCIP_Varstatus_SCIP_VARSTATUS_LOOSE

< variable is a loose variable of the transformed problem

SCIP_Varstatus_SCIP_VARSTATUS_MULTAGGR

< variable is aggregated to x = a_1y_1 + … + a_ky_k + c

SCIP_Varstatus_SCIP_VARSTATUS_NEGATED

< variable is the negation of an original or transformed variable

SCIP_Varstatus_SCIP_VARSTATUS_ORIGINAL

< variable belongs to original problem

SCIP_Vartype_SCIP_VARTYPE_BINARY

< binary variable: \f$ x \in {0,1} \f$

SCIP_Vartype_SCIP_VARTYPE_CONTINUOUS

< continuous variable: \f$ lb \leq x \leq ub \f$

SCIP_Vartype_SCIP_VARTYPE_IMPLINT

< 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

SCIP_Vartype_SCIP_VARTYPE_INTEGER

< integer variable: \f$ x in {lb, \dots, ub} \f$

SCIP_VerbLevel_SCIP_VERBLEVEL_DIALOG

< only interactive dialogs, errors, and warnings are displayed

SCIP_VerbLevel_SCIP_VERBLEVEL_FULL

< all messages are displayed

SCIP_VerbLevel_SCIP_VERBLEVEL_HIGH

< a lot of information is displayed

SCIP_VerbLevel_SCIP_VERBLEVEL_MINIMAL

< only important messages are displayed

SCIP_VerbLevel_SCIP_VERBLEVEL_NONE

< only error and warning messages are displayed

SCIP_VerbLevel_SCIP_VERBLEVEL_NORMAL

< standard messages are displayed

SCNd8

SCNd16

SCNd32

SCNd64

SCNdFAST8

SCNdFAST16

SCNdFAST32

SCNdFAST64

SCNdLEAST8

SCNdLEAST16

SCNdLEAST32

SCNdLEAST64

SCNdMAX

SCNdPTR

SCNi8

SCNi16

SCNi32

SCNi64

SCNiFAST8

SCNiFAST16

SCNiFAST32

SCNiFAST64

SCNiLEAST8

SCNiLEAST16

SCNiLEAST32

SCNiLEAST64

SCNiMAX

SCNiPTR

SCNo8

SCNo16

SCNo32

SCNo64

SCNoFAST8

SCNoFAST16

SCNoFAST32

SCNoFAST64

SCNoLEAST8

SCNoLEAST16

SCNoLEAST32

SCNoLEAST64

SCNoMAX

SCNoPTR

SCNu8

SCNu16

SCNu32

SCNu64

SCNuFAST8

SCNuFAST16

SCNuFAST32

SCNuFAST64

SCNuLEAST8

SCNuLEAST16

SCNuLEAST32

SCNuLEAST64

SCNuMAX

SCNuPTR

SCNx8

SCNx16

SCNx32

SCNx64

SCNxFAST8

SCNxFAST16

SCNxFAST32

SCNxFAST64

SCNxLEAST8

SCNxLEAST16

SCNxLEAST32

SCNxLEAST64

SCNxMAX

SCNxPTR

SEEK_CUR

SEEK_END

SEEK_SET

SEM_VALUE_MAX

SIG_ATOMIC_MAX

SIG_ATOMIC_MIN

SIZE_MAX

SYM_COMPUTETIMING_AFTERPRESOL

SYM_COMPUTETIMING_BEFOREPRESOL

SYM_COMPUTETIMING_DURINGPRESOL

SYM_Rhssense_SYM_SENSE_AND

< AND constraint

SYM_Rhssense_SYM_SENSE_BOUNDIS_TYPE_1

< bounddisjunction type 1

SYM_Rhssense_SYM_SENSE_BOUNDIS_TYPE_2

< bounddisjunction type 2

SYM_Rhssense_SYM_SENSE_EQUATION

< linear equation

SYM_Rhssense_SYM_SENSE_INEQUALITY

< linear inequality

SYM_Rhssense_SYM_SENSE_OR

< OR constrant

SYM_Rhssense_SYM_SENSE_UNKOWN

< unknown sense

SYM_Rhssense_SYM_SENSE_XOR

< XOR constraint

TMP_MAX

TRUE

TTY_NAME_MAX

UINT8_MAX

UINT16_MAX

UINT32_MAX

UINTPTR_MAX

UINT_FAST8_MAX

UINT_FAST16_MAX

UINT_FAST32_MAX

UINT_LEAST8_MAX

UINT_LEAST16_MAX

UINT_LEAST32_MAX

WCONTINUED

WEXITED

WINT_MAX

WINT_MIN

WNOHANG

WNOWAIT

WSTOPPED

WUNTRACED

XATTR_LIST_MAX

XATTR_NAME_MAX

XATTR_SIZE_MAX

_ALLOCA_H

_ASSERT_H

_ATFILE_SOURCE

_BITS_BYTESWAP_H

_BITS_ENDIANNESS_H

_BITS_ENDIAN_H

_BITS_LIBM_SIMD_DECL_STUBS_H

_BITS_POSIX1_LIM_H

_BITS_POSIX2_LIM_H

_BITS_PTHREADTYPES_ARCH_H

_BITS_PTHREADTYPES_COMMON_H

_BITS_STDINT_INTN_H

_BITS_STDINT_LEAST_H

_BITS_STDINT_UINTN_H

_BITS_STDIO_LIM_H

_BITS_TIME64_H

_BITS_TYPESIZES_H

_BITS_TYPES_H

_BITS_TYPES_LOCALE_T_H

_BITS_TYPES___LOCALE_T_H

_BITS_UINTN_IDENTITY_H

_BITS_WCHAR_H

_DEFAULT_SOURCE

_ENDIAN_H

_FEATURES_H

_INTTYPES_H

_IOFBF

_IOLBF

_IONBF

_IO_EOF_SEEN

_IO_ERR_SEEN

_IO_USER_LOCK

_LIBC_LIMITS_H_

_MATH_H

_POSIX2_BC_BASE_MAX

_POSIX2_BC_DIM_MAX

_POSIX2_BC_SCALE_MAX

_POSIX2_BC_STRING_MAX

_POSIX2_CHARCLASS_NAME_MAX

_POSIX2_COLL_WEIGHTS_MAX

_POSIX2_EXPR_NEST_MAX

_POSIX2_LINE_MAX

_POSIX2_RE_DUP_MAX

_POSIX_AIO_LISTIO_MAX

_POSIX_AIO_MAX

_POSIX_ARG_MAX

_POSIX_CHILD_MAX

_POSIX_CLOCKRES_MIN

_POSIX_C_SOURCE

_POSIX_DELAYTIMER_MAX

_POSIX_HOST_NAME_MAX

_POSIX_LINK_MAX

_POSIX_LOGIN_NAME_MAX

_POSIX_MAX_CANON

_POSIX_MAX_INPUT

_POSIX_MQ_OPEN_MAX

_POSIX_MQ_PRIO_MAX

_POSIX_NAME_MAX

_POSIX_NGROUPS_MAX

_POSIX_OPEN_MAX

_POSIX_PATH_MAX

_POSIX_PIPE_BUF

_POSIX_RE_DUP_MAX

_POSIX_RTSIG_MAX

_POSIX_SEM_NSEMS_MAX

_POSIX_SEM_VALUE_MAX

_POSIX_SIGQUEUE_MAX

_POSIX_SOURCE

_POSIX_SSIZE_MAX

_POSIX_STREAM_MAX

_POSIX_SYMLINK_MAX

_POSIX_SYMLOOP_MAX

_POSIX_THREAD_DESTRUCTOR_ITERATIONS

_POSIX_THREAD_KEYS_MAX

_POSIX_THREAD_THREADS_MAX

_POSIX_TIMER_MAX

_POSIX_TTY_NAME_MAX

_POSIX_TZNAME_MAX

_STDC_PREDEF_H

_STDINT_H

_STDIO_H

_STDLIB_H

_STRINGS_H

_STRING_H

_STRUCT_TIMESPEC

_SYS_CDEFS_H

_SYS_SELECT_H

_SYS_TYPES_H

_THREAD_MUTEX_INTERNAL_H

_THREAD_SHARED_TYPES_H

__BIG_ENDIAN

__BIT_TYPES_DEFINED__

__BYTE_ORDER

__FD_SETSIZE

__FILE_defined

__FLOAT_WORD_ORDER

__FP_LOGB0_IS_MIN

__FP_LOGBNAN_IS_MIN

__GLIBC_MINOR__

__GLIBC_USE_C2X_STRTOL

__GLIBC_USE_DEPRECATED_GETS

__GLIBC_USE_DEPRECATED_SCANF

__GLIBC_USE_IEC_60559_BFP_EXT

__GLIBC_USE_IEC_60559_BFP_EXT_C2X

__GLIBC_USE_IEC_60559_EXT

__GLIBC_USE_IEC_60559_FUNCS_EXT

__GLIBC_USE_IEC_60559_FUNCS_EXT_C2X

__GLIBC_USE_IEC_60559_TYPES_EXT

__GLIBC_USE_ISOC2X

__GLIBC_USE_LIB_EXT2

__GLIBC__

__GNU_LIBRARY__

__HAVE_DISTINCT_FLOAT16

__HAVE_DISTINCT_FLOAT32

__HAVE_DISTINCT_FLOAT64

__HAVE_DISTINCT_FLOAT32X

__HAVE_DISTINCT_FLOAT64X

__HAVE_DISTINCT_FLOAT128

__HAVE_DISTINCT_FLOAT128X

__HAVE_FLOAT16

__HAVE_FLOAT32

__HAVE_FLOAT64

__HAVE_FLOAT32X

__HAVE_FLOAT64X

__HAVE_FLOAT64X_LONG_DOUBLE

__HAVE_FLOAT128

__HAVE_FLOAT128X

__HAVE_FLOATN_NOT_TYPEDEF

__HAVE_GENERIC_SELECTION

__INO_T_MATCHES_INO64_T

__KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64

__LDOUBLE_REDIRECTS_TO_FLOAT128_ABI

__LITTLE_ENDIAN

__MATH_DECLARE_LDOUBLE

__MATH_DECLARING_DOUBLE

__MATH_DECLARING_FLOATN

__OFF_T_MATCHES_OFF64_T

__PDP_ENDIAN

__PRI64_PREFIX

__PRIPTR_PREFIX

__PTHREAD_MUTEX_HAVE_PREV

__RLIM_T_MATCHES_RLIM64_T

__SIZEOF_PTHREAD_ATTR_T

__SIZEOF_PTHREAD_BARRIERATTR_T

__SIZEOF_PTHREAD_BARRIER_T

__SIZEOF_PTHREAD_CONDATTR_T

__SIZEOF_PTHREAD_COND_T

__SIZEOF_PTHREAD_MUTEXATTR_T

__SIZEOF_PTHREAD_MUTEX_T

__SIZEOF_PTHREAD_RWLOCKATTR_T

__SIZEOF_PTHREAD_RWLOCK_T

__STATFS_MATCHES_STATFS64

__STDC_IEC_559_COMPLEX__

__STDC_IEC_559__

__STDC_IEC_60559_BFP__

__STDC_IEC_60559_COMPLEX__

__STDC_ISO_10646__

__SYSCALL_WORDSIZE

__TIMESIZE

__USE_ATFILE

__USE_FORTIFY_LEVEL

__USE_ISOC11

__USE_ISOC95

__USE_ISOC99

__USE_MISC

__USE_POSIX

__USE_POSIX2

__USE_POSIX199309

__USE_POSIX199506

__USE_POSIX_IMPLICITLY

__USE_XOPEN2K

__USE_XOPEN2K8

__WALL

__WCLONE

__WCOREFLAG

__WNOTHREAD

__WORDSIZE

__WORDSIZE_TIME64_COMPAT32

__W_CONTINUED

____FILE_defined

_____fpos64_t_defined

_____fpos_t_defined

____gwchar_t_defined

____mbstate_t_defined

__clock_t_defined

__clockid_t_defined

__cookie_io_functions_t_defined

__glibc_c99_flexarr_available

__have_pthread_attr_t

__ldiv_t_defined

__lldiv_t_defined

__sigset_t_defined

__struct_FILE_defined

__time_t_defined

__timer_t_defined

__timeval_defined

math_errhandling

Statics

signgam^⚠

stderr^⚠

stdin^⚠

stdout^⚠

Functions

BMSalignMemsize^⚠

aligns the given byte size corresponding to the minimal alignment for chunk and block memory

BMSallocBlockMemoryArray_call^⚠

allocates array in the block memory pool

BMSallocBlockMemory_call^⚠

allocates memory in the block memory pool

BMSallocBufferMemoryArray_call^⚠

allocates the next unused buffer array

BMSallocBufferMemory_call^⚠

allocates the next unused buffer

BMSallocChunkMemory_call^⚠

allocates a memory element of the given chunk block

BMSallocClearBlockMemoryArray_call^⚠

allocates array in the block memory pool and clears it

BMSallocClearBlockMemory_call^⚠

allocates memory in the block memory pool and clears it

BMSallocClearBufferMemoryArray_call^⚠

allocates the next unused buffer and clears it

BMSallocClearMemory_call^⚠

allocates array and initializes it with 0; returns NULL if memory allocation failed

BMSallocMemoryArray_call^⚠

allocates array; returns NULL if memory allocation failed

BMSallocMemory_call^⚠

allocates memory; returns NULL if memory allocation failed

BMScheckEmptyBlockMemory_call^⚠

outputs error messages, if there are allocated elements in the block memory and returns number of unfreed bytes

BMScheckEmptyMemory_call^⚠

displays a warning message on the screen, if allocated memory exists

BMSclearBlockMemory_call^⚠

frees all chunk blocks in the block memory

BMSclearChunkMemory_call^⚠

clears a chunk block data structure

BMSclearMemory_call^⚠

clears a memory element (i.e. fills it with zeros)

BMScopyMemory_call^⚠

copies the contents of one memory element into another memory element

BMScreateBlockMemory_call^⚠

creates a block memory allocation data structure

BMScreateBufferMemory_call^⚠

creates memory buffer storage

BMScreateChunkMemory_call^⚠

creates a new chunk block data structure

BMSdestroyBlockMemory_call^⚠

clears and deletes block memory

BMSdestroyBufferMemory_call^⚠

destroys buffer memory

BMSdestroyChunkMemory_call^⚠

destroys and frees a chunk block data structure

BMSdisplayBlockMemory_call^⚠

outputs allocation diagnostics of block memory

BMSdisplayMemory_call^⚠

outputs information about currently allocated memory to the screen

BMSduplicateBlockMemoryArray_call^⚠

duplicates array in the block memory pool and copies the data

BMSduplicateBlockMemory_call^⚠

duplicates memory element in the block memory pool and copies the data

BMSduplicateBufferMemoryArray_call^⚠

allocates an array in the next unused buffer and copies the given memory into the buffer

BMSduplicateBufferMemory_call^⚠

allocates the next unused buffer and copies the given memory into the buffer

BMSduplicateChunkMemory_call^⚠

duplicates a given memory element by allocating a new element of the same chunk block and copying the data

BMSduplicateMemoryArray_call^⚠

allocates array and copies the contents of the given source array into the new array

BMSduplicateMemory_call^⚠

allocates memory and copies the contents of the given memory element into the new memory element

BMSfreeBlockMemoryNull_call^⚠

frees memory element in the block memory pool if pointer is not NULL and sets pointer to NULL

BMSfreeBlockMemory_call^⚠

frees memory element in the block memory pool and sets pointer to NULL

BMSfreeBufferMemoryNull_call^⚠

frees a buffer if pointer is not NULL and sets pointer to NULL

BMSfreeBufferMemory_call^⚠

frees a buffer and sets pointer to NULL

BMSfreeChunkMemoryNull_call^⚠

frees a memory element of the given chunk block if pointer is not NULL and sets pointer to NULL

BMSfreeChunkMemory_call^⚠

frees a memory element of the given chunk block and sets pointer to NULL

BMSfreeMemoryNull_call^⚠

frees an allocated memory element if pointer is not NULL and sets pointer to NULL

BMSfreeMemory_call^⚠

frees an allocated memory element and sets pointer to NULL

BMSgarbagecollectBlockMemory_call^⚠

calls garbage collection of block memory, frees chunks without allocated memory elements, and frees chunk blocks without any chunks

BMSgarbagecollectChunkMemory_call^⚠

calls garbage collection of chunk block and frees chunks without allocated memory elements

BMSgetBlockMemoryAllocatedMax_call^⚠

returns the maximal number of allocated bytes in the block memory

BMSgetBlockMemoryAllocated_call^⚠

returns the number of allocated bytes in the block memory

BMSgetBlockMemoryUnusedMax_call^⚠

returns the maximal number of allocated but not used bytes in the block memory

BMSgetBlockMemoryUnused_call^⚠

returns the number of allocated but not used bytes in the block memory

BMSgetBlockMemoryUsedMax_call^⚠

returns the maximal number of used bytes in the block memory

BMSgetBlockMemoryUsed_call^⚠

returns the number of used bytes in the block memory

BMSgetBlockPointerSize_call^⚠

returns the size of the given memory element; returns 0, if the element is not member of the block memory

BMSgetBufferMemoryUsed^⚠

returns the number of allocated bytes in the buffer memory

BMSgetChunkMemoryUsed_call^⚠

returns the number of allocated bytes in the chunk block

BMSgetMemoryUsed_call^⚠

returns total number of allocated bytes

BMSgetNUsedBufferMemory^⚠

gets number of used buffers

BMSgetPointerSize_call^⚠

returns the size of an allocated memory element

BMSisAligned^⚠

checks whether the given size meets the alignment conditions for chunk and block memory

BMSmoveMemory_call^⚠

moves the contents of one memory element into another memory element, should be used if both elements overlap, otherwise BMScopyMemory is faster

BMSprintBufferMemory^⚠

outputs statistics about currently allocated buffers to the screen

BMSreallocBlockMemoryArray_call^⚠

resizes array in the block memory pool and copies the data

BMSreallocBlockMemory_call^⚠

resizes memory element in the block memory pool and copies the data

BMSreallocBufferMemoryArray_call^⚠

reallocates an array in the buffer to at least the given size

BMSreallocBufferMemory_call^⚠

reallocates the buffer to at least the given size

BMSreallocMemoryArray_call^⚠

reallocates array; returns NULL if memory allocation failed

BMSreallocMemory_call^⚠

allocates memory; returns NULL if memory allocation failed

BMSsetBufferMemoryArraygrowfac^⚠

set arraygrowfac

BMSsetBufferMemoryArraygrowinit^⚠

set arraygrowinit

SCIPactivateBenders^⚠

activates the Benders’ decomposition to be used for the current problem

SCIPactivatePricer^⚠

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.

SCIPactivateSolViolationUpdates^⚠

allow violation updates

SCIPactiveCons^⚠

calls constraint activation notification method of single constraint

SCIPactivityCreate^⚠

create a resource activity

SCIPactivityFree^⚠

frees a resource activity

SCIPactivityGetDemand^⚠

returns the demand of the resource activity

SCIPactivityGetDuration^⚠

returns the duration of the resource activity

SCIPactivityGetEnergy^⚠

returns the energy of the resource activity

SCIPactivityGetVar^⚠

returns the start time variable of the resource activity

SCIPaddBendersSubproblem^⚠

registers the Benders’ decomposition subproblem with the Benders’ decomposition struct.

SCIPaddBilinLinearization^⚠

computes coefficients of linearization of a bilinear term in a reference point

SCIPaddBilinMcCormick^⚠

computes coefficients of McCormick under- or overestimation of a bilinear term

SCIPaddBoolParam^⚠

creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set

SCIPaddCharParam^⚠

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

SCIPaddClique^⚠

adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1; if a variable appears twice in the same clique, the corresponding implications are performed

SCIPaddCoefKnapsack^⚠

adds new item to knapsack constraint

SCIPaddCoefLinear^⚠

adds coefficient to linear constraint (if it is not zero)

SCIPaddCoefLogicor^⚠

adds coefficient in logic or constraint

SCIPaddCoefPseudoboolean^⚠

adds linear term pseudo boolean constraint (if it is not zero)

SCIPaddCoefSetppc^⚠

adds coefficient in set partitioning / packing / covering constraint

SCIPaddConflict^⚠

adds a conflict to a given node or globally to the problem if @p node == NULL.

SCIPaddConflictBd^⚠

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:

SCIPaddConflictBinvar^⚠

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:

SCIPaddConflictLb^⚠

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:

SCIPaddConflictRelaxedBd^⚠

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:

SCIPaddConflictRelaxedLb^⚠

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:

SCIPaddConflictRelaxedUb^⚠

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:

SCIPaddConflictUb^⚠

adds upper bound of variable at the time of the given bound change index to the conflict analysis’ candidate storage; this method should be called in one of the following two cases:

SCIPaddCons^⚠

adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the current node (and all of its subnodes); otherwise it is added to the global problem; if a local constraint is added at the root node, it is automatically upgraded into a global constraint

SCIPaddConsAge^⚠

adds given value to age of constraint, but age can never become negative; should be called

SCIPaddConsElemConjunction^⚠

adds constraint to the conjunction of constraints

SCIPaddConsElemDisjunction^⚠

adds constraint to the disjunction of constraints

SCIPaddConsLocal^⚠

adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint; It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is only active in a small part of the tree although it is valid in a larger part.

SCIPaddConsLocks^⚠

adds given values to lock status of the constraint and updates the rounding locks of the involved variables

SCIPaddConsLocksType^⚠

adds given values to lock status of type @p locktype of the constraint and updates the rounding locks of the involved variables

SCIPaddConsNode^⚠

adds constraint to the given node (and all of its subnodes), even if it is a global constraint; It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is only active in a small part of the tree although it is valid in a larger part. In this case, one should pass the more global node where the constraint is valid as “validnode”. Note that the same constraint cannot be added twice to the branching tree with different “validnode” parameters. If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as “validnode”. If the “validnode” is the root node, it is automatically upgraded into a global constraint, but still only added to the given node. If a local constraint is added to the root node, it is added to the global problem instead.

SCIPaddCurrentSol^⚠

adds current LP/pseudo solution to solution storage

SCIPaddCut^⚠

adds cut to separation storage

SCIPaddDecomp^⚠

adds decomposition to SCIP

SCIPaddDelayedPoolCut^⚠

if not already existing, adds row to the delayed global cut pool

SCIPaddDialogEntry^⚠

adds a sub dialog to the given dialog as menu entry and captures it

SCIPaddDialogHistoryLine^⚠

adds a single line of input to the command history which can be accessed with the cursor keys

SCIPaddDialogInputLine^⚠

adds a single line of input which is treated as if the user entered the command line

SCIPaddDiveBoundChange^⚠

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

SCIPaddExprNonlinear^⚠

adds coef * expr to nonlinear constraint

SCIPaddExprViolScoreNonlinear^⚠

adds violation-branching score to an expression

SCIPaddExprsViolScoreNonlinear^⚠

adds violation-branching score to a set of expressions, distributing the score among all the expressions

SCIPaddExternBranchCand^⚠

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

SCIPaddIneqBilinear^⚠

adds a globally valid inequality of the form \f$\text{xcoef}\cdot x \leq \text{ycoef} \cdot y + \text{constant}\f$ to a product expression of the form \f$x\cdot y\f$

SCIPaddIntParam^⚠

creates a int parameter, sets it to its default value, and adds it to the parameter set

SCIPaddLinearCoefToNlRow^⚠

adds variable with a linear coefficient to a nonlinear row

SCIPaddLinearCoefsToNlRow^⚠

adds variables with linear coefficients to a row

SCIPaddLinearConsIndicator^⚠

adds additional linear constraint that is not connected with an indicator constraint, but can be used for separation

SCIPaddLinearVarNonlinear^⚠

adds coef * var to nonlinear constraint

SCIPaddLongintParam^⚠

creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set

SCIPaddNNodes^⚠

add given number to the number of processed nodes in current run and in all runs, including the focus node

SCIPaddNewRowCutpool^⚠

adds row to a cut pool and captures it; doesn’t check for multiple cuts

SCIPaddNlRow^⚠

adds a nonlinear row to the NLP. This row is captured by the NLP.

SCIPaddNlpiConstraints^⚠

add constraints to nlpi

SCIPaddNlpiProblemNlRows^⚠

adds SCIP_NLROWs to a NLPI problem

SCIPaddNlpiProblemRows^⚠

adds SCIP_ROWs to a NLPI problem

SCIPaddNlpiVars^⚠

add variables to nlpi

SCIPaddObjoffset^⚠

adds offset of objective function

SCIPaddOrigObjoffset^⚠

adds offset of objective function to original problem and to all existing solution in original space

SCIPaddPoolCut^⚠

if not already existing, adds row to global cut pool

SCIPaddPricedVar^⚠

adds variable to the problem and uses it as pricing candidate to enter the LP

SCIPaddRealParam^⚠

creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set

SCIPaddReoptDualBndchg^⚠

save bound change based on dual information in the reoptimization tree

SCIPaddReoptnodeBndchg^⚠

add a variable bound change to a given reoptnode

SCIPaddReoptnodeCons^⚠

add stored constraint to a reoptimization node

SCIPaddRow^⚠

adds row to separation storage

SCIPaddRowCutpool^⚠

if not already existing, adds row to a cut pool and captures it

SCIPaddRowDive^⚠

adds a row to the LP in current dive

SCIPaddRowIndicator^⚠

adds additional globally valid row that is not connected with an indicator constraint, but can be used for separation

SCIPaddRowProbing^⚠

adds a row to the LP in the current probing node

SCIPaddRowprepTerm^⚠

adds a term coef*var to a rowprep

SCIPaddRowprepTerms^⚠

adds several terms coef*var to a rowprep

SCIPaddSol^⚠

adds feasible primal solution to solution storage by copying it

SCIPaddSolFree^⚠

adds primal solution to solution storage, frees the solution afterwards

SCIPaddSquareLinearization^⚠

computes coefficients of linearization of a square term in a reference point

SCIPaddSquareSecant^⚠

computes coefficients of secant of a square term

SCIPaddStringParam^⚠

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

SCIPaddTermPseudoboolean^⚠

adds nonlinear term to pseudo boolean constraint (if it is not zero)

SCIPaddTrustregionNeighborhoodConstraint^⚠

adds a trust region neighborhood constraint to the @p targetscip

SCIPaddVar^⚠

adds variable to the problem

SCIPaddVarBranchFactor^⚠

adds the given value to the branch factor of the variable

SCIPaddVarBranchPriority^⚠

adds the given value to the branch priority of the variable

SCIPaddVarCardinality^⚠

adds variable to cardinality constraint, the position is determined by the given weight

SCIPaddVarImplication^⚠

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

SCIPaddVarIndicator^⚠

adds variable to the inequality of the indicator constraint

SCIPaddVarLocks^⚠

adds given values to lock numbers of variable for rounding

SCIPaddVarLocksType^⚠

adds given values to lock numbers of type @p locktype of variable for rounding

SCIPaddVarObj^⚠

adds value to variable’s objective value

SCIPaddVarSOS1^⚠

adds variable to SOS1 constraint, the position is determined by the given weight

SCIPaddVarSOS2^⚠

adds variable to SOS2 constraint, the position is determined by the given weight

SCIPaddVarToRow^⚠

resolves variable to columns and adds them with the coefficient to the row

SCIPaddVarVlb^⚠

informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible

SCIPaddVarVub^⚠

informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible

SCIPaddVarsToRow^⚠

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

SCIPaddVarsToRowSameCoef^⚠

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

SCIPadjustImplicitSolVals^⚠

adjusts solution values of implicit integer variables in handed solution. Solution objective value is not deteriorated by this method.

SCIPadjustedVarLb^⚠

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

SCIPadjustedVarUb^⚠

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

SCIPaggrRowAddCustomCons^⚠

add weighted constraint to the aggregation row

SCIPaggrRowAddObjectiveFunction^⚠

add the objective function with right-hand side @p rhs and scaled by @p scale to the aggregation row

SCIPaggrRowAddRow^⚠

add weighted row to the aggregation row

SCIPaggrRowCalcEfficacyNorm^⚠

calculates the efficacy norm of the given aggregation row, which depends on the “separating/efficacynorm” parameter

SCIPaggrRowCancelVarWithBound^⚠

Removes a given variable @p var from position @p pos the aggregation row and updates the right-hand side according to sign of the coefficient, i.e., rhs -= coef * bound, where bound = lb if coef >= 0 and bound = ub, otherwise.

SCIPaggrRowClear^⚠

clear all entries in the aggregation row but do not free the internal memory

SCIPaggrRowCopy^⚠

copy the aggregation row

SCIPaggrRowCreate^⚠

create an empty the aggregation row

SCIPaggrRowFree^⚠

free a the aggregation row

SCIPaggrRowGetAbsWeightRange^⚠

gets the min and max absolute value of the weights used to aggregate the rows; must not be called for empty aggregation rows

SCIPaggrRowGetInds^⚠

gets the array of corresponding variable problem indices for each non-zero in the aggregation row

SCIPaggrRowGetNNz^⚠

gets the number of non-zeros in the aggregation row

SCIPaggrRowGetNRows^⚠

gets the number of row aggregations

SCIPaggrRowGetRank^⚠

gets the rank of the aggregation row

SCIPaggrRowGetRhs^⚠

gets the right hand side of the aggregation row

SCIPaggrRowGetRowInds^⚠

get array with lp positions of aggregated rows

SCIPaggrRowGetRowWeights^⚠

get array with weights of aggregated rows

SCIPaggrRowHasRowBeenAdded^⚠

checks whether a given row has been added to the aggregation row

SCIPaggrRowIsLocal^⚠

checks if the aggregation row is only valid locally

SCIPaggrRowPrint^⚠

output aggregation row to file stream

SCIPaggrRowRemoveZeros^⚠

removes all (close enough to) zero entries in the aggregation row

SCIPaggrRowSumRows^⚠

aggregate rows using the given weights; the current content of the aggregation row, \p aggrrow, gets overwritten

SCIPaggregateVars^⚠

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.

SCIPallColsInLP^⚠

returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing

SCIPallVarsInProb^⚠

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

SCIPallowDualReds^⚠

returns whether dual reductions are allowed during propagation and presolving

SCIPallowObjProp^⚠

returns whether propagation w.r.t. current objective is allowed

SCIPallowStrongDualReds^⚠

returns whether strong dual reductions are allowed during propagation and presolving

SCIPallowWeakDualReds^⚠

returns whether weak dual reductions are allowed during propagation and presolving

SCIPanalyzeConflict^⚠

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

SCIPanalyzeConflictCons^⚠

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())

SCIPanalyzeDeductionsProbing^⚠

analyses boundchanges resulting from probing on a variable and performs deduced fixations, aggregations, and domain tightenings

SCIPappendExprChild^⚠

appends child to the children list of expr

SCIPappendExprSumExpr^⚠

appends an expression to a sum expression

SCIPappendVarCardinality^⚠

appends variable to cardinality constraint

SCIPappendVarSOS1^⚠

appends variable to SOS1 constraint

SCIPappendVarSOS2^⚠

appends variable to SOS2 constraint

SCIPapplyBendersDecomposition^⚠

applies a Benders’ decomposition to the selected decomposition from the decomposition store

SCIPapplyBendersStoredCuts^⚠

applies the Benders’ decomposition cuts in storage to the input SCIP instance

SCIPapplyCutsProbing^⚠

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

SCIPapplyHeurDualval^⚠

main procedure of the dualval heuristic

SCIPapplyHeurSubNlp^⚠

main procedure of the subNLP heuristic

SCIPapplyLockFixings^⚠

apply fix-and-propagate scheme based on variable locks

SCIPapplyProbingVar^⚠

applies and evaluates probing of a single variable in the given direction and bound

SCIPapplyProximity^⚠

main procedure of the proximity heuristic, creates and solves a sub-SCIP

SCIPapplyRens^⚠

main procedure of the RNS heuristic, creates and solves a sub-SCIP

SCIPapplyReopt^⚠

reactivate the given @p reoptnode and split them into several nodes if necessary

SCIPapplyZeroobj^⚠

main procedure of the zeroobj heuristic, creates and solves a sub-SCIP

SCIPareSolsEqual^⚠

returns whether two given solutions are exactly equal

SCIPassignDecompLinkConss^⚠

assigns linking constraints to blocks

SCIPassumeConvexNonlinear^⚠

returns whether all nonlinear constraints are assumed to be convex

SCIPautoselectDisps^⚠

automatically selects display columns for being shown w.r.t. the display width parameter

SCIPbacktrackProbing^⚠

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

SCIPbanditGetNActions^⚠

return number of actions of this bandit algorithm

SCIPbanditGetRandnumgen^⚠

return the random number generator of a bandit algorithm

SCIPbanditSelect^⚠

select the next action

SCIPbanditUpdate^⚠

update the score of the selected action

SCIPbanditvtableGetName^⚠

return the name of this bandit virtual function table

SCIPbarrierconvtol^⚠

returns convergence tolerance used in barrier algorithm

SCIPbdchgidxIsEarlier^⚠

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

SCIPbdchgidxIsEarlierNonNull^⚠

returns whether first bound change index belongs to an earlier applied bound change than second one

SCIPbdchginfoGetBoundtype^⚠

returns whether the bound change information belongs to a lower or upper bound change

SCIPbdchginfoGetChgtype^⚠

returns whether the bound change information belongs to a branching decision or a deduction

SCIPbdchginfoGetDepth^⚠

returns depth level of given bound change information

SCIPbdchginfoGetIdx^⚠

returns bound change index of given bound change information

SCIPbdchginfoGetInferBoundtype^⚠

returns inference bound of inference variable of given bound change information

SCIPbdchginfoGetInferCons^⚠

returns inference constraint of given bound change information

SCIPbdchginfoGetInferInfo^⚠

returns inference user information of given bound change information

SCIPbdchginfoGetInferProp^⚠

returns inference propagator of given bound change information, or NULL if no propagator was responsible

SCIPbdchginfoGetInferVar^⚠

returns inference variable of given bound change information

SCIPbdchginfoGetNewbound^⚠

returns new bound installed for given bound change information

SCIPbdchginfoGetOldbound^⚠

returns old bound that was overwritten for given bound change information

SCIPbdchginfoGetPos^⚠

returns bound change position in its depth level of given bound change information

SCIPbdchginfoGetVar^⚠

returns variable that belongs to the given bound change information

SCIPbdchginfoHasInferenceReason^⚠

returns whether the bound change has an inference reason (constraint or propagator), that can be resolved

SCIPbdchginfoIsRedundant^⚠

returns whether the bound change information belongs to a redundant bound change

SCIPbdchginfoIsTighter^⚠

for two bound change informations belonging to the same variable and bound, returns whether the first bound change has a tighter new bound as the second bound change

SCIPbendersComp^⚠

compares two benderss w. r. to their priority

SCIPbendersCompName^⚠

comparison method for sorting benderss w.r.t. to their name

SCIPbendersCutLP^⚠

Are Benders’ cuts generated from the LP solutions?

SCIPbendersCutPseudo^⚠

Are Benders’ cuts generated from the pseudo solutions?

SCIPbendersCutRelaxation^⚠

Are Benders’ cuts generated from the relaxation solutions?

SCIPbendersGetAuxiliaryVar^⚠

returns the auxiliary variable for the given subproblem

SCIPbendersGetAuxiliaryVars^⚠

returns all auxiliary variables

SCIPbendersGetBenderscuts^⚠

returns the array of currently available Benders’ cuts; active Benders’ decomposition are in the first slots of the array

SCIPbendersGetData^⚠

gets user data of Benders’ decomposition

SCIPbendersGetDesc^⚠

gets description of Benders’ decomposition

SCIPbendersGetNBenderscuts^⚠

returns the number of currently available Benders’ cuts

SCIPbendersGetNCalls^⚠

gets the number of times, the Bender’ decomposition was called and tried to find a violated second stage constraint

SCIPbendersGetNConvexSubproblems^⚠

returns the number of subproblems that are convex

SCIPbendersGetNCutsFound^⚠

gets the number of optimality cuts found by the collection of Benders’ decomposition subproblems

SCIPbendersGetNNonlinearSubproblems^⚠

returns the number of subproblems that contain non-linear constraints

SCIPbendersGetNStoredCuts^⚠

returns the number of cuts that have been added for storage

SCIPbendersGetNStrengthenCalls^⚠

gets the number of calls to the strengthening round

SCIPbendersGetNStrengthenCutsFound^⚠

gets the number of cuts found from the strengthening round

SCIPbendersGetNStrengthenFails^⚠

gets the number of calls to the strengthening round that fail

SCIPbendersGetNSubproblems^⚠

gets the number of subproblems for the Benders’ decomposition

SCIPbendersGetNTransferredCuts^⚠

returns the number of cuts that have been transferred from sub SCIPs to the master SCIP

SCIPbendersGetName^⚠

gets name of Benders’ decomposition

SCIPbendersGetPriority^⚠

gets priority of Benders’ decomposition

SCIPbendersGetSetupTime^⚠

gets time in seconds used in this Benders’ decomposition for setting up for next stages

SCIPbendersGetStoredCutData^⚠

returns the data for the cuts that have been added by the Benders’ cut plugin

SCIPbendersGetStoredCutOrigData^⚠

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

SCIPbendersGetSubproblemLowerbound^⚠

returns the stored lower bound for the given subproblem

SCIPbendersGetSubproblemObjval^⚠

returns the objective function value of the subproblem for use in cut generation

SCIPbendersGetSubproblemType^⚠

returns the type of the subproblem

SCIPbendersGetTime^⚠

gets execution time in seconds used in this Benders’ decomposition

SCIPbendersInStrengthenRound^⚠

returns the flag indicating that Benders’ decomposition is in a cut strengthening round

SCIPbendersIsActive^⚠

returns whether the given Benders’ decomposition is in use in the current problem

SCIPbendersIsInitialized^⚠

Is Benders’ decomposition initialized?

SCIPbendersMasterIsNonlinear^⚠

returns whether the master problem contains non-linear constraints.

SCIPbendersOnlyCheckConvexRelax^⚠

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.

SCIPbendersSetBenderscutPriority^⚠

sets the priority of a Benders’ decomposition

SCIPbendersSetData^⚠

sets user data of Benders’ decomposition; user has to free old data in advance!

SCIPbendersSetMasterIsNonlinear^⚠

sets the flag indicating whether the master problem contains non-linear constraints

SCIPbendersSetSubproblemIsConvex^⚠

sets the flag indicating whether a subproblem is convex

SCIPbendersSetSubproblemIsIndependent^⚠

sets the independent subproblem flag

SCIPbendersSetSubproblemIsNonlinear^⚠

sets the flag indicating whether a subproblem contains non-linear constraints

SCIPbendersSetSubproblemIsSetup^⚠

sets the subproblem setup flag

SCIPbendersSetSubproblemObjval^⚠

stores the objective function value of the subproblem for use in cut generation

SCIPbendersSetSubproblemType^⚠

sets the subproblem type

SCIPbendersShareAuxVars^⚠

Should this Benders’ use the auxiliary variables from the highest priority Benders’?

SCIPbendersSolSlackVarsActive^⚠

returns whether the solution has non-zero slack variables

SCIPbendersSolveSubproblemCIP^⚠

solves the Benders’ decomposition subproblem

SCIPbendersSolveSubproblemLP^⚠

solves the LP of the Benders’ decomposition subproblem

SCIPbendersSubproblem^⚠

returns the SCIP instance for a given subproblem

SCIPbendersSubproblemIsConvex^⚠

returns whether the subproblem is convex

SCIPbendersSubproblemIsEnabled^⚠

returns whether the subproblem is enabled, i.e. the subproblem is still solved in the solving loop.

SCIPbendersSubproblemIsIndependent^⚠

returns whether the subproblem is independent

SCIPbendersSubproblemIsNonlinear^⚠

returns whether the subproblem contains non-linear constraints.

SCIPbendersSubproblemIsSetup^⚠

returns the subproblem setup flag

SCIPbendersUpdateSubproblemLowerbound^⚠

updates the lower bound for the subproblem. If the lower bound is not greater than the previously stored lowerbound, then no update occurs.

SCIPbenderscutComp^⚠

compares two Benders’ decomposition cuts w. r. to their priority

SCIPbenderscutCompName^⚠

comparison method for sorting Benders’ decomposition cuts w.r.t. to their name

SCIPbenderscutGetData^⚠

gets user data of the Benders’ decomposition cut

SCIPbenderscutGetDesc^⚠

gets description of the Benders’ decomposition cut

SCIPbenderscutGetNCalls^⚠

gets the number of times, the Benders’ decomposition cut was called and tried to find a violated cut

SCIPbenderscutGetNFound^⚠

gets the number of the cuts found by this Benders’ decomposition cut

SCIPbenderscutGetName^⚠

gets name of the Benders’ decomposition cut

SCIPbenderscutGetPriority^⚠

gets priority of the Benders’ decomposition cut

SCIPbenderscutGetSetupTime^⚠

gets time in seconds used in this Benders’ decomposition cut for setting up for next stages

SCIPbenderscutGetTime^⚠

gets time in seconds used in this Benders’ decomposition cut

SCIPbenderscutIsInitialized^⚠

is the Benders’ decomposition cut initialized?

SCIPbenderscutIsLPCut^⚠

returns whether the Benders’ cut uses the LP information

SCIPbenderscutSetData^⚠

sets user data of the Benders’ decomposition cut; user has to free old data in advance!

SCIPbenderscutSetEnabled^⚠

sets the enabled flag of the Benders’ decomposition cut method

SCIPblkmem^⚠

returns block memory to use at the current time

SCIPboundchgGetBoundchgtype^⚠

returns the bound change type of the bound change in the bound change data

SCIPboundchgGetBoundtype^⚠

returns the bound type of the bound change in the bound change data

SCIPboundchgGetNewbound^⚠

returns the new value of the bound in the bound change data

SCIPboundchgGetVar^⚠

returns the variable of the bound change in the bound change data

SCIPboundchgIsRedundant^⚠

returns whether the bound change is redundant due to a more global bound that is at least as strong

SCIPboundtypeOpposite^⚠

gets opposite bound type of given bound type

SCIPbranchExtern^⚠

calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN

SCIPbranchLP^⚠

calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN; if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority

SCIPbranchPseudo^⚠

calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN

SCIPbranchVar^⚠

branches on a non-continuous variable v using the current LP or pseudo solution; if solution value x’ is fractional, two child nodes will be created (x <= floor(x’), x >= ceil(x’)), if solution value is integral, the x’ is equal to lower or upper bound of the branching variable and the bounds of v are finite, then two child nodes will be created (x <= x’‘, x >= x’‘+1 with x’’ = floor((lb + ub)/2)), otherwise (up to) three child nodes will be created (x <= x’-1, x == x’, x >= x’+1)

SCIPbranchVarHole^⚠

branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created

SCIPbranchVarVal^⚠

branches on a variable x using a given value x’; for continuous variables with relative domain width larger epsilon, x’ must not be one of the bounds; two child nodes (x <= x’, x >= x’) are created; for integer variables, if solution value x’ is fractional, two child nodes are created (x <= floor(x’), x >= ceil(x’)), if x’ is integral, three child nodes are created (x <= x’-1, x == x’, x >= x’+1)

SCIPbranchVarValNary^⚠

n-ary branching on a variable x using a given value

SCIPbranchruleComp^⚠

compares two branching rules w. r. to their priority

SCIPbranchruleCompName^⚠

comparison method for sorting branching rules w.r.t. to their name

SCIPbranchruleGetData^⚠

gets user data of branching rule

SCIPbranchruleGetDesc^⚠

gets description of branching rule

SCIPbranchruleGetMaxbounddist^⚠

gets maximal relative distance from current node’s dual bound to primal bound for applying branching rule

SCIPbranchruleGetMaxdepth^⚠

gets maximal depth level, up to which this branching rule should be used (-1 for no limit)

SCIPbranchruleGetNChildren^⚠

gets the total number of children, the branching rule created

SCIPbranchruleGetNConssFound^⚠

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)

SCIPbranchruleGetNCutoffs^⚠

gets the total number of times, the branching rule detected a cutoff

SCIPbranchruleGetNCutsFound^⚠

gets the total number of cuts, the branching rule separated

SCIPbranchruleGetNDomredsFound^⚠

gets the total number of domain reductions, the branching rule found

SCIPbranchruleGetNExternCalls^⚠

gets the total number of times, the branching rule was called on external candidates

SCIPbranchruleGetNLPCalls^⚠

gets the total number of times, the branching rule was called on an LP solution

SCIPbranchruleGetNPseudoCalls^⚠

gets the total number of times, the branching rule was called on a pseudo solution

SCIPbranchruleGetName^⚠

gets name of branching rule

SCIPbranchruleGetPriority^⚠

gets priority of branching rule

SCIPbranchruleGetSetupTime^⚠

gets time in seconds used in this branching rule for setting up for next stages

SCIPbranchruleGetTime^⚠

gets time in seconds used in this branching rule

SCIPbranchruleIsInitialized^⚠

is branching rule initialized?

SCIPbranchruleSetData^⚠

sets user data of branching rule; user has to free old data in advance!

SCIPbtCreate^⚠

creates an binary tree

SCIPbtFree^⚠

frees binary tree

SCIPbtGetRoot^⚠

returns the root node of the binary tree or NULL if the binary tree is empty

SCIPbtIsEmpty^⚠

returns whether the binary tree is empty (has no nodes)

SCIPbtPrintGml^⚠

prints the binary tree in GML format into the given file

SCIPbtSetRoot^⚠

sets root node

SCIPbtnodeCreate^⚠

creates a binary tree node with sorting value and user data

SCIPbtnodeFree^⚠

frees the binary node including the rooted subtree

SCIPbtnodeGetData^⚠

returns the user data pointer stored in that node

SCIPbtnodeGetLeftchild^⚠

returns left child which can be NULL if the given node is a leaf

SCIPbtnodeGetParent^⚠

returns the parent which can be NULL if the given node is the root

SCIPbtnodeGetRightchild^⚠

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

SCIPbtnodeGetSibling^⚠

returns the sibling of the node or NULL if does not exist

SCIPbtnodeIsLeaf^⚠

returns whether the node is a leaf

SCIPbtnodeIsLeftchild^⚠

returns TRUE if the given node is left child

SCIPbtnodeIsRightchild^⚠

returns TRUE if the given node is right child

SCIPbtnodeIsRoot^⚠

returns whether the node is a root node

SCIPbtnodeSetData^⚠

sets the give node data

SCIPbtnodeSetLeftchild^⚠

sets left child

SCIPbtnodeSetParent^⚠

sets parent node

SCIPbtnodeSetRightchild^⚠

sets right child

SCIPbuffer^⚠

returns buffer memory for short living temporary objects

SCIPcacheRowExtensions^⚠

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

SCIPcalcBinomCoef^⚠

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

SCIPcalcChildEstimate^⚠

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

SCIPcalcChildEstimateIncrease^⚠

calculates the increase of the estimate for the objective of the best feasible solution contained in the subtree after applying the given branching

SCIPcalcCliquePartition^⚠

calculates a partition of the given set of binary variables into cliques; takes into account independent clique components

SCIPcalcCumulativeDistribution^⚠

calculates the cumulative distribution P(-infinity <= x <= value) that a normally distributed random variable x takes a value between -infinity and parameter \p value.

SCIPcalcFibHash^⚠

calculates hash for floating-point number by using Fibonacci hashing

SCIPcalcFlowCover^⚠

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:

SCIPcalcGreComDiv^⚠

calculates the greatest common divisor of the two given values

SCIPcalcIntegralScalar^⚠

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

SCIPcalcKnapsackCover^⚠

calculates a lifted knapsack cover cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in the cut. For further details we refer to:

SCIPcalcMIR^⚠

calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in an MIR cut.

SCIPcalcMachineEpsilon^⚠

returns the machine epsilon: the smallest number eps > 0, for which 1.0 + eps > 1.0

SCIPcalcMemGrowSize^⚠

calculate memory size for dynamically allocated arrays

SCIPcalcMultihashSize^⚠

returns a reasonable hash table size (a prime number) that is at least as large as the specified value

SCIPcalcNegatedCliquePartition^⚠

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;

SCIPcalcNodeselPriority^⚠

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

SCIPcalcRootNewton^⚠

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.

SCIPcalcRowIntegralScalar^⚠

tries to find a value, such that all row coefficients, if scaled with this value become integral

SCIPcalcSmaComMul^⚠

calculates the smallest common multiple of the two given values

SCIPcalcStrongCG^⚠

calculates a strong CG cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in a strongcg cut

SCIPcalculatePscostConfidenceBound^⚠

calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs

SCIPcallExprCurvature^⚠

calls the curvature callback for an expression

SCIPcallExprEstimate^⚠

calls the estimate callback for an expression

SCIPcallExprEval^⚠

calls the eval callback for an expression with given values for children

SCIPcallExprEvalFwdiff^⚠

calls the eval and fwdiff callback of an expression with given values for children

SCIPcallExprInitestimates^⚠

calls the initial estimators callback for an expression

SCIPcallExprInteval^⚠

calls the interval evaluation callback for an expression

SCIPcallExprMonotonicity^⚠

calls the monotonicity callback for an expression

SCIPcallExprPrint^⚠

calls the print callback for an expression

SCIPcallExprReverseprop^⚠

calls the reverse propagation callback for an expression

SCIPcallExprSimplify^⚠

calls the simplify callback for an expression

SCIPcallLapackDsyevIpopt^⚠

Calls Lapacks Dsyev routine to compute eigenvalues and eigenvectors of a dense matrix.

SCIPcaptureCons^⚠

increases usage counter of constraint

SCIPcaptureDialog^⚠

captures a dialog

SCIPcaptureExpr^⚠

captures an expression (increments usage count)

SCIPcaptureNlRow^⚠

increases usage counter of a nonlinear row

SCIPcaptureRow^⚠

increases usage counter of LP row

SCIPcaptureVar^⚠

increases usage counter of variable

SCIPcatchEvent^⚠

catches a global (not variable or row dependent) event

SCIPcatchRowEvent^⚠

catches a row coefficient, constant, or side change event on the given row

SCIPcatchVarEvent^⚠

catches an objective value or domain change event on the given transformed variable

SCIPceil^⚠

rounds value - epsilon up to the next integer

SCIPcheckBendersSubproblemOptimality^⚠

checks the optimality of a Benders’ decomposition subproblem by comparing the objective function value against the value of the corresponding auxiliary variable

SCIPcheckCons^⚠

checks single constraint for feasibility of the given solution

SCIPcheckCopyLimits^⚠

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

SCIPcheckCumulativeCondition^⚠

check for the given starting time variables with their demands and durations if the cumulative conditions for the given solution is satisfied

SCIPcheckExprQuadratic^⚠

checks whether an expression is quadratic

SCIPcheckQuadraticNonlinear^⚠

checks whether expression of constraint can be represented as quadratic form

SCIPcheckReoptRestart^⚠

check if the reoptimization process should be restarted

SCIPcheckSol^⚠

checks solution for feasibility without adding it to the solution store

SCIPcheckSolOrig^⚠

checks solution for feasibility in original problem without adding it to the solution store; this method is used to double check a solution in order to validate the presolving process

SCIPcheckSolutionOrbisack^⚠

checks whether a given binary solution is feasible for the orbisack

SCIPchgAndConsCheckFlagWhenUpgr^⚠

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?

SCIPchgAndConsRemovableFlagWhenUpgr^⚠

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?

SCIPchgBarrierconvtol^⚠

sets the convergence tolerance used in barrier algorithm

SCIPchgBoolParam^⚠

changes the value of an existing SCIP_Bool parameter

SCIPchgCapacityKnapsack^⚠

changes capacity of the knapsack constraint

SCIPchgCardvalCardinality^⚠

changes cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)

SCIPchgCharParam^⚠

changes the value of an existing char parameter

SCIPchgChildPrio^⚠

change the node selection priority of the given child

SCIPchgCoefLinear^⚠

changes coefficient of variable in linear constraint; deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint

SCIPchgConsName^⚠

change constraint name

SCIPchgCutoffboundDive^⚠

changes cutoffbound in current dive

SCIPchgDispMode^⚠

changes the display column mode

SCIPchgDualfeastol^⚠

sets the feasibility tolerance for reduced costs

SCIPchgExprNonlinear^⚠

changes expression of a nonlinear constraint

SCIPchgFeastol^⚠

sets the feasibility tolerance for constraints

SCIPchgIntParam^⚠

changes the value of an existing int parameter

SCIPchgLhsLinear^⚠

changes left hand side of linear constraint

SCIPchgLhsNonlinear^⚠

changes left-hand-side of a nonlinear constraint

SCIPchgLhsPseudoboolean^⚠

changes left hand side of pseudoboolean constraint

SCIPchgLongintParam^⚠

changes the value of an existing SCIP_Longint parameter

SCIPchgLpfeastol^⚠

sets the primal feasibility tolerance of LP solver

SCIPchgNlRowConstant^⚠

changes constant of a nonlinear row

SCIPchgNlRowLhs^⚠

changes left hand side of a nonlinear row

SCIPchgNlRowLinearCoef^⚠

changes linear coefficient of a variables in a nonlinear row

SCIPchgNlRowRhs^⚠

changes right hand side of a nonlinear row

SCIPchgNlpiConsSides^⚠

change constraint sides

SCIPchgNlpiExpr^⚠

change the expression in the nonlinear part

SCIPchgNlpiLinearCoefs^⚠

changes or adds linear coefficients in a constraint or objective

SCIPchgNlpiObjConstant^⚠

change the constant offset in the objective

SCIPchgNlpiVarBounds^⚠

change variable bounds

SCIPchgRealParam^⚠

changes the value of an existing SCIP_Real parameter

SCIPchgRelaxfeastol^⚠

sets the primal feasibility tolerance of relaxations

SCIPchgReoptObjective^⚠

changes the objective function

SCIPchgRhsLinear^⚠

changes right hand side of linear constraint

SCIPchgRhsNonlinear^⚠

changes right-hand-side of a nonlinear constraint

SCIPchgRhsPseudoboolean^⚠

changes right hand side of pseudoboolean constraint

SCIPchgRowLhs^⚠

changes left hand side of LP row

SCIPchgRowLhsDive^⚠

changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()

SCIPchgRowRhs^⚠

changes right hand side of LP row

SCIPchgRowRhsDive^⚠

changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()

SCIPchgStringParam^⚠

changes the value of an existing string(char*) parameter

SCIPchgVarBoundsDiveNLP^⚠

changes bounds of a variable in diving NLP

SCIPchgVarBranchDirection^⚠

sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards branch)

SCIPchgVarBranchFactor^⚠

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

SCIPchgVarBranchPriority^⚠

sets the branch priority of the variable; variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable

SCIPchgVarLb^⚠

depending on SCIP’s stage, changes lower bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

SCIPchgVarLbDive^⚠

changes variable’s lower bound in current dive

SCIPchgVarLbGlobal^⚠

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

SCIPchgVarLbLazy^⚠

changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet

SCIPchgVarLbNode^⚠

changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

SCIPchgVarLbProbing^⚠

injects a change of variable’s lower bound into current probing node; the same can also be achieved with a call to SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision

SCIPchgVarName^⚠

changes the name of a variable

SCIPchgVarObj^⚠

changes variable’s objective value

SCIPchgVarObjDive^⚠

changes variable’s objective value in current dive

SCIPchgVarObjDiveNLP^⚠

changes linear objective coefficient of a variable in diving NLP

SCIPchgVarObjProbing^⚠

changes (column) variable’s objective value during probing mode

SCIPchgVarType^⚠

changes type of variable in the problem;

SCIPchgVarUb^⚠

depending on SCIP’s stage, changes upper bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

SCIPchgVarUbDive^⚠

changes variable’s upper bound in current dive

SCIPchgVarUbGlobal^⚠

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

SCIPchgVarUbLazy^⚠

changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet

SCIPchgVarUbNode^⚠

changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn’t store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

SCIPchgVarUbProbing^⚠

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

SCIPchgVarsBoundsDiveNLP^⚠

changes bounds of a set of variables in diving NLP

SCIPclassifyConstraintTypesLinear^⚠

performs linear constraint type classification as used for MIPLIB

SCIPcleanbuffer^⚠

returns clean buffer memory for short living temporary objects initialized to all zero

SCIPcleanupCliques^⚠

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()

SCIPcleanupConssKnapsack^⚠

cleans up (multi-)aggregations and fixings from knapsack constraints

SCIPcleanupConssLinear^⚠

cleans up (multi-)aggregations and fixings from linear constraints

SCIPcleanupConssLogicor^⚠

cleans up (multi-)aggregations and fixings from logicor constraints

SCIPcleanupConssSetppc^⚠

cleans up (multi-)aggregations and fixings from setppc constraints

SCIPcleanupConssVarbound^⚠

cleans up (multi-)aggregations and fixings from varbound constraints

SCIPcleanupRowprep^⚠

Cleans up and attempts to improve rowprep

SCIPcleanupRowprep2^⚠

Cleans up and attempts to improve rowprep without regard for violation

SCIPclearBoolarray^⚠

clears a dynamic bool array

SCIPclearConflictStore^⚠

removes all conflicts depending on an old cutoff bound if the improvement of the incumbent is good enough

SCIPclearCuts^⚠

clears the separation storage

SCIPclearDiveBoundChanges^⚠

clear the dive bound change data structures

SCIPclearExternBranchCands^⚠

removes all external candidates from the storage for external branching

SCIPclearIntarray^⚠

clears a dynamic int array

SCIPclearPtrarray^⚠

clears a dynamic pointer array

SCIPclearRealarray^⚠

clears a dynamic real array

SCIPclearRelaxSolVals^⚠

sets the solution value of all variables in the global relaxation solution to zero

SCIPclearSol^⚠

clears a primal solution

SCIPcliqueGetId^⚠

gets unique identifier of the clique

SCIPcliqueGetIndex^⚠

gets index of the clique in the clique table

SCIPcliqueGetNVars^⚠

gets number of variables in the cliques

SCIPcliqueGetValues^⚠

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

SCIPcliqueGetVars^⚠

gets array of active problem variables in the cliques

SCIPcliqueHasVar^⚠

returns whether the given variable/value pair is member of the given clique

SCIPcliqueIsCleanedUp^⚠

returns whether the given clique is cleaned up

SCIPcliqueIsEquation^⚠

return whether the given clique is an equation

SCIPcliqueSearchVar^⚠

returns the position of the given variable/value pair in the clique; returns -1 if variable/value pair is not member of the clique

SCIPcolGetAge^⚠

gets the age of a column, i.e., the total number of successive times a column was in the LP and was 0.0 in the solution

SCIPcolGetBasisStatus^⚠

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

SCIPcolGetBestBound^⚠

gets best bound of column with respect to the objective function

SCIPcolGetIndex^⚠

gets unique index of col

SCIPcolGetLPDepth^⚠

gets depth in the tree where the column entered the LP, or -1 if it is not in LP

SCIPcolGetLPPos^⚠

gets position of column in current LP, or -1 if it is not in LP

SCIPcolGetLb^⚠

gets lower bound of column

SCIPcolGetMaxPrimsol^⚠

gets the maximal LP solution value, this column ever assumed

SCIPcolGetMinPrimsol^⚠

gets the minimal LP solution value, this column ever assumed

SCIPcolGetNLPNonz^⚠

get number of nonzero entries in column vector, that correspond to rows currently in the SCIP_LP;

SCIPcolGetNNonz^⚠

get number of nonzero entries in column vector

SCIPcolGetNStrongbranchs^⚠

gets number of times, strong branching was applied in current run on the given column

SCIPcolGetObj^⚠

gets objective value of column

SCIPcolGetPrimsol^⚠

gets the primal LP solution of a column

SCIPcolGetRows^⚠

gets array with rows of nonzero entries

SCIPcolGetStrongbranchNode^⚠

gets node number of the last node in current branch and bound run, where strong branching was used on the given column, or -1 if strong branching was never applied to the column in current run

SCIPcolGetUb^⚠

gets upper bound of column

SCIPcolGetVals^⚠

gets array with coefficients of nonzero entries

SCIPcolGetVar^⚠

gets variable this column represents

SCIPcolGetVarProbindex^⚠

gets probindex of corresponding variable

SCIPcolIsInLP^⚠

returns TRUE iff column is member of current LP

SCIPcolIsIntegral^⚠

returns whether the associated variable is of integral type (binary, integer, implicit integer)

SCIPcolIsRemovable^⚠

returns TRUE iff column is removable from the LP (due to aging or cleanup)

SCIPcolSort^⚠

sorts column entries such that LP rows precede non-LP rows and inside both parts lower row indices precede higher ones

SCIPcollectBilinTermsNonlinear^⚠

collects all bilinear terms for a given set of constraints

SCIPcompareExpr^⚠

compare expressions @return -1, 0 or 1 if expr1 <, =, > expr2, respectively @note The given expressions are assumed to be simplified.

SCIPcomprComp^⚠

compares two compressions w. r. to their priority

SCIPcomprCompName^⚠

comparison method for sorting compressions w.r.t. to their name

SCIPcomprGetData^⚠

gets user data of tree compression

SCIPcomprGetDesc^⚠

gets description of tree compression

SCIPcomprGetMinNodes^⚠

gets minimal number of nodes for calling tree compression (returns -1, if no node threshold exists)

SCIPcomprGetNCalls^⚠

gets the number of times, the compression was called and tried to find a compression

SCIPcomprGetNFound^⚠

gets the number of tree compressions found by this compression

SCIPcomprGetName^⚠

gets name of tree compression

SCIPcomprGetPriority^⚠

gets priority of tree compression

SCIPcomprGetSetupTime^⚠

gets time in seconds used in this compression for setting up for next stages

SCIPcomprGetTime^⚠

gets time in seconds used in this compression

SCIPcomprIsInitialized^⚠

is tree compression initialized?

SCIPcomprSetData^⚠

sets user data of tree compression; user has to free old data in advance!

SCIPcomputeArraysIntersection^⚠

computes set intersection (duplicates removed) of two integer arrays that are ordered ascendingly

SCIPcomputeArraysIntersectionInt^⚠

computes set intersection (duplicates removed) of two integer arrays that are ordered ascendingly

SCIPcomputeArraysIntersectionPtr^⚠

computes set intersection (duplicates removed) of two void-pointer arrays that are ordered ascendingly

SCIPcomputeArraysSetminus^⚠

computes set difference (duplicates removed) of two integer arrays that are ordered ascendingly

SCIPcomputeArraysSetminusInt^⚠

computes set difference (duplicates removed) of two integer arrays that are ordered ascendingly

SCIPcomputeBendersSubproblemLowerbound^⚠

solves an independent subproblem to identify its lower bound and updates the lower bound of the corresponding auxiliary variable

SCIPcomputeBilinEnvelope1^⚠

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

SCIPcomputeBilinEnvelope2^⚠

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

SCIPcomputeComponentsSym^⚠

compute components of symmetry group

SCIPcomputeCoverUndercover^⚠

computes a minimal set of covering variables

SCIPcomputeDecompConsLabels^⚠

computes constraint labels from variable labels

SCIPcomputeDecompStats^⚠

computes decomposition statistics and store them in the decomposition object

SCIPcomputeDecompVarsLabels^⚠

creates a decomposition of the variables from a labeling of the constraints

SCIPcomputeExprCurvature^⚠

computes the curvature of a given expression and all its subexpressions

SCIPcomputeExprIntegrality^⚠

computes integrality information of a given expression and all its subexpressions

SCIPcomputeExprQuadraticCurvature^⚠

checks the curvature of the quadratic expression

SCIPcomputeFacetVertexPolyhedralNonlinear^⚠

computes a facet of the convex or concave envelope of a vertex polyhedral function

SCIPcomputeGap^⚠

computes the gap from the primal and the dual bound

SCIPcomputeHmax^⚠

computes w.r.t. the given worst case resource profile the first time point where the given capacity is satisfied for sure

SCIPcomputeHmin^⚠

computes w.r.t. the given worst case resource profile the first time point where the given capacity can be violated

SCIPcomputeLPRelIntPoint^⚠

compute relative interior point to current LP @see SCIPlpComputeRelIntPoint

SCIPcomputeOrbitVar^⚠

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.

SCIPcomputeOrbitsComponentsSym^⚠

compute non-trivial orbits of symmetry group

SCIPcomputeOrbitsFilterSym^⚠

compute non-trivial orbits of symmetry group using filtered generators

SCIPcomputeOrbitsSym^⚠

compute non-trivial orbits of symmetry group

SCIPcomputeTwoSampleTTestValue^⚠

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

SCIPcomputeVarLbGlobal^⚠

for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables

SCIPcomputeVarLbLocal^⚠

for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables

SCIPcomputeVarUbGlobal^⚠

for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables

SCIPcomputeVarUbLocal^⚠

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

SCIPconflicthdlrComp^⚠

compares two conflict handlers w. r. to their priority

SCIPconflicthdlrCompName^⚠

comparison method for sorting conflict handler w.r.t. to their name

SCIPconflicthdlrGetData^⚠

gets user data of conflict handler

SCIPconflicthdlrGetDesc^⚠

gets description of conflict handler

SCIPconflicthdlrGetName^⚠

gets name of conflict handler

SCIPconflicthdlrGetPriority^⚠

gets priority of conflict handler

SCIPconflicthdlrGetSetupTime^⚠

gets time in seconds used in this conflict handler for setting up for next stages

SCIPconflicthdlrGetTime^⚠

gets time in seconds used in this conflict handler

SCIPconflicthdlrIsInitialized^⚠

is conflict handler initialized?

SCIPconflicthdlrSetData^⚠

sets user data of conflict handler; user has to free old data in advance!

SCIPconsAddCoef^⚠

adds the given variable to the input constraint. If the constraint is setppc or logicor the value is ignored. If the constraint is knapsack, then the value is converted to an int. A warning is passed if the SCIP_Real is not an integer. TODO: Allow val to be a pointer.

SCIPconsAddUpgradeLocks^⚠

adds locks to (dis-)allow upgrading of constraint

SCIPconsBendersEnforceSolution^⚠

enforces Benders’ constraints for given solution

SCIPconsGetActiveDepth^⚠

for an active constraint, returns the depth in the tree at which the constraint was activated

SCIPconsGetAge^⚠

gets age of constraint

SCIPconsGetData^⚠

returns the constraint data field of the constraint

SCIPconsGetDualfarkas^⚠

returns the dual farkas solution of an arbitrary SCIP constraint that can be represented as a single linear constraint

SCIPconsGetDualsol^⚠

returns the dual solution of an arbitrary SCIP constraint that can be represented as a single linear constraint

SCIPconsGetHdlr^⚠

returns the constraint handler of the constraint

SCIPconsGetLhs^⚠

returns the left-hand side of an arbitrary SCIP constraint that can be represented as a single linear constraint

SCIPconsGetNLocksNeg^⚠

get number of times the roundings for variables in constraint’s negation are locked

SCIPconsGetNLocksPos^⚠

get number of times the roundings for variables in constraint are locked

SCIPconsGetNLocksTypeNeg^⚠

get number of times the roundings of given locktype for variables in constraint’s negation are locked

SCIPconsGetNLocksTypePos^⚠

get number of times the roundings of given locktype for variables in constraint are locked

SCIPconsGetNUpgradeLocks^⚠

gets number of locks against upgrading the constraint, 0 means this constraint can be upgraded

SCIPconsGetNUses^⚠

gets number of times, the constraint is currently captured

SCIPconsGetName^⚠

returns the name of the constraint

SCIPconsGetPos^⚠

returns the position of constraint in the corresponding handler’s conss array

SCIPconsGetRhs^⚠

returns the right-hand side of an arbitrary SCIP constraint that can be represented as a single linear constraint

SCIPconsGetRow^⚠

returns the row of an arbitrary SCIP constraint that can be represented as a single linear constraint or NULL of no row is awailable

SCIPconsGetValidDepth^⚠

returns the depth in the tree at which the constraint is valid; returns INT_MAX, if the constraint is local and currently not active

SCIPconsIsActive^⚠

returns TRUE iff constraint is active in the current node

SCIPconsIsAdded^⚠

returns if the constraint was already added to a SCIP instance

SCIPconsIsChecked^⚠

returns TRUE iff constraint should be checked for feasibility

SCIPconsIsConflict^⚠

returns TRUE iff constraint is marked as a conflict

SCIPconsIsDeleted^⚠

returns TRUE iff constraint is deleted or marked to be deleted

SCIPconsIsDynamic^⚠

returns TRUE iff constraint is subject to aging

SCIPconsIsEnabled^⚠

returns TRUE iff constraint is enabled in the current node

SCIPconsIsEnforced^⚠

returns TRUE iff constraint should be enforced during node processing

SCIPconsIsGlobal^⚠

returns TRUE iff constraint is globally valid

SCIPconsIsInProb^⚠

returns TRUE iff constraint belongs to the global problem

SCIPconsIsInitial^⚠

returns TRUE iff the LP relaxation of constraint should be in the initial LP

SCIPconsIsLocal^⚠

returns TRUE iff constraint is only locally valid or not added to any (sub)problem

SCIPconsIsLocked^⚠

returns TRUE iff roundings for variables in constraint or in constraint’s negation are locked

SCIPconsIsLockedNeg^⚠

returns TRUE iff roundings for variables in constraint’s negation are locked

SCIPconsIsLockedPos^⚠

returns TRUE iff roundings for variables in constraint are locked

SCIPconsIsLockedType^⚠

returns TRUE iff roundings of the given locktype for variables in constraint or in constraint’s negation are locked

SCIPconsIsLockedTypeNeg^⚠

returns TRUE iff roundings of the given locktype for variables in constraint are locked

SCIPconsIsLockedTypePos^⚠

returns TRUE iff roundings of the given locktype for variables in constraint are locked

SCIPconsIsMarkedPropagate^⚠

returns whether the constraint is marked for propagation

SCIPconsIsModifiable^⚠

returns TRUE iff constraint is modifiable (subject to column generation)

SCIPconsIsObsolete^⚠

returns TRUE iff constraint is marked obsolete

SCIPconsIsOriginal^⚠

returns TRUE iff constraint is belonging to original space

SCIPconsIsPropagated^⚠

returns TRUE iff constraint should be propagated during node processing

SCIPconsIsPropagationEnabled^⚠

returns TRUE iff constraint’s propagation is enabled in the current node

SCIPconsIsRemovable^⚠

returns TRUE iff constraint’s relaxation should be removed from the LP due to aging or cleanup

SCIPconsIsSeparated^⚠

returns TRUE iff constraint should be separated during LP processing

SCIPconsIsSeparationEnabled^⚠

returns TRUE iff constraint’s separation is enabled in the current node

SCIPconsIsStickingAtNode^⚠

returns TRUE iff constraint’s relaxation should be removed from the LP due to aging or cleanup

SCIPconsIsTransformed^⚠

returns TRUE iff constraint is belonging to transformed space

SCIPconsIsUpdatedeactivate^⚠

returns TRUE iff constraint has to be deactivated in update phase

SCIPconshdlrCompCheck^⚠

compares two constraint handlers w. r. to their feasibility check priority

SCIPconshdlrCompEnfo^⚠

compares two constraint handlers w. r. to their enforcing priority

SCIPconshdlrCompSepa^⚠

compares two constraint handlers w. r. to their separation priority

SCIPconshdlrDoesPresolve^⚠

does the constraint handler perform presolving?

SCIPconshdlrGetCheckConss^⚠

gets array with checked constraints of constraint handler; this is local information

SCIPconshdlrGetCheckPriority^⚠

gets checking priority of constraint handler

SCIPconshdlrGetCheckTime^⚠

gets time in seconds used for feasibility checking in this constraint handler

SCIPconshdlrGetConss^⚠

gets array with constraints of constraint handler; the first SCIPconshdlrGetNActiveConss() entries are the active constraints, the last SCIPconshdlrGetNConss() - SCIPconshdlrGetNActiveConss() constraints are deactivated

SCIPconshdlrGetData^⚠

gets user data of constraint handler

SCIPconshdlrGetDesc^⚠

gets description of constraint handler

SCIPconshdlrGetEagerFreq^⚠

gets frequency of constraint handler for eager evaluations in separation, propagation and enforcement

SCIPconshdlrGetEnfoConss^⚠

gets array with enforced constraints of constraint handler; this is local information

SCIPconshdlrGetEnfoLPTime^⚠

gets time in seconds used for LP enforcement in this constraint handler

SCIPconshdlrGetEnfoPSTime^⚠

gets time in seconds used for pseudo enforcement in this constraint handler

SCIPconshdlrGetEnfoPriority^⚠

gets enforcing priority of constraint handler

SCIPconshdlrGetEnfoRelaxTime^⚠

gets time in seconds used for relaxation enforcement in this constraint handler

SCIPconshdlrGetMaxNActiveConss^⚠

gets maximum number of active constraints of constraint handler existing at the same time

SCIPconshdlrGetNActiveConss^⚠

gets number of active constraints of constraint handler

SCIPconshdlrGetNAddConss^⚠

gets number of constraints added in presolving method of constraint handler

SCIPconshdlrGetNAddHoles^⚠

gets number of holes added to domains of variables in presolving method of constraint handler

SCIPconshdlrGetNAggrVars^⚠

gets number of variables aggregated in presolving method of constraint handler

SCIPconshdlrGetNCheckCalls^⚠

gets number of calls to the constraint handler’s checking method

SCIPconshdlrGetNCheckConss^⚠

gets number of checked constraints of constraint handler; this is local information

SCIPconshdlrGetNChgBds^⚠

gets number of bounds changed in presolving method of constraint handler

SCIPconshdlrGetNChgCoefs^⚠

gets number of coefficients changed in presolving method of constraint handler

SCIPconshdlrGetNChgSides^⚠

gets number of constraint sides changed in presolving method of constraint handler

SCIPconshdlrGetNChgVarTypes^⚠

gets number of variable types changed in presolving method of constraint handler

SCIPconshdlrGetNChildren^⚠

gets number of children created by this constraint handler

SCIPconshdlrGetNConss^⚠

gets total number of existing transformed constraints of constraint handler

SCIPconshdlrGetNConssFound^⚠

gets total number of additional constraints added by this constraint handler

SCIPconshdlrGetNCutoffs^⚠

gets total number of times, this constraint handler detected a cutoff

SCIPconshdlrGetNCutsApplied^⚠

gets total number of cuts found by this constraint handler applied to lp

SCIPconshdlrGetNCutsFound^⚠

gets total number of cuts found by this constraint handler

SCIPconshdlrGetNDelConss^⚠

gets number of constraints deleted in presolving method of constraint handler

SCIPconshdlrGetNDomredsFound^⚠

gets total number of domain reductions found by this constraint handler

SCIPconshdlrGetNEnabledConss^⚠

gets number of enabled constraints of constraint handler

SCIPconshdlrGetNEnfoConss^⚠

gets number of enforced constraints of constraint handler; this is local information

SCIPconshdlrGetNEnfoLPCalls^⚠

gets number of calls to the constraint handler’s LP enforcing method

SCIPconshdlrGetNEnfoPSCalls^⚠

gets number of calls to the constraint handler’s pseudo enforcing method

SCIPconshdlrGetNEnfoRelaxCalls^⚠

gets number of calls to the constraint handler’s relaxation enforcing method

SCIPconshdlrGetNFixedVars^⚠

gets number of variables fixed in presolving method of constraint handler

SCIPconshdlrGetNPresolCalls^⚠

gets number of times the presolving method of the constraint handler was called and tried to find reductions

SCIPconshdlrGetNPropCalls^⚠

gets number of calls to the constraint handler’s propagation method

SCIPconshdlrGetNRespropCalls^⚠

gets number of calls to the constraint handler’s resolve propagation method

SCIPconshdlrGetNSepaCalls^⚠

gets number of calls to the constraint handler’s separation method

SCIPconshdlrGetNUpdateConss^⚠

gets number of constraints that have delayed updates

SCIPconshdlrGetNUpgdConss^⚠

gets number of constraints upgraded in presolving method of constraint handler

SCIPconshdlrGetName^⚠

gets name of constraint handler

SCIPconshdlrGetPresolTime^⚠

gets time in seconds used for presolving in this constraint handler

SCIPconshdlrGetPresolTiming^⚠

returns the timing mask of the presolving method of the constraint handler

SCIPconshdlrGetPropFreq^⚠

gets propagation frequency of constraint handler

SCIPconshdlrGetPropTime^⚠

gets time in seconds used for propagation in this constraint handler

SCIPconshdlrGetPropTiming^⚠

returns the timing mask of the propagation method of the constraint handler

SCIPconshdlrGetRespropTime^⚠

gets time in seconds used for resolving propagation in this constraint handler

SCIPconshdlrGetSepaFreq^⚠

gets separation frequency of constraint handler

SCIPconshdlrGetSepaPriority^⚠

gets separation priority of constraint handler

SCIPconshdlrGetSepaTime^⚠

gets time in seconds used for separation in this constraint handler

SCIPconshdlrGetSetupTime^⚠

gets time in seconds used for setting up this constraint handler for new stages

SCIPconshdlrGetStartNActiveConss^⚠

gets initial number of active constraints of constraint handler

SCIPconshdlrGetStrongBranchPropTime^⚠

gets time in seconds used for propagation in this constraint handler during strong branching

SCIPconshdlrGetUpdateConss^⚠

gets array with delayed update constraints

SCIPconshdlrIsClonable^⚠

does the constraint handler have a copy function?

SCIPconshdlrIsInitialized^⚠

is constraint handler initialized?

SCIPconshdlrIsPropagationDelayed^⚠

should propagation method be delayed, if other propagators found reductions?

SCIPconshdlrIsSeparationDelayed^⚠

should separation method be delayed, if other separators found cuts?

SCIPconshdlrNeedsCons^⚠

needs constraint handler a constraint to be called?

SCIPconshdlrSetData^⚠

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

SCIPconshdlrSetEnforelax^⚠

sets the relaxation enforcement method of the constraint handler

SCIPconshdlrSetPresolTiming^⚠

sets the timing mask of the presolving method of the constraint handler

SCIPconshdlrSetProp^⚠

sets both the propagation callback and the propagation frequency of the constraint handler

SCIPconshdlrSetPropTiming^⚠

sets the timing mask of the propagation method of the constraint handler

SCIPconshdlrSetSepa^⚠

sets all separation related callbacks of the constraint handler

SCIPconshdlrWasLPSeparationDelayed^⚠

was LP separation method delayed at the last call?

SCIPconshdlrWasPropagationDelayed^⚠

was propagation method delayed at the last call?

SCIPconshdlrWasSolSeparationDelayed^⚠

was primal solution separation method delayed at the last call?

SCIPconssetchgGetAddedConsData^⚠

gets added constraints data for a constraint set change

SCIPconstructLP^⚠

makes sure that the LP of the current node is loaded and may be accessed through the LP information methods

SCIPconstructSyncstore^⚠

Constructs the parallel interface to execute processes concurrently.

SCIPcontainsExternBranchCand^⚠

checks whether the given variable is contained in the candidate storage for external branching

SCIPconvertCutsToConss^⚠

convert all active cuts from cutpool to linear constraints

SCIPconvertRealToInt^⚠

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

SCIPconvertRealToLongint^⚠

converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for performance; in debug mode we check some additional conditions

SCIPcopy^⚠

copies source SCIP to target SCIP; the copying process is done in the following order:

SCIPcopyBenders^⚠

copies all Benders’ decomposition plugins

SCIPcopyConflicts^⚠

copies all active conflicts from the conflict pool of sourcescip and adds them as linear constraints to targetscip

SCIPcopyConsCompression^⚠

copies source SCIP to target SCIP but compresses constraints

SCIPcopyConsLinear^⚠

creates by copying and captures a linear constraint

SCIPcopyConss^⚠

copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the variables between the source and the target SCIP a hash map can be given; if the variable hash map is NULL or necessary variable mapping is missing, the required variables are created in the target-SCIP and added to the hash map, if not NULL; all variables which are created are added to the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping between the constraints of the source and target-SCIP is stored

SCIPcopyCuts^⚠

copies all active cuts from cutpool of sourcescip to linear constraints in targetscip

SCIPcopyDigraph^⚠

copies directed graph structure

SCIPcopyExpr^⚠

copies an expression including children to use in a (possibly different) SCIP instance

SCIPcopyImplicationsCliques^⚠

copies implications and cliques of sourcescip to targetscip

SCIPcopyLargeNeighborhoodSearch^⚠

get a sub-SCIP copy of the transformed problem

SCIPcopyLimits^⚠

copies limits from source SCIP to target SCIP

SCIPcopyOrig^⚠

copies source SCIP original problem to target SCIP; the copying process is done in the following order:

SCIPcopyOrigConsCompression^⚠

copies source SCIP original problem to target SCIP but compresses constraints

SCIPcopyOrigConss^⚠

copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the variables between the source and the target SCIP a hash map can be given; if the variable hash map is NULL or necessary variable mapping is missing, the required variables are created in the target-SCIP and added to the hash map, if not NULL; all variables which are created are added to the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping between the constraints of the source and target-SCIP is stored

SCIPcopyOrigProb^⚠

create a problem by copying the original problem data of the source SCIP

SCIPcopyOrigVars^⚠

copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated variables do not get copied

SCIPcopyParamSettings^⚠

copies parameter settings from sourcescip to targetscip

SCIPcopyPlugins^⚠

copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the copied SCIP instance might not represent the same problem semantics as the original. Note that in this case dual reductions might be invalid.

SCIPcopyProb^⚠

create a problem by copying the problem data of the source SCIP

SCIPcopyRowprep^⚠

creates a copy of a SCIP_ROWPREP datastructure

SCIPcopyVars^⚠

Copies all active (thus unfixed) variables from source-SCIP, except those that are marked as relaxation only, and adds these variable to the target-SCIP.

SCIPcorGetConsName^⚠

returns the constraint name for the given index

SCIPcorGetNConsNames^⚠

returns the number of constraint names in the COR problem

SCIPcorGetNVarNames^⚠

returns the number of variable names in the COR problem

SCIPcorGetVarName^⚠

returns the variable name for the given index

SCIPcorHasRead^⚠

returns whether the COR file has been successfully read. This is used by the TIM and STO readers.

SCIPcount^⚠

execute counting

SCIPcreate^⚠

creates and initializes SCIP data structures

SCIPcreateBanditEpsgreedy^⚠

create and resets an epsilon greedy bandit algorithm

SCIPcreateBanditExp3^⚠

creates and resets an Exp.3 bandit algorithm using \p scip pointer

SCIPcreateBanditUcb^⚠

create and reset UCB bandit algorithm

SCIPcreateBendersDefault^⚠

Creates a default Benders’ decomposition algorithm and activates it in SCIP

SCIPcreateBoolarray^⚠

creates a dynamic array of bool values

SCIPcreateCPUClock^⚠

creates a clock counting the CPU user seconds

SCIPcreateChild^⚠

creates a child node of the focus node

SCIPcreateClock^⚠

creates a clock using the default clock type

SCIPcreateCons^⚠

creates and captures a constraint of the given constraint handler

SCIPcreateConsAnd^⚠

creates and captures an and constraint

SCIPcreateConsBasicAnd^⚠

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

SCIPcreateConsBasicBounddisjunction^⚠

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

SCIPcreateConsBasicBounddisjunctionRedundant^⚠

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

SCIPcreateConsBasicCardinality^⚠

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

SCIPcreateConsBasicConjunction^⚠

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

SCIPcreateConsBasicCumulative^⚠

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

SCIPcreateConsBasicDisjunction^⚠

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

SCIPcreateConsBasicIndicator^⚠

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

SCIPcreateConsBasicIndicatorLinCons^⚠

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

SCIPcreateConsBasicKnapsack^⚠

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

SCIPcreateConsBasicLinear^⚠

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

SCIPcreateConsBasicLinking^⚠

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

SCIPcreateConsBasicLogicor^⚠

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

SCIPcreateConsBasicNonlinear^⚠

creates and captures a nonlinear constraint with all its constraint flags set to their default values

SCIPcreateConsBasicOr^⚠

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

SCIPcreateConsBasicOrbisack^⚠

creates and captures an orbisack constraint in its most basic variant

SCIPcreateConsBasicOrbitope^⚠

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

SCIPcreateConsBasicPseudoboolean^⚠

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

SCIPcreateConsBasicQuadraticNonlinear^⚠

creates and captures a quadratic nonlinear constraint with all its constraint flags set to their default values

SCIPcreateConsBasicSOCNonlinear^⚠

creates and captures a nonlinear constraint that is a second-order cone constraint with all its constraint flags set to their default values

SCIPcreateConsBasicSOS1^⚠

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

SCIPcreateConsBasicSOS2^⚠

creates and captures a SOS2 constraint with all constraint flags set to their default values.

SCIPcreateConsBasicSetcover^⚠

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

SCIPcreateConsBasicSetpack^⚠

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

SCIPcreateConsBasicSetpart^⚠

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

SCIPcreateConsBasicSignpowerNonlinear^⚠

creates and captures a signpower nonlinear constraint with all its constraint flags set to their default values

SCIPcreateConsBasicSuperindicator^⚠

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

SCIPcreateConsBasicSymresack^⚠

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

SCIPcreateConsBasicVarbound^⚠

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

SCIPcreateConsBasicXor^⚠

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

SCIPcreateConsBounddisjunction^⚠

creates and captures a bound disjunction constraint

SCIPcreateConsBounddisjunctionRedundant^⚠

creates and captures a bound disjunction constraint with possibly redundant literals

SCIPcreateConsCardinality^⚠

creates and captures an cardinality constraint

SCIPcreateConsConjunction^⚠

creates and captures a conjunction constraint

SCIPcreateConsCumulative^⚠

creates and captures a cumulative constraint

SCIPcreateConsDisjunction^⚠

creates and captures a disjunction constraint

SCIPcreateConsIndicator^⚠

creates and captures an indicator constraint

SCIPcreateConsIndicatorGeneric^⚠

creates and captures a indicator constraint in a more generic version.

SCIPcreateConsIndicatorGenericLinCons^⚠

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.

SCIPcreateConsIndicatorLinCons^⚠

creates and captures an indicator constraint with given linear constraint and slack variable

SCIPcreateConsKnapsack^⚠

creates and captures a knapsack constraint

SCIPcreateConsLinear^⚠

creates and captures a linear constraint

SCIPcreateConsLinking^⚠

creates and captures a linking constraint

SCIPcreateConsLogicor^⚠

creates and captures a logic or constraint

SCIPcreateConsNonlinear^⚠

creates and captures a nonlinear constraint

SCIPcreateConsOr^⚠

creates and captures an or constraint

SCIPcreateConsOrbisack^⚠

creates and captures a orbisack constraint

SCIPcreateConsOrbitope^⚠

creates and captures a orbitope constraint

SCIPcreateConsPseudoboolean^⚠

creates and captures a pseudoboolean constraint

SCIPcreateConsPseudobooleanWithConss^⚠

creates and captures a pseudoboolean constraint, with given linear and and-constraints

SCIPcreateConsQuadraticNonlinear^⚠

creates and captures a quadratic nonlinear constraint

SCIPcreateConsSOS1^⚠

creates and captures an SOS1 constraint

SCIPcreateConsSOS2^⚠

creates and captures an SOS2 constraint

SCIPcreateConsSetcover^⚠

creates and captures a set covering constraint

SCIPcreateConsSetpack^⚠

creates and captures a set packing constraint

SCIPcreateConsSetpart^⚠

creates and captures a set partitioning constraint

SCIPcreateConsSuperindicator^⚠

creates and captures a superindicator constraint

SCIPcreateConsSymresack^⚠

creates and captures a symresack constraint

SCIPcreateConsVarbound^⚠

creates and captures a variable bound constraint: lhs <= x + c*y <= rhs

SCIPcreateConsXor^⚠

creates and captures an xor constraint

SCIPcreateCurrentSol^⚠

creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved at the current node

SCIPcreateCutpool^⚠

creates a cut pool

SCIPcreateDecomp^⚠

creates a decomposition

SCIPcreateDigraph^⚠

creates directed graph structure

SCIPcreateDisjointset^⚠

creates a disjoint set (union find) structure \p djset for \p ncomponents many components (of size one)

SCIPcreateDiveset^⚠

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()

SCIPcreateEmptyNlRow^⚠

creates and captures a nonlinear row without any coefficients

SCIPcreateEmptyRow^⚠

creates and captures an LP row without any coefficients

SCIPcreateEmptyRowCons^⚠

creates and captures an LP row without any coefficients from a constraint

SCIPcreateEmptyRowConshdlr^⚠

creates and captures an LP row without any coefficients from a constraint handler

SCIPcreateEmptyRowSepa^⚠

creates and captures an LP row without any coefficients from a separator

SCIPcreateEmptyRowUnspec^⚠

creates and captures an LP row without any coefficients from an unspecified source

SCIPcreateExpr^⚠

creates and captures an expression with given expression data and children

SCIPcreateExpr2^⚠

creates and captures an expression with given expression data and up to two children

SCIPcreateExprAbs^⚠

creates an absolute value expression

SCIPcreateExprCos^⚠

creates a cos expression

SCIPcreateExprEntropy^⚠

creates an entropy expression

SCIPcreateExprExp^⚠

creates an exponential expression

SCIPcreateExprLog^⚠

creates a logarithmic expression

SCIPcreateExprMonomial^⚠

creates and captures an expression representing a monomial

SCIPcreateExprPow^⚠

creates a power expression

SCIPcreateExprProduct^⚠

creates a product expression

SCIPcreateExprQuadratic^⚠

creates and captures an expression representing a quadratic function

SCIPcreateExprSignpower^⚠

creates a signpower expression

SCIPcreateExprSin^⚠

creates a sin expression

SCIPcreateExprSum^⚠

creates a sum expression

SCIPcreateExprValue^⚠

creates constant value expression

SCIPcreateExprVar^⚠

creates a variable expression

SCIPcreateExprVaridx^⚠

creates a variable index expression

SCIPcreateExpriter^⚠

creates an expression iterator

SCIPcreateFiniteSolCopy^⚠

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

SCIPcreateIntarray^⚠

creates a dynamic array of int values

SCIPcreateLPSol^⚠

creates a primal solution, initialized to the current LP solution

SCIPcreateNLPSol^⚠

creates a primal solution, initialized to the current NLP solution

SCIPcreateNlRow^⚠

creates and captures a nonlinear row

SCIPcreateNlRowFromRow^⚠

creates and captures a nonlinear row from a linear row

SCIPcreateNlpiProblem^⚠

creates an empty problem instance

SCIPcreateNlpiProblemFromNlRows^⚠

creates a NLPI problem from given nonlinear rows

SCIPcreateOrigSol^⚠

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

SCIPcreatePartialSol^⚠

creates a partial primal solution, initialized to unknown values

SCIPcreateProb^⚠

creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE) If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.

SCIPcreateProbBasic^⚠

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.

SCIPcreatePseudoSol^⚠

creates a primal solution, initialized to the current pseudo solution

SCIPcreatePtrarray^⚠

creates a dynamic array of pointers

SCIPcreateRandom^⚠

creates and initializes a random number generator

SCIPcreateRealarray^⚠

creates a dynamic array of real values

SCIPcreateRelaxSol^⚠

creates a primal solution, initialized to the current relaxation solution

SCIPcreateRootDialog^⚠

creates a root dialog

SCIPcreateRow^⚠

creates and captures an LP row

SCIPcreateRowCons^⚠

creates and captures an LP row from a constraint

SCIPcreateRowConshdlr^⚠

creates and captures an LP row from a constraint handler

SCIPcreateRowSepa^⚠

creates and captures an LP row from a separator

SCIPcreateRowUnspec^⚠

creates and captures an LP row from an unspecified source

SCIPcreateRowprep^⚠

creates a SCIP_ROWPREP datastructure

SCIPcreateSol^⚠

creates a primal solution, initialized to zero

SCIPcreateSolCopy^⚠

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

SCIPcreateSolCopyOrig^⚠

creates a copy of a solution in the original primal solution space

SCIPcreateSymbreakCons^⚠

creates a symmetry breaking constraint

SCIPcreateUnknownSol^⚠

creates a primal solution, initialized to unknown values

SCIPcreateVar^⚠

creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable;

SCIPcreateVarBasic^⚠

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;

SCIPcreateWallClock^⚠

creates a clock counting the wall clock seconds

SCIPcreateWorstCaseProfile^⚠

creates the worst case resource profile, that is, all jobs are inserted with the earliest start and latest completion time

SCIPcutGenerationHeuristicCMIR^⚠

calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot participate in an MIR cut. The function uses a cut generation heuristic which tries different scaling factors and complementations of the variables to improve the cut’s efficacy. For further details we refer to:

SCIPcutGetAge^⚠

gets the age of the cut: the number of consecutive cut pool separation rounds where the cut was neither in the LP nor violated

SCIPcutGetLPActivityQuot^⚠

returns the ratio of LPs where the row belonging to this cut was active in an LP solution, i.e. where the age of its row has not been increased

SCIPcutGetRow^⚠

gets the row of the cut

SCIPcutoffNode^⚠

marks node and whole sub tree to be cut off from branch and bound tree

SCIPcutoffbounddelta^⚠

return the cutoff bound delta

SCIPcutpoolGetCuts^⚠

gets array of cuts in the cut pool

SCIPcutpoolGetMaxNCuts^⚠

get maximum number of cuts that were stored in the cut pool at the same time

SCIPcutpoolGetNCalls^⚠

get number of times the cut pool was separated

SCIPcutpoolGetNCuts^⚠

get number of cuts in the cut pool

SCIPcutpoolGetNCutsAdded^⚠

get total number of cuts that were added from the cut pool to sepastore

SCIPcutpoolGetNCutsFound^⚠

get total number of cuts that were separated from the cut pool

SCIPcutpoolGetNRootCalls^⚠

get number of times the cut pool was separated at the root

SCIPcutpoolGetTime^⚠

gets time in seconds used for separating cuts from the pool

SCIPcutsTightenCoefficients^⚠

perform activity based coefficient tigthening on the given cut; returns TRUE if the cut was detected to be redundant due to acitivity bounds

SCIPcutselComp^⚠

compares two cut selectors w. r. to their priority

SCIPcutselGetData^⚠

gets user data of cut selector

SCIPcutselGetDesc^⚠

gets description of cut selector

SCIPcutselGetNCalls^⚠

get number of times the cutselector was called

SCIPcutselGetNLocalCuts^⚠

get total number of local cuts that were selected

SCIPcutselGetNLocalCutsFiltered^⚠

get total number of local cuts that were filtered

SCIPcutselGetNLocalForcedCuts^⚠

get total number of forced local cuts that were selected

SCIPcutselGetNRootCalls^⚠

get number of times the cutselector was called at the root

SCIPcutselGetNRootCuts^⚠

get total number of cuts that were selected at the root

SCIPcutselGetNRootCutsFiltered^⚠

get total number of root cuts that were filtered

SCIPcutselGetNRootForcedCuts^⚠

get total number of forced cuts that were selected at the root

SCIPcutselGetName^⚠

gets name of cut selector

SCIPcutselGetPriority^⚠

gets priority of cut selector

SCIPcutselGetSetupTime^⚠

gets time in seconds used in this cut selector for setting up for next stages

SCIPcutselGetTime^⚠

gets time in seconds used in this cut selector

SCIPcutselIsInitialized^⚠

is cut selector initialized?

SCIPcutselSetData^⚠

sets user data of cut selector; user has to free old data in advance!

SCIPdeactivateBenders^⚠

deactivates the Benders’ decomposition

SCIPdeactivatePricer^⚠

deactivates pricer

SCIPdeactivateSolViolationUpdates^⚠

disallow violation updates

SCIPdeactiveCons^⚠

calls constraint deactivation notification method of single constraint

SCIPdebugMessagePrint^⚠

SCIPdecompClear^⚠

clears the corresponding labeling (constraints, variables, or both) of this decomposition

SCIPdecompCreate^⚠

creates a decomposition

SCIPdecompFree^⚠

frees a decomposition

SCIPdecompGetAreaScore^⚠

gets area score of this decomposition

SCIPdecompGetBlockGraphMaxDegree^⚠

gets the maximum degree of the block-decomposition graph of this decomposition

SCIPdecompGetBlockGraphMinDegree^⚠

gets the minimum degree of the block-decomposition graph of this decomposition

SCIPdecompGetConsLabels^⚠

queries labels for an array of constraints

SCIPdecompGetConssSize^⚠

gets constraint size for each block, sorted by increasing block label

SCIPdecompGetModularity^⚠

gets modularity of this decomposition

SCIPdecompGetNBlockGraphArticulations^⚠

gets number of articulation points in the block-decomposition graph of this decomposition

SCIPdecompGetNBlockGraphComponents^⚠

gets number of connected components in the block-decomposition graph of this decomposition

SCIPdecompGetNBlockGraphEdges^⚠

gets number of edges in the block-decomposition graph of this decomposition

SCIPdecompGetNBlocks^⚠

gets number of blocks of this decomposition

SCIPdecompGetNBorderConss^⚠

gets number of border constraints of this decomposition

SCIPdecompGetNBorderVars^⚠

gets number of border variables of this decomposition

SCIPdecompGetVarsLabels^⚠

queries labels for an array of variables

SCIPdecompGetVarsSize^⚠

gets variable size for each block, sorted by increasing block label

SCIPdecompIsOriginal^⚠

returns TRUE if decomposition is in the original space

SCIPdecompPrintStats^⚠

prints decomposition statistics into string buffer

SCIPdecompSetConsLabels^⚠

sets labels for an array of constraints

SCIPdecompSetUseBendersLabels^⚠

sets the parameter that indicates whether the variables must be labeled for the application of Benders’ decomposition

SCIPdecompSetVarsLabels^⚠

sets labels for an array of variables

SCIPdecompUseBendersLabels^⚠

returns TRUE if the variables must be labeled for the application of Benders’ decomposition

SCIPdelCoefLinear^⚠

deletes variable from linear constraint

SCIPdelCons^⚠

globally removes constraint from all subproblems; removes constraint from the constraint set change data of the node, where it was added, or from the problem, if it was a problem constraint

SCIPdelConsLocal^⚠

disables constraint’s separation, enforcing, and propagation capabilities at the current node (and all subnodes); if the method is called during problem modification or at the root node, the constraint is globally deleted from the problem; the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the constraint is automatically enabled again, and after reentering the current node’s subtree, it is automatically disabled again; this may improve performance because redundant checks on this constraint are avoided, but it consumes memory; alternatively, use SCIPdisableCons()

SCIPdelConsNode^⚠

disables constraint’s separation, enforcing, and propagation capabilities at the given node (and all subnodes); if the method is called at the root node, the constraint is globally deleted from the problem; the constraint deletion is being remembered at the given node, s.t. after leaving the node’s subtree, the constraint is automatically enabled again, and after entering the node’s subtree, it is automatically disabled; this may improve performance because redundant checks on this constraint are avoided, but it consumes memory; alternatively, use SCIPdisableCons()

SCIPdelDelayedPoolCut^⚠

removes the row from the delayed global cut pool

SCIPdelNlRow^⚠

removes a nonlinear row from the NLP

SCIPdelNlpiConsSet^⚠

delete a set of constraints

SCIPdelNlpiVarSet^⚠

delete a set of variables

SCIPdelPoolCut^⚠

removes the row from the global cut pool

SCIPdelRowCutpool^⚠

removes the LP row from a cut pool

SCIPdelVar^⚠

removes variable from the problem

SCIPdeleteReoptnode^⚠

deletes the given reoptimization node

SCIPdeleteSubproblemProximity^⚠

frees the sub-MIP created by proximity

SCIPdetermineNVarsAffectedSym^⚠

determine number of variables affected by symmetry group

SCIPdialogDescFixParam^⚠

dialog description method for the fix parameter command

SCIPdialogDescSetParam^⚠

dialog description method for the set parameter command

SCIPdialogDisplayCompletions^⚠

displays all dialog entries with names starting with the given “entryname”

SCIPdialogDisplayMenu^⚠

displays the dialog’s menu

SCIPdialogDisplayMenuEntry^⚠

displays the entry for the dialog in it’s parent’s menu

SCIPdialogExecChangeAddCons^⚠

dialog execution method for the change add constraint

SCIPdialogExecChangeBounds^⚠

dialog execution method for the change bounds command

SCIPdialogExecChangeFreetransproblem^⚠

dialog execution method for the freetransproblem command

SCIPdialogExecChangeMinUC^⚠

dialog execution method for the SCIPtransformMinUC() command

SCIPdialogExecChangeObjSense^⚠

dialog execution method for the changing the objective sense

SCIPdialogExecChecksol^⚠

dialog execution method for the checksol command

SCIPdialogExecCliquegraph^⚠

dialog execution method for the cliquegraph command

SCIPdialogExecConcurrentOpt^⚠

dialog execution method for the parallelopt command

SCIPdialogExecCount^⚠

dialog execution method for the count command

SCIPdialogExecCountPresolve^⚠

dialog execution method for the count command

SCIPdialogExecDisplayBenders^⚠

dialog execution method for the display benders command

SCIPdialogExecDisplayBranching^⚠

dialog execution method for the display branching command

SCIPdialogExecDisplayCompression^⚠

dialog execution method for the display compression command

SCIPdialogExecDisplayConflict^⚠

dialog execution method for the display conflict command

SCIPdialogExecDisplayConshdlrs^⚠

dialog execution method for the display conshdlrs command

SCIPdialogExecDisplayCutselectors^⚠

dialog execution method for the display cutselectors command

SCIPdialogExecDisplayDisplaycols^⚠

dialog execution method for the display displaycols command

SCIPdialogExecDisplayDualSolution^⚠

dialog execution method for the display dual solution command

SCIPdialogExecDisplayExprhdlrs^⚠

dialog execution method for the display exprhdlrs command

SCIPdialogExecDisplayFiniteSolution^⚠

dialog execution method for the display finitesolution command

SCIPdialogExecDisplayHeuristics^⚠

dialog execution method for the display heuristics command

SCIPdialogExecDisplayLPSolutionQuality^⚠

dialog execution method for the display LP solution quality command

SCIPdialogExecDisplayLinearConsClassification^⚠

dialog execution method for linear constraint type classification

SCIPdialogExecDisplayMemory^⚠

dialog execution method for the display memory command

SCIPdialogExecDisplayNlpi^⚠

dialog execution method for the display nlpi command

SCIPdialogExecDisplayNodeselectors^⚠

dialog execution method for the display nodeselectors command

SCIPdialogExecDisplayParameters^⚠

dialog execution method for the display parameters command

SCIPdialogExecDisplayPresolvers^⚠

dialog execution method for the display presolvers command

SCIPdialogExecDisplayPricers^⚠

dialog execution method for the display pricer command

SCIPdialogExecDisplayProblem^⚠

dialog execution method for the display problem command

SCIPdialogExecDisplayPropagators^⚠

dialog execution method for the display propagators command

SCIPdialogExecDisplayReaders^⚠

dialog execution method for the display readers command

SCIPdialogExecDisplayRelaxators^⚠

dialog execution method for the display relaxators command

SCIPdialogExecDisplayReoptStatistics^⚠

dialog execution method for the display reoptstatistics command

SCIPdialogExecDisplaySeparators^⚠

dialog execution method for the display separators command

SCIPdialogExecDisplaySolution^⚠

dialog execution method for the display solution command

SCIPdialogExecDisplaySolutionPool^⚠

dialog execution method for the display of solutions in the pool command

SCIPdialogExecDisplayStatistics^⚠

dialog execution method for the display statistics command

SCIPdialogExecDisplaySubSolution^⚠

dialog execution method for the display subsolution command

SCIPdialogExecDisplaySubproblem^⚠

dialog execution method for the display subproblem command

SCIPdialogExecDisplayTransproblem^⚠

dialog execution method for the display transproblem command

SCIPdialogExecDisplayTranssolution^⚠

dialog execution method for the display transsolution command

SCIPdialogExecDisplayValue^⚠

dialog execution method for the display value command

SCIPdialogExecDisplayVarbranchstatistics^⚠

dialog execution method for the display varbranchstatistics command

SCIPdialogExecFixParam^⚠

dialog execution method for the fix parameter command

SCIPdialogExecFree^⚠

dialog execution method for the free command

SCIPdialogExecHelp^⚠

dialog execution method for the help command

SCIPdialogExecMenu^⚠

standard menu dialog execution method, that displays it’s help screen if the remaining command line is empty

SCIPdialogExecMenuLazy^⚠

standard menu dialog execution method, that doesn’t display it’s help screen

SCIPdialogExecNewstart^⚠

dialog execution method for the newstart command

SCIPdialogExecOptimize^⚠

dialog execution method for the optimize command

SCIPdialogExecPresolve^⚠

dialog execution method for the presolve command

SCIPdialogExecQuit^⚠

dialog execution method for the quit command

SCIPdialogExecRead^⚠

dialog execution method for the read command

SCIPdialogExecSetBranchingDirection^⚠

dialog execution method for the set branching direction command

SCIPdialogExecSetBranchingPriority^⚠

dialog execution method for the set branching priority command

SCIPdialogExecSetDefault^⚠

dialog execution method for the set default command

SCIPdialogExecSetDiffsave^⚠

dialog execution method for the set diffsave command

SCIPdialogExecSetEmphasisBenchmark^⚠

dialog execution method for the set emphasis benchmark command

SCIPdialogExecSetEmphasisCounter^⚠

dialog execution method for the set emphasis counter command

SCIPdialogExecSetEmphasisCpsolver^⚠

dialog execution method for the set emphasis cpsolver command

SCIPdialogExecSetEmphasisEasycip^⚠

dialog execution method for the set emphasis easy CIP command

SCIPdialogExecSetEmphasisFeasibility^⚠

dialog execution method for the set emphasis feasibility command

SCIPdialogExecSetEmphasisHardlp^⚠

dialog execution method for the set emphasis hard LP command

SCIPdialogExecSetEmphasisNumerics^⚠

dialog execution method for the set emphasis numerics command

SCIPdialogExecSetEmphasisOptimality^⚠

dialog execution method for the set emphasis optimality command

SCIPdialogExecSetHeuristicsAggressive^⚠

dialog execution method for the set heuristics aggressive command

SCIPdialogExecSetHeuristicsDefault^⚠

dialog execution method for the set heuristics default command

SCIPdialogExecSetHeuristicsFast^⚠

dialog execution method for the set heuristics fast command

SCIPdialogExecSetHeuristicsOff^⚠

dialog execution method for the set heuristics off command

SCIPdialogExecSetLimitsObjective^⚠

dialog execution method for the set limits objective command

SCIPdialogExecSetLoad^⚠

dialog execution method for the set load command

SCIPdialogExecSetParam^⚠

dialog execution method for the set parameter command

SCIPdialogExecSetPresolvingAggressive^⚠

dialog execution method for the set presolving aggressive command

SCIPdialogExecSetPresolvingDefault^⚠

dialog execution method for the set presolving default command

SCIPdialogExecSetPresolvingFast^⚠

dialog execution method for the set presolving fast command

SCIPdialogExecSetPresolvingOff^⚠

dialog execution method for the set presolving off command

SCIPdialogExecSetSave^⚠

dialog execution method for the set save command

SCIPdialogExecSetSeparatingAggressive^⚠

dialog execution method for the set separating aggressive command

SCIPdialogExecSetSeparatingDefault^⚠

dialog execution method for the set separating default command

SCIPdialogExecSetSeparatingFast^⚠

dialog execution method for the set separating fast command

SCIPdialogExecSetSeparatingOff^⚠

dialog execution method for the set separating off command

SCIPdialogExecTransform^⚠

dialog execution method for the transform command

SCIPdialogExecWriteAllsolutions^⚠

execution method of dialog for writing all solutions

SCIPdialogFindEntry^⚠

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.

SCIPdialogGetData^⚠

gets the user defined data associated with the given dialog

SCIPdialogGetDesc^⚠

gets the description of the dialog

SCIPdialogGetNSubdialogs^⚠

gets the number of sub-dialogs associated with the given dialog

SCIPdialogGetName^⚠

gets the command name of the dialog

SCIPdialogGetParent^⚠

gets the parent dialog of the given dialog

SCIPdialogGetPath^⚠

gets the name of the current path in the dialog tree, separated by the given character

SCIPdialogGetSubdialogs^⚠

gets the array of sub-dialogs associated with the given dialog

SCIPdialogHasEntry^⚠

returns TRUE iff a dialog entry matching exactly the given name is existing in the given dialog

SCIPdialogIsSubmenu^⚠

returns whether the dialog is a sub menu

SCIPdialogMessage^⚠

SCIPdialogSetData^⚠

sets user data of dialog; user has to free old data in advance!

SCIPdialogWriteHistory^⚠

writes command history to specified filename

SCIPdialoghdlrAddHistory^⚠

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

SCIPdialoghdlrAddInputLine^⚠

adds a single line of input to the dialog handler which is treated as if the user entered the command line

SCIPdialoghdlrClearBuffer^⚠

clears the input command buffer of the dialog handler

SCIPdialoghdlrGetLine^⚠

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

SCIPdialoghdlrGetRoot^⚠

@addtogroup PublicDialogMethods

SCIPdialoghdlrGetWord^⚠

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

SCIPdialoghdlrIsBufferEmpty^⚠

returns TRUE iff input command buffer is empty

SCIPdigraphAddArc^⚠

add (directed) arc and a related data to the directed graph structure

SCIPdigraphAddArcSafe^⚠

add (directed) arc to the directed graph structure, if it is not contained, yet

SCIPdigraphComputeDirectedComponents^⚠

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).

SCIPdigraphComputeUndirectedComponents^⚠

Compute undirected connected components on the given graph.

SCIPdigraphFree^⚠

frees given directed graph structure

SCIPdigraphFreeComponents^⚠

frees the component information for the given directed graph

SCIPdigraphGetArticulationPoints^⚠

identifies the articulation points in a given directed graph uses the helper recursive function findArticulationPointsUtil

SCIPdigraphGetComponent^⚠

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.

SCIPdigraphGetNArcs^⚠

returns the total number of arcs in the given digraph

SCIPdigraphGetNComponents^⚠

returns the number of previously computed undirected components for the given directed graph

SCIPdigraphGetNNodes^⚠

returns the number of nodes of the given digraph

SCIPdigraphGetNSuccessors^⚠

returns the number of successor nodes of the given node

SCIPdigraphGetNodeData^⚠

returns the node data, or NULL if no data exist

SCIPdigraphGetSuccessors^⚠

returns the array of indices of the successor nodes; this array must not be changed from outside

SCIPdigraphGetSuccessorsData^⚠

returns the array of data corresponding to the arcs originating at the given node, or NULL if no data exist; this array must not be changed from outside

SCIPdigraphPrint^⚠

output of the given directed graph via the given message handler

SCIPdigraphPrintComponents^⚠

output of the given directed graph via the given message handler

SCIPdigraphPrintGml^⚠

prints the given directed graph structure in GML format into the given file

SCIPdigraphResize^⚠

resize directed graph structure

SCIPdigraphSetNSuccessors^⚠

sets the number of successors to a given value

SCIPdigraphSetNodeData^⚠

sets the node data

SCIPdigraphSetSizes^⚠

sets the sizes of the successor lists for the nodes in a directed graph and allocates memory for the lists

SCIPdigraphTopoSortComponents^⚠

Performes an (almost) topological sort on the undirected components of the given directed graph. The undirected components should be computed before using SCIPdigraphComputeUndirectedComponents().

SCIPdisableCons^⚠

disables constraint’s separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated, separated, and enforced anymore until it is enabled again with a call to SCIPenableCons(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again; note that the constraints enforcing capabilities are necessary for the solution’s feasibility, if the constraint is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree, and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using an appropriate event handler that watches the corresponding variables’ domain changes)

SCIPdisableConsPropagation^⚠

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

SCIPdisableConsSeparation^⚠

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

SCIPdisableDebugSol^⚠

disable solution debugging mechanism

SCIPdisableVarHistory^⚠

disables the collection of any statistic for a variable

SCIPdisjointsetClear^⚠

clears the disjoint set (union find) structure \p djset

SCIPdisjointsetFind^⚠

finds and returns the component identifier of this \p element

SCIPdisjointsetGetComponentCount^⚠

returns the number of independent components in this disjoint set (union find) data structure

SCIPdisjointsetGetSize^⚠

returns the size (number of nodes) of this disjoint set (union find) data structure

SCIPdisjointsetUnion^⚠

merges the components containing the elements \p p and \p q

SCIPdismantleExpr^⚠

prints structure of an expression a la Maple’s dismantle

SCIPdispGetData^⚠

gets user data of display column

SCIPdispGetDesc^⚠

gets description of display column

SCIPdispGetHeader^⚠

gets head line of display column

SCIPdispGetName^⚠

gets name of display column

SCIPdispGetPosition^⚠

gets position of display column

SCIPdispGetPriority^⚠

gets priority of display column

SCIPdispGetStatus^⚠

gets status of display column

SCIPdispGetWidth^⚠

gets width of display column

SCIPdispInt^⚠

displays an integer in decimal form fitting in a given width

SCIPdispIsInitialized^⚠

is display column initialized?

SCIPdispLongint^⚠

displays a long integer in decimal form fitting in a given width

SCIPdispSetData^⚠

sets user data of display column; user has to free old data in advance!

SCIPdispTime^⚠

displays a time value fitting in a given width

SCIPdivesetGetAvgDepth^⚠

get the average depth this dive set reached during execution

SCIPdivesetGetAvgQuot^⚠

get the average upper bound quotient parameter of the diving settings if an incumbent solution exists

SCIPdivesetGetAvgQuotNoSol^⚠

get the average quotient parameter of the diving settings if no solution is available

SCIPdivesetGetAvgSolutionDepth^⚠

get the average depth at which this dive set found a solution

SCIPdivesetGetHeur^⚠

get the heuristic to which this diving setting belongs

SCIPdivesetGetLPResolveDomChgQuot^⚠

returns the domain reduction quotient for triggering an immediate resolve of the diving LP (0.0: always resolve)

SCIPdivesetGetLPSolveFreq^⚠

returns the LP solve frequency for diving LPs (0: dynamically based on number of intermediate domain reductions)

SCIPdivesetGetMaxDepth^⚠

get the maximum depth reached by this dive set

SCIPdivesetGetMaxLPIterOffset^⚠

get the maximum LP iterations offset of the diving settings

SCIPdivesetGetMaxLPIterQuot^⚠

get the maximum LP iterations quotient of the diving settings

SCIPdivesetGetMaxRelDepth^⚠

get the maximum relative depth of the diving settings

SCIPdivesetGetMaxSolutionDepth^⚠

get the maximum depth at which this dive set found a solution

SCIPdivesetGetMinDepth^⚠

get the minimum depth reached by this dive set

SCIPdivesetGetMinRelDepth^⚠

get the minimum relative depth of the diving settings

SCIPdivesetGetMinSolutionDepth^⚠

get the minimum depth at which this dive set found a solution

SCIPdivesetGetNBacktracks^⚠

get the total number of backtracks performed by this dive set

SCIPdivesetGetNCalls^⚠

get the number of calls to this dive set

SCIPdivesetGetNConflicts^⚠

get the total number of conflicts found by this dive set

SCIPdivesetGetNLPIterations^⚠

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

SCIPdivesetGetNProbingNodes^⚠

get the total number of probing nodes used by this dive set

SCIPdivesetGetNSols^⚠

get the total number of solutions (leaf and rounded solutions) found by the dive set

SCIPdivesetGetNSolutionCalls^⚠

get the number of calls successfully terminated at a feasible leaf node

SCIPdivesetGetName^⚠

get the name of the dive set

SCIPdivesetGetRandnumgen^⚠

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

SCIPdivesetGetSolSuccess^⚠

get the number of successful runs of the diving settings

SCIPdivesetGetUbQuot^⚠

get the maximum upper bound quotient parameter of the diving settings if an incumbent solution exists

SCIPdivesetGetUbQuotNoSol^⚠

get the maximum upper bound quotient parameter of the diving settings if no solution is available

SCIPdivesetGetWorkSolution^⚠

get the working solution of this dive set

SCIPdivesetIsPublic^⚠

is this dive set publicly available (ie., can be used by other primal heuristics?)

SCIPdivesetSetWorkSolution^⚠

set the working solution for this dive set

SCIPdivesetSupportsType^⚠

returns TRUE if dive set supports diving of the specified type

SCIPdivesetUseBacktrack^⚠

should backtracking be applied?

SCIPdivesetUseOnlyLPBranchcands^⚠

should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?

SCIPdoNotAggr^⚠

returns whether aggregation of variables is not allowed

SCIPdoNotAggrVar^⚠

returns whether variable is not allowed to be aggregated

SCIPdoNotMultaggr^⚠

returns whether multi-aggregation is disabled

SCIPdoNotMultaggrVar^⚠

returns whether variable is not allowed to be multi-aggregated

SCIPdomchgGetBoundchg^⚠

returns a particular bound change in the domain change data

SCIPdomchgGetNBoundchgs^⚠

returns the number of bound changes in the domain change data

SCIPdropEvent^⚠

drops a global event (stops to track event)

SCIPdropRowEvent^⚠

drops a row coefficient, constant, or side change event (stops to track event) on the given row

SCIPdropVarEvent^⚠

drops an objective value or domain change event (stops to track event) on the given transformed variable

SCIPdualfeasCeil^⚠

rounds value - dual feasibility tolerance up to the next integer

SCIPdualfeasFloor^⚠

rounds value + dual feasibility tolerance down to the next integer

SCIPdualfeasFrac^⚠

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

SCIPdualfeasRound^⚠

rounds value to the nearest integer in dual feasibility tolerance

SCIPdualfeastol^⚠

SCIPduplicateExpr^⚠

duplicates the given expression and its children

SCIPduplicateExprShallow^⚠

duplicates the given expression, but reuses its children

SCIPenableCons^⚠

enables constraint’s separation, propagation, and enforcing capabilities

SCIPenableConsCompression^⚠

enables constraint compression.

SCIPenableConsPropagation^⚠

enables constraint’s propagation capabilities

SCIPenableConsSeparation^⚠

enables constraint’s separation capabilities

SCIPenableDebugSol^⚠

enable debug solution mechanism

SCIPenableNLP^⚠

notifies SCIP that the NLP relaxation should be initialized in INITSOLVE

SCIPenableOrDisableStatisticTiming^⚠

enables or disables all statistic clocks of SCIP concerning plugin statistics, LP execution time, strong branching time, etc.

SCIPenableReoptimization^⚠

include specific heuristics and branching rules for reoptimization

SCIPenableVarHistory^⚠

enables the collection of statistics for a variable

SCIPendDive^⚠

quits LP diving and resets bounds and objective values of columns to the current node’s values

SCIPendDiveNLP^⚠

ends NLP diving

SCIPendProbing^⚠

quits probing and resets bounds and constraints to the focus node’s environment

SCIPendStrongbranch^⚠

end strong branching - call after any strong branching

SCIPenfolpCons^⚠

enforces single constraint for a given LP solution

SCIPenfopsCons^⚠

enforces single constraint for a given pseudo solution

SCIPenforelaxCons^⚠

enforces single constraint for a given relaxation solution

SCIPensureBlockMemoryArray_call^⚠

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!

SCIPensureRowprepSize^⚠

ensures that rowprep has space for at least given number of additional terms

SCIPepsilon^⚠

returns value treated as zero

SCIPerf^⚠

returns the value of the Gauss error function evaluated at a given point

SCIPescapeString^⚠

translates the given string into a string where symbols “, ’, and spaces are escaped with a \ prefix

SCIPevalBilinAuxExprNonlinear^⚠

evaluates an auxiliary expression for a bilinear term

SCIPevalExpr^⚠

evaluate an expression in a point

SCIPevalExprActivity^⚠

possibly reevaluates and then returns the activity of the expression

SCIPevalExprGradient^⚠

evaluates gradient of an expression for a given point

SCIPevalExprHessianDir^⚠

evaluates Hessian-vector product of an expression for a given point and direction

SCIPevalExprQuadratic^⚠

evaluates quadratic term in a solution

SCIPevalExprQuadraticAuxNonlinear^⚠

evaluates quadratic term in a solution w.r.t. auxiliary variables

SCIPeventGetHoleLeft^⚠

gets the left bound of open interval in the hole

SCIPeventGetHoleRight^⚠

gets the right bound of open interval in the hole

SCIPeventGetNewbound^⚠

gets new bound for a bound change event

SCIPeventGetNewobj^⚠

gets new objective value for an objective value change event

SCIPeventGetNewtype^⚠

gets new variable type for a variable type change event

SCIPeventGetNode^⚠

gets node for a node or LP event

SCIPeventGetOldbound^⚠

gets old bound for a bound change event

SCIPeventGetOldobj^⚠

gets old objective value for an objective value change event

SCIPeventGetOldtype^⚠

gets old variable type for a variable type change event

SCIPeventGetRow^⚠

gets row for a row event

SCIPeventGetRowCol^⚠

gets column for a row change coefficient event

SCIPeventGetRowNewCoefVal^⚠

gets new coefficient value for a row change coefficient event

SCIPeventGetRowNewConstVal^⚠

gets new constant value for a row change constant event

SCIPeventGetRowNewSideVal^⚠

gets new side value for a row change side event

SCIPeventGetRowOldCoefVal^⚠

gets old coefficient value for a row change coefficient event

SCIPeventGetRowOldConstVal^⚠

gets old constant value for a row change constant event

SCIPeventGetRowOldSideVal^⚠

gets old side value for a row change side event

SCIPeventGetRowSide^⚠

gets side for a row change side event

SCIPeventGetSol^⚠

gets solution for a primal solution event

SCIPeventGetType^⚠

gets type of event

SCIPeventGetVar^⚠

gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)

SCIPeventhdlrGetData^⚠

gets user data of event handler

SCIPeventhdlrGetName^⚠

gets name of event handler

SCIPeventhdlrGetSetupTime^⚠

gets time in seconds used in this event handler for setting up for next stages

SCIPeventhdlrGetTime^⚠

gets time in seconds used in this event handler

SCIPeventhdlrIsInitialized^⚠

is event handler initialized?

SCIPeventhdlrSetData^⚠

sets user data of event handler; user has to free old data in advance!

SCIPexecPropVbounds^⚠

performs propagation of variables lower and upper bounds

SCIPexecRelpscostBranching^⚠

execution reliability pseudo cost branching with the given branching candidates

SCIPexistsConsLinking^⚠

checks if for the given linking variable (continuous or integer) a linking constraint exists

SCIPexistsDialog^⚠

returns if the dialog already exists

SCIPexprAreQuadraticExprsVariables^⚠

returns whether all expressions that are used in a quadratic expression are variable expressions

SCIPexprGetActivity^⚠

returns the activity that is currently stored for an expression

SCIPexprGetActivityTag^⚠

returns the tag associated with the activity of the expression

SCIPexprGetBardot^⚠

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)

SCIPexprGetChildren^⚠

gives the children of an expression (can be NULL if no children)

SCIPexprGetCurvature^⚠

returns the curvature of an expression

SCIPexprGetData^⚠

gets the expression data of an expression

SCIPexprGetDerivative^⚠

returns the derivative stored in an expression (or SCIP_INVALID if there was an evaluation error)

SCIPexprGetDiffTag^⚠

returns the difftag stored in an expression

SCIPexprGetDot^⚠

gives the value of directional derivative from the last evaluation of a directional derivative of expression (or SCIP_INVALID if there was an error)

SCIPexprGetEvalTag^⚠

gives the evaluation tag from the last evaluation, or 0

SCIPexprGetEvalValue^⚠

gives the value from the last evaluation of an expression (or SCIP_INVALID if there was an eval error)

SCIPexprGetHdlr^⚠

gets the expression handler of an expression

SCIPexprGetNChildren^⚠

gives the number of children of an expression

SCIPexprGetNUses^⚠

gets the number of times the expression is currently captured

SCIPexprGetOwnerData^⚠

gets the data that the owner of an expression has stored in an expression

SCIPexprGetQuadraticBilinTerm^⚠

gives the data of a bilinear expression term

SCIPexprGetQuadraticData^⚠

gives the coefficients and expressions that define a quadratic expression

SCIPexprGetQuadraticQuadTerm^⚠

gives the data of a quadratic expression term

SCIPexprIsIntegral^⚠

returns whether an expression is integral

SCIPexprSetActivity^⚠

set the activity with tag for an expression

SCIPexprSetCurvature^⚠

sets the curvature of an expression

SCIPexprSetData^⚠

sets the expression data of an expression

SCIPexprSetIntegrality^⚠

sets the integrality flag of an expression

SCIPexprcurvAdd^⚠

gives curvature for a sum of two functions with given curvature

SCIPexprcurvGetName^⚠

gives name as string for a curvature

SCIPexprcurvMonomial^⚠

gives curvature for a monomial with given curvatures and bounds for each factor

SCIPexprcurvMonomialInv^⚠

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

SCIPexprcurvMultiply^⚠

gives curvature for a functions with given curvature multiplied by a constant factor

SCIPexprcurvNegate^⚠

gives the curvature for the negation of a function with given curvature

SCIPexprcurvPower^⚠

gives curvature for base^exponent for given bounds and curvature of base-function and constant exponent

SCIPexprcurvPowerInv^⚠

gives required curvature for base so that base^exponent has given curvature under given bounds on base and constant exponent

SCIPexprhdlrComp^⚠

compares two expression handler w.r.t. their name

SCIPexprhdlrGetData^⚠

gives the data of an expression handler

SCIPexprhdlrGetDescription^⚠

gives the description of an expression handler (can be NULL)

SCIPexprhdlrGetEstimateTime^⚠

gets time spend in estimation callback

SCIPexprhdlrGetIntevalTime^⚠

gets time spend in interval evaluation callback

SCIPexprhdlrGetNBranchings^⚠

gets number of times branching candidates reported by of this expression handler were used to assemble branching candidates

SCIPexprhdlrGetNCreated^⚠

gets number of times an expression has been created with given expression handler

SCIPexprhdlrGetNCutoffs^⚠

gets number of times an empty interval was found in reverse propagation

SCIPexprhdlrGetNDomainReductions^⚠

gets number of times a bound reduction was found in reverse propagation (and accepted by caller)

SCIPexprhdlrGetNEstimateCalls^⚠

gets number of times the estimation callback was called

SCIPexprhdlrGetNIntevalCalls^⚠

gets number of times the interval evaluation callback was called

SCIPexprhdlrGetNReversepropCalls^⚠

gets number of times the reverse propagation callback was called

SCIPexprhdlrGetNSimplifications^⚠

gets number of times the simplify callback found a simplification

SCIPexprhdlrGetNSimplifyCalls^⚠

gets number of times the simplify callback was called

SCIPexprhdlrGetName^⚠

gives the name of an expression handler

SCIPexprhdlrGetPrecedence^⚠

gives the precedence of an expression handler

SCIPexprhdlrGetReversepropTime^⚠

gets time spend in reverse propagation callback

SCIPexprhdlrGetSimplifyTime^⚠

gets time spend in simplify callback

SCIPexprhdlrHasBwdiff^⚠

returns whether expression handler implements the backward differentiation callback

SCIPexprhdlrHasCurvature^⚠

returns whether expression handler implements the curvature callback

SCIPexprhdlrHasEstimate^⚠

returns whether expression handler implements the estimator callback

SCIPexprhdlrHasFwdiff^⚠

returns whether expression handler implements the forward differentiation callback

SCIPexprhdlrHasInitEstimates^⚠

returns whether expression handler implements the initial estimators callback

SCIPexprhdlrHasIntEval^⚠

returns whether expression handler implements the interval evaluation callback

SCIPexprhdlrHasMonotonicity^⚠

returns whether expression handler implements the monotonicity callback

SCIPexprhdlrHasPrint^⚠

returns whether expression handler implements the print callback

SCIPexprhdlrHasReverseProp^⚠

returns whether expression handler implements the reverse propagation callback

SCIPexprhdlrHasSimplify^⚠

returns whether expression handler implements the simplification callback

SCIPexprhdlrIncrementNBranchings^⚠

increments the branching candidates count of an expression handler

SCIPexprhdlrIncrementNDomainReductions^⚠

increments the domain reductions count of an expression handler

SCIPexprhdlrSetCompare^⚠

set the compare callback of an expression handler

SCIPexprhdlrSetCopyFreeData^⚠

set the expression handler callbacks to copy and free expression data

SCIPexprhdlrSetCopyFreeHdlr^⚠

set the expression handler callbacks to copy and free an expression handler

SCIPexprhdlrSetCurvature^⚠

set the curvature detection callback of an expression handler

SCIPexprhdlrSetDiff^⚠

set differentiation callbacks of an expression handler

SCIPexprhdlrSetEstimate^⚠

set the estimation callbacks of an expression handler

SCIPexprhdlrSetHash^⚠

set the hash callback of an expression handler

SCIPexprhdlrSetIntEval^⚠

set the interval evaluation callback of an expression handler

SCIPexprhdlrSetIntegrality^⚠

set the integrality detection callback of an expression handler

SCIPexprhdlrSetMonotonicity^⚠

set the monotonicity detection callback of an expression handler

SCIPexprhdlrSetParse^⚠

set the parse callback of an expression handler

SCIPexprhdlrSetPrint^⚠

set the print callback of an expression handler

SCIPexprhdlrSetReverseProp^⚠

set the reverse propagation callback of an expression handler

SCIPexprhdlrSetSimplify^⚠

set the simplify callback of an expression handler

SCIPexpriterGetChildExprDFS^⚠

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

SCIPexpriterGetChildIdxDFS^⚠

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

SCIPexpriterGetChildUserDataDFS^⚠

gives the iterator specific user data of the current expressions current child

SCIPexpriterGetCurrent^⚠

gets the current expression that the expression iterator points to

SCIPexpriterGetCurrentUserData^⚠

gives the iterator specific user data of the current expression

SCIPexpriterGetExprUserData^⚠

gives the iterator specific user data of a given expression

SCIPexpriterGetNext^⚠

moves the iterator to the next expression according to the mode of the expression iterator

SCIPexpriterGetParentDFS^⚠

gives the parent of the current expression of an expression iteration if in DFS mode

SCIPexpriterGetStageDFS^⚠

gets the current stage that the expression iterator is in when using DFS

SCIPexpriterInit^⚠

initializes an expression iterator

SCIPexpriterIsEnd^⚠

returns whether the iterator visited all expressions already

SCIPexpriterIsInit^⚠

returns whether expression iterator is currently initialized

SCIPexpriterRestartDFS^⚠

restarts an already initialized expression iterator in DFS mode

SCIPexpriterSetChildUserData^⚠

sets the iterator specific user data of the current expressions current child

SCIPexpriterSetCurrentUserData^⚠

sets the iterator specific user data of the current expression for an expression iteration if in DFS mode

SCIPexpriterSetExprUserData^⚠

sets the iterator specific user data of a given expression

SCIPexpriterSetStagesDFS^⚠

specifies in which stages to stop a DFS iterator

SCIPexpriterSkipDFS^⚠

moves a DFS iterator to one of the next expressions

SCIPextendBoolarray^⚠

extends dynamic array to be able to store indices from minidx to maxidx

SCIPextendIntarray^⚠

extends dynamic array to be able to store indices from minidx to maxidx

SCIPextendPtrarray^⚠

extends dynamic array to be able to store indices from minidx to maxidx

SCIPextendRealarray^⚠

extends dynamic array to be able to store indices from minidx to maxidx

SCIPextendSubOrbitope^⚠

Given a matrix with nrows and #perms + 1 columns whose first nfilledcols columns contain entries of variables, this routine checks whether the 2-cycles of perm intersect each row of column coltoextend in exactly one position. In this case, we add one column to the suborbitope of the first nfilledcols columns.

SCIPfclose^⚠

SCIPfdopen^⚠

SCIPfeasCeil^⚠

rounds value - feasibility tolerance up to the next integer

SCIPfeasFloor^⚠

rounds value + feasibility tolerance down to the next integer

SCIPfeasFrac^⚠

returns fractional part of value, i.e. x - floor(x)

SCIPfeasRound^⚠

rounds value to the nearest integer in feasibility tolerance

SCIPfeastol^⚠

SCIPfeof^⚠

SCIPfflush^⚠

SCIPfgetc^⚠

SCIPfgets^⚠

SCIPfileExists^⚠

returns, whether the given file exists

SCIPfindBanditvtable^⚠

returns the bandit virtual function table of the given name, or NULL if not existing

SCIPfindBenders^⚠

returns the Benders’ decomposition of the given name, or NULL if not existing

SCIPfindBenderscut^⚠

returns the Benders’ cut of the given name, or NULL if not existing

SCIPfindBranchrule^⚠

returns the branching rule of the given name, or NULL if not existing

SCIPfindCompr^⚠

returns the tree compression of the given name, or NULL if not existing

SCIPfindConcsolverType^⚠

returns the concurrent solver type with the given name, or NULL if not existing

SCIPfindConflicthdlr^⚠

returns the conflict handler of the given name, or NULL if not existing

SCIPfindCons^⚠

returns constraint of given name in the problem, or NULL if not existing

SCIPfindConshdlr^⚠

returns the constraint handler of the given name, or NULL if not existing

SCIPfindCutsel^⚠

returns the cut selector of the given name, or NULL if not existing

SCIPfindDisp^⚠

returns the display column of the given name, or NULL if not existing

SCIPfindEventhdlr^⚠

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

SCIPfindExprhdlr^⚠

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

SCIPfindHeur^⚠

returns the primal heuristic of the given name, or NULL if not existing

SCIPfindNlhdlrNonlinear^⚠

returns a nonlinear handler of a given name (or NULL if not found)

SCIPfindNlpi^⚠

returns the NLPI of the given name, or NULL if not existing

SCIPfindNodesel^⚠

returns the node selector of the given name, or NULL if not existing

SCIPfindOrigCons^⚠

returns original constraint of given name in the problem, or NULL if not existing

SCIPfindPresol^⚠

returns the presolver of the given name, or NULL if not existing

SCIPfindPricer^⚠

returns the variable pricer of the given name, or NULL if not existing

SCIPfindProp^⚠

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

SCIPfindReader^⚠

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

SCIPfindRelax^⚠

returns the relaxation handler of the given name, or NULL if not existing

SCIPfindSepa^⚠

returns the separator of the given name, or NULL if not existing

SCIPfindSimpleRational^⚠

given a (usually very small) interval, tries to find a rational number with simple denominator (i.e. a small number, probably multiplied with powers of 10) out of this interval; returns TRUE iff a valid rational number inside the interval was found

SCIPfindTable^⚠

returns the statistics table of the given name, or NULL if not existing

SCIPfindVar^⚠

returns variable of given name in the problem, or NULL if not existing

SCIPfixParam^⚠

fixes the value of an existing parameter

SCIPfixVar^⚠

in problem creation and solving stage, both bounds of the variable are set to the given value; in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively; conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders arrays returned from the SCIPvarGetImpl…() methods invalid

SCIPfixVarProbing^⚠

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

SCIPflattenVarAggregationGraph^⚠

flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on

SCIPfloor^⚠

rounds value + epsilon down to the next integer

SCIPflushLP^⚠

makes sure that the LP of the current node is flushed

SCIPflushNLP^⚠

makes sure that the NLP of the current node is flushed

SCIPflushRowExtensions^⚠

flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with equal columns into a single coefficient

SCIPfopen^⚠

SCIPfprintf^⚠

SCIPfputc^⚠

SCIPfputs^⚠

SCIPfrac^⚠

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

SCIPfread^⚠

SCIPfree^⚠

frees SCIP data structures

SCIPfreeBandit^⚠

calls destructor and frees memory of bandit algorithm

SCIPfreeBendersSubproblem^⚠

frees the subproblem after calling the solve subproblem method

SCIPfreeBoolarray^⚠

frees a dynamic array of bool values

SCIPfreeClock^⚠

frees a clock

SCIPfreeCutpool^⚠

frees a cut pool

SCIPfreeDecomp^⚠

frees a decomposition

SCIPfreeDisjointset^⚠

frees the disjoint set (union find) data structure

SCIPfreeExprQuadratic^⚠

frees information on quadratic representation of an expression

SCIPfreeExpriter^⚠

frees an expression iterator

SCIPfreeIntarray^⚠

frees a dynamic array of int values

SCIPfreeNlpiProblem^⚠

frees a problem instance

SCIPfreeParseVarsPolynomialData^⚠

frees memory allocated when parsing a signomial from a string

SCIPfreeProb^⚠

frees problem and solution process data

SCIPfreePtrarray^⚠

frees a dynamic array of pointers

SCIPfreeRandom^⚠

frees a random number generator

SCIPfreeRealarray^⚠

frees a dynamic array of real values

SCIPfreeReoptSolve^⚠

frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is preserved

SCIPfreeRepresentation^⚠

free a set of initialized reoptimization nodes

SCIPfreeRowprep^⚠

frees a SCIP_ROWPREP datastructure

SCIPfreeSOCArraysNonlinear^⚠

frees arrays created by SCIPisSOCNonlinear()

SCIPfreeSol^⚠

frees primal CIP solution

SCIPfreeSolve^⚠

frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is preserved

SCIPfreeSyncstore^⚠

releases the current synchronization store

SCIPfreeTransform^⚠

frees all solution process data including presolving and transformed problem, only original problem is kept

SCIPfseek^⚠

SCIPftell^⚠

SCIPfwrite^⚠

SCIPgenVBoundAdd^⚠

adds a generalized variable bound to the genvbounds propagator; if there is already a genvbound for the bound “boundtype” of variable “var”, it will be replaced

SCIPgenerateOrbitopeVarsMatrix^⚠

generate variable matrix for orbitope constraint handler

SCIPgetAbsViolationNonlinear^⚠

gets absolute violation of nonlinear constraint

SCIPgetActiveOnIndicator^⚠

gets activation value of an indicator constraint, TRUE for active on 1, FALSE for active on 0

SCIPgetActiveVars^⚠

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.

SCIPgetActivityLinear^⚠

gets the activity of the linear constraint in the given solution

SCIPgetAndDatasPseudoboolean^⚠

gets and-constraints of pseudoboolean constraint

SCIPgetAvgConflictScore^⚠

gets the average conflict score value over all variables

SCIPgetAvgConflictScoreCurrentRun^⚠

gets the average conflict score value over all variables, only using the conflict information of the current run

SCIPgetAvgConflictlengthScore^⚠

gets the average inference score value over all variables

SCIPgetAvgConflictlengthScoreCurrentRun^⚠

gets the average conflictlength score value over all variables, only using the conflictlength information of the current run

SCIPgetAvgCutoffScore^⚠

gets the average cutoff score value over all variables

SCIPgetAvgCutoffScoreCurrentRun^⚠

gets the average cutoff score value over all variables, only using the cutoff information of the current run

SCIPgetAvgCutoffs^⚠

returns the average number of cutoffs found after branching in given direction over all variables

SCIPgetAvgCutoffsCurrentRun^⚠

returns the average number of cutoffs found after branching in given direction over all variables, only using the cutoff information of the current run

SCIPgetAvgDualbound^⚠

gets average dual bound of all unprocessed nodes for original problem

SCIPgetAvgInferenceScore^⚠

gets the average inference score value over all variables

SCIPgetAvgInferenceScoreCurrentRun^⚠

gets the average inference score value over all variables, only using the inference information of the current run

SCIPgetAvgInferences^⚠

returns the average number of inferences found after branching in given direction over all variables

SCIPgetAvgInferencesCurrentRun^⚠

returns the average number of inferences found after branching in given direction over all variables, only using the inference information of the current run

SCIPgetAvgLowerbound^⚠

gets average lower (dual) bound of all unprocessed nodes in transformed problem

SCIPgetAvgPseudocost^⚠

gets the average pseudo cost value for the given direction over all variables

SCIPgetAvgPseudocostCount^⚠

gets the average number of pseudo cost updates for the given direction over all variables

SCIPgetAvgPseudocostCountCurrentRun^⚠

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

SCIPgetAvgPseudocostCurrentRun^⚠

gets the average pseudo cost value for the given direction over all variables, only using the pseudo cost information of the current run

SCIPgetAvgPseudocostScore^⚠

gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5

SCIPgetAvgPseudocostScoreCurrentRun^⚠

gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5, only using the pseudo cost information of the current run

SCIPgetBenders^⚠

returns the array of currently available Benders’ decomposition; active Benders’ decomposition are in the first slots of the array

SCIPgetBendersAuxiliaryVarVal^⚠

returns the value of the auxiliary variable for a given subproblem

SCIPgetBendersMasterVar^⚠

returns the master problem variable for the given subproblem variable

SCIPgetBendersNSubproblems^⚠

returns the number of subproblems that are stored in the given Benders’ decomposition

SCIPgetBendersSubproblemVar^⚠

returns the subproblem problem variable for the given master variable

SCIPgetBestChild^⚠

gets the best child of the focus node w.r.t. the node selection strategy

SCIPgetBestLeaf^⚠

gets the best leaf from the node queue w.r.t. the node selection strategy

SCIPgetBestNode^⚠

gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy

SCIPgetBestSibling^⚠

gets the best sibling of the focus node w.r.t. the node selection strategy

SCIPgetBestSol^⚠

gets best feasible primal solution found so far if the problem is transformed; in case the problem is in SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate store is empty;

SCIPgetBestboundNode^⚠

gets the node with smallest lower bound from the tree (child, sibling, or leaf)

SCIPgetBilinTermIdxNonlinear^⚠

returns the index of the bilinear term representing the product of the two given variables

SCIPgetBilinTermNonlinear^⚠

returns the bilinear term that represents the product of two given variables

SCIPgetBilinTermsNonlinear^⚠

returns all bilinear terms that are contained in all nonlinear constraints

SCIPgetBinaryVarIndicator^⚠

gets binary variable corresponding to indicator constraint. Returns the negative of the original binary variable if activeone was set to false

SCIPgetBinaryVarIndicatorGeneric^⚠

similar to SCIPgetBinaryVarIndicator but returns the original binary variable passed by the user.

SCIPgetBinaryVarSuperindicator^⚠

gets binary variable corresponding to the superindicator constraint

SCIPgetBinvarRepresentative^⚠

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

SCIPgetBinvarRepresentatives^⚠

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

SCIPgetBinvarsDataLinking^⚠

return all binary variable information of the linking constraint

SCIPgetBinvarsLinking^⚠

returns the binary variables of the linking constraint

SCIPgetBoolParam^⚠

gets the value of an existing SCIP_Bool parameter

SCIPgetBoolarrayMaxIdx^⚠

returns the maximal index of all stored non-zero elements

SCIPgetBoolarrayMinIdx^⚠

returns the minimal index of all stored non-zero elements

SCIPgetBoolarrayVal^⚠

gets value of entry in dynamic array

SCIPgetBoundsBounddisjunction^⚠

gets array of bounds in bound disjunction constraint

SCIPgetBoundtypesBounddisjunction^⚠

gets array of bound types in bound disjunction constraint

SCIPgetBranchScore^⚠

calculates the branching score out of the gain predictions for a binary branching

SCIPgetBranchScoreMultiple^⚠

calculates the branching score out of the gain predictions for a branching with arbitrary many children

SCIPgetBranchingPoint^⚠

computes a branching point for a continuous or discrete variable

SCIPgetBranchrules^⚠

returns the array of currently available branching rules

SCIPgetCapacityCumulative^⚠

returns the capacity of the cumulative constraint

SCIPgetCapacityKnapsack^⚠

gets the capacity of the knapsack constraint

SCIPgetCardvalCardinality^⚠

gets cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)

SCIPgetCharParam^⚠

gets the value of an existing char parameter

SCIPgetChildren^⚠

gets children of focus node along with the number of children

SCIPgetCliques^⚠

gets the array of cliques in the clique table

SCIPgetClockTime^⚠

gets the measured time of a clock in seconds

SCIPgetCoefExprProduct^⚠

gets the constant coefficient of a product expression

SCIPgetCoefsExprSum^⚠

gets the coefficients of a summation expression

SCIPgetColFarkasCoef^⚠

returns the Farkas coefficient of a column in the last (infeasible) LP

SCIPgetColRedcost^⚠

returns the reduced costs of a column in the last (feasible) LP

SCIPgetComprs^⚠

returns the array of currently available tree compression

SCIPgetConcsolverTypes^⚠

returns the array of included concurrent solver types

SCIPgetConfidenceBoundUcb^⚠

returns the upper confidence bound of a selected action

SCIPgetConflictVarLb^⚠

returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower bound

SCIPgetConflictVarUb^⚠

returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global upper bound

SCIPgetConflictgraphSOS1^⚠

gets conflict graph of SOS1 constraints (or NULL if not existent)

SCIPgetConflicthdlrs^⚠

returns the array of currently available conflict handlers

SCIPgetConsCopy^⚠

returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of the source SCIP to the variables of the target SCIP

SCIPgetConsLinking^⚠

returns the linking constraint belonging the given linking variable (continuous or integer) or NULL if it does not exist yet

SCIPgetConsNVars^⚠

method to collect the number of variables of a constraint

SCIPgetConsVals^⚠

returns the value array of an arbitrary SCIP constraint that can be represented as a single linear constraint

SCIPgetConsVars^⚠

method to collect the variables of a constraint

SCIPgetConshdlrs^⚠

returns the array of currently available constraint handlers

SCIPgetConss^⚠

gets array of globally valid constraints currently in the problem

SCIPgetConstantExprSum^⚠

gets the constant of a summation expression

SCIPgetCountedSparseSols^⚠

Method to get the sparse solution.

SCIPgetCurBoundsTagNonlinear^⚠

gets tag indicating current local variable bounds

SCIPgetCurrentNode^⚠

gets current node in the tree

SCIPgetCurvatureNonlinear^⚠

returns the curvature of the expression of a given nonlinear constraint

SCIPgetCutEfficacy^⚠

returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm

SCIPgetCutLPSolCutoffDistance^⚠

returns row’s cutoff distance in the direction of the given primal solution

SCIPgetCutoffbound^⚠

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

SCIPgetCutoffdepth^⚠

returns depth of first node in active path that is marked being cutoff

SCIPgetCuts^⚠

gets the array of cuts currently stored in the separation storage

SCIPgetCutsels^⚠

returns the array of currently available cut selectors

SCIPgetDecomps^⚠

gets available user decompositions for either the original or transformed problem

SCIPgetDelayedGlobalCutpool^⚠

gets the delayed global cut pool used by SCIP

SCIPgetDelayedPoolCuts^⚠

gets current cuts in the delayed global cut pool

SCIPgetDemandsCumulative^⚠

returns the demands of the cumulative constraint

SCIPgetDepth^⚠

gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node, such that the depth includes the probing path

SCIPgetDeterministicTime^⚠

gets deterministic time number of LPs solved so far

SCIPgetDisps^⚠

returns the array of currently available display columns

SCIPgetDiveBoundChangeData^⚠

get the dive bound change data for the preferred or the alternative direction

SCIPgetDiveBoundChanges^⚠

enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings

SCIPgetDivesetScore^⚠

stores the candidate score and preferred rounding direction for a candidate variable

SCIPgetDualSolVal^⚠

returns dual solution value of a constraint

SCIPgetDualbound^⚠

gets global dual bound

SCIPgetDualboundRoot^⚠

gets dual bound of the root node for the original problem

SCIPgetDualfarkasKnapsack^⚠

gets the dual Farkas value of the knapsack constraint in the current infeasible LP

SCIPgetDualfarkasLinear^⚠

gets the dual Farkas value of the linear constraint in the current infeasible LP

SCIPgetDualfarkasLogicor^⚠

gets the dual Farkas value of the logic or constraint in the current infeasible LP

SCIPgetDualfarkasSetppc^⚠

gets the dual Farkas value of the set partitioning / packing / covering constraint in the current infeasible LP

SCIPgetDualfarkasVarbound^⚠

gets the dual Farkas value of the variable bound constraint in the current infeasible LP

SCIPgetDualsolKnapsack^⚠

gets the dual solution of the knapsack constraint in the current LP

SCIPgetDualsolLinear^⚠

gets the dual solution of the linear constraint in the current LP

SCIPgetDualsolLogicor^⚠

gets the dual solution of the logic or constraint in the current LP

SCIPgetDualsolSetppc^⚠

gets the dual solution of the set partitioning / packing / covering constraint in the current LP

SCIPgetDualsolVarbound^⚠

gets the dual solution of the variable bound constraint in the current LP

SCIPgetDurationsCumulative^⚠

returns the durations of the cumulative constraint

SCIPgetEffectiveRootDepth^⚠

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.

SCIPgetEventhdlrs^⚠

returns the array of currently available event handlers

SCIPgetExponentExprPow^⚠

gets the exponent of a power or signed power expression

SCIPgetExprAbsAuxViolationNonlinear^⚠

computes absolute violation for auxvar relation in an expression w.r.t. auxiliary variables

SCIPgetExprAbsOrigViolationNonlinear^⚠

computes absolute violation for auxvar relation in an expression w.r.t. original variables

SCIPgetExprAuxVarNonlinear^⚠

returns the variable used for linearizing a given expression (return value might be NULL)

SCIPgetExprBoundsNonlinear^⚠

returns bounds on the expression

SCIPgetExprEnfoDataNonlinear^⚠

returns the data for one of the enforcements of an expression

SCIPgetExprNAuxvarUsesNonlinear^⚠

number of nonlinear handlers whose separation methods (estimate or enforcement) use auxiliary variable of the expression

SCIPgetExprNEnfosNonlinear^⚠

returns the number of enforcements for an expression

SCIPgetExprNLocksNegNonlinear^⚠

returns the number of negative rounding locks of an expression

SCIPgetExprNLocksPosNonlinear^⚠

returns the number of positive rounding locks of an expression

SCIPgetExprNPropUsesActivityNonlinear^⚠

number of nonlinear handlers whose activity computation and propagation methods depend on the activity of the expression

SCIPgetExprNSepaUsesActivityNonlinear^⚠

number of nonlinear handlers whose separation methods (estimate or enforcement) depend on the activity of the expression

SCIPgetExprNVars^⚠

returns the total number of variable expressions in an expression

SCIPgetExprNewSoltag^⚠

returns a previously unused solution tag for expression evaluation

SCIPgetExprNonlinear^⚠

returns the expression of the given nonlinear constraint

SCIPgetExprPartialDiffGradientDirNonlinear^⚠

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)

SCIPgetExprPartialDiffNonlinear^⚠

returns the partial derivative of an expression w.r.t. a variable (or SCIP_INVALID if there was an evaluation error)

SCIPgetExprRelAuxViolationNonlinear^⚠

computes relative violation for auxvar relation in an expression w.r.t. auxiliary variables

SCIPgetExprVarExprs^⚠

returns all variable expressions contained in a given expression

SCIPgetExprViolScoreNonlinear^⚠

gives violation-branching score stored in expression, or 0.0 if no valid score has been stored

SCIPgetExprhdlrPower^⚠

returns expression handler for power expressions (or NULL if not included)

SCIPgetExprhdlrProduct^⚠

returns expression handler for product expressions (or NULL if not included)

SCIPgetExprhdlrSum^⚠

returns expression handler for sum expressions (or NULL if not included)

SCIPgetExprhdlrValue^⚠

returns expression handler for constant value expressions (or NULL if not included)

SCIPgetExprhdlrVar^⚠

returns expression handler for variable expressions (or NULL if not included)

SCIPgetExprhdlrs^⚠

gives expression handlers

SCIPgetExprsBilinear^⚠

returns an array of expressions that have been detected by the bilinear nonlinear handler

SCIPgetExprsdataBilinear^⚠

returns an array of nonlinear handler expressions data of expressions that have been detected by the bilinear nonlinear handler

SCIPgetExternBranchCands^⚠

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

SCIPgetExternalCodeDescriptions^⚠

returns an array of the descriptions of currently included external codes

SCIPgetExternalCodeNames^⚠

returns an array of names of currently included external codes

SCIPgetFeasibilityLinear^⚠

gets the feasibility of the linear constraint in the given solution

SCIPgetFirstLPDualboundRoot^⚠

gets dual bound for the original problem obtained by the first LP solve at the root node

SCIPgetFirstLPLowerboundRoot^⚠

gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node

SCIPgetFirstLPTime^⚠

gets the time need to solve the first LP in the root node

SCIPgetFirstPrimalBound^⚠

the primal bound of the very first solution

SCIPgetFixedVars^⚠

gets array with fixed and aggregated problem variables; data may become invalid after calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()

SCIPgetFocusDepth^⚠

gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the branching tree, excluding the nodes of the probing path

SCIPgetFocusNode^⚠

gets focus node in the tree

SCIPgetGap^⚠

gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign, or infinity, if they have opposite sign

SCIPgetGlobalCutpool^⚠

gets the global cut pool used by SCIP

SCIPgetGlobalPseudoObjval^⚠

gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) global bound

SCIPgetHeurs^⚠

returns the array of currently available primal heuristics

SCIPgetHmaxCumulative^⚠

returns the right bound of effective horizon

SCIPgetHminCumulative^⚠

returns the left bound of the effective horizon

SCIPgetHugeValue^⚠

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

SCIPgetIndVarPseudoboolean^⚠

gets indicator variable of pseudoboolean constraint, or NULL if there is no

SCIPgetIndexExprVaridx^⚠

gives the index stored in a varidx expression

SCIPgetIntParam^⚠

gets the value of an existing int parameter

SCIPgetIntVarXor^⚠

gets integer variable in xor constraint

SCIPgetIntarrayMaxIdx^⚠

returns the maximal index of all stored non-zero elements

SCIPgetIntarrayMinIdx^⚠

returns the minimal index of all stored non-zero elements

SCIPgetIntarrayVal^⚠

gets value of entry in dynamic array

SCIPgetLPBInvACol^⚠

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

SCIPgetLPBInvARow^⚠

gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)

SCIPgetLPBInvCol^⚠

gets a column from the inverse basis matrix B^-1

SCIPgetLPBInvRow^⚠

gets a row from the inverse basis matrix B^-1

SCIPgetLPBasisInd^⚠

gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1

SCIPgetLPBranchCands^⚠

gets branching candidates for LP solution branching (fractional variables) along with solution values, fractionalities, and number of branching candidates; The number of branching candidates does NOT account for fractional implicit integer variables which should not be used for branching decisions.

SCIPgetLPCols^⚠

gets current LP columns

SCIPgetLPColsData^⚠

gets current LP columns along with the current number of LP columns

SCIPgetLPColumnObjval^⚠

gets part of objective value of current LP that results from COLUMN variables only

SCIPgetLPDualDegeneracy^⚠

computes two measures for dual degeneracy (dual degeneracy rate and variable-constraint ratio) based on the changes applied when reducing the problem to the optimal face

SCIPgetLPFeastol^⚠

gets current primal feasibility tolerance of LP

SCIPgetLPI^⚠

gets the LP interface of SCIP; with the LPI you can use all of the methods defined in lpi/lpi.h;

SCIPgetLPLooseObjval^⚠

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

SCIPgetLPObjval^⚠

gets objective value of current LP (which is the sum of column and loose objective value)

SCIPgetLPRootColumnObjval^⚠

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

SCIPgetLPRootLooseObjval^⚠

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

SCIPgetLPRootObjval^⚠

gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved

SCIPgetLPRows^⚠

gets current LP rows

SCIPgetLPRowsData^⚠

gets current LP rows along with the current number of LP rows

SCIPgetLPSolstat^⚠

gets solution status of current LP

SCIPgetLastBoundRelaxTagNonlinear^⚠

gets the curboundstag from the last time where variable bounds were relaxed

SCIPgetLastDivenode^⚠

returns the number of the node in the current branch and bound run, where the last LP was solved in diving or probing mode

SCIPgetLastStrongbranchLPSolStat^⚠

get LP solution status of last strong branching call (currently only works for strong branching with propagation)

SCIPgetLeaves^⚠

gets leaves of the tree along with the number of leaves

SCIPgetLhsLinear^⚠

gets left hand side of linear constraint

SCIPgetLhsNonlinear^⚠

gets the left hand side of a nonlinear constraint

SCIPgetLhsPseudoboolean^⚠

get left hand side of pseudoboolean constraint

SCIPgetLhsVarbound^⚠

gets left hand side of variable bound constraint lhs <= x + c*y <= rhs

SCIPgetLinDatasWithoutAndPseudoboolean^⚠

gets linear constraint of pseudoboolean constraint

SCIPgetLinearConsIndicator^⚠

gets the linear constraint corresponding to the indicator constraint (may be NULL)

SCIPgetLinearConsPseudoboolean^⚠

gets linear constraint of pseudoboolean constraint

SCIPgetLinearConsTypePseudoboolean^⚠

gets type of linear constraint of pseudoboolean constraint

SCIPgetLinkvarLinking^⚠

returns the linking variable (continuous or integer) of the linking constraint

SCIPgetLinvarMayDecreaseNonlinear^⚠

returns a variable that appears linearly that may be decreased without making any other constraint infeasible

SCIPgetLinvarMayIncreaseNonlinear^⚠

returns a variable that appears linearly that may be increased without making any other constraint infeasible

SCIPgetLocalDualbound^⚠

gets dual bound of current node

SCIPgetLocalLowerbound^⚠

gets lower bound of current node in transformed problem

SCIPgetLocalOrigEstimate^⚠

gets estimate of best primal solution w.r.t. original problem contained in current subtree

SCIPgetLocalTransEstimate^⚠

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

SCIPgetLongintParam^⚠

gets the value of an existing SCIP_Longint parameter

SCIPgetLowerbound^⚠

gets global lower (dual) bound in transformed problem

SCIPgetLowerboundRoot^⚠

gets lower (dual) bound in transformed problem of the root node

SCIPgetMaxDepth^⚠

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

SCIPgetMaxTotalDepth^⚠

gets maximal depth of all processed nodes over all branch and bound runs

SCIPgetMemExternEstim^⚠

returns the estimated number of bytes used by external software, e.g., the LP solver

SCIPgetMemTotal^⚠

returns the total number of bytes in block and buffer memory

SCIPgetMemUsed^⚠

returns the total number of bytes used in block and buffer memory

SCIPgetMessagehdlr^⚠

returns the currently installed message handler

SCIPgetNActiveBenders^⚠

returns the number of currently active Benders’ decomposition

SCIPgetNActiveConss^⚠

gets total number of active constraints at the current node

SCIPgetNActivePricers^⚠

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

SCIPgetNAndsPseudoboolean^⚠

gets number of and constraints of pseudoboolean constraint

SCIPgetNBacktracks^⚠

gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue

SCIPgetNBarrierLPIterations^⚠

gets total number of iterations used so far in barrier algorithm

SCIPgetNBarrierLPs^⚠

gets total number of barrier LPs solved so far

SCIPgetNBenders^⚠

returns the number of currently available Benders’ decomposition

SCIPgetNBestSolsFound^⚠

gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found

SCIPgetNBilinTermsNonlinear^⚠

returns the total number of bilinear terms that are contained in all nonlinear constraints

SCIPgetNBinVars^⚠

gets number of binary active problem variables

SCIPgetNBinvarsLinking^⚠

returns the number of binary variables of the linking constraint

SCIPgetNBranchrules^⚠

returns the number of currently available branching rules

SCIPgetNCheckConss^⚠

computes the number of check constraint in the current node (loop over all constraint handler and cumulates the number of check constraints)

SCIPgetNChildren^⚠

gets number of children of focus node

SCIPgetNCliques^⚠

gets the number of cliques in the clique table

SCIPgetNCliquesCreated^⚠

gets the number of cliques created so far by the cliquetable

SCIPgetNCompr^⚠

returns the number of currently available tree compression

SCIPgetNConcsolverTypes^⚠

returns the number of included concurrent solver types

SCIPgetNConflictConssApplied^⚠

get total number of conflict constraints added to the problem

SCIPgetNConflictConssFound^⚠

get total number of constraints found in conflict analysis (conflict and reconvergence constraints)

SCIPgetNConflictConssFoundNode^⚠

get number of conflict constraints found so far at the current node

SCIPgetNConflictDualproofsApplied^⚠

get total number of dual proof constraints added to the problem

SCIPgetNConflicthdlrs^⚠

returns the number of currently available conflict handlers

SCIPgetNConshdlrs^⚠

returns the number of currently available constraint handlers

SCIPgetNConss^⚠

gets total number of globally valid constraints currently in the problem

SCIPgetNContVars^⚠

gets number of continuous active problem variables

SCIPgetNCountedFeasSubtrees^⚠

returns number of counted feasible subtrees

SCIPgetNCountedSols^⚠

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

SCIPgetNCountedSolsstr^⚠

returns number of counted solutions as string

SCIPgetNCuts^⚠

get current number of cuts in the separation storage

SCIPgetNCutsApplied^⚠

get total number of cuts applied to the LPs

SCIPgetNCutsFound^⚠

get total number of cuts found so far; this includes global cuts from the cut pool as often as they are separated

SCIPgetNCutsFoundRound^⚠

get number of cuts found so far in current separation round

SCIPgetNCutsels^⚠

returns the number of currently available cut selectors

SCIPgetNDelayedCutoffs^⚠

gets number of times a selected node was from a cut off subtree

SCIPgetNDelayedPoolCuts^⚠

gets current number of rows in the delayed global cut pool

SCIPgetNDisps^⚠

returns the number of currently available display columns

SCIPgetNDivingLPIterations^⚠

gets total number of simplex iterations used so far during diving and probing

SCIPgetNDivingLPs^⚠

gets total number of LPs solved so far during diving and probing

SCIPgetNDualLPIterations^⚠

gets total number of iterations used so far in dual simplex

SCIPgetNDualLPs^⚠

gets total number of dual LPs solved so far

SCIPgetNDualResolveLPIterations^⚠

gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis was available

SCIPgetNDualResolveLPs^⚠

gets total number of dual LPs solved so far that were resolved from an advanced start basis

SCIPgetNEnabledConss^⚠

gets total number of enabled constraints at the current node

SCIPgetNEventhdlrs^⚠

returns the number of currently available event handlers

SCIPgetNExprhdlrs^⚠

gives number of expression handlers

SCIPgetNExprsBilinear^⚠

returns the total number of expressions that have been detected by the bilinear nonlinear handler

SCIPgetNExternBranchCands^⚠

gets number of external branching candidates

SCIPgetNExternalCodes^⚠

returns the number of currently included information on external codes

SCIPgetNFeasibleLeaves^⚠

gets number of leaf nodes processed with feasible relaxation solution

SCIPgetNFixedVars^⚠

gets number of fixed or aggregated problem variables

SCIPgetNFixedonesSetppc^⚠

returns current number of variables fixed to one in the constraint

SCIPgetNFixedzerosSetppc^⚠

returns current number of variables fixed to zero in the constraint

SCIPgetNHeurs^⚠

returns the number of currently available primal heuristics

SCIPgetNImplVars^⚠

gets number of implicit integer active problem variables

SCIPgetNImplications^⚠

gets total number of implications between variables that are stored in the implication graph

SCIPgetNInfeasibleLeaves^⚠

gets number of infeasible leaf nodes processed

SCIPgetNIntVars^⚠

gets number of integer active problem variables

SCIPgetNLPBranchCands^⚠

gets number of branching candidates for LP solution branching (number of fractional variables)

SCIPgetNLPCols^⚠

gets current number of LP columns

SCIPgetNLPFracVars^⚠

gets fractional variables of last NLP solution along with solution values and fractionalities

SCIPgetNLPI^⚠

gets the NLP interface and problem used by the SCIP NLP

SCIPgetNLPIterations^⚠

gets total number of iterations used so far in primal and dual simplex and barrier algorithm

SCIPgetNLPNlRows^⚠

gets array with nonlinear rows of the NLP

SCIPgetNLPNlRowsData^⚠

gets current NLP nonlinear rows along with the current number of NLP nonlinear rows

SCIPgetNLPObjval^⚠

gets objective value of current NLP

SCIPgetNLPRows^⚠

gets current number of LP rows

SCIPgetNLPSolstat^⚠

gets solution status of current NLP

SCIPgetNLPStatistics^⚠

gives statistics (number of iterations, solving time, …) of last NLP solve

SCIPgetNLPTermstat^⚠

gets termination status of last NLP solve

SCIPgetNLPVars^⚠

gets array with variables of the NLP

SCIPgetNLPVarsData^⚠

gets current NLP variables along with the current number of NLP variables

SCIPgetNLPVarsLbDualsol^⚠

returns dual solution values associated with lower bounds of NLP variables

SCIPgetNLPVarsNonlinearity^⚠

computes for each variables the number of NLP rows in which the variable appears in the nonlinear part

SCIPgetNLPVarsUbDualsol^⚠

returns dual solution values associated with upper bounds of NLP variables

SCIPgetNLPs^⚠

gets total number of LPs solved so far

SCIPgetNLeaves^⚠

gets number of leaves in the tree

SCIPgetNLimSolsFound^⚠

gets number of feasible primal solutions respecting the objective limit found so far

SCIPgetNLinVarsWithoutAndPseudoboolean^⚠

gets number of linear variables without artificial terms variables of pseudoboolean constraint

SCIPgetNNLPNlRows^⚠

gets current number of nonlinear rows in NLP

SCIPgetNNLPVars^⚠

gets current number of variables in NLP

SCIPgetNNZs^⚠

gets number of active non-zeros in the current transformed problem

SCIPgetNNlhdlrsNonlinear^⚠

get number of nonlinear handler

SCIPgetNNlpis^⚠

returns the number of currently available NLPIs

SCIPgetNNodeInitLPIterations^⚠

gets total number of simplex iterations used so far for initial LP in node relaxations

SCIPgetNNodeInitLPs^⚠

gets total number of LPs solved so far for initial LP in node relaxations

SCIPgetNNodeLPIterations^⚠

gets total number of simplex iterations used so far for node relaxations

SCIPgetNNodeLPs^⚠

gets total number of LPs solved so far for node relaxations

SCIPgetNNodeZeroIterationLPs^⚠

gets total number of LPs solved in 0 iterations for node relaxations

SCIPgetNNodes^⚠

gets number of processed nodes in current run, including the focus node

SCIPgetNNodesLeft^⚠

gets number of nodes left in the tree (children + siblings + leaves)

SCIPgetNNodesels^⚠

returns the number of currently available node selectors

SCIPgetNObjVars^⚠

gets number of active problem variables with a non-zero objective coefficient

SCIPgetNObjlimLeaves^⚠

gets number of processed leaf nodes that hit LP objective limit

SCIPgetNOrigBinVars^⚠

gets number of binary variables in the original problem

SCIPgetNOrigConss^⚠

gets total number of constraints in the original problem

SCIPgetNOrigContVars^⚠

gets number of continuous variables in the original problem

SCIPgetNOrigImplVars^⚠

gets number of implicit integer variables in the original problem

SCIPgetNOrigIntVars^⚠

gets the number of integer variables in the original problem

SCIPgetNOrigVars^⚠

gets number of original problem variables

SCIPgetNParams^⚠

returns the total number of all available SCIP parameters

SCIPgetNPartialSols^⚠

returns number of partial solutions

SCIPgetNPoolCuts^⚠

gets current number of rows in the global cut pool

SCIPgetNPresolRounds^⚠

returns the number of presolve rounds (current or last presolve)

SCIPgetNPresols^⚠

returns the number of currently available presolvers

SCIPgetNPriceRounds^⚠

gets number of pricing rounds performed so far at the current node

SCIPgetNPricers^⚠

returns the number of currently available variable pricers

SCIPgetNPricevars^⚠

get current number of variables in the pricing store

SCIPgetNPricevarsApplied^⚠

get total number of pricing variables applied to the LPs

SCIPgetNPricevarsFound^⚠

get total number of pricing variables found so far

SCIPgetNPrimalLPIterations^⚠

gets total number of iterations used so far in primal simplex

SCIPgetNPrimalLPs^⚠

gets total number of primal LPs solved so far

SCIPgetNPrimalResolveLPIterations^⚠

gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis was available

SCIPgetNPrimalResolveLPs^⚠

gets total number of primal LPs solved so far that were resolved from an advanced start basis

SCIPgetNPrioExternBranchBins^⚠

gets number of binary external branching candidates with maximal branch priority

SCIPgetNPrioExternBranchCands^⚠

gets number of external branching candidates with maximal branch priority

SCIPgetNPrioExternBranchConts^⚠

gets number of continuous external branching candidates with maximal branch priority

SCIPgetNPrioExternBranchImpls^⚠

gets number of implicit integer external branching candidates with maximal branch priority

SCIPgetNPrioExternBranchInts^⚠

gets number of integer external branching candidates with maximal branch priority

SCIPgetNPrioLPBranchCands^⚠

gets number of branching candidates with maximal priority for LP solution branching

SCIPgetNPrioPseudoBranchBins^⚠

gets number of binary branching candidates with maximal branch priority for pseudo solution branching

SCIPgetNPrioPseudoBranchCands^⚠

gets number of branching candidates with maximal branch priority for pseudo solution branching

SCIPgetNPrioPseudoBranchImpls^⚠

gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching

SCIPgetNPrioPseudoBranchInts^⚠

gets number of integer branching candidates with maximal branch priority for pseudo solution branching

SCIPgetNProps^⚠

returns the number of currently available propagators

SCIPgetNPseudoBranchCands^⚠

gets number of branching candidates for pseudo solution branching (non-fixed variables)

SCIPgetNReaders^⚠

returns the number of currently available readers

SCIPgetNRelaxs^⚠

returns the number of currently available relaxation handlers

SCIPgetNReoptLeaves^⚠

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.

SCIPgetNReoptRuns^⚠

gets number of reoptimization runs performed, including the current run

SCIPgetNReoptnodes^⚠

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.

SCIPgetNResolveLPIterations^⚠

gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis was available

SCIPgetNResolveLPs^⚠

gets total number of LPs solved so far that were resolved from an advanced start basis

SCIPgetNRootFirstLPIterations^⚠

gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root node

SCIPgetNRootLPIterations^⚠

gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node

SCIPgetNRootStrongbranchLPIterations^⚠

gets total number of simplex iterations used so far in strong branching at the root node

SCIPgetNRootStrongbranchs^⚠

gets total number of times, strong branching was called at the root node (each call represents solving two LPs)

SCIPgetNRootboundChgs^⚠

gets number of global bound changes

SCIPgetNRootboundChgsRun^⚠

gets number of global bound changes applied in the current run

SCIPgetNRuns^⚠

gets number of branch and bound runs performed, including the current run

SCIPgetNSOS1Vars^⚠

gets number of problem variables that are part of the SOS1 conflict graph

SCIPgetNSepaRounds^⚠

gets number of separation rounds performed so far at the current node

SCIPgetNSepas^⚠

returns the number of currently available separators

SCIPgetNSiblings^⚠

gets number of siblings of focus node

SCIPgetNSols^⚠

gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate storage is returned

SCIPgetNSolsFound^⚠

gets number of feasible primal solutions found so far

SCIPgetNStrongbranchLPIterations^⚠

gets total number of simplex iterations used so far in strong branching

SCIPgetNStrongbranchs^⚠

gets total number of times, strong branching was called (each call represents solving two LPs)

SCIPgetNTables^⚠

returns the number of currently available statistics tables

SCIPgetNTotalNodes^⚠

gets total number of processed nodes in all runs, including the focus node

SCIPgetNTotalVars^⚠

gets number of all problem variables created during creation and solving of problem; this includes also variables that were deleted in the meantime

SCIPgetNUnfixedLPCols^⚠

gets current number of unfixed LP columns

SCIPgetNUpgrConss^⚠

gets number of upgraded constraints

SCIPgetNVars^⚠

gets number of active problem variables

SCIPgetNVarsAnd^⚠

gets number of variables in and constraint

SCIPgetNVarsBounddisjunction^⚠

gets number of variables in bound disjunction constraint

SCIPgetNVarsCardinality^⚠

gets number of variables in cardinality constraint

SCIPgetNVarsCumulative^⚠

returns the number of start time variables of the cumulative constraint

SCIPgetNVarsKnapsack^⚠

gets the number of items in the knapsack constraint

SCIPgetNVarsLinear^⚠

gets the number of variables in the linear constraint

SCIPgetNVarsLogicor^⚠

gets number of variables in logic or constraint

SCIPgetNVarsOr^⚠

gets number of variables in or constraint

SCIPgetNVarsSOS1^⚠

gets number of variables in SOS1 constraint

SCIPgetNVarsSOS2^⚠

gets number of variables in SOS2 constraint

SCIPgetNVarsSetppc^⚠

gets number of variables in set partitioning / packing / covering constraint

SCIPgetNVarsXor^⚠

gets number of variables in xor constraint

SCIPgetNegatedVar^⚠

gets negated variable x’ = lb + ub - x of variable x; negated variable is created, if not yet existing

SCIPgetNegatedVars^⚠

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)

SCIPgetNlRowActivity^⚠

gives the activity of a nonlinear row in the last NLP or pseudo solution

SCIPgetNlRowActivityBounds^⚠

gives the minimal and maximal activity of a nonlinear row w.r.t. the variable’s bounds

SCIPgetNlRowFeasibility^⚠

gives the feasibility of a nonlinear row in the last NLP or pseudo solution

SCIPgetNlRowNLPActivity^⚠

returns the activity of a nonlinear row in the last NLP solution

SCIPgetNlRowNLPFeasibility^⚠

gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility

SCIPgetNlRowNonlinear^⚠

gets the nonlinear constraint as a nonlinear row representation.

SCIPgetNlRowPseudoActivity^⚠

gives the activity of a nonlinear row for the current pseudo solution

SCIPgetNlRowPseudoFeasibility^⚠

gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility

SCIPgetNlRowSolActivity^⚠

gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution

SCIPgetNlRowSolFeasibility^⚠

gives the feasibility of a nonlinear row for the given primal solution

SCIPgetNlhdlrExprDataNonlinear^⚠

gives expression data that a given nonlinear handler stored in an expression

SCIPgetNlhdlrsNonlinear^⚠

get nonlinear handlers

SCIPgetNlpiOracleIpopt^⚠

gives a pointer to the NLPIORACLE object stored in Ipopt-NLPI’s NLPI problem data structure

SCIPgetNlpiProblemPointer^⚠

gets internal pointer to solver-internal problem instance

SCIPgetNlpiSolstat^⚠

gives solution status

SCIPgetNlpiSolution^⚠

gives primal and dual solution for a ranged constraint, the dual variable is positive if the right hand side is active and negative if the left hand side is active

SCIPgetNlpiSolverPointer^⚠

gets internal pointer to NLP solver

SCIPgetNlpiStatistics^⚠

gives solve statistics

SCIPgetNlpiTermstat^⚠

gives termination reason

SCIPgetNlpis^⚠

returns the array of currently available NLPIs (sorted by priority)

SCIPgetNodeDualbound^⚠

gets dual bound of given node

SCIPgetNodeLowerbound^⚠

gets lower bound of given node in transformed problem

SCIPgetNodesel^⚠

returns the currently used node selector

SCIPgetNodesels^⚠

returns the array of currently available node selectors

SCIPgetObjNorm^⚠

returns the Euclidean norm of the objective function vector (available only for transformed problem)

SCIPgetObjlimit^⚠

returns current limit on objective function

SCIPgetObjsense^⚠

returns objective sense of original problem

SCIPgetOpenNodesData^⚠

access to all data of open nodes (leaves, children, and siblings)

SCIPgetOrigConss^⚠

gets array of constraints in the original problem

SCIPgetOrigObjoffset^⚠

returns the objective offset of the original problem

SCIPgetOrigObjscale^⚠

returns the objective scale of the original problem

SCIPgetOrigVars^⚠

gets array with original problem variables; data may become invalid after a call to SCIPchgVarType()

SCIPgetOrigVarsData^⚠

gets variables of the original problem along with the numbers of different variable types; data may become invalid after a call to SCIPchgVarType()

SCIPgetParam^⚠

returns the pointer to the SCIP parameter with the given name

SCIPgetParams^⚠

returns the array of all available SCIP parameters

SCIPgetPartialSols^⚠

returns all partial solutions

SCIPgetPlungeDepth^⚠

gets current plunging depth (successive times, a child was selected as next node)

SCIPgetPoolCuts^⚠

gets current cuts in the global cut pool

SCIPgetPresols^⚠

returns the array of currently available presolvers

SCIPgetPresolvingTime^⚠

gets the current presolving time in seconds

SCIPgetPricers^⚠

returns the array of currently available variable pricers; active pricers are in the first slots of the array

SCIPgetPrimalRayVal^⚠

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())

SCIPgetPrimalbound^⚠

gets global primal bound (objective value of best solution or user objective limit) for the original problem

SCIPgetPrioChild^⚠

gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule

SCIPgetPrioSibling^⚠

gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule

SCIPgetProbData^⚠

gets user problem data

SCIPgetProbName^⚠

returns name of the current problem instance

SCIPgetProbabilityExp3^⚠

returns probability to play an action

SCIPgetProbingDepth^⚠

returns the current probing depth

SCIPgetProbvarLinearSum^⚠

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.

SCIPgetProbvarSum^⚠

transforms given variable, scalar and constant to the corresponding active, fixed, or multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable, “scalar” will be 0.0 and the value of the sum will be stored in “constant”; a multi-aggregation with only one active variable (this can happen due to fixings after the multi-aggregation), is treated like an aggregation; if the multi-aggregation constant is infinite, “scalar” will be 0.0

SCIPgetProps^⚠

returns the array of currently available propagators

SCIPgetPseudoBranchCands^⚠

gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates

SCIPgetPseudoObjval^⚠

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

SCIPgetPseudocostCount^⚠

gets the number of pseudo cost updates for the given direction over all variables

SCIPgetPseudocostVariance^⚠

returns the variance of pseudo costs for all variables in the requested direction

SCIPgetPtrarrayMaxIdx^⚠

returns the maximal index of all stored non-zero elements

SCIPgetPtrarrayMinIdx^⚠

returns the minimal index of all stored non-zero elements

SCIPgetPtrarrayVal^⚠

gets value of entry in dynamic array

SCIPgetRandomInt^⚠

returns a random integer between minrandval and maxrandval

SCIPgetRandomReal^⚠

returns a random real between minrandval and maxrandval

SCIPgetRandomSubset^⚠

draws a random subset of disjoint elements from a given set of disjoint elements; this implementation is suited for the case that nsubelems is considerably smaller then nelems

SCIPgetReaders^⚠

returns the array of currently available readers

SCIPgetReadingTime^⚠

gets the current reading time in seconds

SCIPgetRealParam^⚠

gets the value of an existing SCIP_Real parameter

SCIPgetRealarrayMaxIdx^⚠

returns the maximal index of all stored non-zero elements

SCIPgetRealarrayMinIdx^⚠

returns the minimal index of all stored non-zero elements

SCIPgetRealarrayVal^⚠

gets value of entry in dynamic array

SCIPgetRelViolationNonlinear^⚠

gets scaled violation of nonlinear constraint

SCIPgetRelaxSolObj^⚠

gets the relaxation solution objective value

SCIPgetRelaxSolVal^⚠

gets the relaxation solution value of the given variable

SCIPgetRelaxs^⚠

returns the array of currently available relaxation handlers

SCIPgetReoptChildIDs^⚠

return the ids of child nodes stored in the reoptimization tree

SCIPgetReoptLastOptSol^⚠

returns the optimal solution of the last iteration or NULL of none exists

SCIPgetReoptLeaveIDs^⚠

return the ids of all leave nodes store in the reoptimization tree induced by the given node

SCIPgetReoptOldObjCoef^⚠

returns the objective coefficent of a given variable in a previous iteration

SCIPgetReoptSimilarity^⚠

return the similarity between two objective functions

SCIPgetReoptSolsRun^⚠

returns the stored solutions corresponding to a given run

SCIPgetReoptnode^⚠

gets the node of the reoptimization tree corresponding to the unique @p id

SCIPgetReoptnodePath^⚠

return the branching path stored in the reoptree at ID id

SCIPgetRepropdepth^⚠

returns depth of first node in active path that has to be propagated again

SCIPgetResultantAnd^⚠

gets the resultant variable in and constraint

SCIPgetResultantOr^⚠

gets the resultant variable in or constraint

SCIPgetRhsLinear^⚠

gets right hand side of linear constraint

SCIPgetRhsNonlinear^⚠

gets the right hand side of a nonlinear constraint

SCIPgetRhsPseudoboolean^⚠

get right hand side of pseudoboolean constraint

SCIPgetRhsVarbound^⚠

gets right hand side of variable bound constraint lhs <= x + c*y <= rhs

SCIPgetRhsXor^⚠

gets the right hand side of the xor constraint

SCIPgetRootDialog^⚠

returns the root dialog of SCIP’s interactive user shell

SCIPgetRootNode^⚠

gets the root node of the tree

SCIPgetRowActivity^⚠

returns the activity of a row in the last LP or pseudo solution

SCIPgetRowFeasibility^⚠

returns the feasibility of a row in the last LP or pseudo solution

SCIPgetRowKnapsack^⚠

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!

SCIPgetRowLPActivity^⚠

returns the activity of a row in the last LP solution

SCIPgetRowLPFeasibility^⚠

returns the feasibility of a row in the last LP solution

SCIPgetRowLinear^⚠

returns the linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row!

SCIPgetRowLogicor^⚠

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!

SCIPgetRowMaxActivity^⚠

returns the maximal activity of a row w.r.t. the column’s bounds

SCIPgetRowMaxCoef^⚠

returns maximal absolute value of row vector’s non-zero coefficients

SCIPgetRowMinActivity^⚠

returns the minimal activity of a row w.r.t. the column’s bounds

SCIPgetRowMinCoef^⚠

returns minimal absolute value of row vector’s non-zero coefficients

SCIPgetRowNumIntCols^⚠

returns number of integral columns in the row

SCIPgetRowObjParallelism^⚠

returns the parallelism of row with objective function

SCIPgetRowPseudoActivity^⚠

returns the activity of a row for the current pseudo solution

SCIPgetRowPseudoFeasibility^⚠

returns the feasibility of a row for the current pseudo solution: negative value means infeasibility

SCIPgetRowSetppc^⚠

returns the linear relaxation of the given set partitioning / packing / covering constraint; may return NULL if no LP row was yet created; the user must not modify the row!

SCIPgetRowSolActivity^⚠

returns the activity of a row for the given primal solution

SCIPgetRowSolFeasibility^⚠

returns the feasibility of a row for the given primal solution

SCIPgetRowVarbound^⚠

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!

SCIPgetRowprepRowCons^⚠

generates a SCIP_ROW from a rowprep, setting its origin to given constraint

SCIPgetRowprepRowConshdlr^⚠

generates a SCIP_ROW from a rowprep, setting its origin to given constraint handler

SCIPgetRowprepRowSepa^⚠

generates a SCIP_ROW from a rowprep, setting its origin to given separator

SCIPgetRowprepViolation^⚠

computes violation of rowprep in a given solution

SCIPgetSepaMinEfficacy^⚠

gets value of minimal efficacy for a cut to enter the LP

SCIPgetSepas^⚠

returns the array of currently available separators

SCIPgetSiblings^⚠

gets siblings of focus node along with the number of siblings

SCIPgetSlackConsSuperindicator^⚠

gets the slack constraint corresponding to the superindicator constraint

SCIPgetSlackVarIndicator^⚠

gets slack variable corresponding to indicator constraint

SCIPgetSolHeur^⚠

gets heuristic, that found this solution (or NULL if it’s from the tree)

SCIPgetSolNodenum^⚠

gets node number of the specific branch and bound run, where this solution was found

SCIPgetSolOrigObj^⚠

returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value

SCIPgetSolRunnum^⚠

gets branch and bound run number, where this solution was found

SCIPgetSolTime^⚠

gets clock time, when this solution was found

SCIPgetSolTransObj^⚠

returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value

SCIPgetSolVal^⚠

returns value of variable in primal CIP solution, or in current LP/pseudo solution

SCIPgetSolVals^⚠

gets values of multiple variables in primal CIP solution

SCIPgetSolVarsData^⚠

gets variables of the original or transformed problem along with the numbers of different variable types; the returned problem space (original or transformed) corresponds to the given solution; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()

SCIPgetSols^⚠

gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored

SCIPgetSolverDescFilterSQP^⚠

gets string that describes filterSQP

SCIPgetSolverDescIpopt^⚠

gets string that describes Ipopt

SCIPgetSolverDescWorhp^⚠

gets string that describes Worhp (version number)

SCIPgetSolverNameFilterSQP^⚠

gets string that identifies filterSQP

SCIPgetSolverNameIpopt^⚠

gets string that identifies Ipopt (version number)

SCIPgetSolverNameWorhp^⚠

gets string that identifies Worhp (version number)

SCIPgetSolvingTime^⚠

gets the current solving time in seconds

SCIPgetStage^⚠

returns current stage of SCIP

SCIPgetStartCandidateHeurSubNlp^⚠

gets startpoint candidate to be used in next call to NLP heuristic, or NULL if none

SCIPgetStartPermutationUcb^⚠

return start permutation of the UCB bandit algorithm

SCIPgetStatus^⚠

gets solution status

SCIPgetStringParam^⚠

gets the value of an existing string(char*) parameter

SCIPgetSubscipDepth^⚠

gets depth of current scip instance (increased by each copy call)

SCIPgetSubscipsOff^⚠

returns whether plugins with sub-SCIPs that could cause recursion have been disabled

SCIPgetSymmetry^⚠

return currently available symmetry group information

SCIPgetSymmetryNGenerators^⚠

return number of the symmetry group’s generators

SCIPgetSyncstore^⚠

Gets the synchronization store.

SCIPgetTables^⚠

returns the array of currently available statistics tables

SCIPgetTimeOfDay^⚠

gets current time of day in seconds (standard time zone)

SCIPgetTotalTime^⚠

gets the current total SCIP time in seconds, possibly accumulated over several problems.

SCIPgetTransGap^⚠

gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds have same sign, or infinity, if they have opposite sign

SCIPgetTransObjoffset^⚠

returns the objective offset of the transformed problem

SCIPgetTransObjscale^⚠

returns the objective scale of the transformed problem

SCIPgetTransformedCons^⚠

gets corresponding transformed constraint of a given constraint; returns NULL as transcons, if transformed constraint is not yet existing

SCIPgetTransformedConss^⚠

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

SCIPgetTransformedVar^⚠

gets corresponding transformed variable of a given variable; returns NULL as transvar, if transformed variable is not yet existing

SCIPgetTransformedVars^⚠

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

SCIPgetTreesizeEstimation^⚠

SCIPgetTypeSetppc^⚠

gets type of set partitioning / packing / covering constraint

SCIPgetUpperbound^⚠

gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)

SCIPgetValsLinear^⚠

gets the array of coefficient values in the linear constraint; the user must not modify this array!

SCIPgetValsLinking^⚠

returns the coefficients of the binary variables

SCIPgetValueExprValue^⚠

gets the value of a constant value expression

SCIPgetVanillafullstrongData^⚠

recovers candidate variables and their scores from last vanilla full strong branching call

SCIPgetVarAvgConflictlength^⚠

returns the variable’s average conflict length

SCIPgetVarAvgConflictlengthCurrentRun^⚠

returns the variable’s average conflict length only using conflicts of the current run

SCIPgetVarAvgCutoffScore^⚠

returns the variable’s average cutoff score value

SCIPgetVarAvgCutoffScoreCurrentRun^⚠

returns the variable’s average cutoff score value, only using cutoffs of the current run

SCIPgetVarAvgCutoffs^⚠

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

SCIPgetVarAvgCutoffsCurrentRun^⚠

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

SCIPgetVarAvgInferenceCutoffScore^⚠

returns the variable’s average inference/cutoff score value, weighting the cutoffs of the variable with the given factor

SCIPgetVarAvgInferenceCutoffScoreCurrentRun^⚠

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

SCIPgetVarAvgInferenceScore^⚠

returns the variable’s average inference score value

SCIPgetVarAvgInferenceScoreCurrentRun^⚠

returns the variable’s average inference score value only using inferences of the current run

SCIPgetVarAvgInferences^⚠

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

SCIPgetVarAvgInferencesCurrentRun^⚠

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

SCIPgetVarBdAtIndex^⚠

returns lower or upper bound of variable directly before or after the bound change given by the bound change index was applied

SCIPgetVarClosestVlb^⚠

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

SCIPgetVarClosestVub^⚠

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

SCIPgetVarCoefChg^⚠

check the changes of the variable coefficient in the objective function

SCIPgetVarConflictScore^⚠

returns the variable’s conflict score value

SCIPgetVarConflictScoreCurrentRun^⚠

returns the variable’s conflict score value only using conflicts of the current run

SCIPgetVarConflictlengthScore^⚠

returns the variable’s conflict length score

SCIPgetVarConflictlengthScoreCurrentRun^⚠

returns the variable’s conflict length score only using conflicts of the current run

SCIPgetVarCopy^⚠

returns copy of the source variable; if there already is a copy of the source variable in the variable hash map, it is just returned as target variable; otherwise, if the variables it not marked as relaxation-only, a new variable will be created and added to the target SCIP; this created variable is added to the variable hash map and returned as target variable; relaxation-only variables are not copied and FALSE is returned in *success

SCIPgetVarExprHashmapNonlinear^⚠

returns the hashmap that is internally used to map variables to their corresponding variable expressions

SCIPgetVarExprVar^⚠

gets the variable of a variable expression

SCIPgetVarFarkasCoef^⚠

returns the Farkas coefficient of the variable in the current node’s LP relaxation; the current node has to have an infeasible LP.

SCIPgetVarImplRedcost^⚠

returns the implied reduced costs of the variable in the current node’s LP relaxation; the current node has to have a feasible LP.

SCIPgetVarLbAtIndex^⚠

returns lower bound of variable directly before or after the bound change given by the bound change index was applied

SCIPgetVarLbDive^⚠

gets variable’s lower bound in current dive

SCIPgetVarMultaggrLbGlobal^⚠

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

SCIPgetVarMultaggrLbLocal^⚠

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

SCIPgetVarMultaggrUbGlobal^⚠

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

SCIPgetVarMultaggrUbLocal^⚠

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

SCIPgetVarNStrongbranchs^⚠

gets number of times, strong branching was applied in current run on the given variable

SCIPgetVarObjDive^⚠

gets variable’s objective value in current dive

SCIPgetVarObjProbing^⚠

gets variable’s objective value in current probing

SCIPgetVarPseudocost^⚠

gets the variable’s pseudo cost value for the given direction

SCIPgetVarPseudocostCount^⚠

gets the variable’s (possible fractional) number of pseudo cost updates for the given direction

SCIPgetVarPseudocostCountCurrentRun^⚠

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

SCIPgetVarPseudocostCurrentRun^⚠

gets the variable’s pseudo cost value for the given direction, only using the pseudo cost information of the current run

SCIPgetVarPseudocostScore^⚠

gets the variable’s pseudo cost score value for the given LP solution value

SCIPgetVarPseudocostScoreCurrentRun^⚠

gets the variable’s pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run

SCIPgetVarPseudocostVal^⚠

gets the variable’s pseudo cost value for the given change of the variable’s LP value

SCIPgetVarPseudocostValCurrentRun^⚠

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

SCIPgetVarPseudocostVariance^⚠

get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run

SCIPgetVarRedcost^⚠

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

SCIPgetVarSol^⚠

gets solution value for variable in current node

SCIPgetVarSols^⚠

gets solution values of multiple variables in current node

SCIPgetVarStrongbranchFrac^⚠

gets strong branching information on column variable with fractional value

SCIPgetVarStrongbranchInt^⚠

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)

SCIPgetVarStrongbranchLPAge^⚠

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

SCIPgetVarStrongbranchLast^⚠

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

SCIPgetVarStrongbranchNode^⚠

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

SCIPgetVarStrongbranchWithPropagation^⚠

gets strong branching information with previous domain propagation on column variable

SCIPgetVarUbAtIndex^⚠

returns upper bound of variable directly before or after the bound change given by the bound change index was applied

SCIPgetVarUbDive^⚠

gets variable’s upper bound in current dive

SCIPgetVarVSIDS^⚠

returns the variable’s VSIDS value

SCIPgetVarVSIDSCurrentRun^⚠

returns the variable’s VSIDS value only using conflicts of the current run

SCIPgetVarVarbound^⚠

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

SCIPgetVarWasFixedAtIndex^⚠

returns whether the binary variable was fixed at the time given by the bound change index

SCIPgetVars^⚠

gets array with active problem variables

SCIPgetVarsAnd^⚠

gets array of variables in and constraint

SCIPgetVarsBounddisjunction^⚠

gets array of variables in bound disjunction constraint

SCIPgetVarsCardinality^⚠

gets array of variables in cardinality constraint

SCIPgetVarsCumulative^⚠

returns the start time variables of the cumulative constraint

SCIPgetVarsData^⚠

gets variables of the problem along with the numbers of different variable types; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()

SCIPgetVarsKnapsack^⚠

gets the array of variables in the knapsack constraint; the user must not modify this array!

SCIPgetVarsLinear^⚠

gets the array of variables in the linear constraint; the user must not modify this array!

SCIPgetVarsLogicor^⚠

gets array of variables in logic or constraint

SCIPgetVarsOr^⚠

gets array of variables in or constraint

SCIPgetVarsSOS1^⚠

gets array of variables in SOS1 constraint

SCIPgetVarsSOS2^⚠

gets array of variables in SOS2 constraint

SCIPgetVarsSetppc^⚠

gets array of variables in set partitioning / packing / covering constraint

SCIPgetVarsStrongbranchesFrac^⚠

gets strong branching information on column variables with fractional values

SCIPgetVarsStrongbranchesInt^⚠

gets strong branching information on column variables with integral values

SCIPgetVarsXor^⚠

gets array of variables in xor constraint

SCIPgetVbdcoefVarbound^⚠

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

SCIPgetVbdvarVarbound^⚠

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

SCIPgetVectorEfficacyNorm^⚠

calculates the efficacy norm of the given vector, which depends on the “separating/efficacynorm” parameter

SCIPgetVerbLevel^⚠

returns the current message verbosity level

SCIPgetWeightsCardinality^⚠

gets array of weights in cardinality constraint (or NULL if not existent)

SCIPgetWeightsEpsgreedy^⚠

get weights array of epsilon greedy bandit algorithm

SCIPgetWeightsKnapsack^⚠

gets the array of weights in the knapsack constraint; the user must not modify this array!

SCIPgetWeightsSOS1^⚠

gets array of weights in SOS1 constraint (or NULL if not existent)

SCIPgetWeightsSOS2^⚠

gets array of weights in SOS2 constraint (or NULL if not existent)

SCIPgmlWriteArc^⚠

writes an arc section to the given graph file

SCIPgmlWriteClosing^⚠

writes the ending lines to a GML graph file, does not close a file

SCIPgmlWriteEdge^⚠

writes an edge section to the given graph file

SCIPgmlWriteNode^⚠

writes a node section to the given graph file

SCIPgmlWriteNodeWeight^⚠

writes a node section including weight to the given graph file

SCIPgmlWriteOpening^⚠

writes the starting line to a GML graph file, does not open a file

SCIPhasConsOnlyLinkVars^⚠

returns TRUE if the constraint \p cons contains only linking variables in decomposition \p decomp

SCIPhasCurrentNodeLP^⚠

returns, whether the LP was or is to be solved in the current node

SCIPhasExprCurvature^⚠

checks whether a given expression is convex or concave w.r.t. the original variables

SCIPhasNLPContinuousNonlinearity^⚠

checks whether the NLP has a continuous variable in a nonlinear term

SCIPhasNLPSolution^⚠

indicates whether a solution for the current NLP is available

SCIPhasPerformedPresolve^⚠

returns whether SCIP has performed presolving during the last solve

SCIPhasPrimalRay^⚠

return whether a primal ray is stored that proves unboundedness of the LP relaxation

SCIPhashExpr^⚠

compute the hash value of an expression

SCIPhashGetKeyStandard^⚠

gets the element as the key

SCIPhashKeyEqPtr^⚠

returns TRUE iff both keys(pointer) are equal

SCIPhashKeyEqString^⚠

standard hash key comparator for string keys

SCIPhashKeyValPtr^⚠

returns the hash value of the key

SCIPhashKeyValString^⚠

standard hashing function for string keys

SCIPhashmapCreate^⚠

creates a hash map mapping pointers to pointers

SCIPhashmapEntryGetImage^⚠

gives the image of the hashmap entry

SCIPhashmapEntryGetImageInt^⚠

gives the image of the hashmap entry

SCIPhashmapEntryGetImageReal^⚠

gives the image of the hashmap entry

SCIPhashmapEntryGetOrigin^⚠

gives the origin of the hashmap entry

SCIPhashmapEntrySetImage^⚠

sets pointer image of a hashmap entry

SCIPhashmapEntrySetImageInt^⚠

sets integer image of a hashmap entry

SCIPhashmapEntrySetImageReal^⚠

sets real image of a hashmap entry

SCIPhashmapExists^⚠

checks whether an image to the given origin exists in the hash map

SCIPhashmapFree^⚠

frees the hash map

SCIPhashmapGetEntry^⚠

gives the hashmap entry at the given index or NULL if entry has no element

SCIPhashmapGetImage^⚠

retrieves image of given origin from the hash map, or NULL if no image exists

SCIPhashmapGetImageInt^⚠

retrieves image of given origin from the hash map, or INT_MAX if no image exists

SCIPhashmapGetImageReal^⚠

retrieves image of given origin from the hash map, or SCIP_INVALID if no image exists

SCIPhashmapGetNElements^⚠

gives the number of elements in a hash map

SCIPhashmapGetNEntries^⚠

gives the number of entries in the internal arrays of a hash map

SCIPhashmapInsert^⚠

inserts new origin->image pair in hash map (must not be called for already existing origins!)

SCIPhashmapInsertInt^⚠

inserts new origin->image pair in hash map (must not be called for already existing origins!)

SCIPhashmapInsertReal^⚠

inserts new origin->image pair in hash map (must not be called for already existing origins!)

SCIPhashmapIsEmpty^⚠

indicates whether a hash map has no entries

SCIPhashmapPrintStatistics^⚠

prints statistics about hash map usage

SCIPhashmapRemove^⚠

removes origin->image pair from the hash map, if it exists

SCIPhashmapRemoveAll^⚠

removes all entries in a hash map.

SCIPhashmapSetImage^⚠

sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair

SCIPhashmapSetImageInt^⚠

sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair

SCIPhashmapSetImageReal^⚠

sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a new origin->image pair

SCIPhashsetCreate^⚠

creates a hash set of pointers

SCIPhashsetExists^⚠

checks whether an element exists in the hash set

SCIPhashsetFree^⚠

frees the hash set

SCIPhashsetGetNElements^⚠

gives the number of elements in a hash set

SCIPhashsetGetNSlots^⚠

gives the number of slots of a hash set

SCIPhashsetGetSlots^⚠

gives the array of hash set slots; contains all elements in indetermined order and may contain NULL values

SCIPhashsetInsert^⚠

inserts new element into the hash set

SCIPhashsetIsEmpty^⚠

indicates whether a hash set has no entries

SCIPhashsetPrintStatistics^⚠

prints statistics about hash set usage

SCIPhashsetRemove^⚠

removes an element from the hash set, if it exists

SCIPhashsetRemoveAll^⚠

removes all entries in a hash set.

SCIPhashtableClear^⚠

removes all elements of the hash table

SCIPhashtableCreate^⚠

creates a hash table

SCIPhashtableExists^⚠

returns whether the given element exists in the table

SCIPhashtableFree^⚠

frees the hash table

SCIPhashtableGetEntry^⚠

gives the element at the given index or NULL if entry at that index has no element

SCIPhashtableGetLoad^⚠

returns the load of the given hash table in percentage

SCIPhashtableGetNElements^⚠

returns number of hash table elements

SCIPhashtableGetNEntries^⚠

gives the number of entries in the internal arrays of a hash table

SCIPhashtableInsert^⚠

inserts element in hash table (multiple inserts of same element override the previous entry)

SCIPhashtablePrintStatistics^⚠

prints statistics about hash table usage

SCIPhashtableRemove^⚠

removes element from the hash table, if it exists

SCIPhashtableRemoveAll^⚠

removes all elements of the hash table

SCIPhashtableRetrieve^⚠

retrieve element with key from hash table, returns NULL if not existing

SCIPhashtableSafeInsert^⚠

inserts element in hash table (multiple insertion of same element is checked and results in an error)

SCIPhaveVarsCommonClique^⚠

returns whether there is a clique that contains both given variable/value pairs; the variables must be active binary variables; if regardimplics is FALSE, only the cliques in the clique table are looked at; if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded

SCIPheurComp^⚠

compares two heuristics w.r.t. to their delay positions and priorities

SCIPheurCompName^⚠

comparison method for sorting heuristics w.r.t. to their name

SCIPheurCompPriority^⚠

compares two heuristics w.r.t. to their priority values

SCIPheurGetData^⚠

gets user data of primal heuristic

SCIPheurGetDesc^⚠

gets description of primal heuristic

SCIPheurGetDispchar^⚠

gets display character of primal heuristic

SCIPheurGetDivesets^⚠

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

SCIPheurGetFreq^⚠

gets frequency of primal heuristic

SCIPheurGetFreqofs^⚠

gets frequency offset of primal heuristic

SCIPheurGetMaxdepth^⚠

gets maximal depth level for calling primal heuristic (returns -1, if no depth limit exists)

SCIPheurGetNBestSolsFound^⚠

gets the number of new best primal feasible solutions found by this heuristic

SCIPheurGetNCalls^⚠

gets the number of times, the heuristic was called and tried to find a solution

SCIPheurGetNDivesets^⚠

returns the number of divesets of this primal heuristic

SCIPheurGetNSolsFound^⚠

gets the number of primal feasible solutions found by this heuristic

SCIPheurGetName^⚠

gets name of primal heuristic

SCIPheurGetPriority^⚠

gets priority of primal heuristic

SCIPheurGetSetupTime^⚠

gets time in seconds used in this heuristic for setting up for next stages

SCIPheurGetTime^⚠

gets time in seconds used in this heuristic

SCIPheurGetTimingmask^⚠

returns the timing mask of the heuristic

SCIPheurIsInitialized^⚠

is primal heuristic initialized?

SCIPheurPassIndicator^⚠

pass partial solution for indicator variables to heuristic

SCIPheurPassSolAddSol^⚠

pass solution to trysol heuristic which just gets added (without checking feasibility

SCIPheurPassSolTrySol^⚠

pass solution to trysol heuristic

SCIPheurSetData^⚠

sets user data of primal heuristic; user has to free old data in advance!

SCIPheurSetFreq^⚠

sets frequency of primal heuristic

SCIPheurSetTimingmask^⚠

sets new timing mask for heuristic

SCIPheurUsesSubscip^⚠

does the heuristic use a secondary SCIP instance?

SCIPhistoryGetAvgConflictlength^⚠

gets the average conflict length of the history entry

SCIPhistoryGetCutoffSum^⚠

get number of cutoffs counter

SCIPhistoryGetInferenceSum^⚠

get number of inferences counter

SCIPhistoryGetVSIDS^⚠

gets the conflict score of the history entry

SCIPholelistGetLeft^⚠

returns left bound of open interval in hole

SCIPholelistGetNext^⚠

returns next hole in list or NULL

SCIPholelistGetRight^⚠

returns right bound of open interval in hole

SCIPinDive^⚠

returns whether we are in diving mode

SCIPinProbing^⚠

returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped via SCIPendProbing()

SCIPinRepropagation^⚠

returns whether the current node is already solved and only propagated again

SCIPincConsAge^⚠

increases age of constraint by 1.0; should be called

SCIPincIntarrayVal^⚠

increases value of entry in dynamic array

SCIPincRealarrayVal^⚠

increases value of entry in dynamic array

SCIPincSolVal^⚠

increases value of variable in primal CIP solution

SCIPincludeBanditvtable^⚠

includes a bandit algorithm virtual function table

SCIPincludeBenders^⚠

creates a Benders’ decomposition and includes it in SCIP

SCIPincludeBendersBasic^⚠

creates a Benders’ decomposition and includes it in SCIP with all non-fundamental callbacks set to NULL

SCIPincludeBendersDefault^⚠

creates the default Benders’ decomposition and includes it in SCIP

SCIPincludeBenderscut^⚠

creates a Benders’ cut algorithms and includes it in the associated Benders’ decomposition

SCIPincludeBenderscutBasic^⚠

creates a Benders’ cut and includes it an associated Benders’ decomposition with all non-fundamental callbacks set to NULL

SCIPincludeBranchrule^⚠

creates a branching rule and includes it in SCIP

SCIPincludeBranchruleAllfullstrong^⚠

creates the all variables full strong LP branching rule and includes it in SCIP

SCIPincludeBranchruleBasic^⚠

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().

SCIPincludeBranchruleCloud^⚠

creates the cloud branching rule and includes it in SCIP

SCIPincludeBranchruleDistribution^⚠

creates the distribution branching rule and includes it in SCIP

SCIPincludeBranchruleFullstrong^⚠

creates the full strong LP branching rule and includes it in SCIP

SCIPincludeBranchruleInference^⚠

creates the inference history branching rule and includes it in SCIP

SCIPincludeBranchruleLeastinf^⚠

creates the least infeasible LP branching rule and includes it in SCIP

SCIPincludeBranchruleLookahead^⚠

creates the lookahead branching rule and includes it in SCIP

SCIPincludeBranchruleMostinf^⚠

creates the most infeasible LP branching rule and includes it in SCIP

SCIPincludeBranchruleMultAggr^⚠

creates the multi-aggregated branching rule and includes it in SCIP

SCIPincludeBranchruleNodereopt^⚠

creates the nodereopt branching rule and includes it in SCIP

SCIPincludeBranchrulePscost^⚠

creates the pseudo cost branching rule and includes it in SCIP

SCIPincludeBranchruleRandom^⚠

creates the random branching rule and includes it in SCIP

SCIPincludeBranchruleRelpscost^⚠

creates the reliable pseudo cost branching rule and includes it in SCIP

SCIPincludeBranchruleVanillafullstrong^⚠

creates the vanilla full strong branching rule and includes it in SCIP

SCIPincludeCompr^⚠

@addtogroup PublicCompressionMethods

SCIPincludeComprBasic^⚠

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()

SCIPincludeComprLargestrepr^⚠

creates the largestrepr tree compression and includes it in SCIP

SCIPincludeComprWeakcompr^⚠

creates the weakcompr tree compression and includes it in SCIP

SCIPincludeConcsolverType^⚠

creates a concurrent solver type and includes it in SCIP.

SCIPincludeConcurrentScipSolvers^⚠

creates the concurrent SCIP solver plugins and includes them in SCIP

SCIPincludeConflicthdlr^⚠

creates a conflict handler and includes it in SCIP

SCIPincludeConflicthdlrBasic^⚠

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()

SCIPincludeConsUpgradeNonlinear^⚠

includes a nonlinear constraint upgrade method into the nonlinear constraint handler

SCIPincludeConshdlr^⚠

creates a constraint handler and includes it in SCIP.

SCIPincludeConshdlrAnd^⚠

creates the handler for and constraints and includes it in SCIP

SCIPincludeConshdlrBasic^⚠

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().

SCIPincludeConshdlrBenders^⚠

creates the handler for Benders’ decomposition and includes it in SCIP

SCIPincludeConshdlrBenderslp^⚠

creates the handler for benderslp constraints and includes it in SCIP

SCIPincludeConshdlrBounddisjunction^⚠

creates the handler for bound disjunction constraints and includes it in SCIP

SCIPincludeConshdlrCardinality^⚠

creates the handler for cardinality constraints and includes it in SCIP

SCIPincludeConshdlrComponents^⚠

creates the components constraint handler and includes it in SCIP

SCIPincludeConshdlrConjunction^⚠

creates the handler for conjunction constraints and includes it in SCIP

SCIPincludeConshdlrCountsols^⚠

creates the handler for countsol constraints and includes it in SCIP

SCIPincludeConshdlrCumulative^⚠

creates the constraint handler for cumulative constraints and includes it in SCIP

SCIPincludeConshdlrDisjunction^⚠

creates the handler for disjunction constraints and includes it in SCIP

SCIPincludeConshdlrIndicator^⚠

creates the handler for indicator constraints and includes it in SCIP

SCIPincludeConshdlrIntegral^⚠

creates the handler for the integrality constraint and includes it in SCIP

SCIPincludeConshdlrKnapsack^⚠

creates the handler for knapsack constraints and includes it in SCIP

SCIPincludeConshdlrLinear^⚠

creates the handler for linear constraints and includes it in SCIP

SCIPincludeConshdlrLinking^⚠

creates the handler for linking constraints and includes it in SCIP

SCIPincludeConshdlrLogicor^⚠

creates the handler for logic or constraints and includes it in SCIP

SCIPincludeConshdlrNonlinear^⚠

creates the handler for nonlinear constraints and includes it in SCIP

SCIPincludeConshdlrOr^⚠

creates the handler for or constraints and includes it in SCIP

SCIPincludeConshdlrOrbisack^⚠

creates the handler for orbisack constraints and includes it in SCIP

SCIPincludeConshdlrOrbitope^⚠

creates the handler for orbitope constraints and includes it in SCIP

SCIPincludeConshdlrPseudoboolean^⚠

creates the handler for pseudoboolean constraints and includes it in SCIP

SCIPincludeConshdlrSOS1^⚠

creates the handler for SOS1 constraints and includes it in SCIP

SCIPincludeConshdlrSOS2^⚠

creates the handler for SOS2 constraints and includes it in SCIP

SCIPincludeConshdlrSetppc^⚠

creates the handler for set partitioning / packing / covering constraints and includes it in SCIP

SCIPincludeConshdlrSuperindicator^⚠

creates the handler for superindicator constraints and includes it in SCIP

SCIPincludeConshdlrSymresack^⚠

creates the handler for symresack constraints and includes it in SCIP

SCIPincludeConshdlrVarbound^⚠

creates the handler for variable bound constraints and includes it in SCIP

SCIPincludeConshdlrXor^⚠

creates the handler for xor constraints and includes it in SCIP

SCIPincludeCutsel^⚠

creates a cut selector and includes it in SCIP

SCIPincludeCutselBasic^⚠

Creates a cut selector and includes it in SCIP with its most fundamental callbacks.

SCIPincludeCutselHybrid^⚠

creates the hybrid separator and includes it in SCIP

SCIPincludeDefaultPlugins^⚠

includes default SCIP plugins into SCIP

SCIPincludeDialog^⚠

creates and includes dialog

SCIPincludeDialogDefaultBasic^⚠

includes or updates the default dialog menus in SCIP except for menus “fix” and “set”

SCIPincludeDialogDefaultFix^⚠

includes or updates the “fix” menu for each available parameter setting

SCIPincludeDialogDefaultSet^⚠

includes or updates the “set” menu for each available parameter setting

SCIPincludeDisp^⚠

creates a display column and includes it in SCIP

SCIPincludeDispDefault^⚠

includes the default display columns in SCIP

SCIPincludeEventHdlrEstim^⚠

creates event handler for tree size estimation

SCIPincludeEventHdlrSofttimelimit^⚠

includes event handler for soft time limit

SCIPincludeEventHdlrSolvingphase^⚠

creates event handler for solving phase event

SCIPincludeEventhdlr^⚠

creates an event handler and includes it in SCIP

SCIPincludeEventhdlrBasic^⚠

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()

SCIPincludeExprhdlr^⚠

creates the handler for an expression handler and includes it into SCIP

SCIPincludeExprhdlrAbs^⚠

creates the handler for absolute expression and includes it into SCIP

SCIPincludeExprhdlrCos^⚠

creates the handler for cos expressions and includes it into SCIP

SCIPincludeExprhdlrEntropy^⚠

creates the handler for entropy expressions and includes it into SCIP

SCIPincludeExprhdlrExp^⚠

creates the handler for exponential expressions and includes it into SCIP

SCIPincludeExprhdlrLog^⚠

creates the handler for logarithmic expression and includes it into SCIP

SCIPincludeExprhdlrPow^⚠

creates the handler for power expression and includes it into SCIP

SCIPincludeExprhdlrProduct^⚠

creates the handler for product expressions and includes it into SCIP

SCIPincludeExprhdlrSignpower^⚠

creates the handler for signed power expression and includes it into SCIP

SCIPincludeExprhdlrSin^⚠

creates the handler for sin expressions and includes it into SCIP

SCIPincludeExprhdlrSum^⚠

creates the handler for sum expressions and includes it into SCIP

SCIPincludeExprhdlrValue^⚠

creates the handler for constant value expression and includes it into SCIP

SCIPincludeExprhdlrVar^⚠

creates the handler for variable expression and includes it into SCIP

SCIPincludeExprhdlrVaridx^⚠

creates the handler for variable index expressions and includes it into SCIP

SCIPincludeExternalCodeInformation^⚠

includes information about an external code linked into the SCIP library

SCIPincludeHeur^⚠

creates a primal heuristic and includes it in SCIP.

SCIPincludeHeurActconsdiving^⚠

creates the actconsdiving heuristic and includes it in SCIP

SCIPincludeHeurAdaptivediving^⚠

creates the adaptivediving heuristic and includes it in SCIP

SCIPincludeHeurAlns^⚠

creates the alns primal heuristic and includes it in SCIP

SCIPincludeHeurBasic^⚠

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()

SCIPincludeHeurBound^⚠

creates the bound primal heuristic and includes it in SCIP

SCIPincludeHeurClique^⚠

creates the clique primal heuristic and includes it in SCIP

SCIPincludeHeurCoefdiving^⚠

creates the coefdiving heuristic and includes it in SCIP

SCIPincludeHeurCompletesol^⚠

creates the completesol primal heuristic and includes it in SCIP

SCIPincludeHeurConflictdiving^⚠

creates the conflictdiving heuristic and includes it in SCIP

SCIPincludeHeurCrossover^⚠

creates the crossover primal heuristic and includes it in SCIP

SCIPincludeHeurDins^⚠

creates the DINS primal heuristic and includes it in SCIP

SCIPincludeHeurDistributiondiving^⚠

creates the distributiondiving heuristic and includes it in SCIP

SCIPincludeHeurDps^⚠

creates the dps primal heuristic and includes it in SCIP

SCIPincludeHeurDualval^⚠

creates the dualVal primal heuristic and includes it in SCIP

SCIPincludeHeurFarkasdiving^⚠

creates the farkasdiving heuristic and includes it in SCIP

SCIPincludeHeurFeaspump^⚠

creates the feaspump primal heuristic and includes it in SCIP

SCIPincludeHeurFixandinfer^⚠

creates the fix-and-infer primal heuristic and includes it in SCIP

SCIPincludeHeurFracdiving^⚠

creates the fracdiving heuristic and includes it in SCIP

SCIPincludeHeurGins^⚠

creates the gins primal heuristic and includes it in SCIP

SCIPincludeHeurGuideddiving^⚠

creates the guideddiving heuristic and includes it in SCIP

SCIPincludeHeurIndicator^⚠

creates the indicator primal heuristic and includes it in SCIP

SCIPincludeHeurIntdiving^⚠

creates the intdiving heuristic and includes it in SCIP

SCIPincludeHeurIntshifting^⚠

creates the intshifting heuristic and includes it in SCIP

SCIPincludeHeurLinesearchdiving^⚠

creates the linesearchdiving primal heuristic and includes it in SCIP

SCIPincludeHeurLocalbranching^⚠

creates local branching primal heuristic and includes it in SCIP

SCIPincludeHeurLocks^⚠

creates the locks primal heuristic and includes it in SCIP

SCIPincludeHeurLpface^⚠

creates the lpface primal heuristic and includes it in SCIP

SCIPincludeHeurMpec^⚠

creates the mpec primal heuristic and includes it in SCIP

SCIPincludeHeurMultistart^⚠

creates the multistart primal heuristic and includes it in SCIP

SCIPincludeHeurMutation^⚠

creates the mutation primal heuristic and includes it in SCIP

SCIPincludeHeurNlpdiving^⚠

creates the fracdiving heuristic and includes it in SCIP

SCIPincludeHeurObjpscostdiving^⚠

creates the objpscostdiving heuristic and includes it in SCIP

SCIPincludeHeurOctane^⚠

creates the octane primal heuristic and includes it in SCIP

SCIPincludeHeurOfins^⚠

creates the ofins primal heuristic and includes it in SCIP

SCIPincludeHeurOneopt^⚠

creates the oneopt primal heuristic and includes it in SCIP

SCIPincludeHeurPADM^⚠

creates the PADM primal heuristic and includes it in SCIP

SCIPincludeHeurProximity^⚠

creates the proximity primal heuristic and includes it in SCIP

SCIPincludeHeurPscostdiving^⚠

creates the pscostdiving heuristic and includes it in SCIP

SCIPincludeHeurRandrounding^⚠

creates the rand rounding heuristic and includes it in SCIP

SCIPincludeHeurRens^⚠

creates RENS primal heuristic and includes it in SCIP

SCIPincludeHeurReoptsols^⚠

creates the reoptsols primal heuristic and includes it in SCIP

SCIPincludeHeurRepair^⚠

creates the repair primal heuristic and includes it in SCIP

SCIPincludeHeurRins^⚠

creates RINS primal heuristic and includes it in SCIP

SCIPincludeHeurRootsoldiving^⚠

creates the rootsoldiving heuristic and includes it in SCIP

SCIPincludeHeurRounding^⚠

creates the rounding heuristic with infeasibility recovering and includes it in SCIP

SCIPincludeHeurShiftandpropagate^⚠

creates the shiftandpropagate primal heuristic and includes it in SCIP

SCIPincludeHeurShifting^⚠

creates the shifting heuristic and includes it in SCIP

SCIPincludeHeurSimplerounding^⚠

creates the simple rounding heuristic and includes it in SCIP

SCIPincludeHeurSubNlp^⚠

creates the NLP local search primal heuristic and includes it in SCIP

SCIPincludeHeurTrivial^⚠

creates the trivial primal heuristic and includes it in SCIP

SCIPincludeHeurTrivialnegation^⚠

creates the trivialnegation primal heuristic and includes it in SCIP

SCIPincludeHeurTrustregion^⚠

creates local branching primal heuristic and includes it in SCIP

SCIPincludeHeurTrySol^⚠

creates the trysol primal heuristic and includes it in SCIP

SCIPincludeHeurTwoopt^⚠

creates the twoopt primal heuristic and includes it in SCIP

SCIPincludeHeurUndercover^⚠

creates the undercover primal heuristic and includes it in SCIP

SCIPincludeHeurVbounds^⚠

creates the variable bounds primal heuristic and includes it in SCIP

SCIPincludeHeurVeclendiving^⚠

creates the veclendiving heuristic and includes it in SCIP

SCIPincludeHeurZeroobj^⚠

creates the zeroobj primal heuristic and includes it in SCIP

SCIPincludeHeurZirounding^⚠

creates the zirounding primal heuristic and includes it in SCIP

SCIPincludeLinconsUpgrade^⚠

includes a linear constraint update method into the linear constraint handler

SCIPincludeNlhdlrBilinear^⚠

includes bilinear nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrConcave^⚠

includes concave nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrConvex^⚠

includes convex nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrDefault^⚠

includes default nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrNonlinear^⚠

creates a nonlinear handler and includes it into the nonlinear constraint handler

SCIPincludeNlhdlrPerspective^⚠

includes perspective nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrQuadratic^⚠

includes quadratic nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrQuotient^⚠

includes quotient nonlinear handler in nonlinear constraint handler

SCIPincludeNlhdlrSoc^⚠

includes SOC nonlinear handler in nonlinear constraint handler

SCIPincludeNlpSolverAll^⚠

create solver interface for the solver “All” and includes it into SCIP, if at least 2 NLPIs have already been included

SCIPincludeNlpSolverFilterSQP^⚠

create solver interface for filterSQP solver and include it into SCIP, if filterSQP is available

SCIPincludeNlpSolverIpopt^⚠

create solver interface for Ipopt solver and includes it into SCIP, if Ipopt is available

SCIPincludeNlpSolverWorhp^⚠

create solver interface for Worhp solver and includes it into SCIP, if Worhp is available

SCIPincludeNlpi^⚠

creates an NLPI and includes it into SCIP

SCIPincludeNodesel^⚠

creates a node selector and includes it in SCIP.

SCIPincludeNodeselBasic^⚠

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()

SCIPincludeNodeselBfs^⚠

creates the node selector for best first search and includes it in SCIP

SCIPincludeNodeselBreadthfirst^⚠

creates the node selector for breadth first search and includes it in SCIP

SCIPincludeNodeselDfs^⚠

creates the node selector for depth first search and includes it in SCIP

SCIPincludeNodeselEstimate^⚠

creates the node selector for best estimate search and includes it in SCIP

SCIPincludeNodeselHybridestim^⚠

creates the node selector for hybrid best estim / best bound search and includes it in SCIP

SCIPincludeNodeselRestartdfs^⚠

creates the node selector for restarting depth first search and includes it in SCIP

SCIPincludeNodeselUct^⚠

creates the uct node selector and includes it in SCIP

SCIPincludePresol^⚠

creates a presolver and includes it in SCIP

SCIPincludePresolBasic^⚠

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().

SCIPincludePresolBoundshift^⚠

creates the boundshift presolver and includes it in SCIP

SCIPincludePresolConvertinttobin^⚠

creates the convertinttobin presolver and includes it in SCIP

SCIPincludePresolDomcol^⚠

creates the dominated column presolver and includes it in SCIP

SCIPincludePresolDualagg^⚠

creates the dualagg presolver and includes it in SCIP

SCIPincludePresolDualcomp^⚠

creates the dualcomp presolver and includes it in SCIP

SCIPincludePresolDualinfer^⚠

creates the dual inference presolver and includes it in SCIP

SCIPincludePresolDualsparsify^⚠

creates the dual sparsify presolver and includes it in SCIP

SCIPincludePresolGateextraction^⚠

creates the gateextraction presolver and includes it in SCIP

SCIPincludePresolImplics^⚠

creates the implics presolver and includes it in SCIP

SCIPincludePresolInttobinary^⚠

creates the inttobinary presolver and includes it in SCIP

SCIPincludePresolMILP^⚠

creates the MILP presolver and includes it in SCIP if the presolve library is available

SCIPincludePresolQPKKTref^⚠

creates the QP KKT reformulation presolver and includes it in SCIP

SCIPincludePresolRedvub^⚠

creates the redvub presolver and includes it in SCIP

SCIPincludePresolSparsify^⚠

creates the sparsify presolver and includes it in SCIP

SCIPincludePresolStuffing^⚠

creates the stuffing presolver and includes it in SCIP

SCIPincludePresolTrivial^⚠

creates the trivial presolver and includes it in SCIP

SCIPincludePresolTworowbnd^⚠

creates the tworowbnd presolver and includes it in SCIP

SCIPincludePricer^⚠

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.

SCIPincludePricerBasic^⚠

creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL; if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(), SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(), SCIPsetPricerFarkas();

SCIPincludeProp^⚠

creates a propagator and includes it in SCIP.

SCIPincludePropBasic^⚠

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().

SCIPincludePropDualfix^⚠

creates the dual fixing propagator and includes it in SCIP

SCIPincludePropGenvbounds^⚠

creates the genvbounds propagator and includes it in SCIP

SCIPincludePropNlobbt^⚠

creates the nlobbt propagator and includes it in SCIP

SCIPincludePropObbt^⚠

creates the obbt propagator and includes it in SCIP

SCIPincludePropProbing^⚠

creates the probing propagator and includes it in SCIP

SCIPincludePropPseudoobj^⚠

creates the pseudo objective function propagator and includes it in SCIP

SCIPincludePropRedcost^⚠

creates the redcost propagator and includes it in SCIP

SCIPincludePropRootredcost^⚠

creates the root node reduced cost strengthening propagator and includes it in SCIP

SCIPincludePropSymmetry^⚠

include symmetry propagator

SCIPincludePropVbounds^⚠

creates the vbounds propagator and includes it in SCIP

SCIPincludeReader^⚠

creates a reader and includes it in SCIP

SCIPincludeReaderBasic^⚠

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().

SCIPincludeReaderBnd^⚠

includes the bnd file reader into SCIP

SCIPincludeReaderCcg^⚠

includes the ccg file reader into SCIP

SCIPincludeReaderCip^⚠

includes the cip file reader into SCIP

SCIPincludeReaderCnf^⚠

includes the cnf file reader into SCIP

SCIPincludeReaderCor^⚠

includes the cor file reader into SCIP

SCIPincludeReaderDec^⚠

includes the decomposition file reader into SCIP

SCIPincludeReaderDiff^⚠

includes the diff file reader into SCIP

SCIPincludeReaderFix^⚠

includes the fix file reader into SCIP

SCIPincludeReaderFzn^⚠

includes the FlatZinc file reader into SCIP

SCIPincludeReaderGms^⚠

includes the gms file reader into SCIP

SCIPincludeReaderLp^⚠

includes the lp file reader into SCIP

SCIPincludeReaderMps^⚠

includes the mps file reader into SCIP

SCIPincludeReaderMst^⚠

includes the mst file reader into SCIP

SCIPincludeReaderNl^⚠

includes the .nl file reader into SCIP

SCIPincludeReaderOpb^⚠

includes the opb file reader into SCIP

SCIPincludeReaderOsil^⚠

includes the osil file reader into SCIP

SCIPincludeReaderPbm^⚠

includes the pbm file reader into SCIP

SCIPincludeReaderPip^⚠

includes the pip file reader into SCIP

SCIPincludeReaderPpm^⚠

includes the ppm file reader into SCIP

SCIPincludeReaderRlp^⚠

includes the rlp file reader into SCIP

SCIPincludeReaderSmps^⚠

includes the smps file reader into SCIP

SCIPincludeReaderSol^⚠

includes the sol file reader into SCIP

SCIPincludeReaderSto^⚠

includes the sto file reader into SCIP

SCIPincludeReaderTim^⚠

includes the tim file reader into SCIP

SCIPincludeReaderWbo^⚠

includes the wbo file reader into SCIP

SCIPincludeReaderZpl^⚠

includes the zpl file reader into SCIP

SCIPincludeRelax^⚠

creates a relaxation handler and includes it in SCIP

SCIPincludeRelaxBasic^⚠

creates a relaxation handler and includes it in SCIP. All non fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(), SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()

SCIPincludeSepa^⚠

creates a separator and includes it in SCIP.

SCIPincludeSepaAggregation^⚠

creates the aggregation separator and includes it in SCIP

SCIPincludeSepaBasic^⚠

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().

SCIPincludeSepaCGMIP^⚠

creates the Chvatal-Gomory-MIP cut separator and includes it in SCIP

SCIPincludeSepaClique^⚠

creates the clique separator and includes it in SCIP

SCIPincludeSepaClosecuts^⚠

creates the closecuts separator and includes it in SCIP

SCIPincludeSepaConvexproj^⚠

creates the convexproj separator and includes it in SCIP

SCIPincludeSepaDisjunctive^⚠

creates the disjunctive cut separator and includes it in SCIP

SCIPincludeSepaEccuts^⚠

creates the edge-concave separator and includes it in SCIP

SCIPincludeSepaGauge^⚠

creates the gauge separator and includes it in SCIP

SCIPincludeSepaGomory^⚠

creates the Gomory MIR cut separator and includes it in SCIP

SCIPincludeSepaImpliedbounds^⚠

creates the impliedbounds separator and includes it in SCIP

SCIPincludeSepaInterminor^⚠

creates the interminor separator and includes it in SCIP

SCIPincludeSepaIntobj^⚠

creates the integer objective value separator and includes it in SCIP

SCIPincludeSepaMcf^⚠

creates the mcf separator and includes it in SCIP

SCIPincludeSepaMinor^⚠

creates the minor separator and includes it in SCIP

SCIPincludeSepaMixing^⚠

creates the mixing separator and includes it in SCIP

SCIPincludeSepaOddcycle^⚠

creates the oddcycle separator and includes it in SCIP

SCIPincludeSepaRapidlearning^⚠

creates the rapidlearning separator and includes it in SCIP

SCIPincludeSepaRlt^⚠

creates the RLT separator and includes it in SCIP

SCIPincludeSepaZerohalf^⚠

creates the {0,1/2}-cut separator and includes it in SCIP

SCIPincludeTable^⚠

creates a statistics table and includes it in SCIP

SCIPincludeTableDefault^⚠

creates the default statistics tables and includes them in SCIP

SCIPincrementCurBoundsTagNonlinear^⚠

increments curboundstag and resets lastboundrelax in constraint handler data

SCIPinferBinvarCons^⚠

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

SCIPinferBinvarProp^⚠

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

SCIPinferVarFixCons^⚠

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

SCIPinferVarFixProp^⚠

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

SCIPinferVarLbCons^⚠

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

SCIPinferVarLbProp^⚠

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

SCIPinferVarUbCons^⚠

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

SCIPinferVarUbProp^⚠

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

SCIPinfinity^⚠

returns value treated as infinity

SCIPinfoMessage^⚠

SCIPinitConflictAnalysis^⚠

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();

SCIPinitRepresentation^⚠

initialize a set of empty reoptimization nodes

SCIPinitVarBranchStats^⚠

initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores of a variable to the given values

SCIPinitVarValueBranchStats^⚠

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)

SCIPinitializeRandomSeed^⚠

modifies an initial seed value with the global shift of random seeds

SCIPinitlpCons^⚠

calls LP initialization method for single constraint

SCIPinsertBilinearTermExistingNonlinear^⚠

stores the variables of a bilinear term in the data of the constraint handler

SCIPinsertBilinearTermImplicitNonlinear^⚠

stores the variables of a bilinear term in the data of the constraint handler

SCIPinterruptLP^⚠

interrupts or disables the interrupt of the currently ongoing lp solve; if the lp is not currently constructed just returns with no effect

SCIPinterruptSolve^⚠

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

SCIPintervalAbs^⚠

stores absolute value of operand in resultant

SCIPintervalAdd^⚠

adds operand1 and operand2 and stores result in resultant

SCIPintervalAddInf^⚠

adds operand1 and operand2 and stores infimum of result in infimum of resultant

SCIPintervalAddScalar^⚠

adds operand1 and scalar operand2 and stores result in resultant

SCIPintervalAddSup^⚠

adds operand1 and operand2 and stores supremum of result in supremum of resultant

SCIPintervalAddVectors^⚠

adds vector operand1 and vector operand2 and stores result in vector resultant

SCIPintervalAreDisjoint^⚠

indicates whether operand1 and operand2 are disjoint

SCIPintervalAreDisjointEps^⚠

indicates whether operand1 and operand2 are disjoint with epsilon tolerance

SCIPintervalCos^⚠

stores cosine value of operand in resultant

SCIPintervalDiv^⚠

divides operand1 by operand2 and stores result in resultant

SCIPintervalDivScalar^⚠

divides operand1 by scalar operand2 and stores result in resultant

SCIPintervalEntropy^⚠

stores entropy of operand in resultant

SCIPintervalExp^⚠

stores exponential of operand in resultant @attention we assume a correctly rounded exp(double) function when rounding is to nearest

SCIPintervalGetInf^⚠

returns infimum of interval

SCIPintervalGetRoundingMode^⚠

gets current rounding mode of floating point operations

SCIPintervalGetSup^⚠

returns supremum of interval

SCIPintervalHasRoundingControl^⚠

returns whether rounding mode control is available

SCIPintervalIntersect^⚠

intersection of two intervals

SCIPintervalIntersectEps^⚠

intersection of two intervals with epsilon tolerance

SCIPintervalIsEmpty^⚠

indicates whether interval is empty, i.e., whether inf > sup

SCIPintervalIsEntire^⚠

indicates whether interval is entire, i.e., whether inf ≤ -infinity and sup ≥ infinity

SCIPintervalIsNegativeInfinity^⚠

indicates whether interval is negative infinity, i.e., [-infinity, -infinity]

SCIPintervalIsPositiveInfinity^⚠

indicates whether interval is positive infinity, i.e., [infinity, infinity]

SCIPintervalIsSubsetEQ^⚠

indicates whether operand1 is contained in operand2

SCIPintervalLog^⚠

stores natural logarithm of operand in resultant @attention we assume a correctly rounded log(double) function when rounding is to nearest

SCIPintervalMax^⚠

stores maximum of operands in resultant

SCIPintervalMin^⚠

stores minimum of operands in resultant

SCIPintervalMul^⚠

multiplies operand1 with operand2 and stores result in resultant

SCIPintervalMulInf^⚠

multiplies operand1 with operand2 and stores infimum of result in infimum of resultant

SCIPintervalMulScalar^⚠

multiplies operand1 with scalar operand2 and stores result in resultant

SCIPintervalMulScalarInf^⚠

multiplies operand1 with scalar operand2 and stores infimum of result in infimum of resultant

SCIPintervalMulScalarSup^⚠

multiplies operand1 with scalar operand2 and stores supremum of result in supremum of resultant

SCIPintervalMulSup^⚠

multiplies operand1 with operand2 and stores supremum of result in supremum of resultant

SCIPintervalNegateReal^⚠

negates a number in a way that the compiler does not optimize it away

SCIPintervalPower^⚠

stores operand1 to the power of operand2 in resultant

SCIPintervalPowerScalar^⚠

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

SCIPintervalPowerScalarInteger^⚠

computes bounds on power of a scalar operand1 to an integer operand2

SCIPintervalPowerScalarIntegerInf^⚠

computes lower bound on power of a scalar operand1 to an integer operand2

SCIPintervalPowerScalarIntegerSup^⚠

computes upper bound on power of a scalar operand1 to an integer operand2

SCIPintervalPowerScalarInverse^⚠

given an interval for the image of a power operation, computes an interval for the origin

SCIPintervalPowerScalarScalar^⚠

stores bounds on the power of a scalar operand1 to a scalar operand2 in resultant

SCIPintervalPropagateWeightedSum^⚠

propagates a weighted sum of intervals in a given interval

SCIPintervalQuad^⚠

stores range of quadratic term in resultant

SCIPintervalQuadBivar^⚠

stores range of bivariate quadratic term in resultant

SCIPintervalQuadUpperBound^⚠

computes exact upper bound on \f$ a x^2 + b x \f$ for x in [xlb, xub], b an interval, and a scalar

SCIPintervalReciprocal^⚠

computes the reciprocal of an interval

SCIPintervalScalprod^⚠

computes the scalar product of two vectors of intervals and stores result in resultant

SCIPintervalScalprodScalars^⚠

computes the scalar product of a vector of intervals and a vector of scalars and stores result in resultant

SCIPintervalScalprodScalarsInf^⚠

computes the scalar product of a vector of intervals and a vector of scalars and stores infimum of result in infimum of resultant

SCIPintervalScalprodScalarsSup^⚠

computes the scalar product of a vector of intervals and a vector of scalars and stores supremum of result in supremum of resultant

SCIPintervalSet^⚠

stores given value as interval

SCIPintervalSetBounds^⚠

stores given infimum and supremum as interval

SCIPintervalSetEmpty^⚠

sets interval to empty interval, which will be [1.0, -1.0]

SCIPintervalSetEntire^⚠

sets interval to entire [-infinity, +infinity]

SCIPintervalSetRoundingMode^⚠

sets rounding mode of floating point operations

SCIPintervalSetRoundingModeDownwards^⚠

sets rounding mode of floating point operations to downwards rounding

SCIPintervalSetRoundingModeToNearest^⚠

sets rounding mode of floating point operations to nearest rounding

SCIPintervalSetRoundingModeTowardsZero^⚠

sets rounding mode of floating point operations to towards zero rounding

SCIPintervalSetRoundingModeUpwards^⚠

sets rounding mode of floating point operations to upwards rounding

SCIPintervalSign^⚠

stores sign of operand in resultant

SCIPintervalSignPowerScalar^⚠

stores operand1 to the signed power of the scalar positive operand2 in resultant

SCIPintervalSin^⚠

stores sine value of operand in resultant

SCIPintervalSolveBivariateQuadExpressionAllScalar^⚠

solves a bivariate quadratic equation for the first variable

SCIPintervalSolveUnivariateQuadExpression^⚠

solves a quadratic equation with interval coefficients

SCIPintervalSolveUnivariateQuadExpressionNegative^⚠

computes interval with negative solutions of a quadratic equation with interval coefficients

SCIPintervalSolveUnivariateQuadExpressionPositive^⚠

computes interval with positive solutions of a quadratic equation with interval coefficients

SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar^⚠

computes positive solutions of a quadratic equation with scalar coefficients

SCIPintervalSquare^⚠

squares operand and stores result in resultant

SCIPintervalSquareRoot^⚠

stores (positive part of) square root of operand in resultant @attention we assume a correctly rounded sqrt(double) function when rounding is to nearest

SCIPintervalSub^⚠

subtracts operand2 from operand1 and stores result in resultant

SCIPintervalSubScalar^⚠

subtracts scalar operand2 from operand1 and stores result in resultant

SCIPintervalUnify^⚠

interval enclosure of the union of two intervals

SCIPisAndConsSorted^⚠

return if the variables of the AND-constraint are sorted with respect to their indices

SCIPisBoolParamValid^⚠

checks whether the value of an existing SCIP_Bool parameter is valid

SCIPisCharParamValid^⚠

checks whether parameter value for a given SCIP_Real parameter is valid

SCIPisConflictAnalysisApplicable^⚠

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

SCIPisConflictVarUsed^⚠

checks if the given variable is already part of the current conflict set or queued for resolving with the same or even stronger bound

SCIPisConsCompressionEnabled^⚠

is constraint compression enabled?

SCIPisCutApplicable^⚠

indicates whether a cut is applicable

SCIPisCutEfficacious^⚠

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

SCIPisCutNew^⚠

checks if cut is already existing in global cutpool

SCIPisDivesetAvailable^⚠

check specific preconditions for diving, e.g., if an incumbent solution is available

SCIPisDualSolAvailable^⚠

check whether the dual solution is available

SCIPisDualfeasEQ^⚠

checks, if relative difference of values is in range of dual feasibility tolerance

SCIPisDualfeasFracIntegral^⚠

checks, if given fractional part is smaller than dual feasibility tolerance

SCIPisDualfeasGE^⚠

checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance

SCIPisDualfeasGT^⚠

checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance

SCIPisDualfeasIntegral^⚠

checks, if value is integral within the LP dual feasibility tolerance

SCIPisDualfeasLE^⚠

checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance

SCIPisDualfeasLT^⚠

checks, if relative difference val1 and val2 is lower than dual feasibility tolerance

SCIPisDualfeasNegative^⚠

checks, if value is lower than -dual feasibility tolerance

SCIPisDualfeasPositive^⚠

checks, if value is greater than dual feasibility tolerance

SCIPisDualfeasZero^⚠

checks, if value is in range dual feasibility tolerance of 0.0

SCIPisEQ^⚠

checks, if values are in range of epsilon

SCIPisEfficacious^⚠

checks, if the given cut’s efficacy is larger than the minimal cut efficacy

SCIPisExactSolve^⚠

returns whether the solution process is arithmetically exact, i.e., not subject to roundoff errors

SCIPisExprAbs^⚠

indicates whether expression is of abs-type

SCIPisExprCos^⚠

indicates whether expression is of cosine-type

SCIPisExprEntropy^⚠

indicates whether expression is of entropy-type

SCIPisExprExp^⚠

indicates whether expression is of exp-type

SCIPisExprLog^⚠

indicates whether expression is of log-type

SCIPisExprPower^⚠

returns whether an expression is a power expression

SCIPisExprProduct^⚠

returns whether an expression is a product expression

SCIPisExprSignpower^⚠

indicates whether expression is of signpower-type

SCIPisExprSin^⚠

indicates whether expression is of sine-type

SCIPisExprSum^⚠

returns whether an expression is a sum expression

SCIPisExprValue^⚠

returns whether an expression is a value expression

SCIPisExprVar^⚠

returns whether an expression is a variable expression

SCIPisExprVaridx^⚠

indicates whether expression is varidx expression

SCIPisFeasEQ^⚠

checks, if relative difference of values is in range of feasibility tolerance

SCIPisFeasFracIntegral^⚠

checks, if given fractional part is smaller than feastol

SCIPisFeasGE^⚠

checks, if relative difference of val1 and val2 is not lower than -feastol

SCIPisFeasGT^⚠

checks, if relative difference of val1 and val2 is greater than feastol

SCIPisFeasIntegral^⚠

checks, if value is integral within the LP feasibility bounds

SCIPisFeasLE^⚠

checks, if relative difference of val1 and val2 is not greater than feasibility tolerance

SCIPisFeasLT^⚠

checks, if relative difference val1 and val2 is lower than feasibility tolerance

SCIPisFeasNegative^⚠

checks, if value is lower than -feasibility tolerance

SCIPisFeasPositive^⚠

checks, if value is greater than feasibility tolerance

SCIPisFeasZero^⚠

checks, if value is in range feasibility tolerance of 0.0

SCIPisFilterSQPAvailableFilterSQP^⚠

returns whether filterSQP is available, i.e., whether it has been linked in

SCIPisFracIntegral^⚠

checks, if given fractional part is smaller than epsilon

SCIPisGE^⚠

checks, if val1 is not (more than epsilon) lower than val2

SCIPisGT^⚠

checks, if val1 is (more than epsilon) greater than val2

SCIPisHugeValue^⚠

checks, if value is huge and should be handled separately (e.g., in activity computation)

SCIPisInRestart^⚠

returns whether we are in the restarting phase

SCIPisInfinity^⚠

checks, if value is (positive) infinite

SCIPisIntParamValid^⚠

checks whether the value of an existing int parameter is valid

SCIPisIntegral^⚠

checks, if value is integral within epsilon

SCIPisInvolutionPerm^⚠

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.

SCIPisIpoptAvailableIpopt^⚠

returns whether Ipopt is available, i.e., whether it has been linked in

SCIPisLE^⚠

checks, if val1 is not (more than epsilon) greater than val2

SCIPisLPConstructed^⚠

returns, whether the LP of the current node is already constructed

SCIPisLPDualReliable^⚠

returns whether the current LP solution passed the dual feasibility check

SCIPisLPPrimalReliable^⚠

returns whether the current LP solution passed the primal feasibility check

SCIPisLPRelax^⚠

returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound

SCIPisLPSolBasic^⚠

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

SCIPisLT^⚠

checks, if val1 is (more than epsilon) lower than val2

SCIPisLbBetter^⚠

checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one

SCIPisLongintParamValid^⚠

checks whether parameter value of an existing SCIP_Longint paramter is valid

SCIPisNLPConstructed^⚠

returns, whether an NLP has been constructed

SCIPisNLPEnabled^⚠

returns whether the NLP relaxation has been enabled

SCIPisNegative^⚠

checks, if value is lower than -epsilon

SCIPisObjChangedProbing^⚠

returns whether the objective function has changed during probing mode

SCIPisObjIntegral^⚠

returns whether the objective value is known to be integral in every feasible solution

SCIPisOrbitalfixingEnabled^⚠

return whether orbital fixing is enabled

SCIPisPackingPartitioningOrbitope^⚠

checks whether an orbitope is a packing or partitioning orbitope

SCIPisParamFixed^⚠

gets the fixing status of an existing parameter

SCIPisPositive^⚠

checks, if value is greater than epsilon

SCIPisPresolveFinished^⚠

returns whether the presolving process would be finished given no more presolving reductions are found in this presolving round

SCIPisPrimalboundSol^⚠

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

SCIPisPropagatedVbounds^⚠

returns TRUE if the propagator has the status that all variable lower and upper bounds are propagated

SCIPisRealParamValid^⚠

checks whether parameter value of an existing SCIP_Real paramter is valid

SCIPisRelEQ^⚠

checks, if relative difference of values is in range of epsilon

SCIPisRelGE^⚠

checks, if relative difference of val1 and val2 is not lower than -epsilon

SCIPisRelGT^⚠

checks, if relative difference of val1 and val2 is greater than epsilon

SCIPisRelLE^⚠

checks, if relative difference of val1 and val2 is not greater than epsilon

SCIPisRelLT^⚠

checks, if relative difference of val1 and val2 is lower than epsilon

SCIPisRelaxSolValid^⚠

returns whether the relaxation solution is valid

SCIPisReoptEnabled^⚠

returns whether reoptimization is enabled or not

SCIPisRootLPRelax^⚠

returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound

SCIPisRowprepViolationReliable^⚠

computes violation of rowprep in a given solution and reports whether that value seem numerically reliable

SCIPisSOCNonlinear^⚠

checks whether constraint is SOC representable in original variables and returns the SOC representation

SCIPisScalingIntegral^⚠

checks whether the product val * scalar is integral in epsilon scaled by scalar

SCIPisSolveInterrupted^⚠

indicates whether \SCIP has been informed that the solving process should be interrupted as soon as possible

SCIPisStopped^⚠

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

SCIPisStringParamValid^⚠

checks whether parameter value for a given string parameter is valid

SCIPisStrongbranchDownFirst^⚠

determine which branching direction should be evaluated first by strong branching

SCIPisSumEQ^⚠

checks, if values are in range of sumepsilon

SCIPisSumGE^⚠

checks, if val1 is not (more than sumepsilon) lower than val2

SCIPisSumGT^⚠

checks, if val1 is (more than sumepsilon) greater than val2

SCIPisSumLE^⚠

checks, if val1 is not (more than sumepsilon) greater than val2

SCIPisSumLT^⚠

checks, if val1 is (more than sumepsilon) lower than val2

SCIPisSumNegative^⚠

checks, if value is lower than -sumepsilon

SCIPisSumPositive^⚠

checks, if value is greater than sumepsilon

SCIPisSumRelEQ^⚠

checks, if relative difference of values is in range of sumepsilon

SCIPisSumRelGE^⚠

checks, if relative difference of val1 and val2 is not lower than -sumepsilon

SCIPisSumRelGT^⚠

checks, if relative difference of val1 and val2 is greater than sumepsilon

SCIPisSumRelLE^⚠

checks, if relative difference of val1 and val2 is not greater than sumepsilon

SCIPisSumRelLT^⚠

checks, if relative difference of val1 and val2 is lower than sumepsilon

SCIPisSumZero^⚠

checks, if value is in range sumepsilon of 0.0

SCIPisTransformed^⚠

returns whether the current stage belongs to the transformed problem space

SCIPisUbBetter^⚠

checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one

SCIPisUpdateUnreliable^⚠

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.

SCIPisVarPscostRelerrorReliable^⚠

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

SCIPisViolatedIndicator^⚠

checks whether indicator constraint is violated w.r.t. sol

SCIPisWorhpAvailableWorhp^⚠

returns whether Worhp is available, i.e., whether it has been linked in

SCIPisZero^⚠

checks, if value is in range epsilon of 0.0

SCIPlinConsStatsCreate^⚠

create linear constraint statistics

SCIPlinConsStatsFree^⚠

free linear constraint statistics

SCIPlinConsStatsGetSum^⚠

returns the total number of classified constraints

SCIPlinConsStatsGetTypeCount^⚠

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

SCIPlinConsStatsIncTypeCount^⚠

increases the number of occurrences of a specific type of linear constraint

SCIPlinConsStatsReset^⚠

resets linear constraint statistics

SCIPlinkCurrentSol^⚠

links a primal solution to the current LP or pseudo solution

SCIPlinkLPSol^⚠

links a primal solution to the current LP solution

SCIPlinkNLPSol^⚠

links a primal solution to the current NLP solution

SCIPlinkPseudoSol^⚠

links a primal solution to the current pseudo solution

SCIPlinkRelaxSol^⚠

links a primal solution to the current relaxation solution

SCIPlockVarCons^⚠

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

SCIPlpfeastol^⚠

returns primal feasibility tolerance of LP solver

SCIPlpiAddCols^⚠

adds columns to the LP

SCIPlpiAddRows^⚠

adds rows to the LP

SCIPlpiChgBounds^⚠

changes lower and upper bounds of columns

SCIPlpiChgCoef^⚠

changes a single coefficient

SCIPlpiChgObj^⚠

changes objective values of columns in the LP

SCIPlpiChgObjsen^⚠

changes the objective sense

SCIPlpiChgSides^⚠

changes left and right hand sides of rows

SCIPlpiClear^⚠

clears the whole LP

SCIPlpiClearState^⚠

clears current LPi state (like basis information) of the solver

SCIPlpiCreate^⚠

creates an LP problem object

SCIPlpiDelCols^⚠

deletes all columns in the given range from LP

SCIPlpiDelColset^⚠

deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position

SCIPlpiDelRows^⚠

deletes all rows in the given range from LP

SCIPlpiDelRowset^⚠

deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position

SCIPlpiEndStrongbranch^⚠

end strong branching - call after any strong branching

SCIPlpiExistsDualRay^⚠

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

SCIPlpiExistsPrimalRay^⚠

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

SCIPlpiFree^⚠

deletes an LP problem object

SCIPlpiFreeNorms^⚠

frees LPi pricing norms information

SCIPlpiFreeState^⚠

frees LPi state information

SCIPlpiGetBInvACol^⚠

get column of inverse basis matrix times constraint matrix B^-1 * A

SCIPlpiGetBInvARow^⚠

get row of inverse basis matrix times constraint matrix B^-1 * A

SCIPlpiGetBInvCol^⚠

get column of inverse basis matrix B^-1

SCIPlpiGetBInvRow^⚠

get row of inverse basis matrix B^-1

SCIPlpiGetBase^⚠

gets current basis status for columns and rows; arrays must be large enough to store the basis status

SCIPlpiGetBasisInd^⚠

returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m

SCIPlpiGetBounds^⚠

gets current bounds from LP problem object

SCIPlpiGetCoef^⚠

gets a single coefficient

SCIPlpiGetColNames^⚠

gets column names

SCIPlpiGetCols^⚠

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.

SCIPlpiGetDualfarkas^⚠

gets dual Farkas proof for infeasibility

SCIPlpiGetInternalStatus^⚠

returns the internal solution status of the solver

SCIPlpiGetIntpar^⚠

gets integer parameter of LP

SCIPlpiGetIterations^⚠

gets the number of LP iterations of the last solve call

SCIPlpiGetNCols^⚠

gets the number of columns in the LP

SCIPlpiGetNNonz^⚠

gets the number of nonzero elements in the LP constraint matrix

SCIPlpiGetNRows^⚠

gets the number of rows in the LP

SCIPlpiGetNorms^⚠

stores LPi pricing norms into lpinorms object

SCIPlpiGetObj^⚠

gets objective coefficients from LP problem object

SCIPlpiGetObjsen^⚠

gets the objective sense of the LP

SCIPlpiGetObjval^⚠

gets objective value of solution

SCIPlpiGetPrimalRay^⚠

gets primal ray for unbounded LPs

SCIPlpiGetRealSolQuality^⚠

gets information about the quality of an LP solution

SCIPlpiGetRealpar^⚠

gets floating point parameter of LP

SCIPlpiGetRowNames^⚠

gets row names

SCIPlpiGetRows^⚠

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.

SCIPlpiGetSides^⚠

gets current row sides from LP problem object

SCIPlpiGetSol^⚠

gets primal and dual solution vectors for feasible LPs

SCIPlpiGetSolFeasibility^⚠

gets information about primal and dual feasibility of the current LP solution

SCIPlpiGetSolverDesc^⚠

gets description of LP solver (developer, webpage, …)

SCIPlpiGetSolverName^⚠

gets name and version of LP solver

SCIPlpiGetSolverPointer^⚠

gets pointer for LP solver - use only with great care

SCIPlpiGetState^⚠

stores LPi state (like basis information) into lpistate object

SCIPlpiHasBarrierSolve^⚠

informs about availability of a barrier solving method

SCIPlpiHasDualRay^⚠

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

SCIPlpiHasDualSolve^⚠

informs about availability of a dual simplex solving method

SCIPlpiHasPrimalRay^⚠

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

SCIPlpiHasPrimalSolve^⚠

informs about availability of a primal simplex solving method

SCIPlpiHasStateBasis^⚠

checks, whether the given LPi state contains simplex basis information

SCIPlpiIgnoreInstability^⚠

tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call

SCIPlpiInfinity^⚠

returns value treated as infinity in the LP solver

SCIPlpiInterrupt^⚠

interrupts the currently ongoing lp solve or disables the interrupt

SCIPlpiIsDualFeasible^⚠

returns TRUE iff LP is proven to be dual feasible

SCIPlpiIsDualInfeasible^⚠

returns TRUE iff LP is proven to be dual infeasible

SCIPlpiIsDualUnbounded^⚠

returns TRUE iff LP is proven to be dual unbounded

SCIPlpiIsInfinity^⚠

checks if given value is treated as infinity in the LP solver

SCIPlpiIsIterlimExc^⚠

returns TRUE iff the iteration limit was reached

SCIPlpiIsObjlimExc^⚠

returns TRUE iff the objective limit was reached

SCIPlpiIsOptimal^⚠

returns TRUE iff LP was solved to optimality

SCIPlpiIsPrimalFeasible^⚠

returns TRUE iff LP is proven to be primal feasible

SCIPlpiIsPrimalInfeasible^⚠

returns TRUE iff LP is proven to be primal infeasible

SCIPlpiIsPrimalUnbounded^⚠

returns TRUE iff LP is proven to be primal unbounded

SCIPlpiIsStable^⚠

returns TRUE iff current LP solution is stable

SCIPlpiIsTimelimExc^⚠

returns TRUE iff the time limit was reached

SCIPlpiLoadColLP^⚠

copies LP data with column matrix into LP solver

SCIPlpiReadLP^⚠

reads LP from a file

SCIPlpiReadState^⚠

reads LPi state (like basis information from a file

SCIPlpiScaleCol^⚠

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

SCIPlpiScaleRow^⚠

multiplies a row with a non-zero scalar; for negative scalars, the row’s sense is switched accordingly

SCIPlpiSetBase^⚠

sets current basis status for columns and rows

SCIPlpiSetIntegralityInformation^⚠

pass integrality information about variables to the solver

SCIPlpiSetIntpar^⚠

sets integer parameter of LP

SCIPlpiSetNorms^⚠

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()

SCIPlpiSetRealpar^⚠

sets floating point parameter of LP

SCIPlpiSetState^⚠

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()

SCIPlpiSolveBarrier^⚠

calls barrier or interior point algorithm to solve the LP with crossover to simplex basis

SCIPlpiSolveDual^⚠

calls dual simplex to solve the LP

SCIPlpiSolvePrimal^⚠

calls primal simplex to solve the LP

SCIPlpiStartStrongbranch^⚠

start strong branching - call before any strong branching

SCIPlpiStrongbranchFrac^⚠

performs strong branching iterations on one @b fractional candidate

SCIPlpiStrongbranchInt^⚠

performs strong branching iterations on one candidate with @b integral value

SCIPlpiStrongbranchesFrac^⚠

performs strong branching iterations on given @b fractional candidates

SCIPlpiStrongbranchesInt^⚠

performs strong branching iterations on given candidates with @b integral values

SCIPlpiWasSolved^⚠

returns whether a solve method was called after the last modification of the LP

SCIPlpiWriteLP^⚠

writes LP to a file

SCIPlpiWriteState^⚠

writes LPi state (i.e. basis information) to a file

SCIPmajorVersion^⚠

returns SCIP major version

SCIPmakeIndicatorFeasible^⚠

based on values of other variables, computes slack and binary variable to turn constraint feasible

SCIPmakeIndicatorsFeasible^⚠

based on values of other variables, computes slack and binary variable to turn all constraints feasible

SCIPmakeRowIntegral^⚠

tries to scale row, s.t. all coefficients (of integer variables) become integral

SCIPmakeSOS1sFeasible^⚠

based on solution values of the variables, fixes variables to zero to turn all SOS1 constraints feasible

SCIPmarkColNotRemovableLocal^⚠

marks a column to be not removable from the LP in the current node

SCIPmarkConsPropagate^⚠

marks constraint to be propagated

SCIPmarkDoNotAggrVar^⚠

marks the variable that it must not be aggregated

SCIPmarkDoNotMultaggrVar^⚠

marks the variable that it must not be multi-aggregated

SCIPmarkExprPropagateNonlinear^⚠

mark constraints that include this expression to be propagated again

SCIPmarkLimitChanged^⚠

marks that some limit parameter was changed

SCIPmarkRelaxSolInvalid^⚠

informs SCIP, that the relaxation solution is invalid

SCIPmarkRelaxSolValid^⚠

informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts

SCIPmarkRowNotRemovableLocal^⚠

marks a row to be not removable from the LP in the current node

SCIPmatrixCreate^⚠

initialize matrix by copying all check constraints

SCIPmatrixDownlockConflict^⚠

get if conflicting downlocks of variable present

SCIPmatrixFree^⚠

frees the constraint matrix

SCIPmatrixGetColIdxPtr^⚠

get column based start pointer of row indices

SCIPmatrixGetColLb^⚠

get lower bound of column

SCIPmatrixGetColNDownlocks^⚠

get number of downlocks of column

SCIPmatrixGetColNNonzs^⚠

get the number of non-zero entries of this column

SCIPmatrixGetColNUplocks^⚠

get number of uplocks of column

SCIPmatrixGetColName^⚠

get name of column/variable

SCIPmatrixGetColUb^⚠

get upper bound of column

SCIPmatrixGetColValPtr^⚠

get column based start pointer of values

SCIPmatrixGetCons^⚠

get constraint pointer for constraint representing row

SCIPmatrixGetNColumns^⚠

get number of columns of the matrix

SCIPmatrixGetNNonzs^⚠

get number of non-zeros of matrix

SCIPmatrixGetNRows^⚠

get number of rows of the matrix

SCIPmatrixGetParallelCols^⚠

detect parallel columns, obj ignored

SCIPmatrixGetParallelRows^⚠

detect parallel rows, rhs/lhs are ignored

SCIPmatrixGetRowIdxPtr^⚠

get row based start pointer of column indices

SCIPmatrixGetRowLhs^⚠

get left-hand-side of row

SCIPmatrixGetRowMaxActivity^⚠

get maximal activity of row

SCIPmatrixGetRowMinActivity^⚠

get minimal activity of row

SCIPmatrixGetRowNMaxActNegInf^⚠

get number of negative infinities present within maximal activity

SCIPmatrixGetRowNMaxActPosInf^⚠

get number of positive infinities present within maximal activity

SCIPmatrixGetRowNMinActNegInf^⚠

get number of negative infinities present within minimal activity

SCIPmatrixGetRowNMinActPosInf^⚠

get number of positive infinities present within minimal activity

SCIPmatrixGetRowNNonzs^⚠

get number of non-zeros of this row

SCIPmatrixGetRowName^⚠

get name of row

SCIPmatrixGetRowRhs^⚠

get right-hand-side of row

SCIPmatrixGetRowValPtr^⚠

get row based start pointer of values

SCIPmatrixGetVar^⚠

get variable pointer of column

SCIPmatrixIsRowRhsInfinity^⚠

flag indicating if right-hand-side of row is infinity

SCIPmatrixPrintRow^⚠

print one row of the MIP matrix

SCIPmatrixRemoveColumnBounds^⚠

removes the bounds of a column and updates the activities accordingly

SCIPmatrixUplockConflict^⚠

get if conflicting uplocks of variable present

SCIPmemccpy^⚠

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.

SCIPmergeBendersSubproblemIntoMaster^⚠

merges a subproblem into the master problem.

SCIPmergeNLPIStatistics^⚠

merges the statistics of NLPIs from a source SCIP into a target SCIP

SCIPmergeRowprepTerms^⚠

Merge terms that use same variable and eliminate zero coefficients.

SCIPmergeVariableStatistics^⚠

merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to different SCIP instances.

SCIPmessageFPrintDialog^⚠

SCIPmessageFPrintInfo^⚠

SCIPmessageFPrintVerbInfo^⚠

SCIPmessageFPrintWarning^⚠

SCIPmessagePrintDialog^⚠

SCIPmessagePrintError^⚠

SCIPmessagePrintErrorHeader^⚠

prints the header with source file location for an error message using the static message handler

SCIPmessagePrintInfo^⚠

SCIPmessagePrintVerbInfo^⚠

SCIPmessagePrintWarning^⚠

SCIPmessageSetErrorPrinting^⚠

Method to set the error printing method. Setting the error printing method to NULL will suspend all error methods.

SCIPmessageSetErrorPrintingDefault^⚠

Method to set the error printing method to default version prints everything the stderr.

SCIPmessageVFPrintDialog^⚠

prints a dialog message that requests user interaction into a file, acting like the vfprintf() command

SCIPmessageVFPrintInfo^⚠

prints a message into a file, acting like the vfprintf() command

SCIPmessageVFPrintVerbInfo^⚠

prints a message into a file depending on the verbosity level, acting like the vfprintf() command

SCIPmessageVFPrintWarning^⚠

prints a warning message into a file, acting like the vfprintf() command

SCIPmessageVPrintDialog^⚠

prints a dialog message that requests user interaction, acting like the vprintf() command

SCIPmessageVPrintError^⚠

prints an error message, acting like the vprintf() command using the static message handler

SCIPmessageVPrintInfo^⚠

prints a message, acting like the vprintf() command

SCIPmessageVPrintVerbInfo^⚠

prints a message depending on the verbosity level, acting like the vprintf() command

SCIPmessageVPrintWarning^⚠

prints a warning message, acting like the vprintf() command

SCIPmessagehdlrCapture^⚠

captures message handler

SCIPmessagehdlrCreate^⚠

Creates and captures a message handler which deals with warning, information, and dialog (interactive shell) methods.

SCIPmessagehdlrGetData^⚠

returns the user data of the message handler

SCIPmessagehdlrGetLogfile^⚠

returns the log file or NULL for stdout

SCIPmessagehdlrIsQuiet^⚠

returns TRUE if the message handler is set to be quiet

SCIPmessagehdlrRelease^⚠

releases message handler

SCIPmessagehdlrSetData^⚠

sets the user data of the message handler

SCIPmessagehdlrSetLogfile^⚠

sets the log file name for the message handler

SCIPmessagehdlrSetQuiet^⚠

sets the messages handler to be quiet

SCIPminorVersion^⚠

returns SCIP minor version

SCIPmultiaggregateVar^⚠

converts variable into multi-aggregated variable; this changes the variable array returned from SCIPgetVars() and SCIPgetVarsData();

SCIPmultihashCreate^⚠

creates a multihash table

SCIPmultihashExists^⚠

returns whether the given element exists in the multihash table

SCIPmultihashFree^⚠

frees the multihash table

SCIPmultihashGetLoad^⚠

returns the load of the given multihash table in percentage

SCIPmultihashGetNElements^⚠

returns number of multihash table elements

SCIPmultihashInsert^⚠

inserts element in multihash table (multiple inserts of same element possible)

SCIPmultihashPrintStatistics^⚠

prints statistics about multihash table usage

SCIPmultihashRemove^⚠

removes element from the multihash table, if it exists

SCIPmultihashRemoveAll^⚠

removes all elements of the multihash table

SCIPmultihashRetrieve^⚠

retrieve element with key from multihash table, returns NULL if not existing

SCIPmultihashRetrieveNext^⚠

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)

SCIPmultihashSafeInsert^⚠

inserts element in multihash table (multiple insertion of same element is checked and results in an error)

SCIPmultiplyByConstantExprSum^⚠

multiplies given sum expression by a constant

SCIPnewProbingNode^⚠

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

SCIPnextafter^⚠

returns the next representable value of from in the direction of to

SCIPnlhdlrComp^⚠

compares two nonlinear handlers by detection priority

SCIPnlhdlrGetData^⚠

gives handler data of nonlinear handler

SCIPnlhdlrGetDesc^⚠

gives description of nonlinear handler, can be NULL

SCIPnlhdlrGetDetectPriority^⚠

gives detection priority of nonlinear handler

SCIPnlhdlrGetEnfoPriority^⚠

gives enforcement priority of nonlinear handler

SCIPnlhdlrGetName^⚠

gives name of nonlinear handler

SCIPnlhdlrHasEnfo^⚠

returns whether nonlinear handler implements the enforcement callback

SCIPnlhdlrHasEstimate^⚠

returns whether nonlinear handler implements the estimator callback

SCIPnlhdlrHasExitSepa^⚠

returns whether nonlinear handler implements the separation deinitialization callback

SCIPnlhdlrHasInitSepa^⚠

returns whether nonlinear handler implements the separation initialization callback

SCIPnlhdlrHasIntEval^⚠

returns whether nonlinear handler implements the interval evaluation callback

SCIPnlhdlrHasReverseProp^⚠

returns whether nonlinear handler implements the reverse propagation callback

SCIPnlhdlrIsEnabled^⚠

returns whether nonlinear handler is enabled

SCIPnlhdlrSetCopyHdlr^⚠

sets the copy handler callback of a nonlinear handler

SCIPnlhdlrSetFreeExprData^⚠

sets the nonlinear handler callback to free expression specific data of nonlinear handler

SCIPnlhdlrSetFreeHdlrData^⚠

sets the nonlinear handler callback to free the nonlinear handler data

SCIPnlhdlrSetInitExit^⚠

sets the initialization and deinitialization callback of a nonlinear handler

SCIPnlhdlrSetProp^⚠

sets the propagation callbacks of a nonlinear handler

SCIPnlhdlrSetSepa^⚠

sets the enforcement callbacks of a nonlinear handler

SCIPnlpiComp^⚠

compares two NLPIs w.r.t. their priority

SCIPnlpiGetData^⚠

gets data of an NLPI

SCIPnlpiGetDesc^⚠

gets NLP solver description

SCIPnlpiGetEvalTime^⚠

gives total time spend in function evaluation during NLP solves

SCIPnlpiGetNIterations^⚠

gives total number of iterations spend by NLP solver so far

SCIPnlpiGetNProblems^⚠

gives number of problems created for NLP solver so far

SCIPnlpiGetNSolStat^⚠

gives number of times a solve ended with a specific solution status

SCIPnlpiGetNSolves^⚠

total number of NLP solves so far

SCIPnlpiGetNTermStat^⚠

gives number of times a solve ended with a specific termination status

SCIPnlpiGetName^⚠

gets NLP solver name

SCIPnlpiGetPriority^⚠

gets NLP solver priority

SCIPnlpiGetProblemTime^⚠

gives total time spend in problem creation/modification/freeing

SCIPnlpiGetSolveTime^⚠

gives total time spend in NLP solves (as reported by solver)

SCIPnlpiMergeStatistics^⚠

adds statistics from one NLPI to another

SCIPnlrowGetConstant^⚠

gets constant

SCIPnlrowGetCurvature^⚠

returns the curvature of a nonlinear row

SCIPnlrowGetDualsol^⚠

gets the dual NLP solution of a nlrow

SCIPnlrowGetExpr^⚠

gets expression

SCIPnlrowGetLhs^⚠

returns the left hand side of a nonlinear row

SCIPnlrowGetLinearCoefs^⚠

gets array with coefficients in linear part

SCIPnlrowGetLinearVars^⚠

gets array with variables of linear part

SCIPnlrowGetNLPPos^⚠

gets position of a nonlinear row in current NLP, or -1 if not in NLP

SCIPnlrowGetNLinearVars^⚠

gets number of variables of linear part

SCIPnlrowGetName^⚠

returns the name of a nonlinear row

SCIPnlrowGetRhs^⚠

returns the right hand side of a nonlinear row

SCIPnlrowIsInNLP^⚠

returns TRUE iff row is member of current NLP

SCIPnlrowSetCurvature^⚠

sets the curvature of a nonlinear row

SCIPnodeCompLowerbound^⚠

node comparator for best lower bound

SCIPnodeGetAddedConss^⚠

returns all constraints added to a given node

SCIPnodeGetAncestorBranchingPath^⚠

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

SCIPnodeGetAncestorBranchings^⚠

returns the set of variable branchings that were performed in all ancestor nodes (nodes on the path to the root) to create this node

SCIPnodeGetAncestorBranchingsPart^⚠

returns the set of variable branchings that were performed between the given @p node and the given @p parent node.

SCIPnodeGetConssetchg^⚠

SCIPnodeGetDepth^⚠

gets the depth of the node

SCIPnodeGetDomchg^⚠

gets the domain change information of the node, i.e., the information about the differences in the variables domains to the parent node

SCIPnodeGetEstimate^⚠

gets the estimated value of the best feasible solution in subtree of the node

SCIPnodeGetLowerbound^⚠

gets the lower bound of the node

SCIPnodeGetNAddedConss^⚠

returns the number of added constraints to the given node

SCIPnodeGetNDomchg^⚠

counts the number of bound changes due to branching, constraint propagation, and propagation

SCIPnodeGetNumber^⚠

gets successively assigned number of the node

SCIPnodeGetParent^⚠

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

SCIPnodeGetParentBranchings^⚠

returns the set of variable branchings that were performed in the parent node to create this node

SCIPnodeGetReoptID^⚠

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

SCIPnodeGetReopttype^⚠

gets the reoptimization type of a node

SCIPnodeGetType^⚠

gets the type of the node

SCIPnodeGetVarSOS1^⚠

returns variable that belongs to a given node from the conflict graph

SCIPnodeIsActive^⚠

returns whether node is in the path to the current node

SCIPnodeIsPropagatedAgain^⚠

returns whether the node is marked to be propagated again

SCIPnodePrintAncestorBranchings^⚠

outputs the path into given file stream in GML format

SCIPnodeSetReoptID^⚠

sets a unique id to identify the node during reoptimization

SCIPnodeSetReopttype^⚠

sets the reoptimization type of the node

SCIPnodesGetCommonAncestor^⚠

finds the common ancestor node of two given nodes

SCIPnodesSharePath^⚠

checks for two nodes whether they share the same root path, i.e., whether one is an ancestor of the other

SCIPnodeselGetData^⚠

gets user data of node selector

SCIPnodeselGetDesc^⚠

gets description of node selector

SCIPnodeselGetMemsavePriority^⚠

gets priority of node selector in memory saving mode

SCIPnodeselGetName^⚠

gets name of node selector

SCIPnodeselGetSetupTime^⚠

gets time in seconds used in this node selector for setting up for next stages

SCIPnodeselGetStdPriority^⚠

gets priority of node selector in standard mode

SCIPnodeselGetTime^⚠

gets time in seconds used in this node selector

SCIPnodeselIsInitialized^⚠

is node selector initialized?

SCIPnodeselSetData^⚠

sets user data of node selector; user has to free old data in advance!

SCIPnormalCDF^⚠

calculates the cumulative distribution P(-infinity <= x <= value) that a normally distributed random variable x takes a value between -infinity and parameter \p value.

SCIPnormalGetCriticalValue^⚠

get critical value of a standard normal distribution at a given confidence level

SCIPnormalizeCumulativeCondition^⚠

normalize cumulative condition

SCIPparamGetBool^⚠

returns value of SCIP_Bool parameter

SCIPparamGetBoolDefault^⚠

returns default value of SCIP_Bool parameter

SCIPparamGetChar^⚠

returns value of char parameter

SCIPparamGetCharAllowedValues^⚠

returns allowed values of char parameter, or NULL if everything is allowed

SCIPparamGetCharDefault^⚠

returns default value of char parameter

SCIPparamGetData^⚠

returns locally defined parameter specific data

SCIPparamGetDesc^⚠

returns description of parameter

SCIPparamGetInt^⚠

returns value of int parameter

SCIPparamGetIntDefault^⚠

returns default value of int parameter

SCIPparamGetIntMax^⚠

returns maximal value of int parameter

SCIPparamGetIntMin^⚠

returns minimal value of int parameter

SCIPparamGetLongint^⚠

returns value of SCIP_Longint parameter

SCIPparamGetLongintDefault^⚠

returns default value of SCIP_Longint parameter

SCIPparamGetLongintMax^⚠

returns maximal value of longint parameter

SCIPparamGetLongintMin^⚠

returns minimal value of longint parameter

SCIPparamGetName^⚠

returns name of parameter

SCIPparamGetReal^⚠

returns value of SCIP_Real parameter

SCIPparamGetRealDefault^⚠

returns default value of SCIP_Real parameter

SCIPparamGetRealMax^⚠

returns maximal value of real parameter

SCIPparamGetRealMin^⚠

returns minimal value of real parameter

SCIPparamGetString^⚠

returns value of string parameter

SCIPparamGetStringDefault^⚠

returns default value of String parameter

SCIPparamGetType^⚠

returns type of parameter

SCIPparamIsAdvanced^⚠

returns whether parameter is advanced

SCIPparamIsDefault^⚠

returns whether the parameter is on its default setting

SCIPparamIsFixed^⚠

returns whether parameter is fixed

SCIPparamSetFixed^⚠

sets fixing status of given parameter

SCIPparseCons^⚠

parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is creates and captures;

SCIPparseExpr^⚠

creates an expression from a string

SCIPparseReal^⚠

parse a real value that was written with SCIPprintReal()

SCIPparseVar^⚠

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

SCIPparseVarName^⚠

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

SCIPparseVarsLinearsum^⚠

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

SCIPparseVarsList^⚠

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

SCIPparseVarsPolynomial^⚠

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

SCIPperformGenericDivingAlgorithm^⚠

performs a diving within the limits of the @p diveset parameters

SCIPpermuteArray^⚠

randomly shuffles parts of an array using the Fisher-Yates algorithm

SCIPpermuteIntArray^⚠

randomly shuffles parts of an integer array using the Fisher-Yates algorithm

SCIPpermuteProb^⚠

permutes parts of the problem data structure

SCIPpqueueClear^⚠

clears the priority queue, but doesn’t free the data elements themselves

SCIPpqueueCreate^⚠

creates priority queue

SCIPpqueueDelPos^⚠

delete element at specified position, maintaining the heap property

SCIPpqueueElems^⚠

returns the elements of the queue; changing the returned array may destroy the queue’s ordering!

SCIPpqueueFind^⚠

return the position of @p elem in the priority queue, or -1 if element is not found

SCIPpqueueFirst^⚠

returns the best element of the queue without removing it

SCIPpqueueFree^⚠

frees priority queue, but not the data elements themselves

SCIPpqueueInsert^⚠

inserts element into priority queue

SCIPpqueueNElems^⚠

returns the number of elements in the queue

SCIPpqueueRemove^⚠

removes and returns best element from the priority queue

SCIPpresolComp^⚠

compares two presolvers w. r. to their priority

SCIPpresolCompName^⚠

comparison method for sorting presolvers w.r.t. to their name

SCIPpresolCons^⚠

presolves of single constraint

SCIPpresolGetData^⚠

gets user data of presolver

SCIPpresolGetDesc^⚠

gets description of presolver

SCIPpresolGetMaxrounds^⚠

gets round limit of presolver

SCIPpresolGetNAddConss^⚠

gets number of constraints added in presolver

SCIPpresolGetNAddHoles^⚠

gets number of holes added to domains of variables in presolver

SCIPpresolGetNAggrVars^⚠

gets number of variables aggregated in presolver

SCIPpresolGetNCalls^⚠

gets number of times the presolver was called and tried to find reductions

SCIPpresolGetNChgBds^⚠

gets number of bounds changed in presolver

SCIPpresolGetNChgCoefs^⚠

gets number of coefficients changed in presolver

SCIPpresolGetNChgSides^⚠

gets number of constraint sides changed in presolver

SCIPpresolGetNChgVarTypes^⚠

gets number of variable types changed in presolver

SCIPpresolGetNDelConss^⚠

gets number of constraints deleted in presolver

SCIPpresolGetNFixedVars^⚠

gets number of variables fixed in presolver

SCIPpresolGetNUpgdConss^⚠

gets number of constraints upgraded in presolver

SCIPpresolGetName^⚠

gets name of presolver

SCIPpresolGetPriority^⚠

gets priority of presolver

SCIPpresolGetSetupTime^⚠

gets time in seconds used in this presolver for setting up for next stages

SCIPpresolGetTime^⚠

gets time in seconds used in this presolver

SCIPpresolGetTiming^⚠

gets the timing mask of the presolver

SCIPpresolIsInitialized^⚠

is presolver initialized?

SCIPpresolSetData^⚠

sets user data of presolver; user has to free old data in advance!

SCIPpresolSetTiming^⚠

sets the timing mask of the presolver

SCIPpresolve^⚠

transforms and presolves problem

SCIPpresolveCumulativeCondition^⚠

presolve cumulative condition w.r.t. effective horizon by detecting irrelevant variables

SCIPpressedCtrlC^⚠

returns whether the user pressed CTRL-C to interrupt the solving process

SCIPpricerComp^⚠

compares two pricers w. r. to their priority

SCIPpricerCompName^⚠

comparison method for sorting pricers w.r.t. to their name

SCIPpricerGetData^⚠

gets user data of variable pricer

SCIPpricerGetDesc^⚠

gets description of variable pricer

SCIPpricerGetNCalls^⚠

gets the number of times, the pricer was called and tried to find a variable with negative reduced costs

SCIPpricerGetNVarsFound^⚠

gets the number of variables with negative reduced costs found by this pricer

SCIPpricerGetName^⚠

gets name of variable pricer

SCIPpricerGetPriority^⚠

gets priority of variable pricer

SCIPpricerGetSetupTime^⚠

gets time in seconds used in this pricer for setting up for next stages

SCIPpricerGetTime^⚠

gets time in seconds used in this pricer

SCIPpricerIsActive^⚠

returns whether the given pricer is in use in the current problem

SCIPpricerIsDelayed^⚠

returns whether the pricer should be delayed until no other pricer finds a new variable

SCIPpricerIsInitialized^⚠

is variable pricer initialized?

SCIPpricerSetData^⚠

sets user data of variable pricer; user has to free old data in advance!

SCIPprintBendersStatistics^⚠

outputs Benders’ decomposition statistics

SCIPprintBestSol^⚠

outputs best feasible primal solution found so far to file stream

SCIPprintBestTransSol^⚠

outputs best feasible primal solution found so far in transformed variables to file stream

SCIPprintBranchingStatistics^⚠

outputs history statistics about branchings on variables

SCIPprintBranchruleStatistics^⚠

outputs branching rule statistics

SCIPprintBuildOptions^⚠

prints detailed information on the compile-time flags

SCIPprintCompressionStatistics^⚠

outputs compression statistics

SCIPprintConcsolverStatistics^⚠

outputs concurrent solver statistics

SCIPprintConflictStatistics^⚠

outputs conflict statistics

SCIPprintCons^⚠

outputs constraint information to file stream via the message handler system

SCIPprintConstraintStatistics^⚠

outputs constraint statistics

SCIPprintConstraintTimingStatistics^⚠

outputs constraint timing statistics

SCIPprintCutselectorStatistics^⚠

outputs cutselector statistics

SCIPprintDebugMessage^⚠

SCIPprintDisplayLine^⚠

outputs node information display line

SCIPprintDualSol^⚠

outputs dual solution from LP solver to file stream

SCIPprintError^⚠

prints error message for the given SCIP_RETCODE via the error prints method

SCIPprintExpr^⚠

print an expression as info-message

SCIPprintExprDot^⚠

main part of printing an expression in dot format

SCIPprintExprDotFinal^⚠

finishes printing of expressions in dot format

SCIPprintExprDotInit^⚠

initializes printing of expressions in dot format to a give FILE* pointer

SCIPprintExprDotInit2^⚠

initializes printing of expressions in dot format to a file with given filename

SCIPprintExprQuadratic^⚠

prints quadratic expression

SCIPprintExpressionHandlerStatistics^⚠

outputs expression handler statistics

SCIPprintExternalCodes^⚠

prints information on external codes to a file stream via the message handler system

SCIPprintHeuristicStatistics^⚠

outputs heuristics statistics

SCIPprintLPSolutionQuality^⚠

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

SCIPprintLPStatistics^⚠

outputs LP statistics

SCIPprintLinConsStats^⚠

print linear constraint classification statistics

SCIPprintMIPStart^⚠

outputs discrete variables of solution in original problem space to the given file stream

SCIPprintMemoryDiagnostic^⚠

prints output about used memory

SCIPprintNLPIStatistics^⚠

outputs NLPI statistics

SCIPprintNLPStatistics^⚠

outputs NLP statistics

SCIPprintNlRow^⚠

prints a nonlinear row to file stream

SCIPprintNodeRootPath^⚠

prints all branching decisions on variables from the root to the given node

SCIPprintOrigProblem^⚠

outputs original problem to file stream

SCIPprintOrigProblemStatistics^⚠

outputs statistics for original problem

SCIPprintPresolverStatistics^⚠

outputs presolver statistics

SCIPprintPricerStatistics^⚠

outputs pricer statistics

SCIPprintPropagatorStatistics^⚠

outputs propagator statistics

SCIPprintRay^⚠

outputs non-zero variables of solution representing a ray in original problem space to file stream

SCIPprintReal^⚠

outputs a real number, or “+infinity”, or “-infinity” to a file

SCIPprintRelaxatorStatistics^⚠

outputs relaxator statistics

SCIPprintReoptStatistics^⚠

outputs reoptimization statistics

SCIPprintRootStatistics^⚠

outputs root statistics

SCIPprintRow^⚠

output row to file stream via the message handler system

SCIPprintRowprep^⚠

prints a rowprep

SCIPprintRowprepSol^⚠

prints a rowprep and values in solution

SCIPprintSeparatorStatistics^⚠

outputs separator statistics

SCIPprintSol^⚠

outputs non-zero variables of solution in original problem space to the given file stream

SCIPprintSolReaderFzn^⚠

print given solution in Flatzinc format w.r.t. the output annotation

SCIPprintSolutionStatistics^⚠

outputs solution statistics

SCIPprintStage^⚠

outputs SCIP stage and solution status if applicable via the message handler

SCIPprintStatistics^⚠

outputs solving statistics

SCIPprintStatus^⚠

outputs solution status

SCIPprintStatusStatistics^⚠

outputs status statistics

SCIPprintSysError^⚠

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)

SCIPprintTimingStatistics^⚠

outputs timing statistics

SCIPprintTransProblem^⚠

outputs transformed problem of the current node to file stream

SCIPprintTransProblemStatistics^⚠

outputs statistics for transformed problem

SCIPprintTransSol^⚠

outputs non-zero variables of solution in transformed problem space to file stream

SCIPprintTreeStatistics^⚠

outputs tree statistics

SCIPprintVar^⚠

outputs variable information to file stream via the message system

SCIPprintVersion^⚠

prints a version information line to a file stream via the message handler system

SCIPprocessRowprepNonlinear^⚠

processes a rowprep for cut addition and maybe report branchscores

SCIPprocessShellArguments^⚠

evaluates command line parameters and runs SCIP appropriately in the given SCIP instance

SCIPprofileCreate^⚠

creates resource profile

SCIPprofileDeleteCore^⚠

subtracts the height from the resource profile during core time

SCIPprofileFindLeft^⚠

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

SCIPprofileFree^⚠

frees given resource profile

SCIPprofileGetCapacity^⚠

returns the capacity of the resource profile

SCIPprofileGetEarliestFeasibleStart^⚠

return the earliest possible starting point within the time interval [lb,ub] for a given core (given by its height and duration)

SCIPprofileGetLatestFeasibleStart^⚠

return the latest possible starting point within the time interval [lb,ub] for a given core (given by its height and duration)

SCIPprofileGetLoad^⚠

returns the loads of the resource profile at the given position

SCIPprofileGetLoads^⚠

returns the loads of the resource profile

SCIPprofileGetNTimepoints^⚠

returns the number time points of the resource profile

SCIPprofileGetTime^⚠

returns the time point for given position of the resource profile

SCIPprofileGetTimepoints^⚠

returns the time points of the resource profile

SCIPprofileInsertCore^⚠

insert a core into resource profile; if the core is non-empty the resource profile will be updated otherwise nothing happens

SCIPprofilePrint^⚠

output of the given resource profile

SCIPpropComp^⚠

compares two propagators w. r. to their priority

SCIPpropCompName^⚠

comparison method for sorting propagators w.r.t. to their name

SCIPpropCompPresol^⚠

compares two propagators w. r. to their presolving priority

SCIPpropCons^⚠

calls domain propagation method of single constraint

SCIPpropCumulativeCondition^⚠

propagate the given cumulative condition

SCIPpropDoesPresolve^⚠

does the propagator perform presolving?

SCIPpropGetData^⚠

gets user data of propagator

SCIPpropGetDesc^⚠

gets description of propagator

SCIPpropGetFreq^⚠

gets frequency of propagator

SCIPpropGetNAddConss^⚠

gets number of constraints added during presolving of propagator

SCIPpropGetNAddHoles^⚠

gets number of holes added to domains of variables during presolving of propagator

SCIPpropGetNAggrVars^⚠

gets number of variables aggregated during presolving of propagator

SCIPpropGetNCalls^⚠

gets the total number of times, the propagator was called

SCIPpropGetNChgBds^⚠

gets number of bounds changed during presolving of propagator

SCIPpropGetNChgCoefs^⚠

gets number of coefficients changed during presolving of propagator

SCIPpropGetNChgSides^⚠

gets number of constraint sides changed during presolving of propagator

SCIPpropGetNChgVarTypes^⚠

gets number of variable types changed during presolving of propagator

SCIPpropGetNCutoffs^⚠

gets total number of times, this propagator detected a cutoff

SCIPpropGetNDelConss^⚠

gets number of constraints deleted during presolving of propagator

SCIPpropGetNDomredsFound^⚠

gets total number of domain reductions found by this propagator

SCIPpropGetNFixedVars^⚠

gets number of variables fixed during presolving of propagator

SCIPpropGetNPresolCalls^⚠

gets number of times the propagator was called in presolving and tried to find reductions

SCIPpropGetNRespropCalls^⚠

gets the total number of times, the propagator was called for resolving a propagation

SCIPpropGetNUpgdConss^⚠

gets number of constraints upgraded during presolving of propagator

SCIPpropGetName^⚠

gets name of propagator

SCIPpropGetPresolPriority^⚠

gets presolving priority of propagator

SCIPpropGetPresolTime^⚠

gets time in seconds used in this propagator for presolving

SCIPpropGetPresolTiming^⚠

returns the timing mask of the presolving method of the propagator

SCIPpropGetPriority^⚠

gets priority of propagator

SCIPpropGetRespropTime^⚠

gets time in seconds used in this propagator for resolve propagation

SCIPpropGetSetupTime^⚠

gets time in seconds used for setting up this propagator for new stages

SCIPpropGetStrongBranchPropTime^⚠

gets time in seconds used in this propagator during strong branching

SCIPpropGetTime^⚠

gets time in seconds used in this propagator

SCIPpropGetTimingmask^⚠

returns the timing mask of the propagator

SCIPpropIsDelayed^⚠

should propagator be delayed, if other propagators found reductions?

SCIPpropIsInitialized^⚠

is propagator initialized?

SCIPpropSetData^⚠

sets user data of propagator; user has to free old data in advance!

SCIPpropSetFreq^⚠

sets frequency of propagator

SCIPpropSetPresolTiming^⚠

sets the timing mask of the presolving method of the propagator

SCIPpropWasDelayed^⚠

was propagator delayed at the last call?

SCIPpropagateCutoffboundVar^⚠

propagates the cutoff bound for the given variables

SCIPpropagateProbing^⚠

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

SCIPpropagateProbingImplications^⚠

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

SCIPpruneTree^⚠

removes all nodes from branch and bound tree that were marked to be cut off via SCIPcutoffNode()

SCIPpscostThresholdProbabilityTest^⚠

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.

SCIPqueueClear^⚠

clears the queue, but doesn’t free the data elements themselves

SCIPqueueCreate^⚠

creates a (circular) queue, best used if the size will be fixed or will not be increased that much

SCIPqueueFirst^⚠

returns the first element of the queue without removing it, or NULL if no element exists

SCIPqueueFirstUInt^⚠

returns the first unsigned integer element of the queue without removing it, or UINT_MAX if no element exists

SCIPqueueFree^⚠

frees queue, but not the data elements themselves

SCIPqueueInsert^⚠

inserts pointer element at the end of the queue

SCIPqueueInsertUInt^⚠

inserts unsigned integer element at the end of the queue

SCIPqueueIsEmpty^⚠

returns whether the queue is empty

SCIPqueueNElems^⚠

returns the number of elements in the queue

SCIPqueueRemove^⚠

removes and returns the first element of the queue, or NULL if no element exists

SCIPqueueRemoveUInt^⚠

removes and returns the first unsigned integer element of the queue, or UNIT_MAX if no element exists

SCIPrandomGetInt^⚠

returns a random integer between minrandval and maxrandval

SCIPrandomGetReal^⚠

returns a random real between minrandval and maxrandval

SCIPrandomGetSubset^⚠

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

SCIPrandomPermuteArray^⚠

randomly shuffles parts of an array using the Fisher-Yates algorithm

SCIPrandomPermuteIntArray^⚠

randomly shuffles parts of an integer array using the Fisher-Yates algorithm

SCIPreadCor^⚠

reads problem from file

SCIPreadDiff^⚠

reads problem from file

SCIPreadLp^⚠

reads problem from file

SCIPreadMps^⚠

reads problem from file

SCIPreadOpb^⚠

reads problem from file

SCIPreadParams^⚠

reads parameters from a file

SCIPreadPip^⚠

reads problem from file

SCIPreadProb^⚠

reads problem from file and initializes all solving data structures

SCIPreadSol^⚠

reads a given solution file

SCIPreadSolFile^⚠

reads a given solution file and store the solution values in the given solution pointer

SCIPreadSto^⚠

reads the stochastic information for a stochastic program that is in SMPS format

SCIPreadTim^⚠

reads the stage information for a stochastic programming instance in SMPS format

SCIPreaderCanRead^⚠

return whether the reader can read files

SCIPreaderCanWrite^⚠

return whether the reader can write files

SCIPreaderGetData^⚠

gets user data of reader

SCIPreaderGetDesc^⚠

gets description of reader

SCIPreaderGetExtension^⚠

gets file extension of reader

SCIPreaderGetName^⚠

gets name of reader

SCIPreaderSetData^⚠

sets user data of reader; user has to free old data in advance!

SCIPrealToRational^⚠

converts a real number into a (approximate) rational representation, and returns TRUE iff the conversion was successful

SCIPrecalcNlRowActivity^⚠

recalculates the activity of a nonlinear row in the last NLP or pseudo solution

SCIPrecalcNlRowNLPActivity^⚠

recalculates the activity of a nonlinear row in the last NLP solution

SCIPrecalcNlRowPseudoActivity^⚠

recalculates the activity of a nonlinear row for the current pseudo solution

SCIPrecalcRowActivity^⚠

recalculates the activity of a row in the last LP or pseudo solution

SCIPrecalcRowLPActivity^⚠

recalculates the activity of a row in the last LP solution

SCIPrecalcRowPseudoActivity^⚠

recalculates the activity of a row for the current pseudo solution

SCIPrecomputeSolObj^⚠

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)

SCIPregisterExprUsageNonlinear^⚠

method to be called by a nlhdlr during NLHDLRDETECT to notify an expression that it will be used

SCIPregressionAddObservation^⚠

update regression by a new observation (x,y)

SCIPregressionCreate^⚠

creates and resets a regression

SCIPregressionFree^⚠

frees a regression

SCIPregressionGetIntercept^⚠

get the current y-intercept of the regression

SCIPregressionGetNObservations^⚠

returns the number of observations of this regression

SCIPregressionGetSlope^⚠

return the current slope of the regression

SCIPregressionRemoveObservation^⚠

removes an observation (x,y) from the regression

SCIPregressionReset^⚠

reset regression data structure

SCIPrelDiff^⚠

returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0)

SCIPrelaxComp^⚠

compares two relaxation handlers w. r. to their priority

SCIPrelaxCompName^⚠

comparison method for sorting relaxators w.r.t. to their name

SCIPrelaxGetData^⚠

gets user data of relaxation handler

SCIPrelaxGetDesc^⚠

gets description of relaxation handler

SCIPrelaxGetFreq^⚠

gets frequency of relaxation handler

SCIPrelaxGetImprovedLowerboundTime^⚠

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)

SCIPrelaxGetNAddedConss^⚠

gets the total number of times the relaxation handler added constraints

SCIPrelaxGetNCalls^⚠

gets the total number of times the relaxation handler was called

SCIPrelaxGetNCutoffs^⚠

gets the total number of times the relaxation handler cut off a node

SCIPrelaxGetNImprovedLowerbound^⚠

gets the total number of times the relaxation handler improved a node’s lower bound

SCIPrelaxGetNReducedDomains^⚠

gets the total number of times the relaxation handler reduced variable domains

SCIPrelaxGetNSeparatedCuts^⚠

gets the total number of times the relaxation handler separated cutting planes

SCIPrelaxGetName^⚠

gets name of relaxation handler

SCIPrelaxGetPriority^⚠

gets priority of relaxation handler

SCIPrelaxGetSetupTime^⚠

gets time in seconds used in this relaxator for setting up for next stages

SCIPrelaxGetTime^⚠

gets time in seconds used in this relaxation handler

SCIPrelaxIsInitialized^⚠

is relaxation handler initialized?

SCIPrelaxMarkUnsolved^⚠

marks the current relaxation unsolved, s.t. the relaxation handler is called again in the next solving round

SCIPrelaxSetData^⚠

sets user data of relaxation handler; user has to free old data in advance!

SCIPrelaxfeastol^⚠

return the relaxation primal feasibility tolerance

SCIPreleaseCons^⚠

decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed

SCIPreleaseDialog^⚠

releases a dialog

SCIPreleaseExpr^⚠

releases an expression (decrements usage count and possibly frees expression)

SCIPreleaseNlRow^⚠

decreases usage counter of a nonlinear row, and frees memory if necessary

SCIPreleaseRow^⚠

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

SCIPreleaseVar^⚠

decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed

SCIPremoveExprChildren^⚠

remove all children of expr

SCIPremoveInefficaciousCuts^⚠

removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP

SCIPremoveVarFromGlobalStructures^⚠

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.

SCIPreoptGetFirstRestarts^⚠

returns the number of iteration with the first global restarts

SCIPreoptGetLastRestarts^⚠

returns the number of iteration with the last global restarts

SCIPreoptGetNCutoffReoptnodes^⚠

returns the number of reoptimized nodes that were cut off in the current run

SCIPreoptGetNFeasNodes^⚠

returns the number of nodes providing an improving feasible LP solution in the current run

SCIPreoptGetNInfNodes^⚠

returns the number of stored nodes with an infeasible LP in the current run

SCIPreoptGetNPrunedNodes^⚠

returns the number of nodes that exceeded the cutoff bound in the current run

SCIPreoptGetNRestartsGlobal^⚠

returns the number of global restarts

SCIPreoptGetNRestartsLocal^⚠

returns the number of local restarts in the current run

SCIPreoptGetNTotalCutoffReoptnodes^⚠

returns the number of reoptimized nodes that were cut off over all runs

SCIPreoptGetNTotalFeasNodes^⚠

returns the number of nodes providing an improving feasible LP solution over all runs

SCIPreoptGetNTotalInfNodes^⚠

returns the number of stored nodes with an infeasible LP over all runs

SCIPreoptGetNTotalPrunedNodes^⚠

returns the number of nodes that exceeded the cutoff bound over all runs

SCIPreoptGetNTotalRestartsLocal^⚠

returns the number of local restarts over all runs

SCIPreoptimizeNode^⚠

returns if a node should be reoptimized

SCIPreoptnodeGetConss^⚠

returns all added constraints at ID id

SCIPreoptnodeGetLowerbound^⚠

SCIPreoptnodeGetNChildren^⚠

returns the number of child nodes of @p reoptnode

SCIPreoptnodeGetNConss^⚠

returns the number of bound changes at the node stored at ID id

SCIPreoptnodeGetNDualBoundChgs^⚠

returns the number of stored bound changes based on dual information in the reopttree at ID id

SCIPreoptnodeGetNVars^⚠

returns the number of bound changes stored in the reoptnode

SCIPreoptnodeGetSplitCons^⚠

create the constraint which splits the node stored at ID id on the basis of the stored dual information.

SCIPreoptnodeGetType^⚠

returns the type of the @p reoptnode

SCIPreoptnodeSetParentID^⚠

set the parent id

SCIPreoptsolsGetNCheckedsols^⚠

@addtogroup PRIMALHEURISTICS

SCIPreoptsolsGetNImprovingsols^⚠

SCIPreplaceCommonSubexpressions^⚠

replaces common sub-expressions in a given expression graph by using a hash key for each expression

SCIPreplaceExprChild^⚠

overwrites/replaces a child of an expressions

SCIPrepropagateNode^⚠

marks the given node to be propagated again the next time a node of its subtree is processed

SCIPresetBandit^⚠

reset the bandit algorithm

SCIPresetClock^⚠

resets the time measurement of a clock to zero and completely stops the clock

SCIPresetConsAge^⚠

resets age of constraint to zero; should be called

SCIPresetLPFeastol^⚠

resets primal feasibility tolerance of LP

SCIPresetParam^⚠

resets a single parameter to its default value

SCIPresetParams^⚠

resets all parameters to their default values

SCIPresetReoptSolMarks^⚠

mark all stored solutions as not updated

SCIPresetReoptnodeDualcons^⚠

remove the stored information about bound changes based in dual information

SCIPresetRepresentation^⚠

reset a set of initialized reoptimization nodes

SCIPrespropCons^⚠

resolves propagation conflict of single constraint

SCIPrespropCumulativeCondition^⚠

resolve propagation w.r.t. the cumulative condition

SCIPrestartSolve^⚠

informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has been solved)

SCIPretransformObj^⚠

maps transformed objective value into original space

SCIPretransformSol^⚠

retransforms solution to original problem space

SCIPrewind^⚠

SCIPround^⚠

rounds value to the nearest integer with epsilon tolerance

SCIProundSol^⚠

try to round given solution

SCIProwCalcProbability^⚠

calculates the probability of satisfying an LP-row under the assumption of uniformly distributed variable values.

SCIProwChgRank^⚠

changes the rank of LP row

SCIProwComp^⚠

comparison method for sorting rows by non-decreasing index

SCIProwGetActiveLPCount^⚠

returns the number of times that this row has been sharp in an optimal LP solution

SCIProwGetAge^⚠

gets age of row

SCIProwGetBasisStatus^⚠

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

SCIProwGetCols^⚠

gets array with columns of nonzero entries

SCIProwGetConstant^⚠

gets constant shift of row

SCIProwGetDualfarkas^⚠

gets the dual Farkas coefficient of a row in an infeasible LP

SCIProwGetDualsol^⚠

gets the dual LP solution of a row

SCIProwGetIndex^⚠

gets unique index of row

SCIProwGetLPDepth^⚠

gets depth in the tree where the row entered the LP, or -1 if it is not in LP

SCIProwGetLPPos^⚠

gets position of row in current LP, or -1 if it is not in LP

SCIProwGetLhs^⚠

returns the left hand side of the row

SCIProwGetNLPNonz^⚠

get number of nonzero entries in row vector, that correspond to columns currently in the SCIP_LP;

SCIProwGetNLPsAfterCreation^⚠

returns the number of LPs since this row has been created

SCIProwGetNNonz^⚠

get number of nonzero entries in row vector

SCIProwGetName^⚠

returns the name of the row

SCIProwGetNorm^⚠

gets Euclidean norm of row vector

SCIProwGetOriginCons^⚠

returns origin constraint that created the row (NULL if not available)

SCIProwGetOriginConshdlr^⚠

returns origin constraint handler that created the row (NULL if not available)

SCIProwGetOriginSepa^⚠

returns origin separator that created the row (NULL if not available)

SCIProwGetOrigintype^⚠

returns type of origin that created the row

SCIProwGetOrthogonality^⚠

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

SCIProwGetParallelism^⚠

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

SCIProwGetRank^⚠

gets rank of row

SCIProwGetRhs^⚠

returns the right hand side of the row

SCIProwGetScalarProduct^⚠

returns the scalar product of the coefficient vectors of the two given rows

SCIProwGetSumNorm^⚠

gets sum norm of row vector (sum of absolute values of coefficients)

SCIProwGetVals^⚠

gets array with coefficients of nonzero entries

SCIProwIsInGlobalCutpool^⚠

returns TRUE iff row is member of the global cut pool

SCIProwIsInLP^⚠

returns TRUE iff row is member of current LP

SCIProwIsIntegral^⚠

returns TRUE iff the activity of the row (without the row’s constant) is always integral in a feasible solution

SCIProwIsLocal^⚠

returns TRUE iff row is only valid locally

SCIProwIsModifiable^⚠

returns TRUE iff row is modifiable during node processing (subject to column generation)

SCIProwIsRemovable^⚠

returns TRUE iff row is removable from the LP (due to aging or cleanup)

SCIProwLock^⚠

locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows

SCIProwSort^⚠

sorts row entries such that LP columns precede non-LP columns and inside both parts lower column indices precede higher ones

SCIProwUnlock^⚠

unlocks a lock of an unmodifiable row; a row with no sealed lock may be modified; has no effect on modifiable rows

SCIProwprepAddConstant^⚠

adds constant term to rowprep

SCIProwprepAddSide^⚠

adds constant value to side of rowprep

SCIProwprepGetCoefs^⚠

gives coefficients of rowprep (feel free to modify)

SCIProwprepGetModifiedVars^⚠

returns variables which coefficients were modified in cleanup

SCIProwprepGetNModifiedVars^⚠

returns number of variables which coefficients were modified in cleanup

SCIProwprepGetNVars^⚠

gives number of terms in rowprep

SCIProwprepGetName^⚠

returns name of rowprep (feel free to modify)

SCIProwprepGetSide^⚠

gives side of rowprep

SCIProwprepGetSidetype^⚠

gives kind of inequality of rowprep

SCIProwprepGetVars^⚠

gives variables of rowprep (feel free to modify)

SCIProwprepIsLocal^⚠

returns whether rowprep is locally valid only

SCIProwprepRecordModifications^⚠

enables recording for where modifications were done in cleanup

SCIProwprepReset^⚠

resets rowprep to have 0 terms and side 0.0

SCIProwprepSetLocal^⚠

sets whether rowprep is local

SCIProwprepSetSidetype^⚠

sets side type of rowprep

SCIPrunShell^⚠

creates a SCIP instance with default plugins, evaluates command line parameters, runs SCIP appropriately, and frees the SCIP instance

SCIPscaleRowprep^⚠

scales a rowprep by given factor (after some rounding)

SCIPscaleVarBranchFactor^⚠

scales the branch factor of the variable with the given value

SCIPscaleupRowprep^⚠

Scales up a rowprep to increase coefficients/sides that are within epsilon to an integer value, if possible.

SCIPselectBranchVarPscost^⚠

selects a branching variable, due to pseudo cost, from the given candidate array and returns this variable together with a branching point

SCIPselectCutsHybrid^⚠

perform a cut selection algorithm for the given array of cuts

SCIPselectDownInd^⚠

partial sort an index array in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectDownInt^⚠

partial sort array of ints in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectDownIntInt^⚠

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.

SCIPselectDownIntIntInt^⚠

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.

SCIPselectDownIntIntIntPtr^⚠

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.

SCIPselectDownIntIntIntReal^⚠

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.

SCIPselectDownIntIntLong^⚠

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.

SCIPselectDownIntIntPtr^⚠

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.

SCIPselectDownIntIntReal^⚠

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.

SCIPselectDownIntPtr^⚠

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.

SCIPselectDownIntPtrIntIntBoolBool^⚠

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.

SCIPselectDownIntPtrIntReal^⚠

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.

SCIPselectDownIntReal^⚠

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.

SCIPselectDownLong^⚠

partial sort an array of Longints in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectDownLongPtr^⚠

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.

SCIPselectDownLongPtrInt^⚠

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.

SCIPselectDownLongPtrPtrBoolInt^⚠

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.

SCIPselectDownLongPtrPtrInt^⚠

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.

SCIPselectDownLongPtrPtrIntInt^⚠

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.

SCIPselectDownLongPtrRealBool^⚠

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.

SCIPselectDownLongPtrRealRealBool^⚠

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.

SCIPselectDownLongPtrRealRealIntBool^⚠

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.

SCIPselectDownPtr^⚠

partial sort of an array of pointers in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectDownPtrBool^⚠

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.

SCIPselectDownPtrInt^⚠

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.

SCIPselectDownPtrIntInt^⚠

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.

SCIPselectDownPtrIntIntBoolBool^⚠

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.

SCIPselectDownPtrPtr^⚠

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.

SCIPselectDownPtrPtrInt^⚠

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.

SCIPselectDownPtrPtrIntInt^⚠

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.

SCIPselectDownPtrPtrLongInt^⚠

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.

SCIPselectDownPtrPtrLongIntInt^⚠

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.

SCIPselectDownPtrPtrReal^⚠

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.

SCIPselectDownPtrPtrRealBool^⚠

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.

SCIPselectDownPtrPtrRealInt^⚠

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.

SCIPselectDownPtrReal^⚠

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.

SCIPselectDownPtrRealBool^⚠

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.

SCIPselectDownPtrRealInt^⚠

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.

SCIPselectDownPtrRealIntInt^⚠

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.

SCIPselectDownReal^⚠

partial sort an array of Reals in non-increasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectDownRealBoolPtr^⚠

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.

SCIPselectDownRealInt^⚠

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.

SCIPselectDownRealIntInt^⚠

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.

SCIPselectDownRealIntLong^⚠

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.

SCIPselectDownRealIntPtr^⚠

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.

SCIPselectDownRealLongRealInt^⚠

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.

SCIPselectDownRealPtr^⚠

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.

SCIPselectDownRealPtrPtr^⚠

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.

SCIPselectDownRealPtrPtrInt^⚠

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.

SCIPselectDownRealPtrPtrIntInt^⚠

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.

SCIPselectDownRealRealInt^⚠

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.

SCIPselectDownRealRealIntInt^⚠

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.

SCIPselectDownRealRealPtr^⚠

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.

SCIPselectDownRealRealPtrPtr^⚠

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

SCIPselectDownRealRealRealBoolBoolPtr^⚠

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.

SCIPselectDownRealRealRealBoolPtr^⚠

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.

SCIPselectDownRealRealRealInt^⚠

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.

SCIPselectDownRealRealRealPtr^⚠

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.

SCIPselectInd^⚠

partial sort an index array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectInt^⚠

partial sort array of ints in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectIntInt^⚠

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.

SCIPselectIntIntInt^⚠

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.

SCIPselectIntIntIntPtr^⚠

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.

SCIPselectIntIntIntReal^⚠

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.

SCIPselectIntIntLong^⚠

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.

SCIPselectIntIntPtr^⚠

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.

SCIPselectIntIntReal^⚠

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.

SCIPselectIntPtr^⚠

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.

SCIPselectIntPtrIntIntBoolBool^⚠

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.

SCIPselectIntPtrIntReal^⚠

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.

SCIPselectIntPtrReal^⚠

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.

SCIPselectIntReal^⚠

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.

SCIPselectIntRealLong^⚠

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.

SCIPselectLong^⚠

partial sort an array of Longints in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectLongPtr^⚠

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.

SCIPselectLongPtrInt^⚠

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.

SCIPselectLongPtrPtrBoolInt^⚠

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.

SCIPselectLongPtrPtrInt^⚠

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.

SCIPselectLongPtrPtrIntInt^⚠

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.

SCIPselectLongPtrRealBool^⚠

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.

SCIPselectLongPtrRealRealBool^⚠

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.

SCIPselectLongPtrRealRealIntBool^⚠

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.

SCIPselectPtr^⚠

partial sort of an array of pointers in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectPtrBool^⚠

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.

SCIPselectPtrInt^⚠

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.

SCIPselectPtrIntInt^⚠

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.

SCIPselectPtrIntIntBoolBool^⚠

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.

SCIPselectPtrPtr^⚠

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.

SCIPselectPtrPtrInt^⚠

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.

SCIPselectPtrPtrIntInt^⚠

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.

SCIPselectPtrPtrLongInt^⚠

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.

SCIPselectPtrPtrLongIntInt^⚠

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.

SCIPselectPtrPtrReal^⚠

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.

SCIPselectPtrPtrRealBool^⚠

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.

SCIPselectPtrPtrRealInt^⚠

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.

SCIPselectPtrReal^⚠

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.

SCIPselectPtrRealBool^⚠

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.

SCIPselectPtrRealInt^⚠

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.

SCIPselectPtrRealIntInt^⚠

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.

SCIPselectPtrRealReal^⚠

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.

SCIPselectPtrRealRealBoolBool^⚠

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.

SCIPselectPtrRealRealInt^⚠

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.

SCIPselectPtrRealRealIntBool^⚠

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.

SCIPselectReal^⚠

partial sort an array of Reals in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.

SCIPselectRealBoolPtr^⚠

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.

SCIPselectRealInt^⚠

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.

SCIPselectRealIntInt^⚠

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.

SCIPselectRealIntLong^⚠

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.

SCIPselectRealIntPtr^⚠

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.

SCIPselectRealLongRealInt^⚠

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.

SCIPselectRealPtr^⚠

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.

SCIPselectRealPtrPtrInt^⚠

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.

SCIPselectRealPtrPtrIntInt^⚠

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.

SCIPselectRealRealIntInt^⚠

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.

SCIPselectRealRealPtr^⚠

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.

SCIPselectRealRealRealBoolBoolPtr^⚠

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.

SCIPselectRealRealRealBoolPtr^⚠

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.

SCIPselectRealRealRealInt^⚠

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.

SCIPselectRealRealRealPtr^⚠

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.

SCIPselectSimpleValue^⚠

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

SCIPselectVarPseudoStrongBranching^⚠

Selects a variable from a set of candidates by strong branching

SCIPselectVarStrongBranching^⚠

Selects a variable from a set of candidates by strong branching

SCIPselectWeightedDownInd^⚠

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.

SCIPselectWeightedDownInt^⚠

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.

SCIPselectWeightedDownIntInt^⚠

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.

SCIPselectWeightedDownIntIntInt^⚠

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.

SCIPselectWeightedDownIntIntIntPtr^⚠

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.

SCIPselectWeightedDownIntIntIntReal^⚠

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.

SCIPselectWeightedDownIntIntLong^⚠

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.

SCIPselectWeightedDownIntIntPtr^⚠

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.

SCIPselectWeightedDownIntIntReal^⚠

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.

SCIPselectWeightedDownIntPtr^⚠

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.

SCIPselectWeightedDownIntPtrIntIntBoolBool^⚠

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.

SCIPselectWeightedDownIntPtrIntReal^⚠

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.

SCIPselectWeightedDownIntReal^⚠

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.

SCIPselectWeightedDownLong^⚠

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.

SCIPselectWeightedDownLongPtr^⚠

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.

SCIPselectWeightedDownLongPtrInt^⚠

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.

SCIPselectWeightedDownLongPtrPtrBoolInt^⚠

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.

SCIPselectWeightedDownLongPtrPtrInt^⚠

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.

SCIPselectWeightedDownLongPtrPtrIntInt^⚠

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.

SCIPselectWeightedDownLongPtrRealBool^⚠

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.

SCIPselectWeightedDownLongPtrRealRealBool^⚠

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.

SCIPselectWeightedDownLongPtrRealRealIntBool^⚠

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.

SCIPselectWeightedDownPtr^⚠

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.

SCIPselectWeightedDownPtrBool^⚠

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.

SCIPselectWeightedDownPtrInt^⚠

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.

SCIPselectWeightedDownPtrIntInt^⚠

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.

SCIPselectWeightedDownPtrIntIntBoolBool^⚠

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.

SCIPselectWeightedDownPtrPtr^⚠

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.

SCIPselectWeightedDownPtrPtrInt^⚠

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.

SCIPselectWeightedDownPtrPtrIntInt^⚠

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.

SCIPselectWeightedDownPtrPtrLongInt^⚠

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.

SCIPselectWeightedDownPtrPtrLongIntInt^⚠

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.

SCIPselectWeightedDownPtrPtrReal^⚠

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.

SCIPselectWeightedDownPtrPtrRealBool^⚠

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.

SCIPselectWeightedDownPtrPtrRealInt^⚠

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.

SCIPselectWeightedDownPtrReal^⚠

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.

SCIPselectWeightedDownPtrRealBool^⚠

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.

SCIPselectWeightedDownPtrRealInt^⚠

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.

SCIPselectWeightedDownPtrRealIntInt^⚠

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.

SCIPselectWeightedDownReal^⚠

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.

SCIPselectWeightedDownRealBoolPtr^⚠

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.

SCIPselectWeightedDownRealInt^⚠

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.

SCIPselectWeightedDownRealIntInt^⚠

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.

SCIPselectWeightedDownRealIntLong^⚠

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.

SCIPselectWeightedDownRealIntPtr^⚠

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.

SCIPselectWeightedDownRealLongRealInt^⚠

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.

SCIPselectWeightedDownRealPtr^⚠

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.

SCIPselectWeightedDownRealPtrPtr^⚠

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.

SCIPselectWeightedDownRealPtrPtrInt^⚠

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.

SCIPselectWeightedDownRealPtrPtrIntInt^⚠

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.

SCIPselectWeightedDownRealRealInt^⚠

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.

SCIPselectWeightedDownRealRealIntInt^⚠

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.

SCIPselectWeightedDownRealRealPtr^⚠

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.

SCIPselectWeightedDownRealRealPtrPtr^⚠

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

SCIPselectWeightedDownRealRealRealBoolBoolPtr^⚠

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.

SCIPselectWeightedDownRealRealRealBoolPtr^⚠

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.

SCIPselectWeightedDownRealRealRealInt^⚠

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.

SCIPselectWeightedDownRealRealRealPtr^⚠

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.

SCIPselectWeightedInd^⚠

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.

SCIPselectWeightedInt^⚠

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.

SCIPselectWeightedIntInt^⚠

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.

SCIPselectWeightedIntIntInt^⚠

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.

SCIPselectWeightedIntIntIntPtr^⚠

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.

SCIPselectWeightedIntIntIntReal^⚠

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.

SCIPselectWeightedIntIntLong^⚠

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.

SCIPselectWeightedIntIntPtr^⚠

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.

SCIPselectWeightedIntIntReal^⚠

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.

SCIPselectWeightedIntPtr^⚠

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.

SCIPselectWeightedIntPtrIntIntBoolBool^⚠

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.

SCIPselectWeightedIntPtrIntReal^⚠

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.

SCIPselectWeightedIntPtrReal^⚠

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.

SCIPselectWeightedIntReal^⚠

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.

SCIPselectWeightedIntRealLong^⚠

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.

SCIPselectWeightedLong^⚠

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.

SCIPselectWeightedLongPtr^⚠

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.

SCIPselectWeightedLongPtrInt^⚠

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.

SCIPselectWeightedLongPtrPtrBoolInt^⚠

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.

SCIPselectWeightedLongPtrPtrInt^⚠

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.

SCIPselectWeightedLongPtrPtrIntInt^⚠

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.

SCIPselectWeightedLongPtrRealBool^⚠

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.

SCIPselectWeightedLongPtrRealRealBool^⚠

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.

SCIPselectWeightedLongPtrRealRealIntBool^⚠

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.

SCIPselectWeightedPtr^⚠

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.

SCIPselectWeightedPtrBool^⚠

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.

SCIPselectWeightedPtrInt^⚠

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.

SCIPselectWeightedPtrIntInt^⚠

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.

SCIPselectWeightedPtrIntIntBoolBool^⚠

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.

SCIPselectWeightedPtrPtr^⚠

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.

SCIPselectWeightedPtrPtrInt^⚠

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.

SCIPselectWeightedPtrPtrIntInt^⚠

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.

SCIPselectWeightedPtrPtrLongInt^⚠

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.

SCIPselectWeightedPtrPtrLongIntInt^⚠

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.

SCIPselectWeightedPtrPtrReal^⚠

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.

SCIPselectWeightedPtrPtrRealBool^⚠

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.

SCIPselectWeightedPtrPtrRealInt^⚠

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.

SCIPselectWeightedPtrReal^⚠

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.

SCIPselectWeightedPtrRealBool^⚠

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.

SCIPselectWeightedPtrRealInt^⚠

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.

SCIPselectWeightedPtrRealIntInt^⚠

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.

SCIPselectWeightedPtrRealReal^⚠

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.

SCIPselectWeightedPtrRealRealBoolBool^⚠

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.

SCIPselectWeightedPtrRealRealInt^⚠

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.

SCIPselectWeightedPtrRealRealIntBool^⚠

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.

SCIPselectWeightedReal^⚠

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.

SCIPselectWeightedRealBoolPtr^⚠

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.

SCIPselectWeightedRealInt^⚠

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.

SCIPselectWeightedRealIntInt^⚠

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.

SCIPselectWeightedRealIntLong^⚠

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.

SCIPselectWeightedRealIntPtr^⚠

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.

SCIPselectWeightedRealLongRealInt^⚠

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.

SCIPselectWeightedRealPtr^⚠

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.

SCIPselectWeightedRealPtrPtrInt^⚠

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.

SCIPselectWeightedRealPtrPtrIntInt^⚠

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.

SCIPselectWeightedRealRealIntInt^⚠

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.

SCIPselectWeightedRealRealPtr^⚠

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.

SCIPselectWeightedRealRealRealBoolBoolPtr^⚠

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.

SCIPselectWeightedRealRealRealBoolPtr^⚠

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.

SCIPselectWeightedRealRealRealInt^⚠

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.

SCIPselectWeightedRealRealRealPtr^⚠

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.

SCIPsepaComp^⚠

compares two separators w. r. to their priority

SCIPsepaCompName^⚠

comparison method for sorting separators w.r.t. to their name

SCIPsepaGetData^⚠

gets user data of separator

SCIPsepaGetDesc^⚠

gets description of separator

SCIPsepaGetFreq^⚠

gets frequency of separator

SCIPsepaGetMaxbounddist^⚠

get maximal bound distance at which the separator is called

SCIPsepaGetNCalls^⚠

gets the total number of times the separator was called

SCIPsepaGetNCallsAtNode^⚠

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

SCIPsepaGetNConssFound^⚠

gets total number of additional constraints added by this separator

SCIPsepaGetNCutoffs^⚠

gets total number of times, the separator detected a cutoff

SCIPsepaGetNCutsAdded^⚠

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.

SCIPsepaGetNCutsAddedDirect^⚠

gets the number of cutting planes from the separator added directly to the sepastore

SCIPsepaGetNCutsAddedViaPool^⚠

gets the number of cutting planes from the separator added from the cut pool

SCIPsepaGetNCutsApplied^⚠

gets the total number of cutting planes from the separator applied to the LP

SCIPsepaGetNCutsAppliedDirect^⚠

gets the total number of cutting planes from the separator applied directly to the LP

SCIPsepaGetNCutsAppliedViaPool^⚠

gets the total number of cutting planes from the separator applied to the LP from the cutpool

SCIPsepaGetNCutsFound^⚠

gets the total number of cutting planes added from the separator to the cut pool and to the sepastore directly

SCIPsepaGetNCutsFoundAtNode^⚠

gets the number of cutting planes found by this separator at the current node

SCIPsepaGetNDomredsFound^⚠

gets total number of domain reductions found by this separator

SCIPsepaGetNRootCalls^⚠

gets the total number of times the separator was called at the root

SCIPsepaGetName^⚠

gets name of separator

SCIPsepaGetParentsepa^⚠

gets parent separator (or NULL)

SCIPsepaGetPriority^⚠

gets priority of separator

SCIPsepaGetSetupTime^⚠

gets time in seconds used in this separator for setting up for next stages

SCIPsepaGetTime^⚠

gets time in seconds used in this separator

SCIPsepaIsDelayed^⚠

should separator be delayed, if other separators found cuts?

SCIPsepaIsInitialized^⚠

is separator initialized?

SCIPsepaIsParentsepa^⚠

gets whether separator is a parent separator

SCIPsepaSetData^⚠

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

SCIPsepaSetFreq^⚠

sets frequency of separator

SCIPsepaUsesSubscip^⚠

does the separator use a secondary SCIP instance?

SCIPsepaWasLPDelayed^⚠

was separation of the LP solution delayed at the last call?

SCIPsepaWasSolDelayed^⚠

was separation of the primal solution delayed at the last call?

SCIPsepalpCons^⚠

calls separation method of single constraint for LP solution

SCIPseparateCutpool^⚠

separates cuts from a cut pool

SCIPseparateKnapsackCuts^⚠

separates different classes of valid inequalities for the 0-1 knapsack problem

SCIPseparateRelaxedKnapsack^⚠

SCIPseparateSol^⚠

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

SCIPseparateSolCutpool^⚠

separates cuts w.r.t. given solution from a cut pool

SCIPsepasolCons^⚠

calls separation method of single constraint for given primal solution

SCIPsetBasePointClosecuts^⚠

sets point to be used as base point for computing the point to be separated

SCIPsetBendersCopy^⚠

sets copy method of benders

SCIPsetBendersExit^⚠

sets deinitialization method of benders

SCIPsetBendersExitpre^⚠

sets presolving deinitialization method of benders

SCIPsetBendersExitsol^⚠

sets solving process deinitialization method of benders

SCIPsetBendersFree^⚠

sets destructor method of benders

SCIPsetBendersInit^⚠

sets initialization method of benders

SCIPsetBendersInitpre^⚠

sets presolving initialization method of benders

SCIPsetBendersInitsol^⚠

sets solving process initialization method of benders

SCIPsetBendersPostsolve^⚠

sets the post solving methods for benders

SCIPsetBendersPresubsolve^⚠

sets the method called prior to solving the subproblems for benders

SCIPsetBendersPriority^⚠

sets the priority of a Benders’ decomposition

SCIPsetBendersSolveAndFreesub^⚠

sets the subproblem solving and freeing methods for Benders’ decomposition

SCIPsetBendersSubproblemComp^⚠

sets the subproblem comparison method for determining the solving order in Benders’ decomposition

SCIPsetBenderscutCopy^⚠

sets copy method of Benders’ decomposition cut

SCIPsetBenderscutExit^⚠

sets deinitialization method of benderscut

SCIPsetBenderscutExitsol^⚠

sets solving process deinitialization method of benderscut

SCIPsetBenderscutFree^⚠

sets destructor method of benderscut

SCIPsetBenderscutInit^⚠

sets initialization method of benderscut

SCIPsetBenderscutInitsol^⚠

sets solving process initialization method of benderscut

SCIPsetBenderscutPriority^⚠

sets the priority of a Benders’ decomposition cut algorithm

SCIPsetBetaExp3^⚠

set beta parameter of Exp.3 bandit algorithm to increase gain offset for actions that were not played

SCIPsetBinaryVarIndicator^⚠

sets binary indicator variable for indicator constraint

SCIPsetBoolParam^⚠

changes the value of an existing SCIP_Bool parameter

SCIPsetBoolarrayVal^⚠

sets value of entry in dynamic array

SCIPsetBranchruleCopy^⚠

sets copy method of branching rule

SCIPsetBranchruleExecExt^⚠

sets branching execution method for external candidates

SCIPsetBranchruleExecLp^⚠

sets branching execution method for fractional LP solutions

SCIPsetBranchruleExecPs^⚠

sets branching execution method for not completely fixed pseudo solutions

SCIPsetBranchruleExit^⚠

sets deinitialization method of branching rule

SCIPsetBranchruleExitsol^⚠

sets solving process deinitialization method of branching rule

SCIPsetBranchruleFree^⚠

sets destructor method of branching rule

SCIPsetBranchruleInit^⚠

sets initialization method of branching rule

SCIPsetBranchruleInitsol^⚠

sets solving process initialization method of branching rule

SCIPsetBranchruleMaxbounddist^⚠

sets maximal relative distance from current node’s dual bound to primal bound for applying branching rule

SCIPsetBranchruleMaxdepth^⚠

sets maximal depth level, up to which this branching rule should be used (-1 for no limit)

SCIPsetBranchrulePriority^⚠

sets the priority of a branching rule

SCIPsetCharParam^⚠

changes the value of an existing char parameter

SCIPsetClockEnabled^⚠

enables or disables \p clck

SCIPsetClockTime^⚠

sets the measured time of a clock to the given value in seconds

SCIPsetCommonSubscipParams^⚠

sets the working limits as well as common search parameters for the auxiliary problem

SCIPsetComprCopy^⚠

sets copy method of tree compression

SCIPsetComprExit^⚠

sets deinitialization method of tree compression

SCIPsetComprExitsol^⚠

sets solving process deinitialization method of tree compression

SCIPsetComprFree^⚠

sets destructor method of tree compression

SCIPsetComprInit^⚠

sets initialization method of tree compression

SCIPsetComprInitsol^⚠

sets solving process initialization method of tree compression

SCIPsetComprPriority^⚠

set the priority of a tree compression method

SCIPsetConflicthdlrCopy^⚠

set copy method of conflict handler

SCIPsetConflicthdlrExit^⚠

set deinitialization method of conflict handler

SCIPsetConflicthdlrExitsol^⚠

set solving process deinitialization method of conflict handler

SCIPsetConflicthdlrFree^⚠

set destructor of conflict handler

SCIPsetConflicthdlrInit^⚠

set initialization method of conflict handler

SCIPsetConflicthdlrInitsol^⚠

set solving process initialization method of conflict handler

SCIPsetConflicthdlrPriority^⚠

sets the priority of a conflict handler

SCIPsetConsChecked^⚠

sets the check flag of the given constraint

SCIPsetConsDynamic^⚠

sets the dynamic flag of the given constraint

SCIPsetConsEnforced^⚠

sets the enforce flag of the given constraint

SCIPsetConsInitial^⚠

sets the initial flag of the given constraint

SCIPsetConsLocal^⚠

sets the local flag of the given constraint

SCIPsetConsModifiable^⚠

sets the modifiable flag of the given constraint

SCIPsetConsPropagated^⚠

sets the propagate flag of the given constraint

SCIPsetConsRemovable^⚠

sets the removable flag of the given constraint

SCIPsetConsSeparated^⚠

sets the separate flag of the given constraint

SCIPsetConsStickingAtNode^⚠

sets the stickingatnode flag of the given constraint

SCIPsetConshdlrActive^⚠

sets activation notification method of constraint handler

SCIPsetConshdlrCopy^⚠

sets copy method of both the constraint handler and each associated constraint

SCIPsetConshdlrDeactive^⚠

sets deactivation notification method of constraint handler

SCIPsetConshdlrDelete^⚠

sets method of constraint handler to free specific constraint data

SCIPsetConshdlrDelvars^⚠

sets variable deletion method of constraint handler

SCIPsetConshdlrDisable^⚠

sets disabling notification method of constraint handler

SCIPsetConshdlrEnable^⚠

sets enabling notification method of constraint handler

SCIPsetConshdlrEnforelax^⚠

sets relaxation enforcement method of the constraint handler

SCIPsetConshdlrExit^⚠

sets deinitialization method of constraint handler

SCIPsetConshdlrExitpre^⚠

sets preprocessing deinitialization method of constraint handler

SCIPsetConshdlrExitsol^⚠

sets solving process deinitialization method of constraint handler

SCIPsetConshdlrFree^⚠

sets destructor method of constraint handler

SCIPsetConshdlrGetDiveBdChgs^⚠

sets diving enforcement method of constraint handler

SCIPsetConshdlrGetNVars^⚠

sets constraint variable number getter method of constraint handler

SCIPsetConshdlrGetVars^⚠

sets constraint variable getter method of constraint handler

SCIPsetConshdlrInit^⚠

sets initialization method of constraint handler

SCIPsetConshdlrInitlp^⚠

sets method of constraint handler to initialize LP with relaxations of “initial” constraints

SCIPsetConshdlrInitpre^⚠

sets preprocessing initialization method of constraint handler

SCIPsetConshdlrInitsol^⚠

sets solving process initialization method of constraint handler

SCIPsetConshdlrParse^⚠

sets constraint parsing method of constraint handler

SCIPsetConshdlrPresol^⚠

sets presolving method of constraint handler

SCIPsetConshdlrPrint^⚠

sets constraint display method of constraint handler

SCIPsetConshdlrProp^⚠

sets both the propagation callback and the propagation frequency of the constraint handler

SCIPsetConshdlrResprop^⚠

sets propagation conflict resolving method of constraint handler

SCIPsetConshdlrSepa^⚠

sets all separation related callbacks/parameters of the constraint handler

SCIPsetConshdlrTrans^⚠

sets method of constraint handler to transform constraint data into data belonging to the transformed problem

SCIPsetConstantExprSum^⚠

sets the constant of a summation expression

SCIPsetCutselCopy^⚠

sets copy method of cut selector

SCIPsetCutselExit^⚠

sets deinitialization method of cut selector

SCIPsetCutselExitsol^⚠

sets solving process deinitialization method of cut selector

SCIPsetCutselFree^⚠

sets destructor method of cut selector

SCIPsetCutselInit^⚠

sets initialization method of cut selector

SCIPsetCutselInitsol^⚠

sets solving process initialization method of cut selector

SCIPsetCutselPriority^⚠

sets the priority of a cut selector

SCIPsetEmphasis^⚠

sets parameters to

SCIPsetEpsilonEpsgreedy^⚠

set epsilon parameter of epsilon greedy bandit algorithm

SCIPsetEventhdlrCopy^⚠

sets copy callback of the event handler

SCIPsetEventhdlrDelete^⚠

sets callback of the event handler to free specific event data

SCIPsetEventhdlrExit^⚠

sets deinitialization callback of the event handler

SCIPsetEventhdlrExitsol^⚠

sets solving process deinitialization callback of the event handler

SCIPsetEventhdlrFree^⚠

sets deinitialization callback of the event handler

SCIPsetEventhdlrInit^⚠

sets initialization callback of the event handler

SCIPsetEventhdlrInitsol^⚠

sets solving process initialization callback of the event handler

SCIPsetExprEnfoAuxValueNonlinear^⚠

sets the auxiliary value of expression for one of the enforcements of an expression

SCIPsetFocusnodeLP^⚠

sets whether the LP should be solved at the focus node

SCIPsetGammaExp3^⚠

set gamma parameter of Exp.3 bandit algorithm to increase weight of uniform distribution

SCIPsetHeurCopy^⚠

sets copy method of primal heuristic

SCIPsetHeurExit^⚠

sets deinitialization method of primal heuristic

SCIPsetHeurExitsol^⚠

sets solving process deinitialization method of primal heuristic

SCIPsetHeurFree^⚠

sets destructor method of primal heuristic

SCIPsetHeurInit^⚠

sets initialization method of primal heuristic

SCIPsetHeurInitsol^⚠

sets solving process initialization method of primal heuristic

SCIPsetHeurPriority^⚠

sets the priority of a primal heuristic

SCIPsetHeuristics^⚠

sets heuristic parameters values to

SCIPsetHmaxCumulative^⚠

set the right bound of the effective horizon

SCIPsetHminCumulative^⚠

set the left bound of effective horizon

SCIPsetIndexExprVaridx^⚠

sets the index stored in a varidx expression

SCIPsetIntParam^⚠

changes the value of an existing int parameter

SCIPsetIntarrayVal^⚠

sets value of entry in dynamic array

SCIPsetLPFeastol^⚠

sets primal feasibility tolerance of LP

SCIPsetLinearConsIndicator^⚠

sets the linear constraint corresponding to the indicator constraint (may be NULL)

SCIPsetLongintParam^⚠

changes the value of an existing SCIP_Longint parameter

SCIPsetMessagehdlr^⚠

installs the given message handler, such that all messages are passed to this handler. A messages handler can be created via SCIPmessagehdlrCreate().

SCIPsetMessagehdlrLogfile^⚠

sets the log file name for the currently installed message handler

SCIPsetMessagehdlrQuiet^⚠

sets the currently installed message handler to be quiet (or not)

SCIPsetNLPInitialGuess^⚠

sets or clears initial primal guess for NLP solution (start point for NLP solver)

SCIPsetNLPInitialGuessSol^⚠

sets initial primal guess for NLP solution (start point for NLP solver)

SCIPsetNlRowExpr^⚠

sets or deletes expression in a nonlinear row

SCIPsetNlpiInitialGuess^⚠

sets initial guess

SCIPsetNlpiObjective^⚠

sets or overwrites objective, a minimization problem is expected

SCIPsetNlpiPriority^⚠

sets the priority of an NLPI

SCIPsetNodeselCopy^⚠

sets copy method of node selector

SCIPsetNodeselExit^⚠

sets deinitialization method of node selector

SCIPsetNodeselExitsol^⚠

sets solving process deinitialization method of node selector

SCIPsetNodeselFree^⚠

sets destructor method of node selector

SCIPsetNodeselInit^⚠

sets initialization method of node selector

SCIPsetNodeselInitsol^⚠

sets solving process initialization method of node selector

SCIPsetNodeselMemsavePriority^⚠

sets the priority of a node selector in memory saving mode

SCIPsetNodeselStdPriority^⚠

sets the priority of a node selector in standard mode

SCIPsetObjIntegral^⚠

informs SCIP, that the objective value is always integral in every feasible solution

SCIPsetObjlimit^⚠

sets limit on objective function, such that only solutions better than this limit are accepted

SCIPsetObjsense^⚠

sets objective sense of problem

SCIPsetParamsCountsols^⚠

setting SCIP parameters for such that a valid counting process is possible

SCIPsetPresolCopy^⚠

sets copy method of presolver

SCIPsetPresolExit^⚠

sets deinitialization method of presolver

SCIPsetPresolExitpre^⚠

sets solving process deinitialization method of presolver

SCIPsetPresolFree^⚠

sets destructor method of presolver

SCIPsetPresolInit^⚠

sets initialization method of presolver

SCIPsetPresolInitpre^⚠

sets solving process initialization method of presolver

SCIPsetPresolPriority^⚠

sets the priority of a presolver

SCIPsetPresolving^⚠

sets presolving parameters to

SCIPsetPricerCopy^⚠

sets copy method of pricer

SCIPsetPricerExit^⚠

sets deinitialization method of pricer

SCIPsetPricerExitsol^⚠

sets solving process deinitialization method of pricer

SCIPsetPricerFree^⚠

sets destructor method of pricer

SCIPsetPricerInit^⚠

sets initialization method of pricer

SCIPsetPricerInitsol^⚠

sets solving process initialization method of pricer

SCIPsetPricerPriority^⚠

sets the priority of a variable pricer

SCIPsetProbCopy^⚠

sets callback to copy user data to a subscip

SCIPsetProbData^⚠

sets user problem data

SCIPsetProbDelorig^⚠

sets callback to free user data of original problem

SCIPsetProbDeltrans^⚠

sets callback to free user data of transformed problem

SCIPsetProbExitsol^⚠

sets solving process deinitialization callback of transformed data

SCIPsetProbInitsol^⚠

sets solving process initialization callback of transformed data

SCIPsetProbName^⚠

sets name of the current problem instance

SCIPsetProbTrans^⚠

sets callback to create user data of transformed problem by transforming original user data

SCIPsetProbingLPState^⚠

sets the LP state for the current probing node

SCIPsetPropCopy^⚠

sets copy method of propagator

SCIPsetPropExit^⚠

sets deinitialization method of propagator

SCIPsetPropExitpre^⚠

sets preprocessing deinitialization method of propagator

SCIPsetPropExitsol^⚠

sets solving process deinitialization method of propagator

SCIPsetPropFree^⚠

sets destructor method of propagator

SCIPsetPropInit^⚠

sets initialization method of propagator

SCIPsetPropInitpre^⚠

sets preprocessing initialization method of propagator

SCIPsetPropInitsol^⚠

sets solving process initialization method of propagator

SCIPsetPropPresol^⚠

sets presolving method of propagator

SCIPsetPropPresolPriority^⚠

sets the presolving priority of a propagator

SCIPsetPropPriority^⚠

sets the priority of a propagator

SCIPsetPropResprop^⚠

sets propagation conflict resolving callback of propagator

SCIPsetPtrarrayVal^⚠

sets value of entry in dynamic array

SCIPsetRandomSeed^⚠

initializes a random number generator with a given seed

SCIPsetReaderCopy^⚠

set copy method of reader

SCIPsetReaderFree^⚠

set deinitialization method of reader

SCIPsetReaderRead^⚠

set read method of reader

SCIPsetReaderWrite^⚠

set write method of reader

SCIPsetRealParam^⚠

changes the value of an existing SCIP_Real parameter

SCIPsetRealarrayVal^⚠

sets value of entry in dynamic array

SCIPsetRelaxCopy^⚠

sets copy method of relaxation handler

SCIPsetRelaxExit^⚠

sets deinitialization method of relaxation handler

SCIPsetRelaxExitsol^⚠

sets solving process deinitialization method of relaxation handler

SCIPsetRelaxFree^⚠

sets destructor method of relaxation handler

SCIPsetRelaxInit^⚠

sets initialization method of relaxation handler

SCIPsetRelaxInitsol^⚠

sets solving process initialization method of relaxation handler

SCIPsetRelaxPriority^⚠

sets the priority of a relaxation handler

SCIPsetRelaxSolVal^⚠

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

SCIPsetRelaxSolVals^⚠

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

SCIPsetRelaxSolValsSol^⚠

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

SCIPsetReoptCompression^⚠

set the @p representation as the new search frontier

SCIPsetRootDialog^⚠

makes given dialog the root dialog of SCIP’s interactive user shell; captures dialog and releases former root dialog

SCIPsetSepaCopy^⚠

sets copy method of separator

SCIPsetSepaExit^⚠

sets deinitialization method of separator

SCIPsetSepaExitsol^⚠

sets solving process deinitialization method of separator

SCIPsetSepaFree^⚠

sets destructor method of separator

SCIPsetSepaInit^⚠

sets initialization method of separator

SCIPsetSepaInitsol^⚠

sets solving process initialization method of separator

SCIPsetSepaIsParentsepa^⚠

declares separator to be a parent separator

SCIPsetSepaParentsepa^⚠

sets the parent separator

SCIPsetSepaPriority^⚠

sets the priority of a separator

SCIPsetSeparating^⚠

sets separating parameters to

SCIPsetSlackVarUb^⚠

sets upper bound for slack variable corresponding to indicator constraint

SCIPsetSolVal^⚠

sets value of variable in primal CIP solution

SCIPsetSolVals^⚠

sets values of multiple variables in primal CIP solution

SCIPsetSolveCumulative^⚠

sets method to solve an individual cumulative condition

SCIPsetStringParam^⚠

changes the value of an existing string(char*) parameter

SCIPsetSubscipDepth^⚠

sets depth of scip instance

SCIPsetSubscipsOff^⚠

sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for auxiliary SCIP instances to avoid recursion

SCIPsetVarStrongbranchData^⚠

sets strong branching information for a column variable

SCIPsetupBendersSubproblem^⚠

calls the generic subproblem setup method for a Benders’ decomposition subproblem

SCIPshowExpr^⚠

shows a single expression by use of dot and gv

SCIPshrinkDisjunctiveVarSet^⚠

@defgroup PublicSpecialPresolveMethods Special Methods @ingroup PublicPresolverMethods @brief methods commonly used for presolving

SCIPsignificantVarPscostDifference^⚠

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.

SCIPsimplifyExpr^⚠

simplifies an expression

SCIPsnprintf^⚠

safe version of snprintf

SCIPsnprintfProbingStats^⚠

print statistics of probing

SCIPsolGetAbsBoundViolation^⚠

get maximum absolute bound violation of solution

SCIPsolGetAbsConsViolation^⚠

get maximum absolute constraint violation of solution

SCIPsolGetAbsIntegralityViolation^⚠

get maximum absolute integrality violation of solution

SCIPsolGetAbsLPRowViolation^⚠

get maximum absolute LP row violation of solution

SCIPsolGetDepth^⚠

gets node’s depth, where this solution was found

SCIPsolGetHeur^⚠

gets heuristic that found this solution, or NULL if solution has type different than SCIP_SOLTYPE_HEUR

SCIPsolGetIndex^⚠

returns unique index of given solution

SCIPsolGetNodenum^⚠

gets node number of the specific branch and bound run, where this solution was found

SCIPsolGetOrigObj^⚠

gets objective value of primal CIP solution which lives in the original problem space

SCIPsolGetOrigin^⚠

gets origin of solution

SCIPsolGetRelBoundViolation^⚠

get maximum relative bound violation of solution

SCIPsolGetRelConsViolation^⚠

get maximum relative constraint violation of solution

SCIPsolGetRelLPRowViolation^⚠

get maximum relative LP row violation of solution

SCIPsolGetRelax^⚠

gets relaxation handler that found this solution, or NULL if solution has different type than SCIP_SOLTYPE_RELAX

SCIPsolGetRunnum^⚠

gets branch and bound run number, where this solution was found

SCIPsolGetTime^⚠

gets clock time, when this solution was found

SCIPsolGetType^⚠

gets information if solution was found by the LP, a primal heuristic, or a custom relaxator

SCIPsolIsOriginal^⚠

returns whether the given solution is defined on original variables

SCIPsolIsPartial^⚠

returns whether the given solution is partial

SCIPsolSetHeur^⚠

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.

SCIPsolSetLPRelaxation^⚠

informs the solution that it is an LP relaxation solution

SCIPsolSetPseudo^⚠

informs the solution that it originates from a pseudo solution

SCIPsolSetRelax^⚠

informs the solution that it now belongs to the given relaxation handler

SCIPsolSetStrongbranching^⚠

informs the solution that it is a solution found during strong branching

SCIPsolve^⚠

transforms, presolves, and solves problem

SCIPsolveBendersSubproblem^⚠

calls the solving method for a single Benders’ decomposition subproblem

SCIPsolveBendersSubproblems^⚠

calls the exec method of Benders’ decomposition to solve the subproblems

SCIPsolveConcurrent^⚠

transforms, presolves, and solves problem using additional solvers which emphasize on finding solutions.

SCIPsolveCumulative^⚠

solves given cumulative condition as independent sub problem

SCIPsolveDiveLP^⚠

solves the LP of the current dive; no separation or pricing is applied

SCIPsolveKnapsackApproximately^⚠

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

SCIPsolveKnapsackExactly^⚠

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

SCIPsolveLinearEquationsIpopt^⚠

solves a linear problem of the form Ax = b for a regular matrix A

SCIPsolveNLPParam^⚠

solves the current NLP (or diving NLP if in diving mode) with given parameters

SCIPsolveNlpiParam^⚠

try to solve NLP with all parameters given as SCIP_NLPPARAM struct

SCIPsolveParallel^⚠

transforms, presolves, and solves problem using additional solvers which emphasize on finding solutions.

SCIPsolveProbingLP^⚠

solves the LP at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied

SCIPsolveProbingLPWithPricing^⚠

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

SCIPsolveProbingRelax^⚠

solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied

SCIPsort^⚠

sort an indexed element set in non-decreasing order, resulting in a permutation index array

SCIPsortAndCons^⚠

sort the variables of the AND-constraint with respect to their indices

SCIPsortCompInt^⚠

default comparer for integers

SCIPsortDown^⚠

sort an indexed element set in non-increasing order, resulting in a permutation index array

SCIPsortDownInd^⚠

sort an index array in non-increasing order

SCIPsortDownInt^⚠

sort array of ints in non-increasing order

SCIPsortDownIntInt^⚠

sort of two joint arrays of ints/ints, sorted by first array in non-increasing order

SCIPsortDownIntIntInt^⚠

sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

SCIPsortDownIntIntIntPtr^⚠

sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order

SCIPsortDownIntIntIntReal^⚠

sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order

SCIPsortDownIntIntLong^⚠

sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

SCIPsortDownIntIntPtr^⚠

sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

SCIPsortDownIntIntReal^⚠

sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

SCIPsortDownIntPtr^⚠

sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order

SCIPsortDownIntPtrIntIntBoolBool^⚠

sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

SCIPsortDownIntPtrIntReal^⚠

sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order

SCIPsortDownIntReal^⚠

sort of two joint arrays of ints/reals, sorted by first array in non-increasing order

SCIPsortDownLong^⚠

sort an array of Longints in non-increasing order

SCIPsortDownLongPtr^⚠

sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order

SCIPsortDownLongPtrInt^⚠

sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order

SCIPsortDownLongPtrPtrBoolInt^⚠

sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

SCIPsortDownLongPtrPtrInt^⚠

sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

SCIPsortDownLongPtrPtrIntInt^⚠

sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

SCIPsortDownLongPtrRealBool^⚠

sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

SCIPsortDownLongPtrRealRealBool^⚠

sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order

SCIPsortDownLongPtrRealRealIntBool^⚠

sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order

SCIPsortDownPtr^⚠

sort of an array of pointers in non-increasing order

SCIPsortDownPtrBool^⚠

sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order

SCIPsortDownPtrInt^⚠

sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order

SCIPsortDownPtrIntInt^⚠

sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortDownPtrIntIntBoolBool^⚠

sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

SCIPsortDownPtrPtr^⚠

sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order

SCIPsortDownPtrPtrInt^⚠

sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order

SCIPsortDownPtrPtrIntInt^⚠

sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortDownPtrPtrLongInt^⚠

sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

SCIPsortDownPtrPtrLongIntInt^⚠

sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order

SCIPsortDownPtrPtrReal^⚠

sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

SCIPsortDownPtrPtrRealBool^⚠

sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

SCIPsortDownPtrPtrRealInt^⚠

sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

SCIPsortDownPtrReal^⚠

sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order

SCIPsortDownPtrRealBool^⚠

sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

SCIPsortDownPtrRealInt^⚠

sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

SCIPsortDownPtrRealIntInt^⚠

sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortDownReal^⚠

sort an array of Reals in non-increasing order

SCIPsortDownRealBoolPtr^⚠

sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order

SCIPsortDownRealInt^⚠

sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order

SCIPsortDownRealIntInt^⚠

sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortDownRealIntLong^⚠

sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

SCIPsortDownRealIntPtr^⚠

sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

SCIPsortDownRealLongRealInt^⚠

sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order

SCIPsortDownRealPtr^⚠

sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order

SCIPsortDownRealPtrPtr^⚠

sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order

SCIPsortDownRealPtrPtrInt^⚠

sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

SCIPsortDownRealPtrPtrIntInt^⚠

sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortDownRealRealInt^⚠

sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortDownRealRealIntInt^⚠

sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortDownRealRealPtr^⚠

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

SCIPsortDownRealRealPtrPtr^⚠

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

SCIPsortDownRealRealRealBoolBoolPtr^⚠

sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

SCIPsortDownRealRealRealBoolPtr^⚠

sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order

SCIPsortDownRealRealRealInt^⚠

sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortDownRealRealRealPtr^⚠

sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

SCIPsortInd^⚠

sort an index array in non-decreasing order

SCIPsortInt^⚠

sort array of ints in non-decreasing order

SCIPsortIntInt^⚠

sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order

SCIPsortIntIntInt^⚠

sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

SCIPsortIntIntIntPtr^⚠

sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortIntIntIntReal^⚠

sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

SCIPsortIntIntLong^⚠

sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order

SCIPsortIntIntPtr^⚠

sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortIntIntReal^⚠

sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order

SCIPsortIntPtr^⚠

sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order

SCIPsortIntPtrIntIntBoolBool^⚠

sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

SCIPsortIntPtrIntReal^⚠

sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

SCIPsortIntPtrReal^⚠

sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order

SCIPsortIntReal^⚠

sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order

SCIPsortIntRealLong^⚠

sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order

SCIPsortLong^⚠

sort an array of Longints in non-decreasing order

SCIPsortLongPtr^⚠

sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

SCIPsortLongPtrInt^⚠

sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order

SCIPsortLongPtrPtrBoolInt^⚠

sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

SCIPsortLongPtrPtrInt^⚠

sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

SCIPsortLongPtrPtrIntInt^⚠

sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

SCIPsortLongPtrRealBool^⚠

sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

SCIPsortLongPtrRealRealBool^⚠

sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

SCIPsortLongPtrRealRealIntBool^⚠

sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

SCIPsortPtr^⚠

sort of an array of pointers in non-decreasing order

SCIPsortPtrBool^⚠

sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

SCIPsortPtrInt^⚠

sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order

SCIPsortPtrIntInt^⚠

sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortPtrIntIntBoolBool^⚠

sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

SCIPsortPtrPtr^⚠

sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order

SCIPsortPtrPtrInt^⚠

sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order

SCIPsortPtrPtrIntInt^⚠

sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortPtrPtrLongInt^⚠

sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

SCIPsortPtrPtrLongIntInt^⚠

sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

SCIPsortPtrPtrReal^⚠

sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

SCIPsortPtrPtrRealBool^⚠

sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order

SCIPsortPtrPtrRealInt^⚠

sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

SCIPsortPtrReal^⚠

sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

SCIPsortPtrRealBool^⚠

sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

SCIPsortPtrRealInt^⚠

sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

SCIPsortPtrRealIntInt^⚠

sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortPtrRealReal^⚠

sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order

SCIPsortPtrRealRealBoolBool^⚠

sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order

SCIPsortPtrRealRealInt^⚠

sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order

SCIPsortPtrRealRealIntBool^⚠

sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order

SCIPsortReal^⚠

sort an array of Reals in non-decreasing order

SCIPsortRealBoolPtr^⚠

sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order

SCIPsortRealInt^⚠

sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order

SCIPsortRealIntInt^⚠

sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortRealIntLong^⚠

sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

SCIPsortRealIntPtr^⚠

sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

SCIPsortRealLongRealInt^⚠

sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order

SCIPsortRealPtr^⚠

sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

SCIPsortRealPtrPtrInt^⚠

sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

SCIPsortRealPtrPtrIntInt^⚠

sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortRealRealIntInt^⚠

sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortRealRealPtr^⚠

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

SCIPsortRealRealRealBoolBoolPtr^⚠

sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortRealRealRealBoolPtr^⚠

sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortRealRealRealInt^⚠

sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

SCIPsortRealRealRealPtr^⚠

sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosDownInd^⚠

delete the element at the given position from an index array in non-increasing order

SCIPsortedvecDelPosDownInt^⚠

delete the element at the given position from an array of ints in non-increasing order

SCIPsortedvecDelPosDownIntInt^⚠

delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntIntInt^⚠

delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntIntIntPtr^⚠

delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosDownIntIntIntReal^⚠

delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosDownIntIntLong^⚠

delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntIntPtr^⚠

delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntIntReal^⚠

delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntPtr^⚠

delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownIntPtrIntIntBoolBool^⚠

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

SCIPsortedvecDelPosDownIntPtrIntReal^⚠

delete the element at the given position from four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosDownIntReal^⚠

delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownLong^⚠

delete the element at the given position from an array of Longints, sorted in non-increasing order

SCIPsortedvecDelPosDownLongPtr^⚠

delete the element at the given position from two arrays of Long/pointer, sorted by the first array in non-increasing order

SCIPsortedvecDelPosDownLongPtrInt^⚠

delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order

SCIPsortedvecDelPosDownLongPtrPtrBoolInt^⚠

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

SCIPsortedvecDelPosDownLongPtrPtrInt^⚠

delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownLongPtrPtrIntInt^⚠

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

SCIPsortedvecDelPosDownLongPtrRealBool^⚠

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

SCIPsortedvecDelPosDownLongPtrRealRealBool^⚠

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

SCIPsortedvecDelPosDownLongPtrRealRealIntBool^⚠

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

SCIPsortedvecDelPosDownPtr^⚠

delete the element at the given position from an array of pointers in non-increasing order

SCIPsortedvecDelPosDownPtrBool^⚠

delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrInt^⚠

delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrIntInt^⚠

delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrIntIntBoolBool^⚠

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

SCIPsortedvecDelPosDownPtrPtr^⚠

delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrInt^⚠

delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrIntInt^⚠

delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrLongInt^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrLongIntInt^⚠

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

SCIPsortedvecDelPosDownPtrPtrReal^⚠

delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrRealBool^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrPtrRealInt^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrReal^⚠

delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrRealBool^⚠

delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrRealInt^⚠

delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownPtrRealIntInt^⚠

delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownReal^⚠

delete the element at the given position from an array of Reals, sorted in non-increasing order

SCIPsortedvecDelPosDownRealBoolPtr^⚠

delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealInt^⚠

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealIntInt^⚠

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealIntLong^⚠

delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealIntPtr^⚠

delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealLongRealInt^⚠

delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealPtr^⚠

delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealPtrPtr^⚠

delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealPtrPtrInt^⚠

delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealPtrPtrIntInt^⚠

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

SCIPsortedvecDelPosDownRealRealInt^⚠

delete the element at the given position from three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealRealIntInt^⚠

delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealRealPtr^⚠

delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealRealPtrPtr^⚠

delete the element at the given position from three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr^⚠

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

SCIPsortedvecDelPosDownRealRealRealBoolPtr^⚠

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

SCIPsortedvecDelPosDownRealRealRealInt^⚠

delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecDelPosDownRealRealRealPtr^⚠

delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

SCIPsortedvecDelPosInd^⚠

delete the element at the given position from an index array in non-decreasing order

SCIPsortedvecDelPosInt^⚠

delete the element at the given position from an array of ints in non-decreasing order

SCIPsortedvecDelPosIntInt^⚠

delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntInt^⚠

delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntIntPtr^⚠

delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntIntReal^⚠

delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntLong^⚠

delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntPtr^⚠

delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntIntReal^⚠

delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntPtr^⚠

delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntPtrIntIntBoolBool^⚠

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

SCIPsortedvecDelPosIntPtrIntReal^⚠

delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntPtrReal^⚠

delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntReal^⚠

delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosIntRealLong^⚠

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

SCIPsortedvecDelPosLong^⚠

delete the element at the given position from an array of Longints, sorted by in non-decreasing order

SCIPsortedvecDelPosLongPtr^⚠

delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

SCIPsortedvecDelPosLongPtrInt^⚠

delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order

SCIPsortedvecDelPosLongPtrPtrBoolInt^⚠

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

SCIPsortedvecDelPosLongPtrPtrInt^⚠

delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosLongPtrPtrIntInt^⚠

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

SCIPsortedvecDelPosLongPtrRealBool^⚠

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

SCIPsortedvecDelPosLongPtrRealRealBool^⚠

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

SCIPsortedvecDelPosLongPtrRealRealIntBool^⚠

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

SCIPsortedvecDelPosPtr^⚠

delete the element at the given position from an array of pointers in non-decreasing order

SCIPsortedvecDelPosPtrBool^⚠

delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrInt^⚠

delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrIntInt^⚠

delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrIntIntBoolBool^⚠

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

SCIPsortedvecDelPosPtrPtr^⚠

delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrInt^⚠

delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrIntInt^⚠

delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrLongInt^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrLongIntInt^⚠

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

SCIPsortedvecDelPosPtrPtrReal^⚠

delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrRealBool^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrPtrRealInt^⚠

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrReal^⚠

delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrRealBool^⚠

delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrRealInt^⚠

delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrRealIntInt^⚠

delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrRealRealBoolBool^⚠

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

SCIPsortedvecDelPosPtrRealRealInt^⚠

delete the element at the given position from four joint arrays of pointers/RealsReals//ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosPtrRealRealIntBool^⚠

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

SCIPsortedvecDelPosReal^⚠

delete the element at the given position from an arrays of Reals, sorted in non-decreasing order

SCIPsortedvecDelPosRealBoolPtr^⚠

delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealInt^⚠

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealIntInt^⚠

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealIntLong^⚠

delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealIntPtr^⚠

delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealLongRealInt^⚠

delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealPtr^⚠

delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealPtrPtrInt^⚠

delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealPtrPtrIntInt^⚠

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

SCIPsortedvecDelPosRealRealIntInt^⚠

delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealRealPtr^⚠

delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealRealRealBoolBoolPtr^⚠

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

SCIPsortedvecDelPosRealRealRealBoolPtr^⚠

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

SCIPsortedvecDelPosRealRealRealInt^⚠

delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecDelPosRealRealRealPtr^⚠

delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

SCIPsortedvecFindDownInd^⚠

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’.

SCIPsortedvecFindDownInt^⚠

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’.

SCIPsortedvecFindDownLong^⚠

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’.

SCIPsortedvecFindDownPtr^⚠

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’.

SCIPsortedvecFindDownReal^⚠

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’.

SCIPsortedvecFindInd^⚠

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’.

SCIPsortedvecFindInt^⚠

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’.

SCIPsortedvecFindLong^⚠

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’.

SCIPsortedvecFindPtr^⚠

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’.

SCIPsortedvecFindReal^⚠

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’.

SCIPsortedvecInsertDownInd^⚠

insert a new element into an index array in non-increasing order

SCIPsortedvecInsertDownInt^⚠

insert a new element into an array of ints in non-increasing order

SCIPsortedvecInsertDownIntInt^⚠

insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntInt^⚠

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntIntPtr^⚠

insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntIntReal^⚠

insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntLong^⚠

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntPtr^⚠

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntIntReal^⚠

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntPtr^⚠

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntPtrIntIntBoolBool^⚠

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order

SCIPsortedvecInsertDownIntPtrIntReal^⚠

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownIntReal^⚠

insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownLong^⚠

insert a new element into an array of Longints, sorted in non-increasing order

SCIPsortedvecInsertDownLongPtr^⚠

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order

SCIPsortedvecInsertDownLongPtrInt^⚠

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order

SCIPsortedvecInsertDownLongPtrPtrBoolInt^⚠

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownLongPtrPtrInt^⚠

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownLongPtrPtrIntInt^⚠

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownLongPtrRealBool^⚠

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

SCIPsortedvecInsertDownLongPtrRealRealBool^⚠

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order

SCIPsortedvecInsertDownLongPtrRealRealIntBool^⚠

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order

SCIPsortedvecInsertDownPtr^⚠

insert a new element into an array of pointers in non-increasing order

SCIPsortedvecInsertDownPtrBool^⚠

insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrInt^⚠

insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrIntInt^⚠

insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrIntIntBoolBool^⚠

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtr^⚠

insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrInt^⚠

insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrIntInt^⚠

insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrLongInt^⚠

insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrLongIntInt^⚠

insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrReal^⚠

insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrRealBool^⚠

insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrPtrRealInt^⚠

insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrReal^⚠

insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrRealBool^⚠

insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrRealInt^⚠

insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownPtrRealIntInt^⚠

insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownReal^⚠

insert a new element into an array of Reals, sorted in non-increasing order

SCIPsortedvecInsertDownRealBoolPtr^⚠

insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealInt^⚠

insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealIntInt^⚠

insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealIntLong^⚠

insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealIntPtr^⚠

insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealLongRealInt^⚠

insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealPtr^⚠

insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealPtrPtr^⚠

insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealPtrPtrInt^⚠

insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealPtrPtrIntInt^⚠

insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealInt^⚠

insert a new element into three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealIntInt^⚠

insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealPtr^⚠

insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealPtrPtr^⚠

insert a new element into three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealRealBoolBoolPtr^⚠

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealRealBoolPtr^⚠

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealRealInt^⚠

insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

SCIPsortedvecInsertDownRealRealRealPtr^⚠

insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

SCIPsortedvecInsertInd^⚠

insert a new element into an index array in non-decreasing order

SCIPsortedvecInsertInt^⚠

insert a new element into an array of ints in non-decreasing order

SCIPsortedvecInsertIntInt^⚠

insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntInt^⚠

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntIntPtr^⚠

insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntIntReal^⚠

insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntLong^⚠

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntPtr^⚠

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntIntReal^⚠

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntPtr^⚠

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntPtrIntIntBoolBool^⚠

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntPtrIntReal^⚠

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntPtrReal^⚠

insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntReal^⚠

insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertIntRealLong^⚠

insert a new element into three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order

SCIPsortedvecInsertLong^⚠

insert a new element into an array of Longints, sorted in non-decreasing order

SCIPsortedvecInsertLongPtr^⚠

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

SCIPsortedvecInsertLongPtrInt^⚠

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order

SCIPsortedvecInsertLongPtrPtrBoolInt^⚠

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertLongPtrPtrInt^⚠

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertLongPtrPtrIntInt^⚠

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertLongPtrRealBool^⚠

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

SCIPsortedvecInsertLongPtrRealRealBool^⚠

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

SCIPsortedvecInsertLongPtrRealRealIntBool^⚠

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

SCIPsortedvecInsertPtr^⚠

insert a new element into an array of pointers in non-decreasing order

SCIPsortedvecInsertPtrBool^⚠

insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrInt^⚠

insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrIntInt^⚠

insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrIntIntBoolBool^⚠

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtr^⚠

insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrInt^⚠

insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrIntInt^⚠

insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrLongInt^⚠

insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrLongIntInt^⚠

insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrReal^⚠

insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrRealBool^⚠

insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrPtrRealInt^⚠

insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrReal^⚠

insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealBool^⚠

insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealInt^⚠

insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealIntInt^⚠

insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealRealBoolBool^⚠

insert a new element into four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealRealInt^⚠

insert a new element into four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertPtrRealRealIntBool^⚠

insert a new element into four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order

SCIPsortedvecInsertReal^⚠

insert a new element into an arrays of Reals, sorted in non-decreasing order

SCIPsortedvecInsertRealBoolPtr^⚠

insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealInt^⚠

insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealIntInt^⚠

insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealIntLong^⚠

insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealIntPtr^⚠

insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealLongRealInt^⚠

insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealPtr^⚠

insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealPtrPtrInt^⚠

insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealPtrPtrIntInt^⚠

insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealIntInt^⚠

insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealPtr^⚠

insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealRealBoolBoolPtr^⚠

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealRealBoolPtr^⚠

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealRealInt^⚠

insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

SCIPsortedvecInsertRealRealRealPtr^⚠

insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

SCIPsparseSolCreate^⚠

creates a sparse solution

SCIPsparseSolFree^⚠

frees sparse solution

SCIPsparseSolGetFirstSol^⚠

constructs the first solution of sparse solution (all variables are set to their lower bound value

SCIPsparseSolGetLbs^⚠

returns the the lower bound array for all variables for a given sparse solution

SCIPsparseSolGetNVars^⚠

returns the number of variables in the given sparse solution

SCIPsparseSolGetNextSol^⚠

constructs the next solution of the sparse solution and return whether there was one more or not

SCIPsparseSolGetUbs^⚠

returns the the upper bound array for all variables for a given sparse solution

SCIPsparseSolGetVars^⚠

returns the variables in the given sparse solution

SCIPsplitCumulativeCondition^⚠

searches for a time point within the cumulative condition were the cumulative condition can be split

SCIPsplitFilename^⚠

splits filename into path, name, and extension

SCIPsplitReoptRoot^⚠

splits the root into several nodes and moves the child nodes of the root to one of the created nodes

SCIPstartClock^⚠

starts the time measurement of a clock

SCIPstartDive^⚠

initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available

SCIPstartDiveNLP^⚠

initiates NLP diving

SCIPstartInteraction^⚠

starts interactive mode of SCIP by executing the root dialog

SCIPstartProbing^⚠

initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available

SCIPstartSolvingTime^⚠

starts the current solving time

SCIPstartStrongbranch^⚠

start strong branching - call before any strong branching

SCIPstoGetNScenarios^⚠

returns the total number of scenarios added to the problem

SCIPstopClock^⚠

stops the time measurement of a clock

SCIPstopSolvingTime^⚠

stops the current solving time in seconds

SCIPstoreBendersCut^⚠

adds the generated cuts to the Benders’ cut storage

SCIPstoreSolutionGap^⚠

update statistical information when a new solution was found

SCIPstrAtStart^⚠

checks whether a given string t appears at the beginning of the string s (up to spaces at beginning)

SCIPstrCopySection^⚠

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

SCIPstrToIntValue^⚠

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

SCIPstrToRealValue^⚠

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

SCIPstrncpy^⚠

safe version of strncpy

SCIPstrtok^⚠

extracts tokens from strings - wrapper method for strtok_r()

SCIPstudentTGetCriticalValue^⚠

get critical value of a Student-T distribution for a given number of degrees of freedom at a confidence level

SCIPsubversion^⚠

returns SCIP sub version number

SCIPsumLPRows^⚠

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

SCIPsumepsilon^⚠

returns value treated as zero for sums of floating point values

SCIPswapInts^⚠

swaps two ints

SCIPswapPointers^⚠

swaps the addresses of two pointers

SCIPswapReals^⚠

swaps two real values

SCIPtableGetData^⚠

gets user data of statistics table

SCIPtableGetDesc^⚠

gets description of statistics table

SCIPtableGetEarliestStage^⚠

gets earliest stage of statistics table

SCIPtableGetName^⚠

gets name of statistics table

SCIPtableGetPosition^⚠

gets position of statistics table

SCIPtableIsActive^⚠

is statistics table currently active?

SCIPtableIsInitialized^⚠

is statistics table initialized?

SCIPtableSetData^⚠

sets user data of statistics table; user has to free old data in advance!

SCIPtechVersion^⚠

returns SCIP technical version

SCIPtightenExprIntervalNonlinear^⚠

informs the expression about new bounds that can be used for reverse-propagation and to tighten bounds of corresponding (auxiliary) variable (if any)

SCIPtightenVarLb^⚠

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

SCIPtightenVarLbGlobal^⚠

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

SCIPtightenVarUb^⚠

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

SCIPtightenVarUbGlobal^⚠

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

SCIPtimConsGetStageName^⚠

SCIPtimFindStage^⚠

SCIPtimGetNStages^⚠

SCIPtimGetStageConss^⚠

SCIPtimGetStageNConss^⚠

SCIPtimGetStageNVars^⚠

SCIPtimGetStageName^⚠

SCIPtimGetStageVars^⚠

SCIPtimHasRead^⚠

@}

SCIPtransformCons^⚠

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

SCIPtransformConss^⚠

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

SCIPtransformMinUC^⚠

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

SCIPtransformObj^⚠

maps original space objective value into transformed objective value

SCIPtransformProb^⚠

initializes solving data structures and transforms problem

SCIPtransformVar^⚠

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

SCIPtransformVars^⚠

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

SCIPtranslateSubSol^⚠

translates a solution from a subscip to the main scip

SCIPtranslateSubSols^⚠

checks the solutions from the subscip and adds the first one that is found feasible to the master SCIP

SCIPtryCurrentSol^⚠

checks current LP/pseudo solution for feasibility; if possible, adds it to storage

SCIPtrySol^⚠

checks solution for feasibility; if possible, adds it to storage by copying

SCIPtrySolFree^⚠

checks primal solution; if feasible, adds it to storage; solution is freed afterwards

SCIPtryStrongbranchLPSol^⚠

rounds the current solution and tries it afterwards; if feasible, adds it to storage

SCIPunfixParam^⚠

unfixes the value of an existing parameter

SCIPunlinkSol^⚠

stores solution values of variables in solution’s own array

SCIPunlockVarCons^⚠

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

SCIPunmarkConsPropagate^⚠

unmarks the constraint to be propagated

SCIPupdateConsFlags^⚠

updates the flags of the first constraint according to the ones of the second constraint

SCIPupdateCutoffbound^⚠

updates the cutoff bound

SCIPupdateDistributionScore^⚠

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

SCIPupdateDivesetLPStats^⚠

update diveset LP statistics, should be called after every LP solved by this diving heuristic

SCIPupdateDivesetStats^⚠

update diveset statistics and global diveset statistics

SCIPupdateLocalDualbound^⚠

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

SCIPupdateLocalLowerbound^⚠

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

SCIPupdateNlpiProblem^⚠

updates variable bounds and the cutoff row in a NLPI problem

SCIPupdateNodeDualbound^⚠

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

SCIPupdateNodeLowerbound^⚠

if given value is larger than the node’s lower bound (in transformed problem), sets the node’s lower bound to the new value

SCIPupdatePrimalRay^⚠

updates the primal ray thats proves unboundedness

SCIPupdateSolBoundViolation^⚠

update bound violation of a solution

SCIPupdateSolConsViolation^⚠

update constraint violation of a solution

SCIPupdateSolIntegralityViolation^⚠

update integrality violation of a solution

SCIPupdateSolLPConsViolation^⚠

update LP row and constraint violations of a solution

SCIPupdateSolLPRowViolation^⚠

update LP row violation of a solution

SCIPupdateStartpointHeurSubNlp^⚠

updates the starting point for the NLP heuristic

SCIPupdateVarBranchPriority^⚠

changes the branch priority of the variable to the given value, if it is larger than the current priority

SCIPupdateVarPseudocost^⚠

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

SCIPupgradeConsLinear^⚠

tries to automatically convert a linear constraint into a more specific and more specialized constraint

SCIPvalidateSolve^⚠

validate the result of the solve

SCIPvaluehistoryGetHistories^⚠

return the array containing the histories for the individual (domain) values

SCIPvaluehistoryGetNValues^⚠

return the number of (domain) values for which a history exists

SCIPvaluehistoryGetValues^⚠

return the array containing the (domain) values for which a history exists

SCIPvarCalcDistributionParameters^⚠

calculate the variable’s distribution parameters (mean and variance) for the bounds specified in the arguments. special treatment of infinite bounds necessary

SCIPvarComp^⚠

comparison method for sorting variables by non-decreasing index

SCIPvarCompActiveAndNegated^⚠

comparison method for sorting active and negated variables by non-decreasing index, active and negated variables are handled as the same variables

SCIPvarCompObj^⚠

comparison method for sorting variables by non-decreasing objective coefficient

SCIPvarCompare^⚠

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

SCIPvarCompareActiveAndNegated^⚠

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

SCIPvarGetAggrConstant^⚠

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

SCIPvarGetAggrScalar^⚠

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

SCIPvarGetAggrVar^⚠

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

SCIPvarGetAggregatedObj^⚠

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

SCIPvarGetAvgBranchdepth^⚠

returns the average depth of bound changes in given direction due to branching on the variable

SCIPvarGetAvgBranchdepthCurrentRun^⚠

returns the average depth of bound changes in given direction due to branching on the variable in the current run

SCIPvarGetAvgSol^⚠

returns a weighted average solution value of the variable in all feasible primal solutions found so far

SCIPvarGetBdAtIndex^⚠

returns lower or upper bound of variable directly before or after the bound change given by the bound change index was applied

SCIPvarGetBdchgInfo^⚠

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

SCIPvarGetBdchgInfoLb^⚠

return lower bound change info at requested position

SCIPvarGetBdchgInfoUb^⚠

return upper bound change info at requested position

SCIPvarGetBestBoundGlobal^⚠

gets best global bound of variable with respect to the objective function

SCIPvarGetBestBoundLocal^⚠

gets best local bound of variable with respect to the objective function

SCIPvarGetBestBoundType^⚠

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

SCIPvarGetBestRootLPObjval^⚠

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

SCIPvarGetBestRootRedcost^⚠

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

SCIPvarGetBestRootSol^⚠

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

SCIPvarGetBranchDirection^⚠

gets the preferred branch direction of the variable (downwards, upwards, or auto)

SCIPvarGetBranchFactor^⚠

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

SCIPvarGetBranchPriority^⚠

gets the branch priority of the variable; variables with higher priority should always be preferred to variables with lower priority

SCIPvarGetCliques^⚠

gets array of cliques, the active variable is contained in

SCIPvarGetCol^⚠

gets column of COLUMN variable

SCIPvarGetCutoffSum^⚠

returns the number of cutoffs branching on this variable in given direction produced

SCIPvarGetCutoffSumCurrentRun^⚠

returns the number of cutoffs branching on this variable in given direction produced in the current run

SCIPvarGetData^⚠

returns the user data of the variable

SCIPvarGetHashkey^⚠

hash key retrieval function for variables

SCIPvarGetHashkeyVal^⚠

returns the hash value of the key

SCIPvarGetHolelistGlobal^⚠

gets the global hole list of an active variable

SCIPvarGetHolelistLocal^⚠

gets the current hole list of an active variable

SCIPvarGetHolelistOriginal^⚠

gets the original hole list of an original variable

SCIPvarGetImplBounds^⚠

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

SCIPvarGetImplIds^⚠

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.

SCIPvarGetImplTypes^⚠

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

SCIPvarGetImplVars^⚠

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())

SCIPvarGetImplicVarBounds^⚠

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

SCIPvarGetIndex^⚠

gets unique index of variable

SCIPvarGetInferenceSum^⚠

returns the number of inferences branching on this variable in given direction triggered

SCIPvarGetInferenceSumCurrentRun^⚠

returns the number of inferences branching on this variable in given direction triggered in the current run

SCIPvarGetLPSol^⚠

gets primal LP solution value of variable

SCIPvarGetLPSol_rec^⚠

gets primal LP solution value of variable

SCIPvarGetLastBdchgDepth^⚠

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

SCIPvarGetLastBdchgIndex^⚠

returns the last bound change index, at which the bounds of the given variable were tightened

SCIPvarGetLbAtIndex^⚠

returns lower bound of variable directly before or after the bound change given by the bound change index was applied

SCIPvarGetLbGlobal^⚠

gets global lower bound of variable

SCIPvarGetLbLazy^⚠

gets lazy lower bound of variable

SCIPvarGetLbLocal^⚠

gets current lower bound of variable

SCIPvarGetLbOriginal^⚠

gets original lower bound of original problem variable (i.e. the bound set in problem creation)

SCIPvarGetLbchgInfo^⚠

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

SCIPvarGetMultaggrConstant^⚠

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

SCIPvarGetMultaggrNVars^⚠

gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c

SCIPvarGetMultaggrScalars^⚠

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

SCIPvarGetMultaggrVars^⚠

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

SCIPvarGetNBdchgInfosLb^⚠

gets the number of lower bound change info array

SCIPvarGetNBdchgInfosUb^⚠

gets the number upper bound change info array

SCIPvarGetNBranchings^⚠

returns the number of times, a bound of the variable was changed in given direction due to branching

SCIPvarGetNBranchingsCurrentRun^⚠

returns the number of times, a bound of the variable was changed in given direction due to branching in the current run

SCIPvarGetNCliques^⚠

gets number of cliques, the active variable is contained in

SCIPvarGetNImpls^⚠

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

SCIPvarGetNLPSol^⚠

gets primal NLP solution value of variable

SCIPvarGetNLPSol_rec^⚠

gets primal NLP solution value of variable

SCIPvarGetNLocksDown^⚠

gets number of locks for rounding down

SCIPvarGetNLocksDownType^⚠

gets number of locks for rounding down of a special type

SCIPvarGetNLocksUp^⚠

gets number of locks for rounding up

SCIPvarGetNLocksUpType^⚠

gets number of locks for rounding up of a special type

SCIPvarGetNUses^⚠

gets number of times, the variable is currently captured

SCIPvarGetNVlbs^⚠

gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x

SCIPvarGetNVubs^⚠

gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x

SCIPvarGetName^⚠

returns the name of the variable

SCIPvarGetNegatedVar^⚠

gets the negation of the given variable; may return NULL, if no negation is existing yet

SCIPvarGetNegationConstant^⚠

gets the negation offset of a negated variable x’ = offset - x

SCIPvarGetNegationVar^⚠

gets the negation variable x of a negated variable x’ = offset - x

SCIPvarGetNodeSOS1^⚠

returns node of variable in the conflict graph or -1 if variable is not part of the SOS1 conflict graph

SCIPvarGetObj^⚠

gets objective function value of variable

SCIPvarGetOrigvarSum^⚠

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

SCIPvarGetProbindex^⚠

gets position of variable in problem, or -1 if variable is not active

SCIPvarGetProbvar^⚠

gets corresponding active, fixed, or multi-aggregated problem variable of a variable

SCIPvarGetProbvarBinary^⚠

gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and updates the given negation status

SCIPvarGetProbvarBound^⚠

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

SCIPvarGetProbvarHole^⚠

transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable values

SCIPvarGetPseudoSol^⚠

gets pseudo solution value of variable at current node

SCIPvarGetRootSol^⚠

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

SCIPvarGetSol^⚠

gets current LP or pseudo solution value of variable

SCIPvarGetStatus^⚠

gets status of variable

SCIPvarGetTransVar^⚠

gets transformed variable of ORIGINAL variable

SCIPvarGetType^⚠

gets type of variable

SCIPvarGetUbAtIndex^⚠

returns upper bound of variable directly before or after the bound change given by the bound change index was applied

SCIPvarGetUbGlobal^⚠

gets global upper bound of variable

SCIPvarGetUbLazy^⚠

gets lazy upper bound of variable

SCIPvarGetUbLocal^⚠

gets current upper bound of variable

SCIPvarGetUbOriginal^⚠

gets original upper bound of original problem variable (i.e. the bound set in problem creation)

SCIPvarGetUbchgInfo^⚠

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

SCIPvarGetUnchangedObj^⚠

gets the unchanged objective function value of variable (ignoring temproray changes performed in probing mode)

SCIPvarGetValuehistory^⚠

returns the value based history for the variable

SCIPvarGetVlbCoefs^⚠

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

SCIPvarGetVlbConstants^⚠

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

SCIPvarGetVlbVars^⚠

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())

SCIPvarGetVubCoefs^⚠

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

SCIPvarGetVubConstants^⚠

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

SCIPvarGetVubVars^⚠

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())

SCIPvarGetWorstBoundGlobal^⚠

gets worst global bound of variable with respect to the objective function

SCIPvarGetWorstBoundLocal^⚠

gets worst local bound of variable with respect to the objective function

SCIPvarGetWorstBoundType^⚠

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

SCIPvarHasBinaryImplic^⚠

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

SCIPvarHasImplic^⚠

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

SCIPvarIsActive^⚠

returns whether variable is an active (neither fixed nor aggregated) variable

SCIPvarIsBinary^⚠

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

SCIPvarIsDeletable^⚠

returns whether variable is allowed to be deleted completely from the problem

SCIPvarIsDeleted^⚠

returns whether the variable was deleted from the problem

SCIPvarIsHashkeyEq^⚠

returns TRUE iff the indices of both variables are equal

SCIPvarIsInLP^⚠

returns whether the variable is a COLUMN variable that is member of the current LP

SCIPvarIsInitial^⚠

returns whether variable’s column should be present in the initial root LP

SCIPvarIsIntegral^⚠

returns whether variable is of integral type (binary, integer, or implicit integer)

SCIPvarIsNegated^⚠

returns whether the variable was created by negation of a different variable

SCIPvarIsOriginal^⚠

returns whether the variable belongs to the original problem

SCIPvarIsRelaxationOnly^⚠

returns whether a variable has been introduced to define a relaxation

SCIPvarIsRemovable^⚠

returns whether variable’s column is removable from the LP (due to aging or cleanup)

SCIPvarIsSOS1^⚠

returns whether variable is part of the SOS1 conflict graph

SCIPvarIsTransformed^⚠

returns whether the variable belongs to the transformed problem

SCIPvarIsTransformedOrigvar^⚠

returns whether the given variable is the direct counterpart of an original problem variable

SCIPvarMarkDeletable^⚠

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()

SCIPvarMarkDeleteGlobalStructures^⚠

marks variable to be deleted from global structures (cliques etc.) when cleaning up

SCIPvarMarkNotDeletable^⚠

marks the variable to be not deletable from the problem

SCIPvarMarkRelaxationOnly^⚠

marks that this variable has only been introduced to define a relaxation

SCIPvarMayRoundDown^⚠

is it possible, to round variable down and stay feasible?

SCIPvarMayRoundUp^⚠

is it possible, to round variable up and stay feasible?

SCIPvarSetBestRootSol^⚠

set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables

SCIPvarSetCopyData^⚠

sets method to copy this variable into sub-SCIPs

SCIPvarSetData^⚠

sets the user data for the variable

SCIPvarSetDelorigData^⚠

sets method to free user data for the original variable

SCIPvarSetDeltransData^⚠

sets method to free transformed user data for the variable

SCIPvarSetInitial^⚠

sets the initial flag of a variable; only possible for original or loose variables

SCIPvarSetRemovable^⚠

sets the removable flag of a variable; only possible for original or loose variables

SCIPvarSetTransData^⚠

sets method to transform user data of the variable

SCIPvarWasFixedAtIndex^⚠

returns whether the binary variable was fixed at the time given by the bound change index

SCIPvarWasFixedEarlier^⚠

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

SCIPvariableGraphCreate^⚠

initialization method of variable graph data structure

SCIPvariableGraphFree^⚠

deinitialization method of variable graph data structure

SCIPvariablegraphBreadthFirst^⚠

Perform breadth-first (BFS) search on the variable constraint graph.

SCIPvarsGetProbvar^⚠

gets corresponding active, fixed, or multi-aggregated problem variables of given variables, @note the content of the given array will/might change

SCIPvarsGetProbvarBinary^⚠

gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and updates the given negation status of each variable

SCIPvarsHaveCommonClique^⚠

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

SCIPverbMessage^⚠

SCIPversion^⚠

returns complete SCIP version number in the format “major . minor tech”

SCIPvisualizeConsCumulative^⚠

this method visualizes the cumulative structure in GML format

SCIPwarningMessage^⚠

SCIPwasNodeLastBranchParent^⚠

query if node was the last parent of a branching of the tree

SCIPwriteCcg^⚠

writes problem to file

SCIPwriteCliqueGraph^⚠

writes the clique graph to a gml file

SCIPwriteDiff^⚠

writes problem to file

SCIPwriteGms^⚠

writes problem to file

SCIPwriteImplicationConflictGraph^⚠

stores conflict graph of binary variables’ implications into a file, which can be used as input for the DOT tool

SCIPwriteLP^⚠

writes current LP to a file

SCIPwriteLp^⚠

writes problem to file

SCIPwriteMIP^⚠

writes MIP relaxation of the current branch-and-bound node to a file

SCIPwriteMps^⚠

writes problem to file

SCIPwriteNLP^⚠

writes current NLP to a file

SCIPwriteOpb^⚠

writes problem to file

SCIPwriteOrigProblem^⚠

writes original problem to file

SCIPwriteParam^⚠

writes a single parameter to a file

SCIPwriteParams^⚠

writes all parameters in the parameter set to a file

SCIPwritePbm^⚠

@addtogroup FILEREADERS

SCIPwritePip^⚠

writes problem to file

SCIPwritePpm^⚠

writes problem to file

SCIPwriteSolutionNl^⚠

writes AMPL solution file

SCIPwriteSto^⚠

writes problem to file

SCIPwriteTransProblem^⚠

writes transformed problem which are valid in the current node to file

SCIPwriteVarName^⚠

outputs the variable name to the file stream

SCIPwriteVarsLinearsum^⚠

print the given variables and coefficients as linear sum in the following form c1 <x1> + c2 <x2> … + cn <xn>

SCIPwriteVarsList^⚠

print the given list of variables to output stream separated by the given delimiter character;

SCIPwriteVarsPolynomial^⚠

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 …

_Exit^⚠

__acos^⚠

__acosf^⚠

__acosh^⚠

__acoshf^⚠

__acoshl^⚠

__acosl^⚠

__asin^⚠

__asinf^⚠

__asinh^⚠

__asinhf^⚠

__asinhl^⚠

__asinl^⚠

__asprintf^⚠

__assert^⚠

__assert_fail^⚠

__assert_perror_fail^⚠

__atan^⚠

__atan2^⚠

__atan2f^⚠

__atan2l^⚠

__atanf^⚠

__atanh^⚠

__atanhf^⚠

__atanhl^⚠

__atanl^⚠

__cbrt^⚠

__cbrtf^⚠

__cbrtl^⚠

__ceil^⚠

__ceilf^⚠

__ceill^⚠

__copysign^⚠

__copysignf^⚠

__copysignl^⚠

__cos^⚠

__cosf^⚠

__cosh^⚠

__coshf^⚠

__coshl^⚠

__cosl^⚠

__ctype_get_mb_cur_max^⚠

__drem^⚠

__dremf^⚠

__dreml^⚠

__erf^⚠

__erfc^⚠

__erfcf^⚠

__erfcl^⚠

__erff^⚠

__erfl^⚠

__exp^⚠

__exp2^⚠

__exp2f^⚠

__exp2l^⚠

__expf^⚠

__expl^⚠

__expm1^⚠

__expm1f^⚠

__expm1l^⚠

__fabs^⚠

__fabsf^⚠

__fabsl^⚠

__fdim^⚠

__fdimf^⚠

__fdiml^⚠

__finite^⚠

__finitef^⚠

__finitel^⚠

__floor^⚠

__floorf^⚠

__floorl^⚠

__fma^⚠

__fmaf^⚠

__fmal^⚠

__fmax^⚠

__fmaxf^⚠

__fmaxl^⚠

__fmin^⚠

__fminf^⚠

__fminl^⚠

__fmod^⚠

__fmodf^⚠

__fmodl^⚠

__fpclassify^⚠

__fpclassifyf^⚠

__fpclassifyl^⚠

__frexp^⚠

__frexpf^⚠

__frexpl^⚠

__gamma^⚠

__gammaf^⚠

__gammal^⚠

__getdelim^⚠

__hypot^⚠

__hypotf^⚠

__hypotl^⚠

__ilogb^⚠

__ilogbf^⚠

__ilogbl^⚠

__iseqsig^⚠

__iseqsigf^⚠

__iseqsigl^⚠

__isinf^⚠

__isinff^⚠

__isinfl^⚠

__isnan^⚠

__isnanf^⚠

__isnanl^⚠

__issignaling^⚠

__issignalingf^⚠

__issignalingl^⚠

__j0^⚠

__j0f^⚠

__j0l^⚠

__j1^⚠

__j1f^⚠

__j1l^⚠

__jn^⚠

__jnf^⚠

__jnl^⚠

__ldexp^⚠

__ldexpf^⚠

__ldexpl^⚠

__lgamma^⚠

__lgamma_r^⚠

__lgammaf^⚠

__lgammaf_r^⚠

__lgammal^⚠

__lgammal_r^⚠

__llrint^⚠

__llrintf^⚠

__llrintl^⚠

__llround^⚠

__llroundf^⚠

__llroundl^⚠

__log^⚠

__log2^⚠

__log1p^⚠

__log1pf^⚠

__log1pl^⚠

__log2f^⚠

__log2l^⚠

__log10^⚠

__log10f^⚠

__log10l^⚠

__logb^⚠

__logbf^⚠

__logbl^⚠

__logf^⚠

__logl^⚠

__lrint^⚠

__lrintf^⚠

__lrintl^⚠

__lround^⚠

__lroundf^⚠

__lroundl^⚠

__memcmpeq^⚠

__mempcpy^⚠

__modf^⚠

__modff^⚠

__modfl^⚠

__nan^⚠

__nanf^⚠

__nanl^⚠

__nearbyint^⚠

__nearbyintf^⚠

__nearbyintl^⚠

__nextafter^⚠

__nextafterf^⚠

__nextafterl^⚠

__nexttoward^⚠

__nexttowardf^⚠

__nexttowardl^⚠

__overflow^⚠

__pow^⚠

__powf^⚠

__powl^⚠

__remainder^⚠

__remainderf^⚠

__remainderl^⚠

__remquo^⚠

__remquof^⚠

__remquol^⚠

__rint^⚠

__rintf^⚠

__rintl^⚠

__round^⚠

__roundf^⚠

__roundl^⚠

__scalb^⚠

__scalbf^⚠

__scalbl^⚠

__scalbln^⚠

__scalblnf^⚠

__scalblnl^⚠

__scalbn^⚠

__scalbnf^⚠

__scalbnl^⚠

__signbit^⚠

__signbitf^⚠

__signbitl^⚠

__significand^⚠

__significandf^⚠

__significandl^⚠

__sin^⚠

__sinf^⚠

__sinh^⚠

__sinhf^⚠

__sinhl^⚠

__sinl^⚠

__sqrt^⚠

__sqrtf^⚠

__sqrtl^⚠

__stpcpy^⚠

__stpncpy^⚠

__strtok_r^⚠

__tan^⚠

__tanf^⚠

__tanh^⚠

__tanhf^⚠

__tanhl^⚠

__tanl^⚠

__tgamma^⚠

__tgammaf^⚠

__tgammal^⚠

__trunc^⚠

__truncf^⚠

__truncl^⚠

__uflow^⚠

__y0^⚠

__y0f^⚠

__y0l^⚠

__y1^⚠

__y1f^⚠

__y1l^⚠

__yn^⚠

__ynf^⚠

__ynl^⚠

a64l^⚠

abort^⚠

abs^⚠

acos^⚠

acosf^⚠

acosh^⚠

acoshf^⚠

acoshl^⚠

acosl^⚠

aligned_alloc^⚠

alloca^⚠

arc4random^⚠

arc4random_buf^⚠

arc4random_uniform^⚠

asin^⚠

asinf^⚠

asinh^⚠

asinhf^⚠

asinhl^⚠

asinl^⚠

asprintf^⚠

at_quick_exit^⚠

atan^⚠

atan2^⚠

atan2f^⚠

atan2l^⚠

atanf^⚠

atanh^⚠

atanhf^⚠

atanhl^⚠

atanl^⚠

atexit^⚠

atof^⚠

atoi^⚠

atol^⚠

atoll^⚠

bcmp^⚠

bcopy^⚠

bsearch^⚠

bzero^⚠

calloc^⚠

cbrt^⚠

cbrtf^⚠

cbrtl^⚠

ceil^⚠

ceilf^⚠

ceill^⚠

clearenv^⚠

clearerr^⚠

clearerr_unlocked^⚠

copysign^⚠

copysignf^⚠

copysignl^⚠

cos^⚠

cosf^⚠

cosh^⚠

coshf^⚠

coshl^⚠

cosl^⚠

ctermid^⚠

div^⚠

dprintf^⚠

drand48^⚠

drand48_r^⚠

drem^⚠

dremf^⚠

dreml^⚠

ecvt^⚠

ecvt_r^⚠

erand48^⚠

erand48_r^⚠

erf^⚠

erfc^⚠

erfcf^⚠

erfcl^⚠

erff^⚠

erfl^⚠

exit^⚠

exp^⚠

exp2^⚠

exp2f^⚠

exp2l^⚠

expf^⚠

expl^⚠

explicit_bzero^⚠

expm1^⚠

expm1f^⚠

expm1l^⚠

fabs^⚠

fabsf^⚠

fabsl^⚠

fclose^⚠

fcvt^⚠

fcvt_r^⚠

fdim^⚠

fdimf^⚠

fdiml^⚠

fdopen^⚠

feof^⚠

feof_unlocked^⚠

ferror^⚠

ferror_unlocked^⚠

fflush^⚠

fflush_unlocked^⚠

ffs^⚠

ffsl^⚠

ffsll^⚠

fgetc^⚠

fgetc_unlocked^⚠

fgetpos^⚠

fgets^⚠

fileno^⚠

fileno_unlocked^⚠

finite^⚠

finitef^⚠

finitel^⚠

flockfile^⚠

floor^⚠

floorf^⚠

floorl^⚠

fma^⚠

fmaf^⚠

fmal^⚠

fmax^⚠

fmaxf^⚠

fmaxl^⚠

fmemopen^⚠

fmin^⚠

fminf^⚠

fminl^⚠

fmod^⚠

fmodf^⚠

fmodl^⚠

fopen^⚠

fopencookie^⚠

fprintf^⚠

fputc^⚠

fputc_unlocked^⚠

fputs^⚠

fread^⚠

fread_unlocked^⚠

free^⚠

freopen^⚠

frexp^⚠

frexpf^⚠

frexpl^⚠

fscanf^⚠

fscanf1^⚠

fseek^⚠

fseeko^⚠

fsetpos^⚠

ftell^⚠

ftello^⚠

ftrylockfile^⚠

funlockfile^⚠

fwrite^⚠

fwrite_unlocked^⚠

gamma^⚠

gammaf^⚠

gammal^⚠

gcvt^⚠

getc^⚠

getc_unlocked^⚠

getchar^⚠

getchar_unlocked^⚠

getdelim^⚠

getenv^⚠

getline^⚠

getloadavg^⚠

getsubopt^⚠

getw^⚠

hypot^⚠

hypotf^⚠

hypotl^⚠

ilogb^⚠

ilogbf^⚠

ilogbl^⚠

imaxabs^⚠

imaxdiv^⚠

index^⚠

initstate^⚠

initstate_r^⚠

isinf^⚠

isinff^⚠

isinfl^⚠

isnan^⚠

isnanf^⚠

isnanl^⚠

j0^⚠

j0f^⚠

j0l^⚠

j1^⚠

j1f^⚠

j1l^⚠

jn^⚠

jnf^⚠

jnl^⚠

jrand48^⚠

jrand48_r^⚠

l64a^⚠

labs^⚠

lcong48^⚠

lcong48_r^⚠

ldexp^⚠

ldexpf^⚠

ldexpl^⚠

ldiv^⚠

lgamma^⚠

lgamma_r^⚠

lgammaf^⚠

lgammaf_r^⚠

lgammal^⚠

lgammal_r^⚠

llabs^⚠

lldiv^⚠

llrint^⚠

llrintf^⚠

llrintl^⚠

llround^⚠

llroundf^⚠

llroundl^⚠

log^⚠

log2^⚠

log1p^⚠

log1pf^⚠

log1pl^⚠

log2f^⚠

log2l^⚠

log10^⚠

log10f^⚠

log10l^⚠

logb^⚠

logbf^⚠

logbl^⚠

logf^⚠

logl^⚠

lrand48^⚠

lrand48_r^⚠

lrint^⚠

lrintf^⚠

lrintl^⚠

lround^⚠

lroundf^⚠

lroundl^⚠

malloc^⚠

mblen^⚠

mbstowcs^⚠

mbtowc^⚠

memccpy^⚠

memchr^⚠

memcmp^⚠

memcpy^⚠

memmem^⚠

memmove^⚠

mempcpy^⚠

memset^⚠

mkdtemp^⚠

mkstemp^⚠

mkstemps^⚠

mktemp^⚠

modf^⚠

modff^⚠

modfl^⚠

mrand48^⚠

mrand48_r^⚠

nan^⚠

nanf^⚠

nanl^⚠

nearbyint^⚠

nearbyintf^⚠

nearbyintl^⚠

nextafter^⚠

nextafterf^⚠

nextafterl^⚠

nexttoward^⚠

nexttowardf^⚠

nexttowardl^⚠

nrand48^⚠

nrand48_r^⚠

on_exit^⚠

open_memstream^⚠

pclose^⚠

perror^⚠

popen^⚠

posix_memalign^⚠

pow^⚠

powf^⚠

powl^⚠

printf^⚠

pselect^⚠

putc^⚠

putc_unlocked^⚠

putchar^⚠

putchar_unlocked^⚠

putenv^⚠

puts^⚠

putw^⚠

qecvt^⚠

qecvt_r^⚠

qfcvt^⚠

qfcvt_r^⚠

qgcvt^⚠

qsort^⚠

quick_exit^⚠

rand^⚠

rand_r^⚠

random^⚠

random_r^⚠

realloc^⚠

reallocarray^⚠

realpath^⚠

remainder^⚠

remainderf^⚠

remainderl^⚠

remove^⚠

remquo^⚠

remquof^⚠

remquol^⚠

rename^⚠

renameat^⚠

rewind^⚠

rindex^⚠

rint^⚠

rintf^⚠

rintl^⚠

round^⚠

roundf^⚠

roundl^⚠

rpmatch^⚠

scalb^⚠

scalbf^⚠

scalbl^⚠

scalbln^⚠

scalblnf^⚠

scalblnl^⚠

scalbn^⚠

scalbnf^⚠

scalbnl^⚠

scanf^⚠

scanf1^⚠

seed48^⚠

seed48_r^⚠

select^⚠

setbuf^⚠

setbuffer^⚠

setenv^⚠

setlinebuf^⚠

setstate^⚠

setstate_r^⚠

setvbuf^⚠

significand^⚠

significandf^⚠

significandl^⚠

sin^⚠

sinf^⚠

sinh^⚠

sinhf^⚠

sinhl^⚠

sinl^⚠

snprintf^⚠

sprintf^⚠

sqrt^⚠

sqrtf^⚠

sqrtl^⚠

srand^⚠

srand48^⚠

srand48_r^⚠

srandom^⚠

srandom_r^⚠

sscanf^⚠

sscanf1^⚠

stpcpy^⚠

stpncpy^⚠

strcasecmp^⚠

strcasecmp_l^⚠

strcasestr^⚠

strcat^⚠

strchr^⚠

strchrnul^⚠

strcmp^⚠

strcoll^⚠

strcoll_l^⚠

strcpy^⚠

strcspn^⚠

strdup^⚠

strerror^⚠

strerror_l^⚠

strerror_r^⚠

strlcat^⚠

strlcpy^⚠

strlen^⚠

strncasecmp^⚠

strncasecmp_l^⚠

strncat^⚠

strncmp^⚠

strncpy^⚠

strndup^⚠

strnlen^⚠

strpbrk^⚠

strrchr^⚠

strsep^⚠

strsignal^⚠

strspn^⚠

strstr^⚠

strtod^⚠

strtof^⚠

strtoimax^⚠

strtok^⚠

strtok_r^⚠

strtol^⚠

strtold^⚠

strtoll^⚠

strtoq^⚠

strtoul^⚠

strtoull^⚠

strtoumax^⚠

strtouq^⚠

strxfrm^⚠

strxfrm_l^⚠

system^⚠

tan^⚠

tanf^⚠

tanh^⚠

tanhf^⚠

tanhl^⚠

tanl^⚠

tempnam^⚠

tgamma^⚠

tgammaf^⚠

tgammal^⚠

tmpfile^⚠

tmpnam^⚠

tmpnam_r^⚠

trunc^⚠

truncf^⚠

truncl^⚠

ungetc^⚠

unsetenv^⚠

valloc^⚠

vasprintf^⚠

vdprintf^⚠

vfprintf^⚠

vfscanf^⚠

vfscanf1^⚠

vprintf^⚠

vscanf^⚠

vscanf1^⚠

vsnprintf^⚠

vsprintf^⚠

vsscanf^⚠

vsscanf1^⚠

wcstoimax^⚠

wcstombs^⚠

wcstoumax^⚠

wctomb^⚠

y0^⚠

y0f^⚠

y0l^⚠

y1^⚠

y1f^⚠

y1l^⚠

yn^⚠

ynf^⚠

ynl^⚠

Type Aliases

BMS_BLKMEM

Block Memory Management

BMS_BUFMEM

Buffer Memory Management

BMS_CHKMEM

Chunk Memory Management

FILE

Reopt_ConsType

SCIP

SCIP_AGGREGATE

SCIP_AGGRROW

SCIP_BANDIT

data structure for bandit algorithms

SCIP_BANDITDATA

data structure for specific bandit algorithm implementation

SCIP_BANDITVTABLE

virtual function table for bandit callbacks

SCIP_BDCHGIDX

SCIP_BDCHGINFO

SCIP_BENDERS

SCIP_BENDERSCUT

SCIP_BENDERSCUTDATA

SCIP_BENDERSDATA

SCIP_BOOLARRAY

dynamic array for storing SCIP_Bool values

SCIP_BOUNDCHG

SCIP_BOUNDSTORE

SCIP_BRANCHCAND

SCIP_BRANCHINGDATA

SCIP_BRANCHRULE

SCIP_BRANCHRULEDATA

SCIP_BT

Binary tree data structure

SCIP_BTNODE

search node of \ref SCIP_BT “binary tree”

SCIP_BaseStat

basis status for columns and rows

SCIP_BendersEnfoType

SCIP_BendersSolveLoop

SCIP_BendersSubStatus

SCIP_BendersSubType

SCIP_BoundType

type of variable bound: lower or upper bound

SCIP_BoundchgType

bound change type

SCIP_BranchDir

branching direction for branching on variables

SCIP_CHILD

SCIP_CLIQUE

SCIP_CLIQUELIST

SCIP_CLIQUETABLE

SCIP_CLOCK

SCIP_COL

column of an LP

SCIP_COLSOLVALS

SCIP_COMPR

SCIP_COMPRDATA

SCIP_CONCSOLVER

SCIP_CONCSOLVERDATA

SCIP_CONCSOLVERTYPE

SCIP_CONCSOLVERTYPEDATA

SCIP_CONFLICT

SCIP_CONFLICTHDLR

SCIP_CONFLICTHDLRDATA

SCIP_CONFLICTSET

SCIP_CONS

SCIP_CONSDATA

SCIP_CONSHDLR

SCIP_CONSHDLRDATA

SCIP_CONSNONLINEAR_AUXEXPR

linear auxiliary expression of the form xy {≤,≥,=} coefs[0]w + coefs[1]x + coefs[2]y + cst

SCIP_CONSNONLINEAR_BILINTERM

bilinear term structure

SCIP_CONSSETCHG

SCIP_CPUCLOCK

SCIP_CUT

SCIP_CUTPOOL

SCIP_CUTSEL

SCIP_CUTSELDATA

SCIP_ClockType

SCIP_Confidencelevel

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 %

SCIP_ConflictPresolStrat

dualray presolving strategy

SCIP_ConflictType

types of conflicts

SCIP_DECOMP

SCIP_DECOMPSTORE

SCIP_DIALOG

SCIP_DIALOGDATA

SCIP_DIALOGHDLR

SCIP_DIGRAPH

Directed graph data structure (stored as adjacency list)

SCIP_DISJOINTSET

disjoint set (disjoint set (union find)) data structure for querying and updating connectedness of a graph with integer vertices 0,…,n - 1

SCIP_DISP

SCIP_DISPDATA

SCIP_DIVESET

SCIP_DIVETYPE

SCIP_DOM

SCIP_DOMCHG

SCIP_DOMCHGBOTH

SCIP_DOMCHGBOUND

SCIP_DOMCHGDYN

SCIP_DispMode

display activation status of display column

SCIP_DispStatus

display activation status of display column

SCIP_DiveContext

context for diving statistics

SCIP_DomchgType

domain change data type

SCIP_EVENT

SCIP_EVENTBDCHG

SCIP_EVENTDATA

SCIP_EVENTFILTER

SCIP_EVENTHDLR

SCIP_EVENTHDLRDATA

SCIP_EVENTHOLE

SCIP_EVENTIMPLADD

SCIP_EVENTOBJCHG

SCIP_EVENTQUEUE

SCIP_EVENTROWADDEDLP

SCIP_EVENTROWADDEDSEPA

SCIP_EVENTROWCOEFCHANGED

SCIP_EVENTROWCONSTCHANGED

SCIP_EVENTROWDELETEDLP

SCIP_EVENTROWDELETEDSEPA

SCIP_EVENTROWSIDECHANGED

SCIP_EVENTTYPE

SCIP_EVENTTYPECHG

SCIP_EVENTVARADDED

SCIP_EVENTVARDELETED

SCIP_EVENTVARFIXED

SCIP_EVENTVARUNLOCKED

SCIP_EXPR

SCIP_EXPRCURV

curvature types

SCIP_EXPRDATA

SCIP_EXPRHDLR

@name Expression Handler */ /**@{

SCIP_EXPRHDLRDATA

SCIP_EXPRITER

SCIP_EXPRITERDATA

SCIP_EXPRITER_STAGE

stage of DFS iterator

SCIP_EXPRITER_TYPE

mode for expression iterator

SCIP_EXPRPRINTDATA

SCIP_EXPRPRINT_WHAT

SCIP_EXPR_OWNERDATA

@name Expression Owner */ /**@{

SCIP_FILE

SCIP_FORK

SCIP_HASHMAP

Hash map data structure

SCIP_HASHMAPENTRY

Hash map entry

SCIP_HASHSET

Hash set data structure

SCIP_HASHTABLE

Hash table data structure

SCIP_HEUR

SCIP_HEURDATA

SCIP_HEURTIMING

SCIP_HISTORY

SCIP_HOLE

SCIP_HOLECHG

SCIP_HOLELIST

SCIP_Hashmaptype

type of hashmap: are pointers, reals or ints stored, or unknown

SCIP_IMPLICS

SCIP_INFERENCEDATA

SCIP_INTARRAY

dynamic array for storing int values

SCIP_INTERVAL

interval given by infimum and supremum

SCIP_JUNCTION

SCIP_LEAF

SCIP_LINCONSSTATS

SCIP_LINCONSUPGRADE

@addtogroup CONSHDLRS

SCIP_LINELIST

SCIP_LP

LP structure

SCIP_LPAlgo

type of LP algorithm

SCIP_LPBDCHGS

SCIP_LPI

SCIP_LPINORMS

SCIP_LPISTATE

SCIP_LPParam

LP solver parameters

SCIP_LPSOLVALS

SCIP_LPSolQuality

LP solution quality quantities

SCIP_LPSolStat

solution status after solving LP

SCIP_LeaderRule

selection rules for leaders in SST cuts

SCIP_LeaderTiebreakRule

tie breaks for leader rule based on the leader’s orbit

SCIP_LinConstype

linear constraint types recognizable

SCIP_LinearConsType

solution status after solving LP

SCIP_LockType

SCIP_MATRIX

SCIP_MESSAGEHDLR

SCIP_MESSAGEHDLRDATA

SCIP_MONOTONE

monotonicity

SCIP_MULTAGGR

SCIP_MULTIHASH

Hash table data structure which allows multiple occurences of an element

SCIP_MULTIHASHLIST

Hash table element list to store single elements of a multi hash table

SCIP_NEGATE

SCIP_NLHDLR

SCIP_NLHDLRDATA

SCIP_NLHDLREXPRDATA

SCIP_NLHDLR_METHOD

SCIP_NLP

SCIP_NLPI

SCIP_NLPIDATA

SCIP_NLPIPROBLEM

SCIP_NLPPARAM

parameters for NLP solve

SCIP_NLPSTATISTICS

Statistics from an NLP solve

SCIP_NLROW

SCIP_NODE

SCIP_NODEPQ

SCIP_NODESEL

SCIP_NODESELDATA

SCIP_NlpParam_FastFail

NLP solver fast-fail levels

SCIP_NlpSolStat

NLP solution status

SCIP_NlpTermStat

NLP solver termination status

SCIP_NodeType

SCIP_ORIGINAL

SCIP_ObjSen

objective sense

SCIP_Objsense

objective sense: minimization or maximization

SCIP_OrbitopeType

type of orbitope constraint: full, packing, or partitioning orbitope

SCIP_PARAM

SCIP_PARAMDATA

SCIP_PARAMSET

SCIP_PENDINGBDCHG

SCIP_PQUEUE

Priority queue data structure

SCIP_PRESOL

SCIP_PRESOLDATA

SCIP_PRESOLTIMING

SCIP_PRICER

SCIP_PRICERDATA

SCIP_PROB

SCIP_PROBDATA

SCIP_PROBINGNODE

SCIP_PROFILE

Resource profile data structure

SCIP_PROOFSET

SCIP_PROP

SCIP_PROPDATA

SCIP_PROPTIMING

SCIP_PSEUDOFORK

SCIP_PTRARRAY

dynamic array for storing pointers

SCIP_Parallelmode

The parallel mode

SCIP_ParamEmphasis

possible parameter emphases - used to determine the general SCIP behavior

SCIP_ParamSetting

possible parameter settings - used to determine the behavior of different SCIP components, e.g., heuristics, separators, …

SCIP_ParamType

possible parameter types

SCIP_Pricing

LP pricing strategy

SCIP_QUEUE

(circular) Queue data structure

SCIP_RANDNUMGEN

random number generator

SCIP_READER

SCIP_READERDATA

SCIP_REALARRAY

dynamic array for storing SCIP_Real values

SCIP_REGRESSION

regression data structure to compute an incremental linear regression of paired observations

SCIP_RELAX

SCIP_RELAXATION

SCIP_RELAXDATA

SCIP_REOPT

SCIP_REOPTCONSDATA

SCIP_REOPTNODE

SCIP_REOPTTREE

SCIP_REPRESENTATIVE

SCIP_RESOURCEACTIVITY

Resource activity data structure

SCIP_ROUNDMODE

rounding mode of floating point operations (upwards, downwards, nearest, …)

SCIP_ROW

row of an LP

SCIP_ROWPREP

a linear inequality row in preparation to become a SCIP_ROW

SCIP_ROWSOLVALS

SCIP_RecomputesymType

conditions to recompute symmetries after a restart

SCIP_ReoptType

SCIP_Result

result codes for SCIP callback methods

SCIP_Retcode

return codes for SCIP methods: non-positive return codes are errors

SCIP_RowOriginType

type of origin of row

SCIP_SEPA

SCIP_SEPADATA

SCIP_SET

SCIP_SIBLING

SCIP_SOL

SCIP_SOLNODE

SCIP_SOLTREE

SCIP_SPARSESOL

Sparse solution data structure

SCIP_SSTType

variable types for leader in Schreier Sims cuts

SCIP_STAT

SCIP_SUBPROBLEMSOLVESTAT

SCIP_SUBROOT

SCIP_SYNCDATA

SCIP_SYNCSTORE

SCIP_SetppcType

type of setppc constraint: set partitioning, set packing, or set covering

SCIP_Setting

possible settings for enabling/disabling algorithms and other features

SCIP_SideType

type of row side: left hand or right hand side

SCIP_SolOrigin

origin of solution: where to retrieve uncached elements

SCIP_SolType

type of solution: heuristic or (LP) relaxation solution, or unspecified origin

SCIP_Stage

SCIP operation stage

SCIP_Status

SCIP solving status

SCIP_TABLE

SCIP_TABLEDATA

SCIP_TREE

SCIP_TREEMODEL

SCIP_VALUEHISTORY

Value history data structure

SCIP_VAR

SCIP_VARDATA

SCIP_VBOUNDS

SCIP_VGRAPH

SCIP_VIOL

SCIP_Varstatus

status of problem variables

SCIP_Vartype

variable type

SCIP_VerbLevel

verbosity levels of output

SCIP_WALLCLOCK

SYM_CONSTTYPE

SYM_EXPRDATA

SYM_HANDLETYPE

SYM_MATRIXDATA

SYM_OPTYPE

SYM_RHSTYPE

SYM_Rhssense

define sense of rhs

SYM_SPEC

SYM_VARTYPE

_Float32

_Float64

_Float32x

_Float64x

_IO_lock_t

__FILE

__blkcnt64_t

__blkcnt_t

__blksize_t

__builtin_va_list

__caddr_t

__clock_t

__clockid_t

__compar_fn_t

__daddr_t

__dev_t

__fd_mask

__fpos64_t

__fpos_t

__fsblkcnt64_t

__fsblkcnt_t

__fsfilcnt64_t

__fsfilcnt_t

__fsword_t

__gid_t

__gnuc_va_list

__gwchar_t

__id_t

__ino64_t

__ino_t

__int8_t

__int16_t

__int32_t

__int64_t

__int_least8_t

__int_least16_t

__int_least32_t

__int_least64_t

__intmax_t

__intptr_t

__key_t

__locale_t

__loff_t

__mode_t

__nlink_t

__off64_t

__off_t

__pid_t

__pthread_list_t

__pthread_slist_t

__quad_t

__rlim64_t

__rlim_t

__sig_atomic_t

__socklen_t

__ssize_t

__suseconds64_t

__suseconds_t

__syscall_slong_t

__syscall_ulong_t

__thrd_t

__time_t

__timer_t

__tss_t

__u_char

__u_int

__u_long

__u_quad_t

__u_short

__uid_t

__uint8_t

__uint16_t

__uint32_t

__uint64_t

__uint_least8_t

__uint_least16_t

__uint_least32_t

__uint_least64_t

__uintmax_t

__useconds_t

_bindgen_ty_1

blkcnt_t

blksize_t

caddr_t

clock_t

clockid_t

cookie_close_function_t

cookie_io_functions_t

cookie_read_function_t

cookie_seek_function_t

cookie_write_function_t

daddr_t

dev_t

double_t

fd_mask

float_t

fpos_t

fsblkcnt_t

fsfilcnt_t

fsid_t

gid_t

id_t

ino_t

int_fast8_t

int_fast16_t

int_fast32_t

int_fast64_t

int_least8_t

int_least16_t

int_least32_t

int_least64_t

intmax_t

key_t

locale_t

loff_t

mode_t

nlink_t

off_t

pid_t

pthread_key_t

pthread_once_t

pthread_spinlock_t

pthread_t

quad_t

register_t

sigset_t

suseconds_t

time_t

timer_t

u_char

u_int

u_int8_t

u_int16_t

u_int32_t

u_int64_t

u_long

u_quad_t

u_short

uid_t

uint

uint_fast8_t

uint_fast16_t

uint_fast32_t

uint_fast64_t

uint_least8_t

uint_least16_t

uint_least32_t

uint_least64_t

uintmax_t

ulong

ushort

va_list

wchar_t

Unions

SCIP_ConsNonlinear_BilinTerm__bindgen_ty_1

SCIP_EXPRITER_USERDATA

user data storage type for expression iteration

__atomic_wide_counter

__mbstate_t__bindgen_ty_1

pthread_attr_t

pthread_barrier_t

pthread_barrierattr_t

pthread_cond_t

pthread_condattr_t

pthread_mutex_t

pthread_mutexattr_t

pthread_rwlock_t

pthread_rwlockattr_t