Crate scip_sys

Expand description

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

Re-exports§

pub use self::SCIP_Retcode as SCIP_RETCODE;
pub use self::SCIP_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_ImplintType as SCIP_IMPLINTTYPE;
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_Datatree_Valuetype as SCIP_DATATREE_VALUETYPE;
pub use self::SCIP_DispStatus as SCIP_DISPSTATUS;
pub use self::SCIP_DispMode as SCIP_DISPMODE;
pub use self::SCIP_IsFpRepresentable as SCIP_ISFPREPRESENTABLE;
pub use self::SCIP_RoundModeRational as SCIP_ROUNDMODE_RAT;
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_BendersObjectiveType as SCIP_BENDERSOBJTYPE;
pub use self::SCIP_VerbLevel as SCIP_VERBLEVEL;
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::Ps_dualcostsel as PS_DUALCOSTSEL;
pub use self::SCIP_Stage as SCIP_STAGE;
pub use self::SCIP_Setting as SCIP_SETTING;
pub use self::SYM_Symtype as SYM_SYMTYPE;
pub use self::SYM_Nodetype as SYM_NODETYPE;
pub use self::SYM_Consoptype as SYM_CONSOPTYPE;
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_LinearConsType as SCIP_LINEARCONSTYPE;
pub use self::SCIP_SetppcType as SCIP_SETPPCTYPE;

Structs§

BMS_BlkMem
BMS_BufMem
BMS_ChkMem
SCIP_AggrRow
SCIP_Aggregate
SCIP_AggregateExact
SCIP_AggregationInfo
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_Certificate
SCIP_CertificateBound
SCIP_Certnodedata
SCIP_Child: child information (should not exceed the size of a pointer)
SCIP_Clique
SCIP_CliqueList
SCIP_CliqueTable
SCIP_Clock
SCIP_Col: LP column; The row vector of the LP column is partitioned into two parts: The first col->nlprows rows in the rows array are the ones that belong to the current LP (col->rows[j]->lppos >= 0) and that are linked to the column (col->linkpos[j] >= 0). The remaining col->len - col->nlprows rows in the rows array are the ones that don’t belong to the current LP (col->rows[j]->lppos == -1) or that are not linked to the column (col->linkpos[j] == -1).
SCIP_ColExact
SCIP_ColExactSolVals
SCIP_ColSolVals: collected values of a column which depend on the LP solution We store these values in each column to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP. Note that we do not store the farkascoef value since we do expect a node with infeasible LP to be pruned anyway.
SCIP_Compr
SCIP_ComprData
SCIP_ConcSolver
SCIP_ConcSolverData
SCIP_ConcSolverType
SCIP_ConcSolverTypeData
SCIP_Conflict
SCIP_ConflictRow
SCIP_ConflictSet
SCIP_ConflictStore
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_Datatree
SCIP_DebugSolData
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_DomExact
SCIP_Event
SCIP_EventBdChg
SCIP_EventData
SCIP_EventFilter
SCIP_EventHole
SCIP_EventImplAdd
SCIP_EventImplTypeChg
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: fork with solved LP, where bounds and constraints have been changed, and rows and columns were added
SCIP_HashMap
SCIP_HashMapEntry
SCIP_HashSet
SCIP_HashTable
SCIP_Heur
SCIP_HeurData
SCIP_History
SCIP_Hole
SCIP_HoleChg
SCIP_Holelist
SCIP_IIS
SCIP_IISfinder
SCIP_IISfinderData
SCIP_Implics
SCIP_InferenceData
SCIP_IntArray
SCIP_Interval: interval given by infimum and supremum
SCIP_Junction: fork without LP solution, where only bounds and constraints have been changed
SCIP_LPBdChgs
SCIP_LPi
SCIP_LPiExact
SCIP_LPiNorms
SCIP_LPiState
SCIP_Leaf: leaf information (should not exceed the size of a pointer)
SCIP_LinConsStats
SCIP_LinConsUpgrade
SCIP_Linelist
SCIP_Loose
SCIP_Lp: current LP data
SCIP_LpExact
SCIP_LpExactSolVals
SCIP_LpSolVals: collected values of the LP data which depend on the LP solution We store these values to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP.
SCIP_Matrix
SCIP_MatrixValsExact
SCIP_Messagehdlr
SCIP_MessagehdlrData
SCIP_MirInfo
SCIP_Multaggr
SCIP_MultaggrExact
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: node data structure
SCIP_NodePQ
SCIP_Nodesel
SCIP_NodeselData
SCIP_Original
SCIP_PQueue
SCIP_Param
SCIP_ParamData
SCIP_ParamSet
SCIP_PendingBdchg: bound change information for pending bound changes
SCIP_Presol
SCIP_PresolData
SCIP_Pricer
SCIP_PricerData
SCIP_Primal
SCIP_Prob
SCIP_ProbData
SCIP_Probingnode: probing node, possibly with solved LP, where bounds and constraints have been changed, and rows and columns might have been added
SCIP_Profile
SCIP_ProjShiftData
SCIP_ProofSet
SCIP_Prop
SCIP_PropData
SCIP_Pseudofork: fork without LP solution, where bounds and constraints have been changed, and rows and columns were added
SCIP_PtrArray
SCIP_Queue
SCIP_RandNumGen
SCIP_Rational
SCIP_RationalArray
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: LP row The column vector of the LP row is partitioned into two parts: The first row->nlpcols columns in the cols array are the ones that belong to the current LP (row->cols[j]->lppos >= 0) and that are linked to the row (row->linkpos[j] >= 0). The remaining row->len - row->nlpcols columns in the cols array are the ones that don’t belong to the current LP (row->cols[j]->lppos == -1) or that are not linked to the row (row->linkpos[j] == -1).
SCIP_RowExact
SCIP_RowExactSolVals
SCIP_RowPrep
SCIP_RowSolVals: collected values of a row which depend on the LP solution We store these values in each row to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP. We do not store the dualfarkas value since we expect a node with infeasible LP to be pruned anyway. In this unlikely case, we have to resolve the LP.
SCIP_Sepa
SCIP_SepaData
SCIP_Set: global SCIP settings
SCIP_Sibling: sibling information (should not exceed the size of a pointer)
SCIP_Sol
SCIP_SolNode
SCIP_SolTree
SCIP_SparseSol
SCIP_Stat
SCIP_SubproblemSolveStat
SCIP_Subroot: fork with solved LP, where bounds and constraints have been changed, and rows and columns were removed and added
SCIP_SyncData
SCIP_SyncStore
SCIP_Table
SCIP_TableData
SCIP_Tree: branch and bound tree
SCIP_Treemodel
SCIP_VBounds
SCIP_VGraph
SCIP_ValsExact
SCIP_ValueHistory
SCIP_Var
SCIP_VarData
SCIP_VarDataExact
SCIP_Viol
SCIP_WallClock
SYM_ExprData
SYM_Graph
Scip
__BindgenBitfieldUnit
__BindgenFloat16
__arm_legacy_debug_state
__arm_pagein_state
__darwin_arm_cpmu_state64
__darwin_arm_debug_state32
__darwin_arm_debug_state64
__darwin_arm_exception_state
__darwin_arm_exception_state64
__darwin_arm_exception_state64_v2
__darwin_arm_neon_state
__darwin_arm_neon_state64
__darwin_arm_sme2_state
__darwin_arm_sme_state
__darwin_arm_sme_za_state
__darwin_arm_sve_p_state
__darwin_arm_sve_z_state
__darwin_arm_thread_state
__darwin_arm_thread_state64
__darwin_arm_vfp_state
__darwin_mcontext32
__darwin_mcontext64
__darwin_pthread_handler_rec
__darwin_sigaltstack
__darwin_ucontext
__double2
__float2
__sFILE
__sFILEX
__sbuf
__sigaction
__siginfo
_malloc_zone_t
_opaque_pthread_attr_t
_opaque_pthread_cond_t
_opaque_pthread_condattr_t
_opaque_pthread_mutex_t
_opaque_pthread_mutexattr_t
_opaque_pthread_once_t
_opaque_pthread_rwlock_t
_opaque_pthread_rwlockattr_t
_opaque_pthread_t
div_t
exception
imaxdiv_t
ldiv_t
lldiv_t
proc_rlimit_control_wakeupmon
rlimit
rusage
rusage_info_v0
rusage_info_v1
rusage_info_v2
rusage_info_v3
rusage_info_v4
rusage_info_v5
rusage_info_v6
sigaction
sigevent
sigstack
sigvec
timeval
wait__bindgen_ty_1
wait__bindgen_ty_2

Constants§

ARG_MAX
ARTIFICIALVARNAMEPREFIX
BC_BASE_MAX
BC_DIM_MAX
BC_SCALE_MAX
BC_STRING_MAX
BIG_ENDIAN
BUFSIZ
BUS_ADRALN
BUS_ADRERR
BUS_NOOP
BUS_OBJERR
BYTE_ORDER
CHARCLASS_NAME_MAX
CHAR_BIT
CHAR_MAX
CHAR_MIN
CHILD_MAX
CLD_CONTINUED
CLD_DUMPED
CLD_EXITED
CLD_KILLED
CLD_NOOP
CLD_STOPPED
CLD_TRAPPED
CLK_TCK
COLL_WEIGHTS_MAX
CPUMON_MAKE_FATAL
DBL_HAS_SUBNORM
DOMAIN
EOF
EQUIV_CLASS_MAX
EXIT_FAILURE
EXIT_SUCCESS
EXPR_NEST_MAX
FALSE
FILENAME_MAX
FLT_HAS_SUBNORM
FOOTPRINT_INTERVAL_RESET
FOPEN_MAX
FPE_FLTDIV
FPE_FLTINV
FPE_FLTOVF
FPE_FLTRES
FPE_FLTSUB
FPE_FLTUND
FPE_INTDIV
FPE_INTOVF
FPE_NOOP
FP_FAST_FMA
FP_FAST_FMAF
FP_FAST_FMAL
FP_ILOGB0
FP_ILOGBNAN
FP_QNAN
FP_SNAN
FP_SUPERNORMAL
GID_MAX
ILL_BADSTK
ILL_COPROC
ILL_ILLADR
ILL_ILLOPC
ILL_ILLOPN
ILL_ILLTRP
ILL_NOOP
ILL_PRVOPC
ILL_PRVREG
INT8_MAX
INT8_MIN
INT16_MAX
INT16_MIN
INT32_MAX
INT32_MIN
INT64_MAX
INT64_MIN
INTPTR_MAX
INTPTR_MIN
INT_FAST8_MAX
INT_FAST8_MIN
INT_FAST16_MAX
INT_FAST16_MIN
INT_FAST32_MAX
INT_FAST32_MIN
INT_FAST64_MAX
INT_FAST64_MIN
INT_LEAST8_MAX
INT_LEAST8_MIN
INT_LEAST16_MAX
INT_LEAST16_MIN
INT_LEAST32_MAX
INT_LEAST32_MIN
INT_LEAST64_MAX
INT_LEAST64_MIN
INT_MAX
INT_MIN
IOPOL_APPLICATION
IOPOL_ATIME_UPDATES_DEFAULT
IOPOL_ATIME_UPDATES_OFF
IOPOL_DEFAULT
IOPOL_IMPORTANT
IOPOL_MATERIALIZE_DATALESS_FILES_DEFAULT
IOPOL_MATERIALIZE_DATALESS_FILES_OFF
IOPOL_MATERIALIZE_DATALESS_FILES_ON
IOPOL_NORMAL
IOPOL_PASSIVE
IOPOL_SCOPE_DARWIN_BG
IOPOL_SCOPE_PROCESS
IOPOL_SCOPE_THREAD
IOPOL_STANDARD
IOPOL_THROTTLE
IOPOL_TYPE_DISK
IOPOL_TYPE_VFS_ALLOW_LOW_SPACE_WRITES
IOPOL_TYPE_VFS_ATIME_UPDATES
IOPOL_TYPE_VFS_DISALLOW_RW_FOR_O_EVTONLY
IOPOL_TYPE_VFS_IGNORE_CONTENT_PROTECTION
IOPOL_TYPE_VFS_IGNORE_PERMISSIONS
IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES
IOPOL_TYPE_VFS_SKIP_MTIME_UPDATE
IOPOL_TYPE_VFS_STATFS_NO_DATA_VOLUME
IOPOL_TYPE_VFS_TRIGGER_RESOLVE
IOPOL_UTILITY
IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_OFF
IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_ON
IOPOL_VFS_CONTENT_PROTECTION_DEFAULT
IOPOL_VFS_CONTENT_PROTECTION_IGNORE
IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_DEFAULT
IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_ON
IOPOL_VFS_IGNORE_PERMISSIONS_OFF
IOPOL_VFS_IGNORE_PERMISSIONS_ON
IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_DEFAULT
IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_ON
IOPOL_VFS_SKIP_MTIME_UPDATE_IGNORE
IOPOL_VFS_SKIP_MTIME_UPDATE_OFF
IOPOL_VFS_SKIP_MTIME_UPDATE_ON
IOPOL_VFS_STATFS_FORCE_NO_DATA_VOLUME
IOPOL_VFS_STATFS_NO_DATA_VOLUME_DEFAULT
IOPOL_VFS_TRIGGER_RESOLVE_DEFAULT
IOPOL_VFS_TRIGGER_RESOLVE_OFF
IOV_MAX
LDBL_HAS_SUBNORM
LINE_MAX
LINK_MAX
LITTLE_ENDIAN
LLONG_MAX
LLONG_MIN
LONG_BIT
LONG_MAX
LONG_MIN
L_ctermid
L_tmpnam
MAC_OS_VERSION_11_0
MAC_OS_VERSION_11_1
MAC_OS_VERSION_11_3
MAC_OS_VERSION_11_4
MAC_OS_VERSION_11_5
MAC_OS_VERSION_11_6
MAC_OS_VERSION_12_0
MAC_OS_VERSION_12_1
MAC_OS_VERSION_12_2
MAC_OS_VERSION_12_3
MAC_OS_VERSION_12_4
MAC_OS_VERSION_12_5
MAC_OS_VERSION_12_6
MAC_OS_VERSION_12_7
MAC_OS_VERSION_13_0
MAC_OS_VERSION_13_1
MAC_OS_VERSION_13_2
MAC_OS_VERSION_13_3
MAC_OS_VERSION_13_4
MAC_OS_VERSION_13_5
MAC_OS_VERSION_13_6
MAC_OS_VERSION_13_7
MAC_OS_VERSION_14_0
MAC_OS_VERSION_14_1
MAC_OS_VERSION_14_2
MAC_OS_VERSION_14_3
MAC_OS_VERSION_14_4
MAC_OS_VERSION_14_5
MAC_OS_VERSION_14_6
MAC_OS_VERSION_14_7
MAC_OS_VERSION_15_0
MAC_OS_VERSION_15_1
MAC_OS_VERSION_15_2
MAC_OS_VERSION_15_3
MAC_OS_VERSION_15_4
MAC_OS_VERSION_15_5
MAC_OS_X_VERSION_10_0
MAC_OS_X_VERSION_10_1
MAC_OS_X_VERSION_10_2
MAC_OS_X_VERSION_10_3
MAC_OS_X_VERSION_10_4
MAC_OS_X_VERSION_10_5
MAC_OS_X_VERSION_10_6
MAC_OS_X_VERSION_10_7
MAC_OS_X_VERSION_10_8
MAC_OS_X_VERSION_10_9
MAC_OS_X_VERSION_10_10
MAC_OS_X_VERSION_10_11
MAC_OS_X_VERSION_10_12
MAC_OS_X_VERSION_10_13
MAC_OS_X_VERSION_10_14
MAC_OS_X_VERSION_10_15
MAC_OS_X_VERSION_10_16
MAC_OS_X_VERSION_10_10_2
MAC_OS_X_VERSION_10_10_3
MAC_OS_X_VERSION_10_11_2
MAC_OS_X_VERSION_10_11_3
MAC_OS_X_VERSION_10_11_4
MAC_OS_X_VERSION_10_12_1
MAC_OS_X_VERSION_10_12_2
MAC_OS_X_VERSION_10_12_4
MAC_OS_X_VERSION_10_13_1
MAC_OS_X_VERSION_10_13_2
MAC_OS_X_VERSION_10_13_4
MAC_OS_X_VERSION_10_14_1
MAC_OS_X_VERSION_10_14_4
MAC_OS_X_VERSION_10_14_5
MAC_OS_X_VERSION_10_14_6
MAC_OS_X_VERSION_10_15_1
MAC_OS_X_VERSION_10_15_4
MATH_ERREXCEPT
MATH_ERRNO
MAX_CANON
MAX_INPUT
MB_LEN_MAX
MINSIGSTKSZ
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
NL_ARGMAX
NL_LANGMAX
NL_MSGMAX
NL_NMAX
NL_SETMAX
NL_TEXTMAX
NSIG
NZERO
OFF_MAX
OFF_MIN
OPEN_MAX
OVERFLOW
PASS_MAX
PATH_MAX
PDP_ENDIAN
PIPE_BUF
PLOSS
POLL_ERR
POLL_HUP
POLL_IN
POLL_MSG
POLL_OUT
POLL_PRI
PRIO_DARWIN_BG
PRIO_DARWIN_NONUI
PRIO_DARWIN_PROCESS
PRIO_DARWIN_THREAD
PRIO_MAX
PRIO_MIN
PRIO_PGRP
PRIO_PROCESS
PRIO_USER
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
P_tmpdir
Ps_dualcostsel_PS_DUALCOSTSEL_ACTIVE_EXLP: < active rows of exact lp
Ps_dualcostsel_PS_DUALCOSTSEL_ACTIVE_FPLP: < active rows of fp lp
Ps_dualcostsel_PS_DUALCOSTSEL_NO: < no selection
QUAD_EPSILON
QUAD_MAX
QUAD_MIN
RAND_MAX
RENAME_EXCL
RENAME_NOFOLLOW_ANY
RENAME_RESERVED1
RENAME_SECLUDE
RENAME_SWAP
RE_DUP_MAX
RLIMIT_AS
RLIMIT_CORE
RLIMIT_CPU
RLIMIT_CPU_USAGE_MONITOR
RLIMIT_DATA
RLIMIT_FOOTPRINT_INTERVAL
RLIMIT_FSIZE
RLIMIT_MEMLOCK
RLIMIT_NOFILE
RLIMIT_NPROC
RLIMIT_RSS
RLIMIT_STACK
RLIMIT_THREAD_CPULIMITS
RLIMIT_WAKEUPS_MONITOR
RLIM_NLIMITS
RSIZE_MAX
RUSAGE_CHILDREN
RUSAGE_INFO_CURRENT
RUSAGE_INFO_V0
RUSAGE_INFO_V1
RUSAGE_INFO_V2
RUSAGE_INFO_V3
RUSAGE_INFO_V4
RUSAGE_INFO_V5
RUSAGE_INFO_V6
RUSAGE_SELF
RU_PROC_RUNS_RESLIDE
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
SA_64REGSET
SA_NOCLDSTOP
SA_NOCLDWAIT
SA_NODEFER
SA_ONSTACK
SA_RESETHAND
SA_RESTART
SA_SIGINFO
SA_USERSPACE_MASK
SA_USERTRAMP
SCHAR_MAX
SCHAR_MIN
SCIP_APIVERSION
SCIP_BUILD_TYPE
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_BendersObjectiveType_SCIP_BENDERSOBJTYPE_MAX: < the minimum of the maximum subproblem objectives is computed in the master problem
SCIP_BendersObjectiveType_SCIP_BENDERSOBJTYPE_SUM: < the individual subproblem objectives are summed in the master problem
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_DEPRECATED_VARTYPE_IMPLINT_CHAR
SCIP_DIVETYPE_INTEGRALITY
SCIP_DIVETYPE_NONE
SCIP_DIVETYPE_SOS1VARIABLE
SCIP_Datatree_Valuetype_SCIP_DATATREE_BOOL: < a SCIP_Bool value
SCIP_Datatree_Valuetype_SCIP_DATATREE_BOOLARRAY: < an array of SCIP_Bool values
SCIP_Datatree_Valuetype_SCIP_DATATREE_DATATREE: < a SCIP_DATATREE object
SCIP_Datatree_Valuetype_SCIP_DATATREE_LONG: < a SCIP_Longint integer value
SCIP_Datatree_Valuetype_SCIP_DATATREE_LONGARRAY: < an array of SCIP_Longint values
SCIP_Datatree_Valuetype_SCIP_DATATREE_REAL: < a SCIP_Real floating point value
SCIP_Datatree_Valuetype_SCIP_DATATREE_REALARRAY: < an array of SCIP_Real values
SCIP_Datatree_Valuetype_SCIP_DATATREE_STRING: < a C string
SCIP_Datatree_Valuetype_SCIP_DATATREE_STRINGARRAY: < an array of C strings
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_SCHEDULER: < within the scheduler heuristic
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_HEURTIMING_NONE
SCIP_Hashmaptype_SCIP_HASHMAPTYPE_INT: < the hashmap stores ints
SCIP_Hashmaptype_SCIP_HASHMAPTYPE_LONG: < the hashmap stores long 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_INVALID
SCIP_ImplintType_SCIP_IMPLINTTYPE_NONE: < The variable is not implied integral by other variables
SCIP_ImplintType_SCIP_IMPLINTTYPE_STRONG: < The constraint handlers enforce that if the problem is relaxed to have integrality constraints for the non-implied integral variables only, in every feasible solution all strongly implied integral variables have integer solution values.
SCIP_ImplintType_SCIP_IMPLINTTYPE_WEAK: < The constraint handlers enforce that if the problem is relaxed to have integrality constraints for the non-implied integral variables only, there exists an optimal solution where all weakly and strongly implied integral variables have integer solution values. For infeasible problems, when relaxing integrality of all implied integer variables, the problem remains infeasible. For unbounded problems, when enforcing integrality of all implied integer variables, the problem remains unbounded.
SCIP_IsFpRepresentable_SCIP_ISFPREPRESENTABLE_FALSE: < is not representable
SCIP_IsFpRepresentable_SCIP_ISFPREPRESENTABLE_TRUE: < is representable
SCIP_IsFpRepresentable_SCIP_ISFPREPRESENTABLE_UNKNOWN: < representability is unknown
SCIP_LONGINT_FORMAT
SCIP_LONGINT_MAX
SCIP_LONGINT_MIN
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_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_PROPTIMING_NONE
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_REAL_UNITROUNDOFF
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_RoundModeRational_SCIP_R_ROUND_DOWNWARDS: < always round to nearest smaller double
SCIP_RoundModeRational_SCIP_R_ROUND_NEAREST: < always round to nearest double
SCIP_RoundModeRational_SCIP_R_ROUND_UPWARDS: < always round to nearest larger double
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_SPACECONTROL
SCIP_SSTType_SCIP_SSTTYPE_BINARY: < binary variables
SCIP_SSTType_SCIP_SSTTYPE_CONTINUOUS: < continuous 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_DUALLIMIT: < the solving process was interrupted because the dual 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_PRIMALLIMIT: < the solving process was interrupted because the primal limit was reached
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 improvement w.r.t. primal bound)
SCIP_Status_SCIP_STATUS_TERMINATE: < 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 (SIGINT or SCIPinterruptSolve())
SCIP_VARTYPE_BINARY_CHAR
SCIP_VARTYPE_CONTINUOUS_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: < @deprecated use SCIPcreateVarImpl() or SCIPvarChgImplType() to control implied integrality
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_DATA
SEEK_END
SEEK_HOLE
SEEK_SET
SEGV_ACCERR
SEGV_MAPERR
SEGV_NOOP
SHRT_MAX
SHRT_MIN
SIGABRT
SIGALRM
SIGBUS
SIGCHLD
SIGCONT
SIGEMT
SIGEV_NONE
SIGEV_SIGNAL
SIGEV_THREAD
SIGFPE
SIGHUP
SIGILL
SIGINFO
SIGINT
SIGIO
SIGIOT
SIGKILL
SIGPIPE
SIGPROF
SIGQUIT
SIGSEGV
SIGSTKSZ
SIGSTOP
SIGSYS
SIGTERM
SIGTRAP
SIGTSTP
SIGTTIN
SIGTTOU
SIGURG
SIGUSR1
SIGUSR2
SIGVTALRM
SIGWINCH
SIGXCPU
SIGXFSZ
SIG_ATOMIC_MAX
SIG_ATOMIC_MIN
SIG_BLOCK
SIG_SETMASK
SIG_UNBLOCK
SING
SIZE_MAX
SIZE_T_MAX
SI_ASYNCIO
SI_MESGQ
SI_QUEUE
SI_TIMER
SI_USER
SSIZE_MAX
SS_DISABLE
SS_ONSTACK
SV_INTERRUPT
SV_NOCLDSTOP
SV_NODEFER
SV_ONSTACK
SV_RESETHAND
SV_SIGINFO
SYM_COMPUTETIMING_AFTERPRESOL
SYM_COMPUTETIMING_BEFOREPRESOL
SYM_COMPUTETIMING_DURINGPRESOL
SYM_Consoptype_SYM_CONSOPTYPE_AND: < encodes the AND-operator in AND-constraints
SYM_Consoptype_SYM_CONSOPTYPE_BDDISJ: < constraint of type bounddisjunction
SYM_Consoptype_SYM_CONSOPTYPE_CARD_TUPLE: < encodes pairs in cardinality constraints
SYM_Consoptype_SYM_CONSOPTYPE_COEF: < indicates coefficients from parent expressions
SYM_Consoptype_SYM_CONSOPTYPE_EQ: < encodes == in indicator constraints for activation variable
SYM_Consoptype_SYM_CONSOPTYPE_LAST: < number of predefined enum types, needs to always hold the biggest value
SYM_Consoptype_SYM_CONSOPTYPE_OR: < encodes the OR-operator in OR-constraints
SYM_Consoptype_SYM_CONSOPTYPE_PB_AND: < indicates AND conss in pseudoboolean conss
SYM_Consoptype_SYM_CONSOPTYPE_PB_LINEAR: < indicates linear conss in pseudoboolean conss
SYM_Consoptype_SYM_CONSOPTYPE_PB_OBJ: < indicates pseudoboolean cons is objective function
SYM_Consoptype_SYM_CONSOPTYPE_PB_SOFT: < indicates pseudoboolean cons is soft constraint
SYM_Consoptype_SYM_CONSOPTYPE_SLACK: < indicates slack vars in indicator constraints
SYM_Consoptype_SYM_CONSOPTYPE_SOS2_TUPLE: < encodes pairs in SOS2 constraints
SYM_Consoptype_SYM_CONSOPTYPE_SQDIFF: < indicates a squared difference
SYM_Consoptype_SYM_CONSOPTYPE_SUM: < indicates sums if sum-expr undefined
SYM_Consoptype_SYM_CONSOPTYPE_UNKNOWN: < unknown constraint type
SYM_Consoptype_SYM_CONSOPTYPE_XORINT: < encodes the internal variable in XOR-constraints
SYM_Nodetype_SYM_NODETYPE_CONS: < constraint node
SYM_Nodetype_SYM_NODETYPE_OPERATOR: < operator node
SYM_Nodetype_SYM_NODETYPE_VAL: < numerical value node
SYM_Nodetype_SYM_NODETYPE_VAR: < variable node
SYM_Symtype_SYM_SYMTYPE_PERM: < permutation symmetries
SYM_Symtype_SYM_SYMTYPE_SIGNPERM: < signed permutation symmetries
SYM_TIMING_AFTERPRESOL
SYM_TIMING_BEFOREPRESOL
SYM_TIMING_DURINGPRESOL
TLOSS
TMP_MAX
TRAP_BRKPT
TRAP_TRACE
TRUE
UCHAR_MAX
UID_MAX
UINT8_MAX
UINT16_MAX
UINT32_MAX
UINT64_MAX
UINTPTR_MAX
UINT_FAST8_MAX
UINT_FAST16_MAX
UINT_FAST32_MAX
UINT_FAST64_MAX
UINT_LEAST8_MAX
UINT_LEAST16_MAX
UINT_LEAST32_MAX
UINT_LEAST64_MAX
UINT_MAX
ULLONG_MAX
ULONG_MAX
UNDERFLOW
UQUAD_MAX
USE_CLANG_LIMITS
USE_CLANG_STDARG
USE_CLANG_STDDEF
USE_CLANG_TYPES
USHRT_MAX
WAIT_ANY
WAIT_MYPGRP
WAKEMON_DISABLE
WAKEMON_ENABLE
WAKEMON_GET_PARAMS
WAKEMON_MAKE_FATAL
WAKEMON_SET_DEFAULTS
WCONTINUED
WCOREFLAG
WEXITED
WINT_MAX
WINT_MIN
WNOHANG
WNOWAIT
WORD_BIT
WSTOPPED
WUNTRACED
_ARM_SIGNAL_
_DARWIN_FEATURE_64_BIT_INODE
_DARWIN_FEATURE_ONLY_64_BIT_INODE
_DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE
_DARWIN_FEATURE_ONLY_VERS_1050
_DARWIN_FEATURE_UNIX_CONFORMANCE
_FORTIFY_SOURCE
_IOFBF
_IOLBF
_IONBF
_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_EQUIV_CLASS_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_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_SSIZE_MAX
_POSIX_SS_REPL_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_TRACE_EVENT_NAME_MAX
_POSIX_TRACE_NAME_MAX
_POSIX_TRACE_SYS_MAX
_POSIX_TRACE_USER_EVENT_MAX
_POSIX_TTY_NAME_MAX
_POSIX_TZNAME_MAX
_QUAD_HIGHWORD
_QUAD_LOWWORD
_RLIMIT_POSIX_FLAG
_USE_FORTIFY_LEVEL
_WSTOPPED
_XOPEN_IOV_MAX
_XOPEN_NAME_MAX
_XOPEN_PATH_MAX
__API_TO_BE_DEPRECATED
__API_TO_BE_DEPRECATED_DRIVERKIT
__API_TO_BE_DEPRECATED_IOS
__API_TO_BE_DEPRECATED_IOSAPPLICATIONEXTENSION
__API_TO_BE_DEPRECATED_KERNELKIT
__API_TO_BE_DEPRECATED_MACCATALYST
__API_TO_BE_DEPRECATED_MACCATALYSTAPPLICATIONEXTENSION
__API_TO_BE_DEPRECATED_MACOS
__API_TO_BE_DEPRECATED_MACOSAPPLICATIONEXTENSION
__API_TO_BE_DEPRECATED_TVOS
__API_TO_BE_DEPRECATED_TVOSAPPLICATIONEXTENSION
__API_TO_BE_DEPRECATED_VISIONOS
__API_TO_BE_DEPRECATED_VISIONOSAPPLICATIONEXTENSION
__API_TO_BE_DEPRECATED_WATCHOS
__API_TO_BE_DEPRECATED_WATCHOSAPPLICATIONEXTENSION
__AVAILABILITY_FILE
__AVAILABILITY_VERSIONS_VERSION_HASH
__AVAILABILITY_VERSIONS_VERSION_STRING
__BRIDGEOS_2_0
__BRIDGEOS_3_0
__BRIDGEOS_3_1
__BRIDGEOS_3_4
__BRIDGEOS_4_0
__BRIDGEOS_4_1
__BRIDGEOS_5_0
__BRIDGEOS_5_1
__BRIDGEOS_5_3
__BRIDGEOS_6_0
__BRIDGEOS_6_2
__BRIDGEOS_6_4
__BRIDGEOS_6_5
__BRIDGEOS_6_6
__BRIDGEOS_7_0
__BRIDGEOS_7_1
__BRIDGEOS_7_2
__BRIDGEOS_7_3
__BRIDGEOS_7_4
__BRIDGEOS_7_6
__BRIDGEOS_8_0
__BRIDGEOS_8_1
__BRIDGEOS_8_2
__BRIDGEOS_8_3
__BRIDGEOS_8_4
__BRIDGEOS_8_5
__BRIDGEOS_8_6
__BRIDGEOS_9_0
__BRIDGEOS_9_1
__BRIDGEOS_9_2
__BRIDGEOS_9_3
__BRIDGEOS_9_4
__BRIDGEOS_9_5
__DARWIN_64_BIT_INO_T
__DARWIN_BIG_ENDIAN
__DARWIN_BYTE_ORDER
__DARWIN_CLK_TCK
__DARWIN_C_ANSI
__DARWIN_C_FULL
__DARWIN_C_LEVEL
__DARWIN_LITTLE_ENDIAN
__DARWIN_NON_CANCELABLE
__DARWIN_NO_LONG_LONG
__DARWIN_NSIG
__DARWIN_ONLY_64_BIT_INO_T
__DARWIN_ONLY_UNIX_CONFORMANCE
__DARWIN_ONLY_VERS_1050
__DARWIN_OPAQUE_ARM_THREAD_STATE64
__DARWIN_PDP_ENDIAN
__DARWIN_SUF_EXTSN
__DARWIN_UNIX03
__DARWIN_VERS_1050
__DARWIN_WCHAR_MIN
__DRIVERKIT_19_0
__DRIVERKIT_20_0
__DRIVERKIT_21_0
__DRIVERKIT_22_0
__DRIVERKIT_22_4
__DRIVERKIT_22_5
__DRIVERKIT_22_6
__DRIVERKIT_23_0
__DRIVERKIT_23_1
__DRIVERKIT_23_2
__DRIVERKIT_23_3
__DRIVERKIT_23_4
__DRIVERKIT_23_5
__DRIVERKIT_23_6
__DRIVERKIT_24_0
__DRIVERKIT_24_1
__DRIVERKIT_24_2
__DRIVERKIT_24_3
__DRIVERKIT_24_4
__DRIVERKIT_24_5
__ENABLE_LEGACY_MAC_AVAILABILITY
__HAS_FIXED_CHK_PROTOTYPES
__IPHONE_2_0
__IPHONE_2_1
__IPHONE_2_2
__IPHONE_3_0
__IPHONE_3_1
__IPHONE_3_2
__IPHONE_4_0
__IPHONE_4_1
__IPHONE_4_2
__IPHONE_4_3
__IPHONE_5_0
__IPHONE_5_1
__IPHONE_6_0
__IPHONE_6_1
__IPHONE_7_0
__IPHONE_7_1
__IPHONE_8_0
__IPHONE_8_1
__IPHONE_8_2
__IPHONE_8_3
__IPHONE_8_4
__IPHONE_9_0
__IPHONE_9_1
__IPHONE_9_2
__IPHONE_9_3
__IPHONE_10_0
__IPHONE_10_1
__IPHONE_10_2
__IPHONE_10_3
__IPHONE_11_0
__IPHONE_11_1
__IPHONE_11_2
__IPHONE_11_3
__IPHONE_11_4
__IPHONE_12_0
__IPHONE_12_1
__IPHONE_12_2
__IPHONE_12_3
__IPHONE_12_4
__IPHONE_13_0
__IPHONE_13_1
__IPHONE_13_2
__IPHONE_13_3
__IPHONE_13_4
__IPHONE_13_5
__IPHONE_13_6
__IPHONE_13_7
__IPHONE_14_0
__IPHONE_14_1
__IPHONE_14_2
__IPHONE_14_3
__IPHONE_14_4
__IPHONE_14_5
__IPHONE_14_6
__IPHONE_14_7
__IPHONE_14_8
__IPHONE_15_0
__IPHONE_15_1
__IPHONE_15_2
__IPHONE_15_3
__IPHONE_15_4
__IPHONE_15_5
__IPHONE_15_6
__IPHONE_15_7
__IPHONE_15_8
__IPHONE_16_0
__IPHONE_16_1
__IPHONE_16_2
__IPHONE_16_3
__IPHONE_16_4
__IPHONE_16_5
__IPHONE_16_6
__IPHONE_16_7
__IPHONE_17_0
__IPHONE_17_1
__IPHONE_17_2
__IPHONE_17_3
__IPHONE_17_4
__IPHONE_17_5
__IPHONE_17_6
__IPHONE_17_7
__IPHONE_18_0
__IPHONE_18_1
__IPHONE_18_2
__IPHONE_18_3
__IPHONE_18_4
__IPHONE_18_5
__MAC_10_0
__MAC_10_1
__MAC_10_2
__MAC_10_3
__MAC_10_4
__MAC_10_5
__MAC_10_6
__MAC_10_7
__MAC_10_8
__MAC_10_9
__MAC_10_10
__MAC_10_11
__MAC_10_12
__MAC_10_13
__MAC_10_14
__MAC_10_15
__MAC_10_16
__MAC_10_10_2
__MAC_10_10_3
__MAC_10_11_2
__MAC_10_11_3
__MAC_10_11_4
__MAC_10_12_1
__MAC_10_12_2
__MAC_10_12_4
__MAC_10_13_1
__MAC_10_13_2
__MAC_10_13_4
__MAC_10_14_1
__MAC_10_14_4
__MAC_10_14_5
__MAC_10_14_6
__MAC_10_15_1
__MAC_10_15_4
__MAC_11_0
__MAC_11_1
__MAC_11_3
__MAC_11_4
__MAC_11_5
__MAC_11_6
__MAC_12_0
__MAC_12_1
__MAC_12_2
__MAC_12_3
__MAC_12_4
__MAC_12_5
__MAC_12_6
__MAC_12_7
__MAC_13_0
__MAC_13_1
__MAC_13_2
__MAC_13_3
__MAC_13_4
__MAC_13_5
__MAC_13_6
__MAC_13_7
__MAC_14_0
__MAC_14_1
__MAC_14_2
__MAC_14_3
__MAC_14_4
__MAC_14_5
__MAC_14_6
__MAC_14_7
__MAC_15_0
__MAC_15_1
__MAC_15_2
__MAC_15_3
__MAC_15_4
__MAC_15_5
__MAC_OS_X_VERSION_MAX_ALLOWED
__PRI_8_LENGTH_MODIFIER__
__PRI_64_LENGTH_MODIFIER__
__PRI_MAX_LENGTH_MODIFIER__
__PTHREAD_ATTR_SIZE__
__PTHREAD_CONDATTR_SIZE__
__PTHREAD_COND_SIZE__
__PTHREAD_MUTEXATTR_SIZE__
__PTHREAD_MUTEX_SIZE__
__PTHREAD_ONCE_SIZE__
__PTHREAD_RWLOCKATTR_SIZE__
__PTHREAD_RWLOCK_SIZE__
__PTHREAD_SIZE__
__SALC
__SAPP
__SCN_64_LENGTH_MODIFIER__
__SCN_MAX_LENGTH_MODIFIER__
__SEOF
__SERR
__SIGN
__SLBF
__SMBF
__SMOD
__SNBF
__SNPT
__SOFF
__SOPT
__SRD
__SRW
__SSTR
__STDC_WANT_LIB_EXT1__
__SWR
__TVOS_9_0
__TVOS_9_1
__TVOS_9_2
__TVOS_10_0
__TVOS_10_0_1
__TVOS_10_1
__TVOS_10_2
__TVOS_11_0
__TVOS_11_1
__TVOS_11_2
__TVOS_11_3
__TVOS_11_4
__TVOS_12_0
__TVOS_12_1
__TVOS_12_2
__TVOS_12_3
__TVOS_12_4
__TVOS_13_0
__TVOS_13_2
__TVOS_13_3
__TVOS_13_4
__TVOS_14_0
__TVOS_14_1
__TVOS_14_2
__TVOS_14_3
__TVOS_14_5
__TVOS_14_6
__TVOS_14_7
__TVOS_15_0
__TVOS_15_1
__TVOS_15_2
__TVOS_15_3
__TVOS_15_4
__TVOS_15_5
__TVOS_15_6
__TVOS_16_0
__TVOS_16_1
__TVOS_16_2
__TVOS_16_3
__TVOS_16_4
__TVOS_16_5
__TVOS_16_6
__TVOS_17_0
__TVOS_17_1
__TVOS_17_2
__TVOS_17_3
__TVOS_17_4
__TVOS_17_5
__TVOS_17_6
__TVOS_18_0
__TVOS_18_1
__TVOS_18_2
__TVOS_18_3
__TVOS_18_4
__TVOS_18_5
__VISIONOS_1_0
__VISIONOS_1_1
__VISIONOS_1_2
__VISIONOS_1_3
__VISIONOS_2_0
__VISIONOS_2_1
__VISIONOS_2_2
__VISIONOS_2_3
__VISIONOS_2_4
__VISIONOS_2_5
__WATCHOS_1_0
__WATCHOS_2_0
__WATCHOS_2_1
__WATCHOS_2_2
__WATCHOS_3_0
__WATCHOS_3_1
__WATCHOS_3_2
__WATCHOS_3_1_1
__WATCHOS_4_0
__WATCHOS_4_1
__WATCHOS_4_2
__WATCHOS_4_3
__WATCHOS_5_0
__WATCHOS_5_1
__WATCHOS_5_2
__WATCHOS_5_3
__WATCHOS_6_0
__WATCHOS_6_1
__WATCHOS_6_2
__WATCHOS_7_0
__WATCHOS_7_1
__WATCHOS_7_2
__WATCHOS_7_3
__WATCHOS_7_4
__WATCHOS_7_5
__WATCHOS_7_6
__WATCHOS_8_0
__WATCHOS_8_1
__WATCHOS_8_3
__WATCHOS_8_4
__WATCHOS_8_5
__WATCHOS_8_6
__WATCHOS_8_7
__WATCHOS_8_8
__WATCHOS_9_0
__WATCHOS_9_1
__WATCHOS_9_2
__WATCHOS_9_3
__WATCHOS_9_4
__WATCHOS_9_5
__WATCHOS_9_6
__WATCHOS_10_0
__WATCHOS_10_1
__WATCHOS_10_2
__WATCHOS_10_3
__WATCHOS_10_4
__WATCHOS_10_5
__WATCHOS_10_6
__WATCHOS_10_7
__WATCHOS_11_0
__WATCHOS_11_1
__WATCHOS_11_2
__WATCHOS_11_3
__WATCHOS_11_4
__WATCHOS_11_5
__WORDSIZE
__bool_true_false_are_defined
__has_bounds_safety_attributes
__has_ptrcheck
__has_safe_buffers
false_
idtype_t_P_ALL
idtype_t_P_PGID
idtype_t_P_PID
true_

Statics§

__mb_cur_max^⚠
__stderrp^⚠
__stdinp^⚠
__stdoutp^⚠
signgam^⚠
suboptarg^⚠
sys_errlist^⚠
sys_nerr^⚠

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
SCIPaddCertificateAggrInfo^⚠: adds aggregation information to certificate for one row
SCIPaddCertificateMirInfo^⚠: adds mir information (split, etc) to certificate for one row
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
SCIPaddCoefExactLinear^⚠: adds coefficient to linear constraint (if it is not zero)
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 a variable to the 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.
SCIPaddConsUpgrade^⚠: adds constraint to the problem and upgrades conflict in the conflict store; if oldcons is valid globally, newcons is added to the global problem; otherwise it is added to the local subproblem of the current node
SCIPaddCurrentSol^⚠: adds current LP/pseudo solution to solution 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
SCIPaddOrigObjoffsetExact^⚠: 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
SCIPaddRowExact^⚠: adds row to exact separation storage
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
SCIPaddVarExactData^⚠: adds exact data to variable
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
SCIPaddVarsToRowExact^⚠: 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 implied integral 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
SCIPadjustedVarLbExactFloat^⚠: 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
SCIPadjustedVarUbExactFloat^⚠: 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
SCIPaggrRowAddObjectiveFunctionSafely^⚠: add the objective function with right-hand side @p rhs and scaled by @p scale to the aggregation row variant of SCIPaggrRowAddObjectiveFunction that is safe to use in exact mode
SCIPaggrRowAddRow^⚠: add weighted row to the aggregation row
SCIPaggrRowAddRowSafely^⚠: add weighted row to aggregation row @note this method is the variant of SCIPaggrRowAddRow that is safe to use in exact solving mode
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
SCIPaggrRowClearSafely^⚠: version for use in exact solving mode of SCIPaggrRowClear()
SCIPaggrRowCopy^⚠: copy the aggregation row
SCIPaggrRowCreate^⚠: create an empty 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, is 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.
SCIPaggregateVarsExact^⚠: 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
SCIPallowNegSlack^⚠: returns whether aggregation is allowed to use negative slack in exact solving mode
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
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
SCIPbenderGetMasterAuxiliaryVar^⚠: returns the master auxiliary variable that represents an underestimation of the subproblem objective value.
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
SCIPbendersGetNLPParam^⚠: returns NLP solver parameters used for solving NLP 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
SCIPbendersGetNSubproblemMasterVars^⚠: returns the number of subproblem master variables for the given subproblem
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
SCIPbendersGetObjectiveType^⚠: returns the objective type for the aggregation of the Benders’ decomposition subproblem objectives
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
SCIPbendersGetSubproblemMasterVars^⚠: returns the subproblem master variables for the given subproblem
SCIPbendersGetSubproblemMasterVarsData^⚠: returns the subproblem master variable data 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
SCIPbendersSubproblemsAreInfeasible^⚠: returns whether at least one of the subproblems has been identified as infeasible. NOTE: this is without any variable fixing being performed
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
SCIPboundchgGetLPSolVal^⚠: returns the lp solution value in the branching data of 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
SCIPbranchLPExact^⚠: branches on an LP solution exactly; does not call branching rules, since fractionalities are assumed to small; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
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?
SCIPbranchruleMarkExact^⚠: marks this branching rule as safe to use in exact solving mode
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
SCIPcalcIntegralScalarExact^⚠: tries to find a value, such that all given values, if scaled with this value become integral
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
SCIPcallExprGetSymData^⚠: calls the symmetry information callback for an expression
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
SCIPcaptureRowExact^⚠: increases usage counter of exact 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
SCIPcertifyActivityConflict^⚠: prints activity conflict to certificate file
SCIPcertifyActivityVarBound^⚠: prints activity bound to proof section
SCIPcertifyActivityVarBoundExact^⚠: prints activity bound to proof section
SCIPcertifyCons^⚠: prints constraint to certificate
SCIPcertifyConsOrigExactLinear^⚠: prints the certificate for a given original exact linear constraint
SCIPcertifyMirCut^⚠: print MIR cut to certificate file
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
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
SCIPchgCoefExactLinear^⚠: changes coefficient of variable in linear constraint; deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint
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
SCIPchgLhsExactLinear^⚠: changes left hand side of linear constraint
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
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 of the original problem.
SCIPchgRhsExactLinear^⚠: changes right hand side of linear constraint
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
SCIPchgRowExactLhs^⚠: changes left hand side of exact LP row
SCIPchgRowExactRhs^⚠: changes right hand side of exact LP row
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
SCIPchgVarImplType^⚠: changes implied integral type of variable in the problem
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
SCIPchgVarLbExact^⚠: depending on SCIP’s stage, changes exact 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
SCIPchgVarLbExactDive^⚠: changes variable’s lower bound in current exact 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
SCIPchgVarLbGlobalExact^⚠: changes exact global lower bound of variable;
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
SCIPchgVarObjExact^⚠: changes variable’s exact objective value
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
SCIPchgVarUbExact^⚠: depending on SCIP’s stage, changes exact 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
SCIPchgVarUbExactDive^⚠: changes variable’s upper bound in current exact 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
SCIPchgVarUbGlobalExact^⚠: changes exact global upper bound of variable;
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
SCIPchildChgNodeselPrio^⚠: change the node selection priority of the given child
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^⚠: tries to remove conflicts depending on an old cutoff bound if the improvement of the new 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
SCIPcolAddCoef^⚠: adds a previously non existing coefficient to an LP column
SCIPcolCalcFarkasCoef^⚠: calculates the Farkas coefficient y^T A_i of a column i using the given dual Farkas vector y
SCIPcolCalcRedcost^⚠: calculates the reduced costs of a column using the given dual solution vector
SCIPcolChgCoef^⚠: changes or adds a coefficient to an LP column
SCIPcolChgLb^⚠: changes lower bound of column
SCIPcolChgObj^⚠: changes objective value of column
SCIPcolChgUb^⚠: changes upper bound of column
SCIPcolCreate^⚠: creates an LP column
SCIPcolDelCoef^⚠: deletes coefficient from column
SCIPcolExactAddCoef^⚠: adds a previously non existing coefficient to an LP column
SCIPcolExactCalcFarkasRedcostCoef^⚠: calculates the Farkas coefficient or reduced cost of a column i using the given dual Farkas vector y
SCIPcolExactChgCoef^⚠: changes or adds a coefficient to an LP column
SCIPcolExactChgLb^⚠: changes lower bound of column
SCIPcolExactChgObj^⚠: changes objective value of column
SCIPcolExactChgUb^⚠: changes upper bound of column
SCIPcolExactCreate^⚠: creates an LP column
SCIPcolExactDelCoef^⚠: deletes coefficient from column
SCIPcolExactFree^⚠: frees an LP column
SCIPcolExactGetBestBound^⚠: gets best bound of column with respect to the objective function
SCIPcolExactGetLb^⚠: gets lower bound of column
SCIPcolExactGetObj^⚠: gets objective value of column
SCIPcolExactGetPrimsol^⚠: gets the primal LP solution of a column
SCIPcolExactGetUb^⚠: gets upper bound of column
SCIPcolExactGetVar^⚠: gets variable this column represents
SCIPcolExactIncCoef^⚠: increases value of an existing or nonexisting coefficient in an LP column
SCIPcolExactPrint^⚠: output column to file stream
SCIPcolFree^⚠: frees an LP column
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
SCIPcolGetColExact^⚠: returns exact col corresponding to fpcol, if it exists. Otherwise returns NULL
SCIPcolGetFarkasCoef^⚠: gets the Farkas coefficient y^T A_i of a column i in last LP (which must be infeasible)
SCIPcolGetFarkasValue^⚠: gets the Farkas value of a column in last LP (which must be infeasible), i.e. the Farkas coefficient y^T A_i times the best bound for this coefficient, i.e. max{y^T A_i x_i | lb <= x_i <= ub}
SCIPcolGetFeasibility^⚠: gets the feasibility of (the dual row of) a column in last LP or after recalculation
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
SCIPcolGetRedcost^⚠: gets the reduced costs of a column in last LP or after recalculation
SCIPcolGetRows^⚠: gets array with rows of nonzero entries
SCIPcolGetStrongbranch^⚠: gets strong branching information on a column variable
SCIPcolGetStrongbranchLPAge^⚠: if strong branching was already applied on the column at the current node, returns the number of LPs solved after the LP where the strong branching on this column was applied; if strong branching was not yet applied on the column at the current node, returns INT_MAX
SCIPcolGetStrongbranchLast^⚠: gets last strong branching information available for a column variable; returns values of SCIP_INVALID, if strong branching was not yet called on the given column; keep in mind, that the returned old values may have nothing to do with the current LP solution
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
SCIPcolGetStrongbranches^⚠: gets strong branching information on column variables
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
SCIPcolIncCoef^⚠: increases value of an existing or nonexisting coefficient in an LP column
SCIPcolInvalidateStrongbranchData^⚠: invalidates strong branching information for a column variable
SCIPcolIsImpliedIntegral^⚠: returns whether the associated variable is implied integral
SCIPcolIsInLP^⚠: returns TRUE iff column is member of current LP
SCIPcolIsIntegral^⚠: returns whether the associated variable is of integral type (binary, integer, or implied integral)
SCIPcolIsRemovable^⚠: returns TRUE iff column is removable from the LP (due to aging or cleanup)
SCIPcolMarkNotRemovableLocal^⚠: marks a column to be not removable from the LP in the current node because it became obsolete
SCIPcolPrint^⚠: output column to file stream
SCIPcolSetStrongbranchData^⚠: sets strong branching information for a column variable
SCIPcolSort^⚠: sorts column entries such that LP rows precede non-LP rows and inside both parts lower row indices precede higher ones
SCIPcollectBendersStatistics^⚠: collects Benders’ decomposition statistics
SCIPcollectBilinTermsNonlinear^⚠: collects all bilinear terms for a given set of constraints
SCIPcollectBranchingStatistics^⚠: collects branching statistics about variables in a SCIP_DATATREE
SCIPcollectBranchruleStatistics^⚠: collects branching rule statistics in a SCIP_DATATREE object
SCIPcollectCompressionStatistics^⚠: collects compression statistics
SCIPcollectConcsolverStatistics^⚠: collects concurrent solver statistics
SCIPcollectConflictStatistics^⚠: collects conflict statistics
SCIPcollectConstraintStatistics^⚠: collects constraint statistics
SCIPcollectConstraintTimingStatistics^⚠: collects constraint timing statistics
SCIPcollectCutselectorStatistics^⚠: collects cutselector statistics
SCIPcollectExpressionHandlerStatistics^⚠: collects expression handler statistics
SCIPcollectHeuristicStatistics^⚠: collects heuristics statistics into SCIP_DATATREE
SCIPcollectLPStatistics^⚠: collects LP statistics
SCIPcollectMemoryGarbage^⚠: run garbage collection on block memory
SCIPcollectNLPIStatistics^⚠: collects NLPI statistics
SCIPcollectNLPStatistics^⚠: collects NLP statistics
SCIPcollectOrigProblemStatistics^⚠: collects statistics for original problem in a SCIP_DATATREE object
SCIPcollectPresolverStatistics^⚠: collects presolver statistics
SCIPcollectPricerStatistics^⚠: collects pricer statistics
SCIPcollectPropagatorStatistics^⚠: collects propagator statistics
SCIPcollectRelaxatorStatistics^⚠: collects relaxator statistics
SCIPcollectRootStatistics^⚠: collects root statistics
SCIPcollectSeparatorStatistics^⚠: collects separator statistics
SCIPcollectSolutionStatistics^⚠: collects solution statistics
SCIPcollectStatusStatistics^⚠: collects status statistics in a SCIP_DATATREE object
SCIPcollectTimingStatistics^⚠: collects timing statistics in SCIP_DATATREE
SCIPcollectTransProblemStatistics^⚠: collects statistics for transformed problem
SCIPcollectTreeStatistics^⚠: collects tree statistics
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!
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
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
SCIPcomputeVarLbLocalExact^⚠: 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
SCIPcomputeVarUbLocalExact^⚠: 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
SCIPconsCompCheck^⚠: compares two constraints w.r.t. their feasibility check priority
SCIPconsCreateRow^⚠: creates and returns the row of an arbitrary SCIP constraint that can be represented as a single linear constraint
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
SCIPconsGetLhsExact^⚠: returns the exact 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
SCIPconsGetRhsExact^⚠: returns exact 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 available
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.t. their feasibility check priority
SCIPconshdlrCompEnfo^⚠: compares two constraint handlers w.r.t. their enforcing priority
SCIPconshdlrCompSepa^⚠: compares two constraint handlers w.r.t. 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?
SCIPconshdlrIsExact^⚠: is constraint handler safe to use in exact solving mode?
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?
SCIPconshdlrMarkExact^⚠: marks the constraint handler as safe to use in exact solving mode
SCIPconshdlrNeedsCons^⚠: does the constraint handler need a constraint in order 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
SCIPconshdlrSetNeedsCons^⚠: sets the needscons flag of constraint handler, for example to disable without constraints
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
SCIPconshdlrSupportsPermsymDetection^⚠: returns whether conshdlr supports permutation symmetry detection
SCIPconshdlrSupportsSignedPermsymDetection^⚠: returns whether conshdlr supports signed permutation symmetry detection
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
SCIPcopyConsExactLinear^⚠: creates a linear constraint from an exact linear constraint by rounding values to floating-point and captures it
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
SCIPcreateBanditExp3IX^⚠: creates and resets an Exp.3-IX 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
SCIPcreateConsBasicExactLinear^⚠: 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
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()
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
SCIPcreateConsExactLinear^⚠: creates and captures a linear 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.
SCIPcreateConsIndicatorGenericLinConsPure^⚠: creates and captures an indicator constraint with given linear constraint 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; no slack variable is specified
SCIPcreateConsIndicatorLinCons^⚠: creates and captures an indicator constraint with given linear constraint and slack variable
SCIPcreateConsIndicatorLinConsPure^⚠: creates and captures an indicator constraint with given linear constraint; no slack variable is specified
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
SCIPcreateDatatree^⚠: creates a new SCIP_DATATREE
SCIPcreateDatatreeInTree^⚠: creates a new SCIP_DATATREE and inserts it into a SCIP_DATATREE object
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
SCIPcreateEmptyRowCons^⚠: creates and captures an LP row without any coefficients from a constraint
SCIPcreateEmptyRowConsExact^⚠: creates and captures an LP row without any coefficients from a constraint handler
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
SCIPcreateLPSolExact^⚠: creates an exact primal solution, initialized to the current exact 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
SCIPcreateRowCons^⚠: creates and captures an LP row from a constraint
SCIPcreateRowConshdlr^⚠: creates and captures an LP row from a constraint handler
SCIPcreateRowExact^⚠: creates and captures an exact LP row
SCIPcreateRowExactFromRow^⚠: creates and captures an exact LP row from an existing fp row
SCIPcreateRowKnapsack^⚠: creates and returns the row of the given knapsack constraint
SCIPcreateRowLinear^⚠: creates and returns the row of the given linear constraint
SCIPcreateRowLogicor^⚠: creates and returns the row of the given logicor constraint
SCIPcreateRowSepa^⚠: creates and captures an LP row from a separator
SCIPcreateRowSetppc^⚠: creates and returns the row of the given set partitioning / packing / covering constraint
SCIPcreateRowUnspec^⚠: creates and captures an LP row from an unspecified source
SCIPcreateRowVarbound^⚠: creates and returns the row of the given varbound constraint
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
SCIPcreateSolExact^⚠: creates an exact primal solution, initialized to zero
SCIPcreateSymOpNodeType^⚠: creates new operator node type (used for symmetry detection) and returns its representation
SCIPcreateSymbreakCons^⚠: creates a symmetry breaking constraint
SCIPcreateUnknownSol^⚠: creates a primal solution, initialized to unknown values
SCIPcreateVar^⚠: creates and captures problem variable
SCIPcreateVarBasic^⚠: creates and captures problem variable without setting optional callbacks and variable data.
SCIPcreateVarImpl^⚠: creates and captures problem variable that may be implied integral
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!
SCIPdatatreeGetBool^⚠: gets a SCIP_Bool value from a SCIP_DATATREE object
SCIPdatatreeGetBoolArray^⚠: gets a SCIP_Bool array from a SCIP_DATATREE object
SCIPdatatreeGetLong^⚠: gets a long value from a SCIP_DATATREE object
SCIPdatatreeGetLongArray^⚠: gets a SCIP_Longint array from a SCIP_DATATREE object
SCIPdatatreeGetReal^⚠: gets a SCIP_Real value from a SCIP_DATATREE object
SCIPdatatreeGetRealArray^⚠: gets a SCIP_Real array from a SCIP_DATATREE object
SCIPdatatreeGetString^⚠: gets a string value from a SCIP_DATATREE object
SCIPdatatreeGetStringArray^⚠: gets a string array from a SCIP_DATATREE object
SCIPdatatreeGetTree^⚠: gets a data tree value from a SCIP_DATATREE object
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
SCIPdelCoefExactLinear^⚠: deletes variable from linear constraint
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
SCIPdetectSingleOrDoubleLexMatrices^⚠: detects whether permutations define single or double lex matrices
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
SCIPdialogExecDisplayIIS^⚠: dialog execution method for the display IIS 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
SCIPdialogExecDisplaySymmetry^⚠: dialog execution method for the display symmetry 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
SCIPdialogExecIIS^⚠: dialog execution method for the iis 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
SCIPdialogIsHidden^⚠: is dialog hidden
SCIPdialogIsSubmenu^⚠: returns whether the dialog is a sub menu
SCIPdialogMessage^⚠
SCIPdialogSetData^⚠: sets user data of dialog; user has to free old data in advance!
SCIPdialogSetHidden^⚠: set dialog to be hidden
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
SCIPdisplaySymmetryGenerators^⚠: displays generators of symmetry group, if available
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
SCIPdotWriteArc^⚠: adds an arc (edge) between two nodes in the dot graph
SCIPdotWriteClosing^⚠: writes the closing line to a dot graph file, does not close a file
SCIPdotWriteNode^⚠: adds a node to the dot graph
SCIPdotWriteOpening^⚠: writes the opening line to a dot graph file, does not open a file
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
SCIPenableExactSolving^⚠: enables or disables exact solving mode
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
SCIPendExactDive^⚠: quits exact LP diving and resets bounds and objective values of columns to the current node’s values
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
SCIPestimateRoot^⚠: Separation for roots with exponent in [0,1]
SCIPevalBilinAuxExprNonlinear^⚠: evaluates an auxiliary expression for a bilinear term
SCIPevalExpr^⚠: evaluate an expression in a point
SCIPevalExprActivity^⚠: possibly reevaluates 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
SCIPeventGetNewImpltype^⚠: gets new implied integral type for an implied integral type change event
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
SCIPeventGetOldImpltype^⚠: gets old implied integral type for an implied integral type change event
SCIPeventGetOldbound^⚠: gets old bound for a bound change event
SCIPeventGetOldboundExact^⚠: gets exact 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
SCIPexprGetIntegrality^⚠: returns implied integrality 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, i.e. whether the integrality flag is not equal to SCIP_IMPLINTTYPE_NONE
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
SCIPexprhdlrHasGetSymData^⚠: return whether expression handler implements the symmetry data 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
SCIPexprhdlrSetGetSymdata^⚠: set the symmetry information callback 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
SCIPfindIISfinder^⚠: returns the IIS finder 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
SCIPfixVarExact^⚠: 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
SCIPfreeCertificateActiveAggrInfo^⚠: frees the active aggregation information
SCIPfreeCertificateActiveMirInfo^⚠: frees the active mir information
SCIPfreeClock^⚠: frees a clock
SCIPfreeCutpool^⚠: frees a cut pool
SCIPfreeDatatree^⚠: frees a SCIP_DATATREE object
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
SCIPfreeParseVarsPolynomialDataExact^⚠: 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
SCIPfreeReaderdataCor^⚠: frees the COR reader data
SCIPfreeReaderdataSto^⚠: frees the STO reader data
SCIPfreeReaderdataTim^⚠: frees the reader data for the tim file
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
SCIPgenerateFpRowsFromRowExact^⚠: generates two fprows that are a relaxation of the exact row wrt the lhs/rhs, respectively
SCIPgenerateIIS^⚠: the execution method that iterates over the IIS finder plugins
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.
SCIPgetActivityExactLinear^⚠: gets the activity of the linear constraint in the given solution
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 score 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 score 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
SCIPgetAvgDPseudocostScore^⚠: gets the average discounted pseudo cost score value over all variables, assuming a fractionality of 0.5
SCIPgetAvgDualbound^⚠: gets average dual bound of all unprocessed nodes for original problem
SCIPgetAvgGMIeff^⚠: returns the average normalized efficacy of a GMI cut over all variables
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
SCIPgetConsPermsymGraph^⚠: method to get the permutation symmetry detection graph of a constraint
SCIPgetConsSignedPermsymGraph^⚠: method to get the signed permutation symmetry detection graph of a constraint
SCIPgetConsVals^⚠: returns the value array of an arbitrary SCIP constraint that can be represented as a single linear constraint
SCIPgetConsValsExact^⚠: returns the exact 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
SCIPgetCutoffboundExact^⚠: gets global cutoff bound of exact 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^⚠: computes a deterministic measure of time from statistics
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
SCIPgetDualboundExact^⚠: gets global exact 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
SCIPgetExprActivityNonlinear^⚠: computes value of constraint expression in a given solution
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
SCIPgetExprMonomialData^⚠: returns a monomial representation of a product 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
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
SCIPgetFeasibilityExactLinear^⚠: gets the feasibility of the linear constraint in the given solution
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^⚠: gets 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
SCIPgetFpDualfarkasExactLinear^⚠: gets the dual Farkas value of the linear constraint in the current infeasible LP
SCIPgetFpDualsolExactLinear^⚠: gets the dual solution of the linear constraint in the current LP
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)
SCIPgetIIS^⚠: Gets the IIS storage.
SCIPgetIISfinders^⚠: returns the array of currently available IIS finders
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 continuous implied integral variables, which should not be used for branching
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
SCIPgetLPExactObjval^⚠: gets objective value of current exact LP (which is the sum of column and loose objective value)
SCIPgetLPExactSolstat^⚠: gets solution status of current exact LP
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
SCIPgetLhsExactLinear^⚠: gets left hand side of linear constraint
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
SCIPgetLowerboundExact^⚠: gets global exact lower (dual) bound in transformed problem
SCIPgetLowerboundRoot^⚠: gets lower (dual) bound in transformed problem of the root node
SCIPgetMasterProblemRelaxBenders^⚠: returns the master problem SCIP instance
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
SCIPgetNBinImplVars^⚠: gets number of binary implied integral active problem variables
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, reconvergence constraints, and dual proofs)
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
SCIPgetNContImplVars^⚠: gets number of continuous implied integral active problem variables
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 added to the sepastore 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
SCIPgetNExactLPs^⚠: gets number of calls to the exact LP solver
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
SCIPgetNIISfinders^⚠: returns the number of currently available IIS finders
SCIPgetNImplVars^⚠: gets number of implied integral 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
SCIPgetNIntImplVars^⚠: gets number of integer implied integral active problem variables
SCIPgetNIntVars^⚠: gets number of integer active problem variables
SCIPgetNLPBranchCands^⚠: gets number of branching candidates for LP solution branching (number of fractional variables); implied integral variables with integrality constraints are included
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
SCIPgetNLPNlRowsStat^⚠: gets statistics on convexity of rows in NLP
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
SCIPgetNOrigBinImplVars^⚠: gets number of binary implied integral variables in the original problem
SCIPgetNOrigBinVars^⚠: gets number of binary variables in the original problem
SCIPgetNOrigConss^⚠: gets total number of constraints in the original problem
SCIPgetNOrigContImplVars^⚠: gets number of continuous implied integral variables in the original problem
SCIPgetNOrigContVars^⚠: gets number of continuous variables in the original problem
SCIPgetNOrigImplVars^⚠: gets number of implied integral variables in the original problem
SCIPgetNOrigIntImplVars^⚠: gets number of integer implied integral 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.
SCIPgetNResConflictConssApplied^⚠: get total number of resolution conflict constraints added to the problem
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
SCIPgetNRootIntFixingsRun^⚠: gets number of global fixings applied in the current run
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
SCIPgetNVarsExactLinear^⚠: gets the number of variables in the linear 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
SCIPgetOrigObjoffsetExact^⚠: returns the exact objective offset of the original problem
SCIPgetOrigObjscale^⚠: returns the objective scale of the original problem
SCIPgetOrigVars^⚠: gets array with original problem variables
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
SCIPgetPrimalDualIntegral^⚠: recomputes and returns the primal dual gap stored in the stats
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
SCIPgetPrimalboundExact^⚠: 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
SCIPgetProbabilityExp3IX^⚠: 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.
SCIPgetProbvarLinearSumExact^⚠: 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
SCIPgetProbvarSumExact^⚠: 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
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
SCIPgetRhsExactLinear^⚠: gets right hand side of linear 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
SCIPgetRowExactExactLinear^⚠: returns the exact linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row!
SCIPgetRowExactLinear^⚠: 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!
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
SCIPgetRowNumImpliedIntCols^⚠: returns number of implied integral columns in the row
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
SCIPgetRowSolActivityExact^⚠: returns the activity of a row for the given primal solution
SCIPgetRowSolActivityWithErrorboundExact^⚠: returns the activity of a row for the given primal solution with running error analysis
SCIPgetRowSolFeasibility^⚠: returns the feasibility of a row for the given primal solution
SCIPgetRowSolFeasibilityExact^⚠: 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
SCIPgetSolOrigObjExact^⚠: gets exact 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
SCIPgetSolTransObjExact^⚠: gets 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
SCIPgetSolValExact^⚠: gets 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
SCIPgetSolverDescConopt^⚠: gets string that describes CONOPT
SCIPgetSolverDescFilterSQP^⚠: gets string that describes filterSQP
SCIPgetSolverDescIpopt^⚠: gets string that describes Ipopt
SCIPgetSolverDescWorhp^⚠: gets string that describes Worhp (version number)
SCIPgetSolverNameConopt^⚠: gets string that identifies CONOPT
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
SCIPgetSymDataExpr^⚠: retrieves symmetry information from an expression
SCIPgetSymInferredVarType^⚠: returns inferred type of variable used for symmetry handling
SCIPgetSymOpNodeType^⚠: returns representation of an operator node type.
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)
SCIPgetUpperboundExact^⚠: gets global exact upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
SCIPgetValsExactLinear^⚠: gets the array of coefficient values in the linear constraint; the user must not modify this array!
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
SCIPgetValsRealExactLinear^⚠: gets the array of coefficient values in the linear constraint; the user must not modify this array!
SCIPgetValueExprValue^⚠: gets the value of a constant value expression
SCIPgetVanillafullstrongData^⚠: recovers candidate variables and their scores from last vanilla full strong branching call
SCIPgetVarAncPseudocostCountCurrentRun^⚠: gets the variable’s (possible fractional) number of ancestor pseudo cost updates for the given direction, only using the pseudo cost information of the current run
SCIPgetVarAncPseudocostVal^⚠: gets the variable’s ancestral pseudo cost value for the given change of the variable’s LP value
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
SCIPgetVarAvgGMIScore^⚠: returns the variable’s average GMI efficacy score value
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
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
SCIPgetVarDPseudocostScore^⚠: gets the variable’s discounted pseudo cost score value for the given LP solution value.
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.
SCIPgetVarLastGMIScore^⚠: returns the variable’s last GMI efficacy score value
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()
SCIPgetVarsExactLinear^⚠: gets the array of variables in the linear constraint; the user must not modify this array!
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
SCIPhashmapGetImageLong^⚠: retrieves image of given origin from the hash map, or SCIP_LONGINT_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!)
SCIPhashmapInsertLong^⚠: 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.
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?
SCIPheurMarkExact^⚠: marks the primal heuristic as safe to use in exact solving mode
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
SCIPiisAddNNodes^⚠: Increments the number of nodes in the IIS solve.
SCIPiisGetNNodes^⚠: Gets the number of nodes in the IIS solve.
SCIPiisGetRandnumgen^⚠: get the randnumgen of the IIS
SCIPiisGetSubscip^⚠: get the subscip of an IIS
SCIPiisGetTime^⚠: gets time in seconds used in the IIS calculations
SCIPiisGreedyMakeIrreducible^⚠: perform the greedy deletion algorithm with singleton batches to obtain an irreducible infeasible subsystem (IIS)
SCIPiisIsSubscipInfeasible^⚠: Gets whether the IIS subscip is currently infeasible.
SCIPiisIsSubscipIrreducible^⚠: Gets whether the IIS subscip is irreducible.
SCIPiisSetSubscipInfeasible^⚠: Sets the flag that states whether the IIS subscip is currently infeasible.
SCIPiisSetSubscipIrreducible^⚠: Sets the flag that states whether the IIS subscip is irreducible.
SCIPiisfinderComp^⚠: compares two IIS finders w. r. to their priority
SCIPiisfinderGetData^⚠: gets user data of IIS finder
SCIPiisfinderGetDesc^⚠: gets description of IIS finder
SCIPiisfinderGetName^⚠: gets name of IIS finder
SCIPiisfinderGetPriority^⚠: gets priority of IIS finder
SCIPiisfinderGetTime^⚠: gets time in seconds used in this IIS finder
SCIPiisfinderInfoMessage^⚠: prints output line during IIS calculations
SCIPiisfinderSetData^⚠: sets user data of IIS finder; user has to free old data in advance!
SCIPinDive^⚠: returns whether we are in diving mode
SCIPinExactDive^⚠: returns whether we are in exact 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
SCIPincAvgGMIeff^⚠: increases the average normalized efficacy of a GMI cut over all variables
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
SCIPincVarGMISumScore^⚠: sets the variable’s avg GMI efficacy score value
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 @pre This method can be called if SCIP is in one of the following stages: - \ref SCIP_STAGE_INIT - \ref SCIP_STAGE_PROBLEM
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
SCIPincludeBranchruleGomory^⚠: creates the Gomory cut 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
SCIPincludeConshdlrExactLinear^⚠: creates the handler for linear constraints and includes it in SCIP
SCIPincludeConshdlrExactSol^⚠: creates the handler for ExactSol constraints and includes it in SCIP
SCIPincludeConshdlrFixedvar^⚠: creates the fixedvar constraint handler 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^⚠: includes orbitope constraint handlers
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.
SCIPincludeCutselDynamic^⚠: creates the dynamic hybrid separator and includes it in SCIP
SCIPincludeCutselEnsemble^⚠: creates the ensemble separator and includes it in SCIP
SCIPincludeCutselHybrid^⚠: creates the hybrid separator and includes it in SCIP
SCIPincludeDefaultPlugins^⚠: includes default plugins into SCIP with respect to priorities
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
SCIPincludeHeurDKS^⚠: creates the aks 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
SCIPincludeHeurIndicatordiving^⚠: creates the indicatordiving 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
SCIPincludeHeurScheduler^⚠: creates the scheduler primal heuristic 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
SCIPincludeIISfinder^⚠: creates an IIS finder and includes it in SCIP
SCIPincludeIISfinderBasic^⚠: Creates an IIS finder and includes it in SCIP with its most fundamental callbacks.
SCIPincludeIISfinderGreedy^⚠: creates the greedy IIS finder rule 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
SCIPincludeNlhdlrSignomial^⚠: includes signomial nonlinear handler to 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
SCIPincludeNlpSolverConopt^⚠: create solver interface for CONOPT solver and includes it into SCIP
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
SCIPincludePresolImplint^⚠: creates the implicit integer 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()
SCIPincludeRelaxBenders^⚠: creates the benders relaxator and includes it in SCIP
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
SCIPincludeSepaFlower^⚠: creates the flower 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
SCIPincludeSepaLagromory^⚠: creates the Lagromory 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
SCIPinferVarLbConsExact^⚠: changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter 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
SCIPinferVarUbConsExact^⚠: changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter 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
SCIPinsertDatatreeBool^⚠: inserts a bool value into a SCIP_DATATREE object
SCIPinsertDatatreeBoolArray^⚠: inserts a SCIP_Bool array into a SCIP_DATATREE object
SCIPinsertDatatreeInt^⚠: inserts an int value into a SCIP_DATATREE object
SCIPinsertDatatreeIntArray^⚠: inserts an int array into a SCIP_DATATREE object
SCIPinsertDatatreeLong^⚠: inserts a long value into a SCIP_DATATREE object
SCIPinsertDatatreeLongArray^⚠: inserts a SCIP_Longint array into a SCIP_DATATREE object
SCIPinsertDatatreeReal^⚠: inserts a SCIP_Real value into a SCIP_DATATREE object
SCIPinsertDatatreeRealArray^⚠: inserts a SCIP_Real array into a SCIP_DATATREE object
SCIPinsertDatatreeString^⚠: inserts a string value into a SCIP_DATATREE object
SCIPinsertDatatreeStringArray^⚠: inserts a string array into a SCIP_DATATREE object
SCIPinsertDatatreeTree^⚠: inserts a data tree value into a SCIP_DATATREE object
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
SCIPintervalAbsMax^⚠: returns the maximum of the absolute values of the infimum and supremum of the interval
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]
SCIPintervalSetRational^⚠: stores given value as interval
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
SCIPisCertified^⚠: returns whether certificate output is activated
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
SCIPisConoptAvailableConopt^⚠: returns whether CONOPT is available, i.e., whether it has been linked in
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
SCIPisExact^⚠: returns whether the solution process is arithmetically exact, i.e., not subject to roundoff errors
SCIPisExactDivePossible^⚠: checks if exact diving mode is possible at this point in time
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
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.
SCIPisVarAggrCoefAcceptable^⚠: checks whether a loose variable can be used in a new aggregation with given coefficient
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
SCIPlinkLPSolExact^⚠: links a primal solution to the current exact 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
SCIPlpAddCol^⚠: adds a column to the LP and captures the variable
SCIPlpAddRow^⚠: adds a row to the LP and captures it
SCIPlpCleanupAll^⚠: removes all non-basic columns at 0.0 and basic rows in the whole LP
SCIPlpCleanupNew^⚠: removes all non-basic columns at 0.0 and basic rows in the part of the LP created at the current node
SCIPlpClear^⚠: removes all columns and rows from LP, releases all rows
SCIPlpComputeRelIntPoint^⚠: compute relative interior point
SCIPlpCreate^⚠: creates empty LP data object
SCIPlpDecNLoosevars^⚠: decrease the number of loose variables by one
SCIPlpDiving^⚠: returns whether the LP is in diving mode
SCIPlpDivingObjChanged^⚠: returns whether the LP is in diving mode and the objective value of at least one column was changed
SCIPlpDivingRowsChanged^⚠
SCIPlpEndDive^⚠: quits LP diving and resets bounds and objective values of columns to the current node’s values
SCIPlpEndProbing^⚠: informs the LP that probing mode was finished
SCIPlpEndStrongbranch^⚠: end strong branching - call after any strong branching
SCIPlpEndStrongbranchProbing^⚠: informs the LP that the probing mode is not used for strongbranching anymore
SCIPlpExactAddCol^⚠: adds a column to the LP and captures the variable
SCIPlpExactAddRow^⚠: adds a row to the LP and captures it
SCIPlpExactAllowExactSolve^⚠: allows an exact lp to be solved in the next exact bound computation
SCIPlpExactBoundShiftUseful^⚠: returns whether the success rate of the Neumaier-Shcherbina safe bounding method is sufficiently high
SCIPlpExactClear^⚠: removes all columns and rows from LP, releases all rows
SCIPlpExactCreate^⚠: creates empty LP data object
SCIPlpExactDecNLoosevars^⚠: decrease the number of loose variables by one
SCIPlpExactDelRowset^⚠
SCIPlpExactDiving^⚠: returns whether the exact LP is in diving mode
SCIPlpExactEndDive^⚠: quits exact LP diving and resets bounds and objective values of columns to the current node’s values
SCIPlpExactFlush^⚠: applies all cached changes to the LP solver
SCIPlpExactForceExactSolve^⚠: forces an exact lp to be solved in the next exact bound computation
SCIPlpExactForceSafeBound^⚠: forces the next exact bound computation to be executed even in probing mode
SCIPlpExactFree^⚠: frees LP data object
SCIPlpExactFreeState^⚠: frees exact LP state information
SCIPlpExactGetDualfarkas^⚠: stores the dual Farkas multipliers for infeasibility proof in rows. besides
SCIPlpExactGetIterations^⚠: get number of iterations used in last LP solve
SCIPlpExactGetNRows^⚠
SCIPlpExactGetObjval^⚠: gets objective value of current LP
SCIPlpExactGetPrimalRay^⚠: returns primal ray proving the unboundedness of the current LP
SCIPlpExactGetPseudoObjval^⚠: 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
SCIPlpExactGetSol^⚠: stores the LP solution in the columns and rows
SCIPlpExactGetSolstat^⚠: gets solution status of current exact LP
SCIPlpExactGetState^⚠: stores exact LP state (like basis information) into LP state object
SCIPlpExactGetUnboundedSol^⚠: stores LP solution with infinite objective value in the columns and rows
SCIPlpExactIsSolved^⚠: returns whether the exact lp was solved
SCIPlpExactIsSynced^⚠: checks that lp and fplp are properly synced
SCIPlpExactLink^⚠: ensures all rows/columns are correctly updated, but changes are not yet communicated to the exact LP solver
SCIPlpExactOverwriteFpDualSol^⚠: overwrites the dual values stored in the fp lp with exact values
SCIPlpExactProjectShiftPossible^⚠: returns whether it is possible to use project and shift bounding method
SCIPlpExactReset^⚠: resets the LP to the empty LP by removing all columns and rows from LP, releasing all rows, and flushing the changes to the LP solver
SCIPlpExactSetCutoffbound^⚠: sets the upper objective limit of the exact LP solver
SCIPlpExactSetState^⚠: loads exact LP state (like basis information) into solver
SCIPlpExactShrinkCols^⚠: removes all columns after the given number of cols from the LP
SCIPlpExactShrinkRows^⚠: removes and releases all rows after the given number of rows from the LP
SCIPlpExactSolveAndEval^⚠: solves the LP with simplex algorithm, and copy the solution into the column’s data
SCIPlpExactStartDive^⚠: starts exact LP diving and saves bounds and objective values of columns to the current nodes’s values
SCIPlpExactSyncLPs^⚠: synchronizes the exact LP with cuts from the floating-point LP
SCIPlpExactUpdateAddVar^⚠: informs LP, that given variable was added to the problem
SCIPlpExactUpdateDelVar^⚠: informs LP, that given variable is to be deleted from the problem
SCIPlpExactUpdateVarColumn^⚠: informs LP, that given formerly loose problem variable is now a column variable
SCIPlpExactUpdateVarLb^⚠: updates current pseudo and loose objective value for a change in a variable’s lower bound
SCIPlpExactUpdateVarLbGlobal^⚠: updates current root pseudo objective value for a global change in a variable’s lower bound
SCIPlpExactUpdateVarLoose^⚠: informs LP, that given formerly column problem variable is now again a loose variable
SCIPlpExactUpdateVarObj^⚠: updates current pseudo and loose objective value for a change in a variable’s objective value
SCIPlpExactUpdateVarUb^⚠: updates current pseudo objective value for a change in a variable’s upper bound
SCIPlpExactUpdateVarUbGlobal^⚠: updates current root pseudo objective value for a global change in a variable’s upper bound
SCIPlpExactWrite^⚠: writes exact LP to a file
SCIPlpFlush^⚠: applies all cached changes to the LP solver
SCIPlpFree^⚠: frees LP data object
SCIPlpFreeNorms^⚠: frees pricing norms information
SCIPlpFreeState^⚠: frees LP state information
SCIPlpGetBInvACol^⚠: 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
SCIPlpGetBInvARow^⚠: gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
SCIPlpGetBInvCol^⚠: gets a column from the inverse basis matrix B^-1
SCIPlpGetBInvRow^⚠: gets a row from the inverse basis matrix B^-1
SCIPlpGetBase^⚠: gets current basis status for columns and rows; arrays must be large enough to store the basis status
SCIPlpGetBasisInd^⚠: gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
SCIPlpGetCols^⚠: gets array with columns of the LP
SCIPlpGetColumnObjval^⚠: gets part of objective value of current LP that results from COLUMN variables only
SCIPlpGetCutoffbound^⚠: return the current cutoff bound of the lp
SCIPlpGetDualDegeneracy^⚠: 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
SCIPlpGetDualfarkas^⚠: stores the dual Farkas multipliers for infeasibility proof in rows. besides, the proof is checked for validity if lp/checkfarkas = TRUE.
SCIPlpGetFeastol^⚠: gets current primal feasibility tolerance of LP solver
SCIPlpGetGlobalPseudoObjval^⚠: gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) global bound
SCIPlpGetIterations^⚠: get number of iterations used in last LP solve
SCIPlpGetLPI^⚠: gets the LP solver interface
SCIPlpGetLooseObjval^⚠: gets part of objective value of current LP that results from LOOSE variables only
SCIPlpGetModifiedPseudoObjval^⚠: gets pseudo objective value, if a bound of the given variable would be modified in the given way
SCIPlpGetNCols^⚠: gets current number of columns in LP
SCIPlpGetNNewcols^⚠: gets number of newly added columns after the last mark
SCIPlpGetNNewrows^⚠: gets number of newly added rows after the last mark
SCIPlpGetNRows^⚠: gets current number of rows in LP
SCIPlpGetNUnfixedCols^⚠: gets current number of unfixed columns in LP
SCIPlpGetNewcols^⚠: gets array with newly added columns after the last mark
SCIPlpGetNewrows^⚠: gets array with newly added rows after the last mark
SCIPlpGetNorms^⚠: stores pricing norms into LP norms object
SCIPlpGetObjNorm^⚠: gets Euclidean norm of objective function vector of column variables, only use this method if lp->objsqrnormunreliable == FALSE, so probably you have to call SCIPlpRecalculateObjSqrNorm before
SCIPlpGetObjval^⚠: gets objective value of current LP
SCIPlpGetPrimalRay^⚠: returns primal ray proving the unboundedness of the current LP
SCIPlpGetProvedLowerbound^⚠: gets proven lower (dual) bound of last LP solution
SCIPlpGetPseudoObjval^⚠: 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
SCIPlpGetRootColumnObjval^⚠: 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
SCIPlpGetRootLooseObjval^⚠: 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
SCIPlpGetRootObjval^⚠: gets the objective value of the root node LP; returns SCIP_INVALID if the root node LP was not (yet) solved
SCIPlpGetRows^⚠: gets array with rows of the LP
SCIPlpGetSol^⚠: stores the LP solution in the columns and rows
SCIPlpGetSolstat^⚠: gets solution status of current LP
SCIPlpGetState^⚠: stores LP state (like basis information) into LP state object
SCIPlpGetUnboundedSol^⚠: stores LP solution with infinite objective value in the columns and rows
SCIPlpInterrupt^⚠: interrupts the currently ongoing lp solve or disables the interrupt
SCIPlpInvalidateRootObjval^⚠: invalidates the root LP solution value
SCIPlpIsDualReliable^⚠: return whether the current LP solution passed the dual feasibility check
SCIPlpIsFeasEQ^⚠: checks if absolute difference of values is in range of LP primal feastol
SCIPlpIsFeasGE^⚠: checks if absolute difference of val1 and val2 is not lower than -LP primal feastol
SCIPlpIsFeasGT^⚠: checks if absolute difference of val1 and val2 is greater than LP primal feastol
SCIPlpIsFeasLE^⚠: checks if absolute difference of val1 and val2 is not greater than LP primal feastol
SCIPlpIsFeasLT^⚠: checks if absolute difference of val1 and val2 is lower than LP primal feastol
SCIPlpIsFeasNegative^⚠: checks if value is lower than -LP primal feasibility tolerance
SCIPlpIsFeasPositive^⚠: checks if value is greater than LP primal feasibility tolerance
SCIPlpIsFeasZero^⚠: checks if value is in range LP primal feasibility tolerance of 0.0
SCIPlpIsInfeasibilityProved^⚠: gets proven dual bound of last LP solution
SCIPlpIsPrimalReliable^⚠: return whether the current LP solution passed the primal feasibility check
SCIPlpIsRelax^⚠: returns whether the current LP is a relaxation of the problem for which it has been solved and its solution value a valid local lower bound?
SCIPlpIsRootLPRelax^⚠: returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
SCIPlpIsSolBasic^⚠: returns whether the current LP solution is a basic solution
SCIPlpIsSolved^⚠: returns whether the current LP is flushed and solved
SCIPlpMarkDivingObjChanged^⚠: marks the diving LP to have a changed objective function
SCIPlpMarkFlushed^⚠: marks the LP to be flushed, even if the LP thinks it is not flushed
SCIPlpMarkSize^⚠: remembers number of columns and rows to track the newly added ones
SCIPlpRecalculateObjSqrNorm^⚠: recalculates Euclidean norm of objective function vector of column variables if it have gotten unreliable during calculation
SCIPlpRecomputeLocalAndGlobalPseudoObjval^⚠: recomputes local and global pseudo objective values
SCIPlpRecordOldRowSideDive^⚠: records a current row side such that any change will be undone after diving
SCIPlpRemoveAllObsoletes^⚠: removes all non-basic columns and basic rows in whole LP, that are too old
SCIPlpRemoveNewObsoletes^⚠: removes all non-basic columns and basic rows in the part of the LP created at the current node, that are too old
SCIPlpRemoveRedundantRows^⚠: removes all redundant rows that were added at the current node
SCIPlpReset^⚠: resets the LP to the empty LP by removing all columns and rows from LP, releasing all rows, and flushing the changes to the LP solver
SCIPlpResetFeastol^⚠: resets primal feasibility tolerance of LP solver
SCIPlpSetCutoffbound^⚠: sets the upper objective limit of the LP solver
SCIPlpSetFeastol^⚠: sets primal feasibility tolerance of LP solver
SCIPlpSetIsRelax^⚠: sets whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
SCIPlpSetNorms^⚠: loads pricing norms from LP norms object into solver
SCIPlpSetRootLPIsRelax^⚠: sets whether the root LP is a relaxation of the problem and its optimal objective value is a global lower bound
SCIPlpSetSizeMark^⚠: sets the remembered number of columns and rows to the given values
SCIPlpSetState^⚠: loads LP state (like basis information) into solver
SCIPlpShrinkCols^⚠: removes all columns after the given number of columns from the LP
SCIPlpShrinkRows^⚠: removes and releases all rows after the given number of rows from the LP
SCIPlpSolveAndEval^⚠: solves the LP with simplex algorithm, and copy the solution into the column’s data
SCIPlpStartDive^⚠: initiates LP diving
SCIPlpStartProbing^⚠: informs the LP that probing mode was initiated
SCIPlpStartStrongbranch^⚠: start strong branching - call before any strong branching
SCIPlpStartStrongbranchProbing^⚠: informs the LP that the probing mode is now used for strongbranching
SCIPlpStoreRootObjval^⚠: remembers the current LP objective value as root solution value
SCIPlpSumRows^⚠: 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
SCIPlpUnmarkDivingObjChanged^⚠: marks the diving LP to not have a changed objective function anymore
SCIPlpUpdateAddVar^⚠: informs LP, that given variable was added to the problem
SCIPlpUpdateAges^⚠: increases age of columns with solution value 0.0 and rows with activity not at its bounds, resets age of non-zero columns and sharp rows
SCIPlpUpdateDelVar^⚠: informs LP, that given variable is to be deleted from the problem
SCIPlpUpdateVarColumn^⚠: informs LP, that given formerly loose problem variable is now a column variable
SCIPlpUpdateVarLb^⚠: updates current pseudo and loose objective value for a change in a variable’s lower bound
SCIPlpUpdateVarLbGlobal^⚠: updates current root pseudo objective value for a global change in a variable’s lower bound
SCIPlpUpdateVarLoose^⚠: informs LP, that given formerly column problem variable is now again a loose variable
SCIPlpUpdateVarObj^⚠: updates current pseudo and loose objective value for a change in a variable’s objective coefficient
SCIPlpUpdateVarUb^⚠: updates current pseudo objective value for a change in a variable’s upper bound
SCIPlpUpdateVarUbGlobal^⚠: updates current root pseudo objective value for a global change in a variable’s upper bound
SCIPlpWrite^⚠: writes LP to a file
SCIPlpWriteMip^⚠: writes MIP to a file
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
SCIPmakeSolExact^⚠: copy the fp values to the exact arrays of the solution
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
SCIPmatrixGetRowLhsExact^⚠: 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
SCIPmatrixGetRowRhsExact^⚠: get right-hand-side of row
SCIPmatrixGetRowValPtr^⚠: get row based start pointer of values
SCIPmatrixGetRowValPtrExact^⚠: 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();
SCIPmultiaggregateVarExact^⚠: converts variable into exact 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
SCIPmultiplyBySumExprSum^⚠: constructs the expanded product of two sum expressions
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
SCIPnlhdlrHasSollinearize^⚠: returns whether nonlinear handler implements the solution linearization 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
SCIPnlhdlrSetSollinearize^⚠: sets the solution linearization callback 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
SCIPnodeAddBoundchg^⚠: adds bound change to focus node, or child of focus node, or probing node; if possible, adjusts bound to integral value
SCIPnodeAddBoundchgExact^⚠: adds exact bound change to focus node, or child of focus node, or probing node; if possible, adjusts bound to integral value
SCIPnodeAddBoundinfer^⚠: adds bound change with inference information to focus node, child of focus node, or probing node; if possible, adjusts bound to integral value; at most one of infercons and inferprop may be non-NULL
SCIPnodeAddBoundinferExact^⚠: adds exact bound change with inference information to focus node, child of focus node, or probing node; if possible, adjusts bound to integral value; at most one of infercons and inferprop may be non-NULL
SCIPnodeAddCons^⚠: adds constraint locally to the node and captures it; activates constraint, if node is active; if a local constraint is added to the root node, it is automatically upgraded into a global constraint
SCIPnodeAddHolechg^⚠: adds hole change to focus node, or child of focus node
SCIPnodeAddHoleinfer^⚠: adds hole with inference information to focus node, child of focus node, or probing node; if possible, adjusts bound to integral value; at most one of infercons and inferprop may be non-NULL
SCIPnodeCaptureLPIState^⚠: increases the reference counter of the LP state in the fork or subroot node
SCIPnodeCompLowerbound^⚠: node comparator for best lower bound
SCIPnodeCreateChild^⚠: creates a child node of the focus node
SCIPnodeCutoff^⚠: cuts off node and whole sub tree from branch and bound tree
SCIPnodeDelCons^⚠: locally deletes constraint at the given node by disabling its separation, enforcing, and propagation capabilities at the node; captures constraint; disables constraint, if node is active
SCIPnodeFocus^⚠: installs a child, a sibling, or a leaf node as the new focus node
SCIPnodeFree^⚠: frees node and inactive path iteratively
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
SCIPnodeGetDualBoundchgs^⚠: returns all bound changes based on dual information.
SCIPnodeGetEstimate^⚠: gets the estimated value of the best feasible solution in subtree of the node
SCIPnodeGetLowerbound^⚠: gets the lower bound of the node
SCIPnodeGetLowerboundExact^⚠: gets the rational 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
SCIPnodeGetNDualBndchgs^⚠: returns the number of bound changes based on dual information.
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
SCIPnodeGetPropsAfterDual^⚠: return bound changes on non-continuous variables based on constraint and propagator propagation
SCIPnodeGetPropsBeforeDual^⚠: return all bound changes on non-continuous variables based on constraint and propagator propagation
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
SCIPnodeMarkPropagated^⚠: marks node, that it is completely propagated in the current repropagation subtree level
SCIPnodePrintAncestorBranchings^⚠: outputs the path into given file stream in GML format
SCIPnodePropagateAgain^⚠: marks node, that propagation should be applied again the next time, a node of its subtree is focused
SCIPnodePropagateImplics^⚠: propagates implications of binary fixings at the given node triggered by the implication graph and the clique table
SCIPnodeReleaseLPIState^⚠: decreases the reference counter of the LP state in the fork or subroot node
SCIPnodeSetEstimate^⚠: sets the node’s estimated bound to the new value
SCIPnodeSetReoptID^⚠: sets a unique id to identify the node during reoptimization
SCIPnodeSetReopttype^⚠: sets the reoptimization type of the node
SCIPnodeUpdateLowerbound^⚠: if given value is larger than the node’s lower bound, sets the node’s lower bound to the new value
SCIPnodeUpdateLowerboundLP^⚠: updates lower bound of node using lower bound of LP
SCIPnodepqBound^⚠: free all nodes from the queue that are cut off by the given upper bound
SCIPnodepqClear^⚠: deletes all nodes in the node priority queue
SCIPnodepqCompare^⚠: compares two nodes; returns -1/0/+1 if node1 better/equal/worse than node2
SCIPnodepqCreate^⚠: creates node priority queue
SCIPnodepqDestroy^⚠: frees node priority queue, but not the data nodes themselves
SCIPnodepqFirst^⚠: returns the best node of the queue without removing it
SCIPnodepqFree^⚠: frees node priority queue and all nodes in the queue
SCIPnodepqGetLowerbound^⚠: gets the minimal lower bound of all nodes in the queue
SCIPnodepqGetLowerboundExact^⚠: gets the minimal exact lower bound of all nodes in the queue or NULL if empty
SCIPnodepqGetLowerboundNode^⚠: gets the node with minimal lower bound of all nodes in the queue
SCIPnodepqGetLowerboundSum^⚠: gets the sum of lower bounds of all nodes in the queue
SCIPnodepqGetNodesel^⚠: returns the node selector associated with the given node priority queue
SCIPnodepqInsert^⚠: inserts node into node priority queue
SCIPnodepqLen^⚠: returns the number of nodes stored in the node priority queue
SCIPnodepqNodes^⚠: returns the nodes array of the queue
SCIPnodepqRemove^⚠: removes node from the node priority queue
SCIPnodepqSetNodesel^⚠: sets the node selector used for sorting the nodes in the queue, and resorts the queue if necessary
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
SCIPnodeselCompare^⚠: compares two nodes; returns -1/0/+1 if node1 better/equal/worse than node2
SCIPnodeselCopyInclude^⚠: copies the given node selector to a new scip
SCIPnodeselCreate^⚠: creates a node selector
SCIPnodeselEnableOrDisableClocks^⚠: enables or disables all clocks of \p nodesel, depending on the value of the flag
SCIPnodeselExit^⚠: deinitializes node selector
SCIPnodeselExitsol^⚠: informs node selector that the branch and bound process data is being freed
SCIPnodeselFree^⚠: frees memory of node selector
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
SCIPnodeselInit^⚠: initializes node selector
SCIPnodeselInitsol^⚠: informs node selector that the branch and bound process is being started
SCIPnodeselIsInitialized^⚠: is node selector initialized?
SCIPnodeselSelect^⚠: select next node to be processed
SCIPnodeselSetCopy^⚠: sets copy method of node selector
SCIPnodeselSetData^⚠: sets user data of node selector; user has to free old data in advance!
SCIPnodeselSetExit^⚠: sets deinitialization method of node selector
SCIPnodeselSetExitsol^⚠: sets solving process deinitialization method of node selector
SCIPnodeselSetFree^⚠: sets destructor method of node selector
SCIPnodeselSetInit^⚠: sets initialization method of node selector
SCIPnodeselSetInitsol^⚠: sets solving process initialization method of node selector
SCIPnodeselSetMemsavePriority^⚠: sets priority of node selector in memory saving mode
SCIPnodeselSetStdPriority^⚠: sets priority of node selector in standard mode
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
SCIPoverwriteFPsol^⚠: overwrite the fp-values in a solution with the rounded exact ones
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
SCIPparseRational^⚠: parse a rational value
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
SCIPparseVarsLinearsumExact^⚠: 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
SCIPparseVarsPolynomialExact^⚠: 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
SCIPpermuteProb^⚠: permutes parts of the problem data structure
SCIPpowerExprSum^⚠: constructs the expanded power of a sum expression
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?
SCIPpresolMarkExact^⚠: marks the presolver as safe to use in exact solving mode
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?
SCIPpricerMarkExact^⚠: marks the variable pricer as safe to use in exact solving mode
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
SCIPprintDatatreeAsTable^⚠: prints a generic table from a data store
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
SCIPprintRowExact^⚠: output exact 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
SCIPprintSolExact^⚠: print a rational solution
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
SCIPprintStatisticsJson^⚠: outputs solving statistics in JSON format
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?
SCIPpropMarkExact^⚠: marks the propagator as safe to use in exact solving mode
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
SCIPpropSetTimingmask^⚠: sets new timing mask for 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
SCIPrationalAbs^⚠: set res to Abs(op)
SCIPrationalAdd^⚠: adds two rationals and saves the result in res
SCIPrationalAddProd^⚠
SCIPrationalAddProdReal^⚠
SCIPrationalAddReal^⚠: adds a rational and a real and saves the result in res
SCIPrationalCanonicalize^⚠
SCIPrationalCheckInfByValue^⚠
SCIPrationalChgInfinity^⚠: changes the infinity threshold to new value
SCIPrationalComputeApproximation^⚠: compute an approximate number with denominator <= maxdenom, closest to src and save it in res using continued fractions
SCIPrationalCopy^⚠: creates a copy of a rational using ordinary memory
SCIPrationalCopyArray^⚠: copies an array of rationals using ordinary memory
SCIPrationalCopyBlock^⚠: creates a copy of a rational using block memory
SCIPrationalCopyBlockArray^⚠: copies an array of rationals using block memory
SCIPrationalCopyBuffer^⚠: creates a copy of a rational
SCIPrationalCopyBufferArray^⚠: copy an array of rationals using buffer memory
SCIPrationalCreate^⚠: creates a rational using standard memory allocation
SCIPrationalCreateArray^⚠: creates an array of rationals using ordinary memory
SCIPrationalCreateBlock^⚠: creates a rational using block memory
SCIPrationalCreateBlockArray^⚠: creates an array of rationals using block memory
SCIPrationalCreateBuffer^⚠: creates a rational using buffer memory
SCIPrationalCreateBufferArray^⚠: creates an array of rationals using buffer memory
SCIPrationalCreateString^⚠: allocates and creates a rational from a string if known, otherwise assigns a null pointer
SCIPrationalDenominator^⚠: returns the denominator of a rational as a long
SCIPrationalDenominatorIsLE^⚠: compares denominator of a rational to a long
SCIPrationalDiff^⚠: subtracts two rationals and saves the result in res
SCIPrationalDiffProd^⚠
SCIPrationalDiffProdReal^⚠
SCIPrationalDiffReal^⚠: subtracts a rational and a real and saves the result in res
SCIPrationalDiv^⚠: divide two rationals and save the result in res
SCIPrationalDivReal^⚠: divide a rational by a real and save the result in res
SCIPrationalFree^⚠: deletes a rational and frees the allocated ordinary memory
SCIPrationalFreeArray^⚠: deletes an array of rationals and frees the allocated ordinary memory
SCIPrationalFreeBlock^⚠: deletes a rational and frees the allocated block memory
SCIPrationalFreeBlockArray^⚠: deletes an array of rationals and frees the allocated block memory
SCIPrationalFreeBuffer^⚠: deletes a rational and frees the allocated buffer memory
SCIPrationalFreeBufferArray^⚠: deletes an array of rationals and frees the allocated buffer memory
SCIPrationalGetFrac^⚠: computes fractional part of a rational number
SCIPrationalGetInfinity^⚠: return the infinity threshold for rationals
SCIPrationalGetReal^⚠: returns approximation of rational as SCIP_Real
SCIPrationalGetSign^⚠: returns the sign of the rational (1 if positive, -1 if negative, 0 if zero)
SCIPrationalInvert^⚠: set res to 1/op
SCIPrationalIsAbsEQ^⚠: checks if two rationals are equal
SCIPrationalIsAbsGT^⚠: checks if first rational is greater than second rational
SCIPrationalIsAbsInfinity^⚠: checks if rational is negative infinity
SCIPrationalIsApproxEQReal^⚠: checks if real approx of rational and real are equal
SCIPrationalIsEQ^⚠: checks if two rationals are equal
SCIPrationalIsEQReal^⚠: checks if rational and real are equal
SCIPrationalIsFpRepresentable^⚠: checks if rational is exactly representable as real
SCIPrationalIsGE^⚠: checks if first rational is greater or equal than second rational
SCIPrationalIsGEReal^⚠: checks if rational is greater or equal than real
SCIPrationalIsGT^⚠: checks if first rational is greater than second rational
SCIPrationalIsGTReal^⚠: checks if rational is greater than real
SCIPrationalIsInfinity^⚠: checks if rational is positive infinity
SCIPrationalIsIntegral^⚠: checks if rational is integral
SCIPrationalIsLE^⚠: checks if first rational is less or equal than second rational
SCIPrationalIsLEReal^⚠: checks if rational is less or equal than real
SCIPrationalIsLT^⚠: checks if first rational is smaller than second rational
SCIPrationalIsLTReal^⚠: checks if rational is less than real
SCIPrationalIsNegInfinity^⚠: checks if rational is negative infinity
SCIPrationalIsNegative^⚠: checks if rational is negative
SCIPrationalIsPositive^⚠: checks if rational is positive
SCIPrationalIsString^⚠: checks if a string describes a rational number
SCIPrationalIsZero^⚠: checks if rational is zero
SCIPrationalMax^⚠: compute the maximum of two rationals
SCIPrationalMessage^⚠: prints rational into a file using message handler
SCIPrationalMin^⚠: compute the minimum of two rationals
SCIPrationalMult^⚠: multiplies two rationals and saves the result in res
SCIPrationalMultReal^⚠: multiply a rational and a real and save the result in res
SCIPrationalNegate^⚠: set res to -op
SCIPrationalNumerator^⚠: returns the numerator of a rational as a long
SCIPrationalPrint^⚠: prints a rational to command line (for debugging)
SCIPrationalPrintDebugMessage^⚠: prints a debug message
SCIPrationalPrintVerbInfo^⚠: prints rational depending on the verbosity level
SCIPrationalPrintf^⚠: printf extension for rationals (does not support all format options yet)
SCIPrationalReallocArray^⚠: realloc a rational ordinary array
SCIPrationalReallocBlockArray^⚠: realloc a rational block arrray
SCIPrationalReallocBufferArray^⚠: realloc a rational buffer arrray
SCIPrationalRelDiff^⚠: returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0) of two rationals
SCIPrationalResetFloatingPointRepresentable^⚠: resets the flag isfprepresentable to SCIP_ISFPREPRESENTABLE_UNKNOWN
SCIPrationalRoundInteger^⚠: rounds a rational to an integer and saves it as a rational
SCIPrationalRoundLong^⚠: rounds rational to next integer in direction of roundmode
SCIPrationalRoundReal^⚠: gets the relaxation of a rational as a real
SCIPrationalSetFraction^⚠: sets a rational to a nom/denom value
SCIPrationalSetInfinity^⚠: sets a rational to positive infinity
SCIPrationalSetNegInfinity^⚠: sets a rational to negative infinity
SCIPrationalSetRational^⚠: sets a rational to the value of another rational
SCIPrationalSetReal^⚠: sets a rational to the value of another a real
SCIPrationalSetString^⚠: sets a rational to the value described by a string
SCIPrationalStrLen^⚠: returns the strlen of a rational number
SCIPrationalToString^⚠: converts a rational to a string for printing, returns the number of copied characters.
SCIPrationalarrayCopy^⚠: creates a copy of a dynamic array of real values
SCIPrationalarrayCreate^⚠: creates a dynamic array of real values
SCIPrationalarrayFree^⚠: frees a dynamic array of real values
SCIPrationalarrayGetMaxIdx^⚠: returns the maximal index of all stored non-zero elements
SCIPrationalarrayGetMinIdx^⚠: returns the minimal index of all stored non-zero elements
SCIPrationalarrayGetVal^⚠: gets value of entry in dynamic array
SCIPrationalarrayIncVal^⚠: increases value of entry in dynamic array
SCIPrationalarrayPrint^⚠: prints a rationalarray to std out
SCIPrationalarrayResize^⚠: resizes a dynamic array of real values
SCIPrationalarraySetVal^⚠: sets value of entry in dynamic array
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
SCIPreaderMarkExact^⚠: marks the reader as safe to use in exact solving mode
SCIPreaderSetData^⚠: sets user data of reader; user has to free old data in advance!
SCIPrealIsExactlyIntegral^⚠: checks, if value is integral without any tolerances
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?
SCIPrelaxMarkExact^⚠: marks the relaxator as safe to use in exact solving mode
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
SCIPreleaseRowExact^⚠: 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
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
SCIPretransformSolExact^⚠: retransforms exact solution to original problem space
SCIPrewind^⚠
SCIPround^⚠: rounds value to the nearest integer with epsilon tolerance
SCIProundSol^⚠: try to round given solution
SCIProwAddCoef^⚠: adds a previously non existing coefficient to an LP row
SCIProwAddConstant^⚠: add constant value to a row
SCIProwCalcIntegralScalar^⚠: tries to find a value, such that all row coefficients, if scaled with this value become integral
SCIProwCalcProbability^⚠: calculates the probability of satisfying an LP-row under the assumption of uniformly distributed variable values.
SCIProwCapture^⚠: increases usage counter of LP row
SCIProwCatchEvent^⚠: includes event handler with given data in row’s event filter
SCIProwChgCoef^⚠: changes or adds a coefficient to an LP row
SCIProwChgConstant^⚠: changes constant value of a row
SCIProwChgLhs^⚠: changes left hand side of LP row
SCIProwChgLocal^⚠: changes the local flag of LP row
SCIProwChgRank^⚠: changes the rank of LP row
SCIProwChgRhs^⚠: changes right hand side of LP row
SCIProwComp^⚠: comparison method for sorting rows by non-decreasing index
SCIProwCreate^⚠: creates and captures an LP row
SCIProwDelCoef^⚠: deletes coefficient from row
SCIProwDelaySort^⚠: enables delaying of row sorting
SCIProwDropEvent^⚠: deletes event handler with given data from row’s event filter
SCIProwEnsureSize^⚠: ensures, that column array of row can store at least num entries
SCIProwExactAddCoef^⚠: adds a previously non existing coefficient to an LP row
SCIProwExactAddConstant^⚠: add constant value to a row
SCIProwExactCapture^⚠: increases usage counter of LP row
SCIProwExactChgCoef^⚠: changes or adds a coefficient to an LP row
SCIProwExactChgConstant^⚠: changes constant value of a row
SCIProwExactChgLhs^⚠: changes left hand side of exact LP row
SCIProwExactChgRhs^⚠: changes right hand side of exact LP row
SCIProwExactComp^⚠: comparison method for sorting rows by non-decreasing index
SCIProwExactCreate^⚠: creates and captures an LP row
SCIProwExactCreateFromRow^⚠: creates and captures an exact LP row from a fp row
SCIProwExactDelCoef^⚠: deletes coefficient from row
SCIProwExactDelaySort^⚠: enables delaying of row sorting
SCIProwExactEnsureSize^⚠: ensuresr, that column array of row can store at least num entries
SCIProwExactForceSort^⚠: disables delaying of row sorting, sorts row and merges coefficients with equal columns
SCIProwExactFree^⚠: frees an LP row
SCIProwExactGenerateFpRows^⚠: populate data of two empty fp rows with data from exact row
SCIProwExactGetCols^⚠: gets array of exact columns
SCIProwExactGetConstant^⚠: returns the constant of the row
SCIProwExactGetIndex^⚠: get the index of an exact row
SCIProwExactGetLPActivity^⚠: returns the activity of a row in the current LP solution
SCIProwExactGetLPFeasibility^⚠: returns the feasibility of a row in the current LP solution: negative value means infeasibility
SCIProwExactGetLhs^⚠: returns the left hand side of the row
SCIProwExactGetNNonz^⚠: gets the length of a row
SCIProwExactGetPseudoActivity^⚠: returns the pseudo activity of a row in the current pseudo solution
SCIProwExactGetPseudoFeasibility^⚠: returns the pseudo feasibility of a row in the current pseudo solution: negative value means infeasibility
SCIProwExactGetRhs^⚠: returns the right hand side of the row
SCIProwExactGetRow^⚠: returns fp row corresponding to exact row, if it exists. Otherwise returns NULL
SCIProwExactGetRowRhs^⚠: returns rhs-relaxation part of exact row, if it exists. Otherwise returns NULL
SCIProwExactGetSolActivity^⚠: returns the activity of a row for a given solution
SCIProwExactGetSolActivityWithErrorbound^⚠: does activity computation with running error analysis for a row, return TRUE on success
SCIProwExactGetSolFeasibility^⚠: returns the feasibility of a row for the given solution
SCIProwExactGetVals^⚠: gets array with coefficients of nonzero entries
SCIProwExactHasFpRelax^⚠: true if row can be relaxed (possibly as two fp rows)
SCIProwExactIncCoef^⚠: increases value of an existing or nonexisting coefficient in an LP column
SCIProwExactIsInLP^⚠: returns TRUE iff row is member of current LP
SCIProwExactIsModifiable^⚠: return TRUE iff row is modifiable
SCIProwExactLock^⚠: locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows
SCIProwExactPrint^⚠: output column to file stream
SCIProwExactRecalcLPActivity^⚠: recalculates the current activity of a row
SCIProwExactRecalcPseudoActivity^⚠: calculates the current pseudo activity of a row
SCIProwExactRelease^⚠: decreases usage counter of LP row, and frees memory if necessary
SCIProwExactSort^⚠: sorts row entries such that LP columns precede non-LP columns and inside both parts lower column indices precede higher ones
SCIProwExactUnlock^⚠: unlocks a lock of an unmodifiable row; a row with no sealed lock may be modified; has no effect on modifiable rows
SCIProwForceSort^⚠: disables delaying of row sorting, sorts row and merges coefficients with equal columns
SCIProwFree^⚠: frees an LP row
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
SCIProwGetLPActivity^⚠: returns the activity of a row in the current LP solution
SCIProwGetLPDepth^⚠: gets depth in the tree where the row entered the LP, or -1 if it is not in LP
SCIProwGetLPEfficacy^⚠: returns row’s efficacy with respect to the current LP solution: e = -feasibility/norm
SCIProwGetLPFeasibility^⚠: returns the feasibility of a row in the current LP solution: negative value means infeasibility
SCIProwGetLPPos^⚠: gets position of row in current LP, or -1 if it is not in LP
SCIProwGetLPSolCutoffDistance^⚠: returns row’s cutoff distance in the direction of the given primal solution
SCIProwGetLhs^⚠: returns the left hand side of the row
SCIProwGetMaxActivity^⚠: returns the maximal activity of a row w.r.t. the columns’ bounds
SCIProwGetMaxidx^⚠: gets maximal column index of row entries
SCIProwGetMaxval^⚠: gets maximal absolute value of row vector coefficients
SCIProwGetMinActivity^⚠: returns the minimal activity of a row w.r.t. the columns’ bounds
SCIProwGetMinidx^⚠: gets minimal column index of row entries
SCIProwGetMinval^⚠: gets minimal absolute value of row vector’s non-zero coefficients
SCIProwGetNLPEfficacy^⚠: returns row’s efficacy with respect to the NLP solution: e = -feasibility/norm
SCIProwGetNLPFeasibility^⚠: returns the feasibility of a row in the current NLP solution: negative value means infeasibility
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
SCIProwGetNumImpliedIntCols^⚠: gets number of implied integral columns in row
SCIProwGetNumIntCols^⚠: gets number of integral columns in row
SCIProwGetObjParallelism^⚠: gets parallelism of row with objective function: if the returned value is 1, the row is parallel to the objective function, if the value is 0, it is orthogonal to the objective function
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
SCIProwGetPseudoActivity^⚠: returns the pseudo activity of a row in the current pseudo solution
SCIProwGetPseudoFeasibility^⚠: returns the pseudo feasibility of a row in the current pseudo solution: negative value means infeasibility
SCIProwGetRank^⚠: gets rank of row
SCIProwGetRelaxEfficacy^⚠: returns row’s efficacy with respect to the relaxed solution: e = -feasibility/norm
SCIProwGetRelaxFeasibility^⚠: returns the feasibility of a row in the current relaxed solution: negative value means infeasibility
SCIProwGetRhs^⚠: returns the right hand side of the row
SCIProwGetRowExact^⚠: returns exact row corresponding to fprow, if it exists. Otherwise returns NULL
SCIProwGetScalarProduct^⚠: returns the scalar product of the coefficient vectors of the two given rows
SCIProwGetSolActivity^⚠: returns the activity of a row for a given solution
SCIProwGetSolEfficacy^⚠: returns row’s efficacy with respect to the given primal solution: e = -feasibility/norm
SCIProwGetSolFeasibility^⚠: returns the feasibility of a row for the given solution
SCIProwGetSumNorm^⚠: gets sum norm of row vector (sum of absolute values of coefficients)
SCIProwGetVals^⚠: gets array with coefficients of nonzero entries
SCIProwHasExRow^⚠: returns true, if an exact row for this fprow was already created
SCIProwIncCoef^⚠: increases value of an existing or nonexisting coefficient in an LP column
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 if the activity of the row (without the row’s constant) is integral for an optimal solution
SCIProwIsLPEfficacious^⚠: returns whether the row’s efficacy with respect to the current LP solution is greater than the minimal cut efficacy
SCIProwIsLocal^⚠: returns TRUE iff row is only valid locally
SCIProwIsModifiable^⚠: returns TRUE iff row is modifiable during node processing (subject to column generation)
SCIProwIsRedundant^⚠: returns whether the row is unmodifiable and redundant w.r.t. the columns’ bounds
SCIProwIsRemovable^⚠: returns TRUE iff row is removable from the LP (due to aging or cleanup)
SCIProwIsSolEfficacious^⚠: returns whether the row’s efficacy with respect to the given primal solution is greater than the minimal cut efficacy
SCIProwLock^⚠: locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows
SCIProwMakeIntegral^⚠: tries to scale row, s.t. all coefficients become integral
SCIProwMarkNotRemovableLocal^⚠: marks a row to be not removable from the LP in the current node
SCIProwPrint^⚠: output row to file stream
SCIProwRecalcLPActivity^⚠: recalculates the current activity of a row
SCIProwRecalcNorms^⚠: recalculates norms of a row
SCIProwRecalcPseudoActivity^⚠: calculates the current pseudo activity of a row
SCIProwRelease^⚠: decreases usage counter of LP row, and frees memory if necessary
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
SCIProwprepSetCoef^⚠: sets coefficient idx of rowprep
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
SCIPselectCutsDynamic^⚠: perform a cut selection algorithm for the given array of cuts
SCIPselectCutsEnsemble^⚠: perform a cut selection algorithm for the given array of cuts
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.
SCIPselectIntIntPtrPtr^⚠: partial sort of four joint arrays of ints/ints/pointers/pointers, sorted by first array in non-decreasing order around the \p k-th element, see \ref SelectionAlgorithms for more information.
SCIPselectIntIntPtrPtrInterval^⚠: partial sort of five joint arrays of ints/ints/pointers/pointers/interval, 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.
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.
SCIPselectRealPtrPtr^⚠: partial sort of three joint arrays of Reals/Pointer/Pointer, 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.
SCIPselectWeightedIntIntPtrPtr^⚠: partial sort of four joint arrays of ints/ints/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.
SCIPselectWeightedIntIntPtrPtrInterval^⚠: partial sort of five joint arrays of ints/ints/pointers/pointers/interval, 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.
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.
SCIPselectWeightedRealPtrPtr^⚠: partial sort of three joint arrays of Reals/Pointer/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.
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
SCIPsepaMarkExact^⚠: marks the separator as safe to use in exact solving mode
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
SCIPsetAddBoolParam^⚠: creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
SCIPsetAddCharParam^⚠: creates a char parameter, sets it to its default value, and adds it to the parameter set
SCIPsetAddIntParam^⚠: creates a int parameter, sets it to its default value, and adds it to the parameter set
SCIPsetAddLongintParam^⚠: creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
SCIPsetAddRealParam^⚠: creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
SCIPsetAddStringParam^⚠: creates a string parameter, sets it to its default value, and adds it to the parameter set
SCIPsetBarrierconvtol^⚠: returns convergence tolerance used in barrier algorithm
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
SCIPsetBendersObjectiveType^⚠: sets the objective type for the aggregation of the Benders’ decomposition subproblem objectives. This is either the summation of the objective values or a minimax of the objective values (such as for a makespan objective)
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
SCIPsetCalcMemGrowSize^⚠: calculate memory size for dynamically allocated arrays
SCIPsetCalcPathGrowSize^⚠: calculate memory size for path array
SCIPsetCalcTreeGrowSize^⚠: calculate memory size for tree array
SCIPsetCeil^⚠: rounds value - feasibility tolerance up to the next integer in epsilon tolerance
SCIPsetCharParam^⚠: changes the value of an existing char parameter
SCIPsetCheckParamValuePtrUnique^⚠: checks whether the value pointers attached to each parameter are unique
SCIPsetChgBoolParam^⚠: changes the value of an existing SCIP_Bool parameter
SCIPsetChgCharParam^⚠: changes the value of an existing Char parameter
SCIPsetChgIntParam^⚠: changes the value of an existing Int parameter
SCIPsetChgLongintParam^⚠: changes the value of an existing SCIP_Longint parameter
SCIPsetChgParamFixed^⚠: changes the fixing status of an existing parameter
SCIPsetChgRealParam^⚠: changes the value of an existing SCIP_Real parameter
SCIPsetChgStringParam^⚠: changes the value of an existing String 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
SCIPsetConshdlrGetPermsymGraph^⚠: sets permutation symmetry detection graph getter method of constraint handler
SCIPsetConshdlrGetSignedPermsymGraph^⚠: sets signed permutation symmetry detection graph 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
SCIPsetCopyParams^⚠: copies parameters from sourcescip to targetscip
SCIPsetCopyPlugins^⚠: 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.
SCIPsetCreate^⚠: creates global SCIP settings
SCIPsetCutoffbounddelta^⚠: return the delta to use for computing the cutoff bound for integral objectives
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
SCIPsetDebugMessagePrint^⚠
SCIPsetDualfeasCeil^⚠: rounds value - dual feasibility tolerance up to the next integer
SCIPsetDualfeasFloor^⚠: rounds value + dual feasibility tolerance down to the next integer
SCIPsetDualfeasFrac^⚠: returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance
SCIPsetDualfeasRound^⚠: rounds value to the nearest integer in dual feasibility tolerance
SCIPsetDualfeastol^⚠
SCIPsetEmphasis^⚠: sets parameters to
SCIPsetEnableOrDisablePluginClocks^⚠: enable or disable all plugin timers depending on the value of the flag \p enabled
SCIPsetEpsilon^⚠: returns value treated as zero
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
SCIPsetExistsDialog^⚠: returns if the dialog already exists
SCIPsetExitPlugins^⚠: calls exit methods of all plugins
SCIPsetExitprePlugins^⚠: calls exitpre methods of all plugins
SCIPsetExitsolPlugins^⚠: calls exitsol methods of all plugins
SCIPsetExprEnfoAuxValueNonlinear^⚠: sets the auxiliary value of expression for one of the enforcements of an expression
SCIPsetFeasCeil^⚠: rounds value - feasibility tolerance up to the next integer
SCIPsetFeasFloor^⚠: rounds value + feasibility tolerance down to the next integer
SCIPsetFeasFrac^⚠: returns fractional part of value, i.e. x - floor(x) in feasibility tolerance
SCIPsetFeasRound^⚠: rounds value to the nearest integer in feasibility tolerance
SCIPsetFeastol^⚠
SCIPsetFindBanditvtable^⚠: returns the bandit virtual function table of the given name, or NULL if not existing
SCIPsetFindBenders^⚠: returns the Benders’ decomposition of the given name, or NULL if not existing
SCIPsetFindBranchrule^⚠: returns the branching rule of the given name, or NULL if not existing
SCIPsetFindCompr^⚠: returns the tree compression of the given name, or NULL if not existing
SCIPsetFindConcsolverType^⚠: returns the concurrent solver type with the given name, or NULL if not existing
SCIPsetFindConflicthdlr^⚠: returns the conflict handler of the given name, or NULL if not existing
SCIPsetFindConshdlr^⚠: returns the constraint handler of the given name, or NULL if not existing
SCIPsetFindCutsel^⚠: returns the cut selector of the given name, or NULL if not existing
SCIPsetFindDisp^⚠: returns the display column of the given name, or NULL if not existing
SCIPsetFindEventhdlr^⚠: returns the event handler of the given name, or NULL if not existing
SCIPsetFindExprhdlr^⚠: returns the expression handler of the given name, or NULL if not existing
SCIPsetFindHeur^⚠: returns the primal heuristic of the given name, or NULL if not existing
SCIPsetFindIISfinder^⚠: returns the IIS finder of the given name, or NULL if not existing
SCIPsetFindNlpi^⚠: returns the NLPI of the given name, or NULL if not existing
SCIPsetFindNodesel^⚠: returns the node selector of the given name, or NULL if not existing
SCIPsetFindPresol^⚠: returns the presolver of the given name, or NULL if not existing
SCIPsetFindPricer^⚠: returns the variable pricer of the given name, or NULL if not existing
SCIPsetFindProp^⚠: returns the propagator of the given name, or NULL if not existing
SCIPsetFindReader^⚠: returns the file reader of the given name, or NULL if not existing
SCIPsetFindRelax^⚠: returns the relaxator of the given name, or NULL if not existing
SCIPsetFindSepa^⚠: returns the separator of the given name, or NULL if not existing
SCIPsetFindTable^⚠: returns the statistics table of the given name, or NULL if not existing
SCIPsetFloor^⚠: rounds value + feasibility tolerance down to the next integer in epsilon tolerance
SCIPsetFocusnodeLP^⚠: sets whether the LP should be solved at the focus node
SCIPsetFrac^⚠: returns fractional part of value, i.e. x - floor(x) in epsilon tolerance
SCIPsetFree^⚠: frees global SCIP settings
SCIPsetFreeConcsolvers^⚠: frees all concurrent solvers in the concurrent solver list
SCIPsetGammaExp3^⚠: set gamma parameter of Exp.3 bandit algorithm to increase weight of uniform distribution
SCIPsetGetBoolParam^⚠: gets the value of an existing SCIP_Bool parameter
SCIPsetGetCharParam^⚠: gets the value of an existing Char parameter
SCIPsetGetDebugSolData^⚠: returns debug solution data
SCIPsetGetHugeValue^⚠: returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity computation)
SCIPsetGetIntParam^⚠: gets the value of an existing Int parameter
SCIPsetGetLongintParam^⚠: gets the value of an existing SCIP_Longint parameter
SCIPsetGetNParams^⚠: returns the total number of all available SCIP parameters
SCIPsetGetNodesel^⚠: returns node selector with highest priority in the current mode
SCIPsetGetParam^⚠: returns the pointer to the SCIP parameter with the given name
SCIPsetGetParams^⚠: returns the array of all available SCIP parameters
SCIPsetGetPriceMaxvars^⚠: returns the maximal number of variables priced into the LP per round
SCIPsetGetRealParam^⚠: gets the value of an existing SCIP_Real parameter
SCIPsetGetReferencevalue^⚠: returns user defined objective value (in original space) for reference purposes
SCIPsetGetSepaMaxCoefRatioRowprep^⚠: returns the maximal ratio between coefficients to ensure in rowprep cleanup
SCIPsetGetSepaMaxcuts^⚠: returns the maximal number of cuts separated per round
SCIPsetGetSepaMaxcutsGenFactor^⚠: returns factor for the maximal number of cuts generated per round
SCIPsetGetStage^⚠: returns current stage of SCIP
SCIPsetGetStringParam^⚠: gets the value of an existing String parameter
SCIPsetGetSubscipsOff^⚠: returns the flag indicating whether sub-SCIPs that could cause recursion have been deactivated
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
SCIPsetIISfinderCopy^⚠: sets copy method of IIS finder
SCIPsetIISfinderFree^⚠: sets destructor method of IIS finder
SCIPsetIISfinderPriority^⚠: sets the priority of an IIS finder
SCIPsetIncludeBanditvtable^⚠: inserts bandit virtual function table into set
SCIPsetIncludeBenders^⚠: inserts Benders’ decomposition into the Benders’ decomposition list
SCIPsetIncludeBranchrule^⚠: inserts branching rule in branching rule list
SCIPsetIncludeCompr^⚠: inserts tree compression in tree compression list
SCIPsetIncludeConcsolver^⚠: inserts concurrent solver into the concurrent solver list
SCIPsetIncludeConcsolverType^⚠: inserts concurrent solver type into the concurrent solver type list
SCIPsetIncludeConflicthdlr^⚠: inserts conflict handler in conflict handler list
SCIPsetIncludeConshdlr^⚠: inserts constraint handler in constraint handler list
SCIPsetIncludeCutsel^⚠: inserts cut selector in cut selector list
SCIPsetIncludeDialog^⚠: inserts dialog in dialog list
SCIPsetIncludeDisp^⚠: inserts display column in display column list
SCIPsetIncludeEventhdlr^⚠: inserts event handler in event handler list
SCIPsetIncludeExprhdlr^⚠: inserts expression handler in expression handler list
SCIPsetIncludeExternalCode^⚠: inserts information about an external code in external codes list
SCIPsetIncludeHeur^⚠: inserts primal heuristic in primal heuristic list
SCIPsetIncludeIISfinder^⚠: inserts IIS finders in IIS finder list
SCIPsetIncludeNlpi^⚠: inserts NLPI in NLPI list
SCIPsetIncludeNodesel^⚠: inserts node selector in node selector list
SCIPsetIncludePresol^⚠: inserts presolver in presolver list
SCIPsetIncludePricer^⚠: inserts variable pricer in variable pricer list
SCIPsetIncludeProp^⚠: inserts propagator in propagator list
SCIPsetIncludeReader^⚠: inserts file reader in file reader list
SCIPsetIncludeRelax^⚠: inserts relaxator in relaxator list
SCIPsetIncludeSepa^⚠: inserts separator in separator list
SCIPsetIncludeTable^⚠: inserts statistics table in statistics table list
SCIPsetIndexExprVaridx^⚠: sets the index stored in a varidx expression
SCIPsetInfinity^⚠: returns value treated as infinity
SCIPsetInitPlugins^⚠: calls init methods of all plugins
SCIPsetInitializeRandomSeed^⚠: modifies an initial seed value with the global shift of random seeds
SCIPsetInitprePlugins^⚠: calls initpre methods of all plugins
SCIPsetInitsolPlugins^⚠: calls initsol methods of all plugins
SCIPsetIntParam^⚠: changes the value of an existing int parameter
SCIPsetIntarrayVal^⚠: sets value of entry in dynamic array
SCIPsetIsDualfeasEQ^⚠: checks if relative difference of values is in range of dual feasibility tolerance
SCIPsetIsDualfeasFracIntegral^⚠: checks if given fractional part is smaller than dual feasibility tolerance
SCIPsetIsDualfeasGE^⚠: checks if relative difference of val1 and val2 is not lower than -dual feasibility tolerance
SCIPsetIsDualfeasGT^⚠: checks if relative difference of val1 and val2 is greater than dual feasibility tolerance
SCIPsetIsDualfeasIntegral^⚠: checks if value is integral within the dual feasibility bounds
SCIPsetIsDualfeasLE^⚠: checks if relative difference of val1 and val2 is not greater than dual feasibility tolerance
SCIPsetIsDualfeasLT^⚠: checks if relative difference of val1 and val2 is lower than dual feasibility tolerance
SCIPsetIsDualfeasNegative^⚠: checks if value is lower than -dual feasibility tolerance
SCIPsetIsDualfeasPositive^⚠: checks if value is greater than dual feasibility tolerance
SCIPsetIsDualfeasZero^⚠: checks if value is in range dual feasibility tolerance of 0.0
SCIPsetIsEQ^⚠: checks if values are in range of epsilon
SCIPsetIsEfficacious^⚠: checks if the given cut’s efficacy is larger than the minimal cut efficacy
SCIPsetIsFeasEQ^⚠: checks if relative difference of values is in range of feastol
SCIPsetIsFeasFracIntegral^⚠: checks if given fractional part is smaller than feastol
SCIPsetIsFeasGE^⚠: checks if relative difference of val1 and val2 is not lower than -feastol
SCIPsetIsFeasGT^⚠: checks if relative difference of val1 and val2 is greater than feastol
SCIPsetIsFeasIntegral^⚠: checks if value is integral within the feasibility bounds
SCIPsetIsFeasLE^⚠: checks if relative difference of val1 and val2 is not greater than feastol
SCIPsetIsFeasLT^⚠: checks if relative difference of val1 and val2 is lower than feastol
SCIPsetIsFeasNegative^⚠: checks if value is lower than -feasibility tolerance
SCIPsetIsFeasPositive^⚠: checks if value is greater than feasibility tolerance
SCIPsetIsFeasZero^⚠: checks if value is in range feasibility tolerance of 0.0
SCIPsetIsFracIntegral^⚠: checks if given fractional part is smaller than epsilon
SCIPsetIsGE^⚠: checks if val1 is not (more than epsilon) lower than val2
SCIPsetIsGT^⚠: checks if val1 is (more than epsilon) greater than val2
SCIPsetIsHugeValue^⚠: checks if value is huge and should be handled separately (e.g., in activity computation)
SCIPsetIsInfinity^⚠: checks if value is (positive) infinite
SCIPsetIsIntegral^⚠: checks if value is integral within epsilon
SCIPsetIsLE^⚠: checks if val1 is not (more than epsilon) greater than val2
SCIPsetIsLT^⚠: checks if val1 is (more than epsilon) lower than val2
SCIPsetIsLbBetter^⚠: checks if the given new lower bound is at least min(oldub - oldlb, |oldlb|) times the bound strengthening epsilon better than the old one or the change in the lower bound would fix the sign of the variable
SCIPsetIsNegative^⚠: checks if value is lower than -epsilon
SCIPsetIsParamFixed^⚠: gets the fixing status value of an existing parameter
SCIPsetIsPositive^⚠: checks if value is greater than epsilon
SCIPsetIsRelEQ^⚠: checks if relative difference of values is in range of epsilon
SCIPsetIsRelGE^⚠: checks if relative difference of val1 and val2 is not lower than -epsilon
SCIPsetIsRelGT^⚠: checks if relative difference of val1 and val2 is greater than epsilon
SCIPsetIsRelLE^⚠: checks if relative difference of val1 and val2 is not greater than epsilon
SCIPsetIsRelLT^⚠: checks if relative difference of val1 and val2 is lower than epsilon
SCIPsetIsScalingIntegral^⚠: checks whether the product val * scalar is integral in epsilon scaled by scalar
SCIPsetIsSumEQ^⚠: checks if values are in range of sumepsilon
SCIPsetIsSumGE^⚠: checks if val1 is not (more than sumepsilon) lower than val2
SCIPsetIsSumGT^⚠: checks if val1 is (more than sumepsilon) greater than val2
SCIPsetIsSumLE^⚠: checks if val1 is not (more than sumepsilon) greater than val2
SCIPsetIsSumLT^⚠: checks if val1 is (more than sumepsilon) lower than val2
SCIPsetIsSumNegative^⚠: checks if value is lower than -sumepsilon
SCIPsetIsSumPositive^⚠: checks if value is greater than sumepsilon
SCIPsetIsSumRelEQ^⚠: checks if relative difference of values is in range of sumepsilon
SCIPsetIsSumRelGE^⚠: checks if relative difference of val1 and val2 is not lower than -sumepsilon
SCIPsetIsSumRelGT^⚠: checks if relative difference of val1 and val2 is greater than sumepsilon
SCIPsetIsSumRelLE^⚠: checks if relative difference of val1 and val2 is not greater than sumepsilon
SCIPsetIsSumRelLT^⚠: checks if relative difference of val1 and val2 is lower than sumepsilon
SCIPsetIsSumZero^⚠: checks if value is in range sumepsilon of 0.0
SCIPsetIsUbBetter^⚠: checks if the given new upper bound is at least min(oldub - oldlb, |oldub|) times the bound strengthening epsilon better than the old one or the change in the upper bound would fix the sign of the variable
SCIPsetIsUpdateUnreliable^⚠: 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 cancelled out when increasing the value and are random after decreasing it. We dot 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. The idea to get more reliable values 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.
SCIPsetIsZero^⚠: checks if value is in range epsilon of 0.0
SCIPsetLPFeastol^⚠: sets primal feasibility tolerance of LP
SCIPsetLPFeastolFactor^⚠: returns factor w.r.t. primal feasibility tolerance that determines default (and maximal) feasibility tolerance
SCIPsetLicenseConopt^⚠: sets the license to be passed to CONOPT’s COIDEF_License
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)
SCIPsetNlRowCurvature^⚠: set curvature of a nonlinear row
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
SCIPsetParam^⚠: changes the value of an existing parameter
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
SCIPsetPrintDebugMessage^⚠
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
SCIPsetPseudocostdelta^⚠: returns minimal minimal objective distance value to use for pseudo cost updates
SCIPsetPseudocosteps^⚠: returns minimal variable distance value to use for pseudo cost updates
SCIPsetPtrarrayVal^⚠: sets value of entry in dynamic array
SCIPsetRandomSeed^⚠: initializes a random number generator with a given seed
SCIPsetReadParams^⚠: reads parameters from a file
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
SCIPsetRecompfac^⚠: returns minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update
SCIPsetReinsertConshdlrSepaPrio^⚠: reinserts a constraint handler with modified sepa priority into the sepa priority sorted 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
SCIPsetRelaxfeastol^⚠: return the primal feasibility tolerance for relaxations
SCIPsetReoptCompression^⚠: set the @p representation as the new search frontier
SCIPsetResetParam^⚠: resets a single parameters to its default value
SCIPsetResetParams^⚠: resets all parameters to their default values
SCIPsetRootDialog^⚠: makes given dialog the root dialog of SCIP’s interactive user shell; captures dialog and releases former root dialog
SCIPsetRound^⚠: rounds value to the nearest integer in epsilon tolerance
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
SCIPsetSetBarrierconvtol^⚠: sets LP convergence tolerance used in barrier algorithm
SCIPsetSetBoolParam^⚠: changes the value of an existing SCIP_Bool parameter
SCIPsetSetCharParam^⚠: changes the value of an existing Char parameter
SCIPsetSetDefaultBoolParam^⚠: changes the default value of an existing SCIP_Bool parameter
SCIPsetSetDefaultIntParam^⚠: changes the default value of an existing Int parameter
SCIPsetSetDualfeastol^⚠: sets feasibility tolerance for reduced costs in LP solution
SCIPsetSetEmphasis^⚠: sets parameters to
SCIPsetSetFeastol^⚠: sets feasibility tolerance
SCIPsetSetHeuristics^⚠: sets heuristic parameters values to
SCIPsetSetIntParam^⚠: changes the value of an existing Int parameter
SCIPsetSetLimitChanged^⚠: marks that some limit parameter was changed
SCIPsetSetLongintParam^⚠: changes the value of an existing SCIP_Longint parameter
SCIPsetSetParam^⚠: changes the value of an existing parameter
SCIPsetSetPresolving^⚠: sets presolving parameters to
SCIPsetSetPriorityNlpi^⚠: set priority of an NLPI
SCIPsetSetRealParam^⚠: changes the value of an existing SCIP_Real parameter
SCIPsetSetRelaxfeastol^⚠: sets primal feasibility tolerance for relaxations (relaxfeastol)
SCIPsetSetReoptimizationParams^⚠: set parameters for reoptimization
SCIPsetSetSeparating^⚠: sets separating parameters to
SCIPsetSetStringParam^⚠: changes the value of an existing String parameter
SCIPsetSetSubscipsOff^⚠: sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for auxiliary SCIP instances to avoid recursion
SCIPsetSetVerbLevel^⚠: sets verbosity level for message output
SCIPsetSlackVarUb^⚠: sets upper bound for slack variable corresponding to indicator constraint
SCIPsetSolVal^⚠: sets value of variable in primal CIP solution
SCIPsetSolValExact^⚠: sets exact 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
SCIPsetSortBenders^⚠: sorts Benders’ decomposition by priorities
SCIPsetSortBendersName^⚠: sorts Benders’ decomposition by name
SCIPsetSortBranchrules^⚠: sorts branching rules by priorities
SCIPsetSortBranchrulesName^⚠: sorts branching rules by name
SCIPsetSortComprs^⚠: sorts compressions by priorities
SCIPsetSortComprsName^⚠: sorts heuristics by names
SCIPsetSortConflicthdlrs^⚠: sorts conflict handlers by priorities
SCIPsetSortConflicthdlrsName^⚠: sorts conflict handlers by name
SCIPsetSortCutsels^⚠: sorts cut selectors by priorities
SCIPsetSortExprhdlrs^⚠: sorts expression handlers by name
SCIPsetSortHeurs^⚠: sorts heuristics by priorities
SCIPsetSortHeursName^⚠: sorts heuristics by name
SCIPsetSortIISfinders^⚠: sorts the IIS finders by priorities
SCIPsetSortNlpis^⚠: sorts NLPIs by priorities
SCIPsetSortPresols^⚠: sorts presolvers by priorities
SCIPsetSortPresolsName^⚠: sorts presolvers by name
SCIPsetSortPricers^⚠: sorts pricers by priorities
SCIPsetSortPricersName^⚠: sorts pricers by name
SCIPsetSortProps^⚠: sorts propagators by priorities
SCIPsetSortPropsName^⚠: sorts propagators w.r.t. names
SCIPsetSortPropsPresol^⚠: sorts propagators by priorities for presolving
SCIPsetSortRelaxs^⚠: sorts relaxators by priorities
SCIPsetSortRelaxsName^⚠: sorts relaxators by name
SCIPsetSortSepas^⚠: sorts separators by priorities
SCIPsetSortSepasName^⚠: sorts separators by name
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
SCIPsetSumCeil^⚠: rounds value - sumepsilon tolerance up to the next integer
SCIPsetSumFloor^⚠: rounds value + sumepsilon tolerance down to the next integer
SCIPsetSumFrac^⚠: returns fractional part of value, i.e. x - floor(x) in sumepsilon tolerance
SCIPsetSumRound^⚠: rounds value to the nearest integer in sumepsilon tolerance
SCIPsetSumepsilon^⚠: returns value treated as zero for sums of floating point values
SCIPsetVarLastGMIScore^⚠: sets the variable’s last GMI efficacy score value
SCIPsetVarStrongbranchData^⚠: sets strong branching information for a column variable
SCIPsetWriteParams^⚠: writes all parameters in the parameter set to a file
SCIPsetupBendersSubproblem^⚠: calls the generic subproblem setup method for a Benders’ decomposition subproblem
SCIPshouldCertificateTrackBounds^⚠: should the certificate track bound changes?
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
SCIPskipSpace^⚠: increases string pointer as long as it refers to a space character or an explicit space control sequence
SCIPsnprintf^⚠: safe version of snprintf
SCIPsnprintfProbingStats^⚠: print statistics of probing
SCIPsolAdjustImplicitSolVals^⚠: adjusts solution values of implied integral variables in handed solution, solution objective value is not deteriorated by this method
SCIPsolCheck^⚠: checks primal CIP solution for feasibility
SCIPsolCheckOrig^⚠: checks solution for feasibility in original problem without adding it to the solution store
SCIPsolClear^⚠: clears primal CIP solution
SCIPsolComp^⚠: comparison method for sorting solution by decreasing objective value (best solution will be sorted to the end)
SCIPsolCopy^⚠: creates a copy of a primal CIP solution
SCIPsolCreate^⚠: creates primal CIP solution, initialized to zero
SCIPsolCreateCurrentSol^⚠: creates primal CIP solution, initialized to the current solution
SCIPsolCreateCurrentSolExact^⚠: creates primal CIP solution with exact rational values, initialized to the current solution
SCIPsolCreateExact^⚠: creates primal CIP solution with exact rational values, initialized to zero
SCIPsolCreateLPSol^⚠: creates primal CIP solution, initialized to the current LP solution
SCIPsolCreateLPSolExact^⚠: creates primal CIP solution with exact rational values, initialized to the current LP solution
SCIPsolCreateNLPSol^⚠: creates primal CIP solution, initialized to the current NLP solution
SCIPsolCreateOriginal^⚠: creates primal CIP solution in original problem space, initialized to the offset in the original problem
SCIPsolCreateOriginalExact^⚠: creates exact primal CIP solution in original problem space, initialized to the offset in the original problem
SCIPsolCreatePartial^⚠: creates partial primal CIP solution, initialized to unknown values
SCIPsolCreatePseudoSol^⚠: creates primal CIP solution, initialized to the current pseudo solution
SCIPsolCreatePseudoSolExact^⚠: creates primal CIP solution, initialized to the current exact pseudo solution
SCIPsolCreateRelaxSol^⚠: creates primal CIP solution, initialized to the current relaxation solution
SCIPsolCreateUnknown^⚠: creates primal CIP solution, initialized to unknown values
SCIPsolFree^⚠: frees primal CIP solution
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
SCIPsolGetObj^⚠: gets objective value of primal CIP solution in transformed problem
SCIPsolGetObjExact^⚠: gets objective value of primal CIP solution in transformed problem
SCIPsolGetOrigObj^⚠: gets objective value of primal CIP solution which lives in the original problem space
SCIPsolGetOrigObjExact^⚠: gets objective value of primal CIP solution which lives in the original problem space
SCIPsolGetOrigin^⚠: gets origin of solution
SCIPsolGetPrimalIndex^⚠: gets current position of solution in array of existing solutions of primal data
SCIPsolGetRayVal^⚠: returns value of variable in primal ray represented by primal CIP 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
SCIPsolGetVal^⚠: returns value of variable in primal CIP solution
SCIPsolGetValExact^⚠: returns value of variable in primal CIP solution
SCIPsolIncVal^⚠: increases value of variable in primal CIP solution
SCIPsolIsExact^⚠: returns whether a solution is an exact rational solution
SCIPsolIsOriginal^⚠: returns whether the given solution is defined on original variables
SCIPsolIsPartial^⚠: returns whether the given solution is partial
SCIPsolLinkCurrentSol^⚠: copies current solution (LP or pseudo solution) into CIP solution by linking
SCIPsolLinkLPSol^⚠: copies current LP solution into CIP solution by linking
SCIPsolLinkLPSolExact^⚠: copies current exact LP solution into CIP solution by linking
SCIPsolLinkNLPSol^⚠: copies current NLP solution into CIP solution by linking
SCIPsolLinkPseudoSol^⚠: copies current pseudo solution into CIP solution by linking
SCIPsolLinkPseudoSolExact^⚠: copies current pseudo solution into CIP solution by linking
SCIPsolLinkRelaxSol^⚠: copies current relaxation solution into CIP solution by linking
SCIPsolMakeExact^⚠: copies the real values to the exact arrays of the solution
SCIPsolMakeReal^⚠: approximates and copies the exact values to the real arrays of the solution and frees the exact data
SCIPsolMarkPartial^⚠
SCIPsolOrigAddObjval^⚠: adds value to the objective value of a given original primal CIP solution
SCIPsolOrigAddObjvalExact^⚠: adds value to the objective value of a given original primal CIP solution
SCIPsolOverwriteFPSolWithExact^⚠: overwrite FP solution with exact values
SCIPsolPrint^⚠: outputs non-zero elements of solution to file stream
SCIPsolPrintExact^⚠: outputs non-zero elements of solution to file stream
SCIPsolPrintRay^⚠: outputs non-zero elements of solution representing a ray to file stream
SCIPsolRecomputeInternObjExact^⚠: recomputes the objective value of an exact solution, e.g., when initialized from a real solution
SCIPsolRecomputeObj^⚠: 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)
SCIPsolResetViolations^⚠: reset violations of a solution
SCIPsolRetransform^⚠: retransforms solution to original problem space
SCIPsolRetransformExact^⚠: retransforms exact part of solution to original problem space
SCIPsolRound^⚠: try to round given solution
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
SCIPsolSetOrigin^⚠: set new origin type for a solution
SCIPsolSetPrimalIndex^⚠: sets current position of solution in array of existing solutions of primal data
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
SCIPsolSetUnknown^⚠: declares all entries in the primal CIP solution to be unknown
SCIPsolSetVal^⚠: sets value of variable in primal CIP solution
SCIPsolSetValExact^⚠: sets value of variable in primal CIP solution
SCIPsolTransform^⚠: transformes given original solution to the transformed space; a corresponding transformed solution has to be given which is copied into the existing solution and freed afterwards
SCIPsolUnlink^⚠: stores solution values of variables in solution’s own array
SCIPsolUnlinkExact^⚠: stores solution values of variables in solution’s own array
SCIPsolUpdateBoundViolation^⚠: update bound violation of a solution
SCIPsolUpdateConsViolation^⚠: update constraint violation of a solution
SCIPsolUpdateIntegralityViolation^⚠: update integrality violation of a solution
SCIPsolUpdateLPConsViolation^⚠: update violation of a constraint that is represented in the LP
SCIPsolUpdateLPRowViolation^⚠: update LP row violation of a solution
SCIPsolUpdateVarObj^⚠: updates primal solutions after a change in a variable’s objective value
SCIPsolUpdateVarsum^⚠: updates the solution value sums in variables by adding the value in the given solution
SCIPsolsAreEqual^⚠: returns whether the given solutions in transformed space are equal
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 the configured concurrent solvers
SCIPsolveCumulative^⚠: solves given cumulative condition as independent sub problem
SCIPsolveDiveLP^⚠: solves the LP of the current dive; no separation or pricing is applied
SCIPsolveExactDiveLP^⚠: solves the exact 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
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
SCIPsortArgsortInt^⚠: implements argsort
SCIPsortArgsortPtr^⚠: implements argsort
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/Pointer/Pointer, 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
SCIPsortIntIntPtrPtr^⚠: sort of four joint arrays of ints/ints/pointers/pointers/ sorted by first array in non-decreasing order
SCIPsortIntIntPtrPtrInterval^⚠: sort of five joint arrays of ints/ints/pointers/pointers/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
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
SCIPsortRealPtrPtr^⚠: sort of three joint arrays of Reals/Pointers/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/Pointer/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
SCIPsortedvecDelPosIntIntPtrPtr^⚠: delete the element at the given position from four joint arrays of ints/ints/pointers/pointers, sorted by first array in non-decreasing order
SCIPsortedvecDelPosIntIntPtrPtrInterval^⚠: delete the element at the given position from five joint arrays of ints/ints/pointers/pointers/interval, 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
SCIPsortedvecDelPosRealPtrPtr^⚠: delete the element at the given position from three joint arrays of Reals/Pointer/Pointer, 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/Pointer/Pointer, 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
SCIPsortedvecInsertIntIntPtrPtr^⚠: insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order
SCIPsortedvecInsertIntIntPtrPtrInterval^⚠: 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
SCIPsortedvecInsertRealPtrPtr^⚠: insert a new element into three joint arrays of Reals/Pointer/Pointer, 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
SCIPstartExactDive^⚠: initiates exact LP diving, making methods SCIPchgVarObjExactDive(), SCIPchgVarLbExactDive(), and SCIPchgVarUbExactDive() available
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
SCIPstatusName^⚠: gets name for a solution status
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
SCIPstoreCertificateActiveAggrInfo^⚠: stores the active aggregation information in the certificate data structures for a row
SCIPstoreCertificateActiveMirInfo^⚠: stores the active mir information in the certificate data structures for a row
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
SCIPstrToRationalValue^⚠: extract the next token as a rational value if it is one; in case no value is parsed the endptr is set to @p desc
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
SCIPstrcasecmp^⚠: portable version of strcasecmp for case-insensitive comparison of two strings
SCIPstrncasecmp^⚠: portable version of strncasecmp for case-insensitive comparison of two strings up to a given number of characters
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
SCIPsymEQ^⚠: helper function to test if val1 = val2 while permitting infinity-values
SCIPsymGE^⚠: helper function to test if val1 >= val2 while permitting infinity-values
SCIPsymGT^⚠: helper function to test if val1 > val2 while permitting infinity-values
SCIPsymLE^⚠: helper function to test if val1 <= val2 while permitting infinity-values
SCIPsymLT^⚠: helper function to test if val1 < val2 while permitting infinity-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 (or patch) 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
SCIPtightenVarLbExact^⚠: changes exact 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
SCIPtightenVarUbExact^⚠: changes exact 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
SCIPtreeAddDiveBoundChange^⚠: adds a diving bound change to the tree together with the information if this is a bound change for the preferred direction or not
SCIPtreeBacktrackProbing^⚠: 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 SCIPtreeCreateProbingNode() cannot be undone
SCIPtreeBranchVar^⚠: branches on a variable x if x is a continuous variable, then two child nodes will be created (x <= x’, x >= x’) but if the bounds of x are such that their relative difference is smaller than epsilon, the variable is fixed to val (if not SCIP_INVALID) or a well chosen alternative in the current node, i.e., no children are created if x is not a continuous variable, then: 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 x 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) if solution value is equal to one of the bounds and the other bound is infinite, only two child nodes will be created (the third one would be infeasible anyway)
SCIPtreeBranchVarExact^⚠: branches on a variable x; unlike the fp-version this will also branch x <= floor(x’), x >= ceil(x’) if x’ is very close to being integral at one of its bounds; in the fp version this case would be branched in the middle of the domain; not meant for branching on a continuous variables
SCIPtreeBranchVarHole^⚠: branches a variable x using the given domain hole; two child nodes will be created (x <= left, x >= right)
SCIPtreeBranchVarNary^⚠: n-ary branching on a variable x Branches on variable x such that up to n/2 children are created on each side of the usual branching value. The branching value is selected as in SCIPtreeBranchVar(). If n is 2 or the variables local domain is too small for a branching into n pieces, SCIPtreeBranchVar() is called. The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes. If n is odd, one child with domain width ‘width’ and having the branching value in the middle is created. Otherwise, two children with domain width ‘width’ and being left and right of the branching value are created. Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance from the first nodes. The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value. If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
SCIPtreeCalcChildEstimate^⚠: 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
SCIPtreeCalcNodeselPriority^⚠: 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
SCIPtreeClear^⚠: clears and resets tree data structure and deletes all nodes
SCIPtreeClearDiveBoundChanges^⚠: clear the tree dive bound change data structure
SCIPtreeCreate^⚠: creates an initialized tree data structure
SCIPtreeCreatePresolvingRoot^⚠: creates a temporary presolving root node of the tree and installs it as focus node
SCIPtreeCreateProbingNode^⚠: creates a new probing child node in the probing path
SCIPtreeCreateRoot^⚠: creates the root node of the tree and puts it into the leaves queue
SCIPtreeCutoff^⚠: cuts off nodes with lower bound not better than given upper bound
SCIPtreeEndProbing^⚠: switches back from probing to normal operation mode, frees all nodes on the probing path, restores bounds of all variables and restores active constraints arrays of focus node
SCIPtreeFree^⚠: frees tree data structure
SCIPtreeFreePresolvingRoot^⚠: frees the temporary presolving root and resets tree data structure
SCIPtreeGetAvgLowerbound^⚠: gets the average lower bound of all nodes in the tree
SCIPtreeGetBestChild^⚠: gets the best child of the focus node w.r.t. the node selection strategy
SCIPtreeGetBestLeaf^⚠: gets the best leaf from the node queue w.r.t. the node selection strategy
SCIPtreeGetBestNode^⚠: gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
SCIPtreeGetBestSibling^⚠: gets the best sibling of the focus node w.r.t. the node selection strategy
SCIPtreeGetCurrentDepth^⚠: gets depth of current node in the tree, i.e. the length of the active path minus 1, or -1 if no current node exists
SCIPtreeGetCurrentNode^⚠: gets current node of the tree, i.e. the last node in the active path, or NULL if no current node exists
SCIPtreeGetDiveBoundChangeData^⚠: get the dive bound change data for the preferred or the alternative direction
SCIPtreeGetEffectiveRootDepth^⚠: returns the depth of the effective root node (i.e. the first depth level of a node with at least two children)
SCIPtreeGetFocusDepth^⚠: gets depth of focus node in the tree, or -1 if no focus node exists
SCIPtreeGetFocusNode^⚠: gets focus node of the tree
SCIPtreeGetLowerbound^⚠: gets the minimal lower bound of all nodes in the tree
SCIPtreeGetLowerboundExact^⚠: gets the minimal exact lower bound of all nodes in the tree or NULL if empty
SCIPtreeGetLowerboundNode^⚠: gets the node with minimal lower bound of all nodes in the tree (child, sibling, or leaf)
SCIPtreeGetNChildren^⚠: gets number of children of the focus node
SCIPtreeGetNLeaves^⚠: gets number of leaves in the tree (excluding children and siblings of focus nodes)
SCIPtreeGetNNodes^⚠: gets number of open nodes in the tree (children + siblings + leaves)
SCIPtreeGetNSiblings^⚠: gets number of siblings of the focus node
SCIPtreeGetNodesel^⚠: returns the node selector associated with the given node priority queue
SCIPtreeGetPrioChild^⚠: gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
SCIPtreeGetPrioSibling^⚠: gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
SCIPtreeGetProbingDepth^⚠: returns the current probing depth, i.e. the number of probing sub nodes existing in the probing path
SCIPtreeGetProbingRoot^⚠: returns the temporary probing root node, or NULL if the we are not in probing mode
SCIPtreeGetRootNode^⚠: gets the root node of the tree
SCIPtreeHasCurrentNodeLP^⚠: returns whether the LP was or is to be solved in the current node
SCIPtreeHasFocusNodeLP^⚠: returns whether the LP was or is to be solved in the focus node
SCIPtreeInRepropagation^⚠: returns whether the focus node is already solved and only propagated again
SCIPtreeIsFocusNodeLPConstructed^⚠: returns whether the LP of the focus node is already constructed
SCIPtreeIsPathComplete^⚠: returns whether the active path goes completely down to the focus node
SCIPtreeLoadLP^⚠: constructs the LP relaxation of the focus node
SCIPtreeLoadLPState^⚠: loads LP state for fork/subroot of the focus node
SCIPtreeLoadProbingLPState^⚠: loads the LP state for the current probing node
SCIPtreeMarkProbingNodeHasLP^⚠: marks the probing node to have a solved LP relaxation
SCIPtreeMarkProbingObjChanged^⚠: marks the current probing node to have a changed objective function
SCIPtreeProbing^⚠: returns whether the current node is a temporary probing node
SCIPtreeProbingObjChanged^⚠: returns whether we are in probing and the objective value of at least one column was changed
SCIPtreeRestoreRelaxSol^⚠: restores relaxation solution after diving or probing
SCIPtreeSetFocusNodeLP^⚠: sets mark to solve or to ignore the LP while processing the focus node
SCIPtreeSetNodesel^⚠: sets the node selector used for sorting the nodes in the priority queue, and resorts the queue if necessary
SCIPtreeSetProbingLPState^⚠: sets the LP state for the current probing node
SCIPtreeStartProbing^⚠: switches to probing mode and creates a probing root
SCIPtreeStoreRelaxSol^⚠: stores relaxation solution before diving or probing
SCIPtreeWasNodeLastBranchParent^⚠: query if focus node was already branched on
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
SCIPtrySolFreeExact^⚠: checks exact 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
SCIPunlinkSolExact^⚠: stores exact 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 (higher for minimization, lower for maximization) than the node’s dual bound, sets the node’s dual bound to the new value.
SCIPupdateNodeLowerbound^⚠: if given value is higher 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
SCIPupdateVarAncPseudocost^⚠: updates the ancestor pseudo costs of the given variable and the global ancestor 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
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
SCIPvalidateSolveExact^⚠: validate the result of an exact solve
SCIPvalsExactCopy^⚠: creates a copy of a primal CIP solution
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
SCIPvarGetAggrConstantExact^⚠: 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
SCIPvarGetAggrScalarExact^⚠: 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
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
SCIPvarGetBestBoundGlobalExact^⚠: 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
SCIPvarGetBestBoundLocalExact^⚠: 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
SCIPvarGetBestBoundTypeExact^⚠: 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
SCIPvarGetCertificateIndex^⚠: returns position of variable in certificate
SCIPvarGetCliques^⚠: gets array of cliques, the active variable is contained in
SCIPvarGetCol^⚠: gets column of COLUMN variable
SCIPvarGetColExact^⚠: 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.
SCIPvarGetImplType^⚠: gets the implied integral type of the variable
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
SCIPvarGetLPSolExact^⚠: gets primal LP solution value of variable
SCIPvarGetLPSolExact_rec^⚠: 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
SCIPvarGetLbCertificateIndexGlobal^⚠: returns index of variable bound in vipr certificate
SCIPvarGetLbCertificateIndexLocal^⚠: returns index of variable bound in vipr certificate
SCIPvarGetLbGlobal^⚠: gets global lower bound of variable
SCIPvarGetLbGlobalExact^⚠: gets global lower bound of variable
SCIPvarGetLbLazy^⚠: gets lazy lower bound of variable
SCIPvarGetLbLocal^⚠: gets current lower bound of variable
SCIPvarGetLbLocalExact^⚠: gets current lower bound of variable
SCIPvarGetLbOriginal^⚠: gets original lower bound of original problem variable (i.e. the bound set in problem creation)
SCIPvarGetLbOriginalExact^⚠: 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
SCIPvarGetMaxAggrCoef^⚠: gets upper bound on absolute coefficient of a loose variable in (multi)aggregations of other variables
SCIPvarGetMinAggrCoef^⚠: gets lower bound on absolute coefficient of a loose variable in (multi)aggregations of other variables
SCIPvarGetMultaggrConstant^⚠: gets aggregation constant c of a multi aggregated variable x = a0*y0 + … + a(n-1)*y(n-1) + c
SCIPvarGetMultaggrConstantExact^⚠: gets exact 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
SCIPvarGetMultaggrScalarsExact^⚠: gets vector of exact 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
SCIPvarGetObjExact^⚠: gets objective function value of variable
SCIPvarGetObjInterval^⚠: gets exact 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
SCIPvarGetOrigvarSumExact^⚠: 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
SCIPvarGetProbvarBoundExact^⚠: transforms given variable, boundtype and exact 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
SCIPvarGetPseudoSolExact^⚠: gets pseudo solution value of variable
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
SCIPvarGetSolExact^⚠: gets current LP or pseudo solution value of variable
SCIPvarGetStatus^⚠: gets status of variable
SCIPvarGetStatusExact^⚠: returns the status of the exact variable data
SCIPvarGetTransVar^⚠: gets transformed variable of ORIGINAL variable
SCIPvarGetType^⚠: gets type of variable
SCIPvarGetUbCertificateIndexGlobal^⚠: returns index of variable bound in vipr certificate
SCIPvarGetUbCertificateIndexLocal^⚠: returns index of variable bound in vipr certificate
SCIPvarGetUbGlobal^⚠: gets global upper bound of variable
SCIPvarGetUbGlobalExact^⚠: gets global upper bound of variable
SCIPvarGetUbLazy^⚠: gets lazy upper bound of variable
SCIPvarGetUbLocal^⚠: gets current upper bound of variable
SCIPvarGetUbLocalExact^⚠: gets current upper bound of variable
SCIPvarGetUbOriginal^⚠: gets original upper bound of original problem variable (i.e. the bound set in problem creation)
SCIPvarGetUbOriginalExact^⚠: 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
SCIPvarGetWorstBoundGlobalExact^⚠: 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
SCIPvarGetWorstBoundLocalExact^⚠: 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
SCIPvarGetWorstBoundTypeExact^⚠: 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
SCIPvarIsExact^⚠: returns whether the variable has exact variable data
SCIPvarIsHashkeyEq^⚠: returns TRUE iff the indices of both variables are equal
SCIPvarIsImpliedIntegral^⚠: returns whether variable is implied integral (weakly or strongly)
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 implied integral of any type)
SCIPvarIsNegated^⚠: returns whether the variable was created by negation of a different variable
SCIPvarIsNonimpliedIntegral^⚠: returns TRUE if the variable is integral, but not implied integral.
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
SCIPvarSetCertificateIndex^⚠: sets index of variable in certificate
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
SCIPvarSetLbCertificateIndexGlobal^⚠: sets index of variable in certificate
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
SCIPvarSetUbCertificateIndexGlobal^⚠: sets index of variable in certificate
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.
SCIPvarsCountTypes^⚠: for a given array of variables, this function counts the numbers of variables for each variable and implied type combination
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 SCIP version number as major + minor / 100
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
SCIPwriteDatatreeJson^⚠: writes a SCIP_DATATREE object as JSON to a file
SCIPwriteGms^⚠: writes problem to file
SCIPwriteLP^⚠: writes current LP to a file
SCIPwriteLPexact^⚠: writes current exact 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
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>
SCIPwriteVarsLinearsumExact^⚠: print the given variables and rational 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 monomials as polynomial in the following form c1 <x11>^e11 <x12>^e12 … <x1n>^e1n + c2 <x21>^e21 <x22>^e22 … + … + cn <xn1>^en1 …
_Exit^⚠
__assert_rtn^⚠
__ceilf16^⚠
__copysignf16^⚠
__cospi^⚠
__cospif^⚠
__exp10^⚠
__exp10f^⚠
__fabsf16^⚠
__floorf16^⚠
__fmaf16^⚠
__fmaxf16^⚠
__fminf16^⚠
__fpclassifyd^⚠
__fpclassifyf^⚠
__fpclassifyl^⚠
__hypotf16^⚠
__math_errhandling^⚠
__nextafterf16^⚠
__rintf16^⚠
__roundf16^⚠
__sincos_stret^⚠
__sincosf_stret^⚠
__sincospi_stret^⚠
__sincospif_stret^⚠
__sinpi^⚠
__sinpif^⚠
__snprintf_chk^⚠
__sprintf_chk^⚠
__sqrtf16^⚠
__srget^⚠
__svfscanf^⚠
__swbuf^⚠
__tanpi^⚠
__tanpif^⚠
__truncf16^⚠
__vsnprintf_chk^⚠
__vsprintf_chk^⚠
a64l^⚠
abort^⚠
abs^⚠
acos^⚠
acosf^⚠
acosh^⚠
acoshf^⚠
acoshl^⚠
acosl^⚠
aligned_alloc^⚠
alloca^⚠
arc4random^⚠
arc4random_addrandom^⚠
arc4random_buf^⚠
arc4random_stir^⚠
arc4random_uniform^⚠
asin^⚠
asinf^⚠
asinh^⚠
asinhf^⚠
asinhl^⚠
asinl^⚠
asprintf^⚠
at_quick_exit^⚠
atan^⚠
atan2^⚠
atan2f^⚠
atan2l^⚠
atanf^⚠
atanh^⚠
atanhf^⚠
atanhl^⚠
atanl^⚠
atexit^⚠
atexit_b^⚠
atof^⚠
atoi^⚠
atol^⚠
atoll^⚠
bcmp^⚠
bcopy^⚠
bsearch^⚠
bsearch_b^⚠
bzero^⚠
calloc^⚠
cbrt^⚠
cbrtf^⚠
cbrtl^⚠
ceil^⚠
ceilf^⚠
ceill^⚠
cgetcap^⚠
cgetclose^⚠
cgetent^⚠
cgetfirst^⚠
cgetmatch^⚠
cgetnext^⚠
cgetnum^⚠
cgetset^⚠
cgetstr^⚠
cgetustr^⚠
clearerr^⚠
colLink^⚠: insert column coefficients in corresponding rows
colUnlink^⚠: removes column coefficients from corresponding rows
copysign^⚠
copysignf^⚠
copysignl^⚠
cos^⚠
cosf^⚠
cosh^⚠
coshf^⚠
coshl^⚠
cosl^⚠
ctermid^⚠
ctermid_r^⚠
daemon^⚠
devname^⚠
devname_r^⚠
div^⚠
dprintf^⚠
drand48^⚠
ecvt^⚠
erand48^⚠
erf^⚠
erfc^⚠
erfcf^⚠
erfcl^⚠
erff^⚠
erfl^⚠
exit^⚠
exp^⚠
exp2^⚠
exp2f^⚠
exp2l^⚠
expf^⚠
expl^⚠
expm1^⚠
expm1f^⚠
expm1l^⚠
fabs^⚠
fabsf^⚠
fabsl^⚠
fclose^⚠
fcvt^⚠
fdim^⚠
fdimf^⚠
fdiml^⚠
fdopen^⚠
feof^⚠
ferror^⚠
fflush^⚠
ffs^⚠
ffsl^⚠
ffsll^⚠
fgetc^⚠
fgetln^⚠
fgetpos^⚠
fgets^⚠
fileno^⚠
flockfile^⚠
floor^⚠
floorf^⚠
floorl^⚠
fls^⚠
flsl^⚠
flsll^⚠
fma^⚠
fmaf^⚠
fmal^⚠
fmax^⚠
fmaxf^⚠
fmaxl^⚠
fmemopen^⚠
fmin^⚠
fminf^⚠
fminl^⚠
fmod^⚠
fmodf^⚠
fmodl^⚠
fmtcheck^⚠
fopen^⚠
fprintf^⚠
fpurge^⚠
fputc^⚠
fputs^⚠
fread^⚠
free^⚠
freopen^⚠
frexp^⚠
frexpf^⚠
frexpl^⚠
fscanf^⚠
fseek^⚠
fseeko^⚠
fsetpos^⚠
ftell^⚠
ftello^⚠
ftrylockfile^⚠
funlockfile^⚠
funopen^⚠
fwrite^⚠
gcvt^⚠
getbsize^⚠
getc^⚠
getc_unlocked^⚠
getchar^⚠
getchar_unlocked^⚠
getdelim^⚠
getenv^⚠
getiopolicy_np^⚠
getline^⚠
getloadavg^⚠
getpriority^⚠
getprogname^⚠
getrlimit^⚠
getrusage^⚠
gets^⚠
getsubopt^⚠
getw^⚠
grantpt^⚠
heapsort^⚠
heapsort_b^⚠
hypot^⚠
hypotf^⚠
hypotl^⚠
ilogb^⚠
ilogbf^⚠
ilogbl^⚠
imaxabs^⚠
imaxdiv^⚠
index^⚠
initstate^⚠
j0^⚠
j1^⚠
jn^⚠
jrand48^⚠
l64a^⚠
labs^⚠
lcong48^⚠
ldexp^⚠
ldexpf^⚠
ldexpl^⚠
ldiv^⚠
lgamma^⚠
lgammaf^⚠
lgammal^⚠
llabs^⚠
lldiv^⚠
llrint^⚠
llrintf^⚠
llrintl^⚠
llround^⚠
llroundf^⚠
llroundl^⚠
log^⚠
log2^⚠
log1p^⚠
log1pf^⚠
log1pl^⚠
log2f^⚠
log2l^⚠
log10^⚠
log10f^⚠
log10l^⚠
logb^⚠
logbf^⚠
logbl^⚠
logf^⚠
logl^⚠
lrand48^⚠
lrint^⚠
lrintf^⚠
lrintl^⚠
lround^⚠
lroundf^⚠
lroundl^⚠
malloc^⚠
malloc_type_aligned_alloc^⚠
malloc_type_calloc^⚠
malloc_type_free^⚠
malloc_type_malloc^⚠
malloc_type_posix_memalign^⚠
malloc_type_realloc^⚠
malloc_type_valloc^⚠
malloc_type_zone_calloc^⚠
malloc_type_zone_free^⚠
malloc_type_zone_malloc^⚠
malloc_type_zone_memalign^⚠
malloc_type_zone_realloc^⚠
malloc_type_zone_valloc^⚠
mblen^⚠
mbstowcs^⚠
mbtowc^⚠
memccpy^⚠
memchr^⚠
memcmp^⚠
memcpy^⚠
memmem^⚠
memmove^⚠
memset^⚠
memset_pattern4^⚠
memset_pattern8^⚠
memset_pattern16^⚠
memset_s^⚠
mergesort^⚠
mergesort_b^⚠
mkstemp^⚠
mktemp^⚠
modf^⚠
modff^⚠
modfl^⚠
mrand48^⚠
nan^⚠
nanf^⚠
nanl^⚠
nearbyint^⚠
nearbyintf^⚠
nearbyintl^⚠
nextafter^⚠
nextafterf^⚠
nextafterl^⚠
nexttoward^⚠
nexttowardf^⚠
nexttowardl^⚠
nrand48^⚠
open_memstream^⚠
pclose^⚠
perror^⚠
popen^⚠
posix_memalign^⚠
posix_openpt^⚠
pow^⚠
powf^⚠
powl^⚠
printf^⚠
psort^⚠
psort_b^⚠
psort_r^⚠
ptsname^⚠
ptsname_r^⚠
putc^⚠
putc_unlocked^⚠
putchar^⚠
putchar_unlocked^⚠
putenv^⚠
puts^⚠
putw^⚠
qsort^⚠
qsort_b^⚠
qsort_r^⚠
quick_exit^⚠
radixsort^⚠
rand^⚠
rand_r^⚠
random^⚠
realloc^⚠
reallocf^⚠
realpath^⚠
remainder^⚠
remainderf^⚠
remainderl^⚠
remove^⚠
remquo^⚠
remquof^⚠
remquol^⚠
rename^⚠
renameat^⚠
renameatx_np^⚠
renamex_np^⚠
rewind^⚠
rindex^⚠
rint^⚠
rintf^⚠
rintl^⚠
round^⚠
roundf^⚠
roundl^⚠
rowLink^⚠: insert row coefficients in corresponding columns
rowUnlink^⚠: removes row coefficients from corresponding columns
rpmatch^⚠
scalb^⚠
scalbln^⚠
scalblnf^⚠
scalblnl^⚠
scalbn^⚠
scalbnf^⚠
scalbnl^⚠
scanf^⚠
seed48^⚠
setbuf^⚠
setbuffer^⚠
setenv^⚠
setiopolicy_np^⚠
setkey^⚠
setlinebuf^⚠
setpriority^⚠
setprogname^⚠
setrlimit^⚠
setstate^⚠
setvbuf^⚠
signal^⚠
sin^⚠
sinf^⚠
sinh^⚠
sinhf^⚠
sinhl^⚠
sinl^⚠
snprintf^⚠
sprintf^⚠
sqrt^⚠
sqrtf^⚠
sqrtl^⚠
sradixsort^⚠
srand^⚠
srand48^⚠
sranddev^⚠
srandom^⚠
srandomdev^⚠
sscanf^⚠
stpcpy^⚠
stpncpy^⚠
strcasecmp^⚠
strcasestr^⚠
strcat^⚠
strchr^⚠
strchrnul^⚠
strcmp^⚠
strcoll^⚠
strcpy^⚠
strcspn^⚠
strdup^⚠
strerror^⚠
strerror_r^⚠
strlcat^⚠
strlcpy^⚠
strlen^⚠
strmode^⚠
strncasecmp^⚠
strncat^⚠
strncmp^⚠
strncpy^⚠
strndup^⚠
strnlen^⚠
strnstr^⚠
strpbrk^⚠
strrchr^⚠
strsep^⚠
strsignal^⚠
strsignal_r^⚠
strspn^⚠
strstr^⚠
strtod^⚠
strtof^⚠
strtoimax^⚠
strtok^⚠
strtok_r^⚠
strtol^⚠
strtold^⚠
strtoll^⚠
strtonum^⚠
strtoq^⚠
strtoul^⚠
strtoull^⚠
strtoumax^⚠
strtouq^⚠
strxfrm^⚠
swab^⚠
system^⚠
tan^⚠
tanf^⚠
tanh^⚠
tanhf^⚠
tanhl^⚠
tanl^⚠
tempnam^⚠
tgamma^⚠
tgammaf^⚠
tgammal^⚠
timingsafe_bcmp^⚠
tmpfile^⚠
tmpnam^⚠
trunc^⚠
truncf^⚠
truncl^⚠
ungetc^⚠
unlockpt^⚠
unsetenv^⚠
valloc^⚠
vasprintf^⚠
vdprintf^⚠
vfprintf^⚠
vfscanf^⚠
vprintf^⚠
vscanf^⚠
vsnprintf^⚠
vsprintf^⚠
vsscanf^⚠
wait^⚠
wait3^⚠
wait4^⚠
waitid^⚠
waitpid^⚠
wcstoimax^⚠
wcstombs^⚠
wcstoumax^⚠
wctomb^⚠
y0^⚠
y1^⚠
yn^⚠

Type Aliases§

BMS_BLKMEM: Block Memory Management
BMS_BUFMEM: Buffer Memory Management
BMS_CHKMEM: Chunk Memory Management
FILE
Ps_dualcostsel
Reopt_ConsType
SCIP
SCIP_AGGREGATE
SCIP_AGGREGATEEXACT
SCIP_AGGREGATIONINFO
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_BendersObjectiveType
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_CERTIFICATE
SCIP_CERTIFICATEBOUND
SCIP_CERTNODEDATA
SCIP_CHILD: child information (should not exceed the size of a pointer)
SCIP_CLIQUE
SCIP_CLIQUELIST
SCIP_CLIQUETABLE
SCIP_CLOCK
SCIP_COL: column of an LP
SCIP_COLEXACT: column of an exact LP
SCIP_COLEXACTSOLVALS
SCIP_COLSOLVALS: collected values of a column which depend on the LP solution We store these values in each column to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP. Note that we do not store the farkascoef value since we do expect a node with infeasible LP to be pruned anyway.
SCIP_COMPR
SCIP_COMPRDATA
SCIP_CONCSOLVER
SCIP_CONCSOLVERDATA
SCIP_CONCSOLVERTYPE
SCIP_CONCSOLVERTYPEDATA
SCIP_CONFLICT
SCIP_CONFLICTHDLR
SCIP_CONFLICTHDLRDATA
SCIP_CONFLICTROW
SCIP_CONFLICTSET
SCIP_CONFLICTSTORE
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_DATATREE: generic hierarchical data storage
SCIP_DEBUGSOLDATA: solution data for debugging purposes
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_DOMEXACT
SCIP_Datatree_Valuetype: type of values stored in a SCIP_DATATREE
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_EVENTTYPEIMPLCHG
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: fork with solved LP, where bounds and constraints have been changed, and rows and columns were added
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_IISFINDER
SCIP_IISFINDERDATA
SCIP_IMPLICS
SCIP_INFERENCEDATA
SCIP_INTARRAY: dynamic array for storing int values
SCIP_INTERVAL: interval given by infimum and supremum
SCIP_ImplintType: implied integral type
SCIP_IsFpRepresentable: information if a rational is exactly representable as a floating point number
SCIP_JUNCTION: fork without LP solution, where only bounds and constraints have been changed
SCIP_LEAF: leaf information (should not exceed the size of a pointer)
SCIP_LINCONSSTATS
SCIP_LINCONSUPGRADE: @addtogroup CONSHDLRS
SCIP_LINELIST
SCIP_LOOSE
SCIP_LP: LP structure
SCIP_LPAlgo: type of LP algorithm
SCIP_LPBDCHGS
SCIP_LPEXACT: exact LP structure
SCIP_LPEXACTSOLVALS
SCIP_LPI
SCIP_LPIEXACT
SCIP_LPINORMS
SCIP_LPISTATE
SCIP_LPParam: LP solver parameters
SCIP_LPSOLVALS: collected values of the LP data which depend on the LP solution We store these values to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP.
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_MATRIXVALSEXACT
SCIP_MESSAGEHDLR
SCIP_MESSAGEHDLRDATA
SCIP_MIRINFO
SCIP_MONOTONE: monotonicity
SCIP_MULTAGGR
SCIP_MULTAGGREXACT
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: node data structure
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: bound change information for pending bound changes
SCIP_PQUEUE: Priority queue data structure
SCIP_PRESOL
SCIP_PRESOLDATA
SCIP_PRESOLTIMING
SCIP_PRICER
SCIP_PRICERDATA
SCIP_PRIMAL
SCIP_PROB
SCIP_PROBDATA
SCIP_PROBINGNODE: probing node, possibly with solved LP, where bounds and constraints have been changed, and rows and columns might have been added
SCIP_PROFILE: Resource profile data structure
SCIP_PROJSHIFTDATA: data used for project and shift
SCIP_PROOFSET
SCIP_PROP
SCIP_PROPDATA
SCIP_PROPTIMING
SCIP_PSEUDOFORK: fork without LP solution, where bounds and constraints have been changed, and rows and columns were added
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_RATIONAL: type used for rational numbers
SCIP_RATIONALARRAY: dynamic array for storing SCIP_Real values
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_ROWEXACT: row of an exact LP
SCIP_ROWEXACTSOLVALS
SCIP_ROWPREP: a linear inequality row in preparation to become a SCIP_ROW
SCIP_ROWSOLVALS: collected values of a row which depend on the LP solution We store these values in each row to recover the LP solution at start of diving or probing mode, say, without having to resolve the LP. We do not store the dualfarkas value since we expect a node with infeasible LP to be pruned anyway. In this unlikely case, we have to resolve the LP.
SCIP_ReoptType
SCIP_Result: result codes for SCIP callback methods
SCIP_Retcode: return codes for SCIP methods: non-positive return codes are errors
SCIP_RoundModeRational: defines the possible rounding direction for a rational number, when converting to a double
SCIP_RowOriginType: type of origin of row
SCIP_SEPA
SCIP_SEPADATA
SCIP_SET: global SCIP settings
SCIP_SIBLING: sibling information (should not exceed the size of a pointer)
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: fork with solved LP, where bounds and constraints have been changed, and rows and columns were removed and added
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: branch and bound tree
SCIP_TREEMODEL
SCIP_VALSEXACT
SCIP_VALUEHISTORY: Value history data structure
SCIP_VAR
SCIP_VARDATA
SCIP_VARDATAEXACT
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_Consoptype: define type of simple constraints/operators in symmetry detection
SYM_EXPRDATA
SYM_GRAPH
SYM_HANDLETYPE
SYM_Nodetype: define type of nodes in symmetry detection expression trees
SYM_SPEC
SYM_Symtype: define symmetry types detectable by SCIP
__builtin_va_list
__darwin_blkcnt_t
__darwin_blksize_t
__darwin_clock_t
__darwin_ct_rune_t
__darwin_dev_t
__darwin_fsblkcnt_t
__darwin_fsfilcnt_t
__darwin_gid_t
__darwin_id_t
__darwin_ino64_t
__darwin_ino_t
__darwin_intptr_t
__darwin_mach_port_name_t
__darwin_mach_port_t
__darwin_mbstate_t
__darwin_mode_t
__darwin_natural_t
__darwin_nl_item
__darwin_off_t
__darwin_pid_t
__darwin_pthread_attr_t
__darwin_pthread_cond_t
__darwin_pthread_condattr_t
__darwin_pthread_key_t
__darwin_pthread_mutex_t
__darwin_pthread_mutexattr_t
__darwin_pthread_once_t
__darwin_pthread_rwlock_t
__darwin_pthread_rwlockattr_t
__darwin_pthread_t
__darwin_ptrdiff_t
__darwin_rune_t
__darwin_sigset_t
__darwin_size_t
__darwin_socklen_t
__darwin_ssize_t
__darwin_suseconds_t
__darwin_time_t
__darwin_uid_t
__darwin_useconds_t
__darwin_uuid_string_t
__darwin_uuid_t
__darwin_va_list
__darwin_wchar_t
__darwin_wctrans_t
__darwin_wctype_t
__darwin_wint_t
__gnuc_va_list
__int8_t
__int16_t
__int32_t
__int64_t
__uint8_t
__uint16_t
__uint32_t
__uint64_t
__uint128_t
ct_rune_t
dev_t
double_t
errno_t
float_t
fpos_t
id_t
idtype_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
malloc_type_id_t
malloc_zone_t
max_align_t
mcontext_t
mode_t
off_t
pid_t
pthread_attr_t
register_t
rlim_t
rsize_t
rune_t
rusage_info_current
rusage_info_t
sig_atomic_t
sig_t
siginfo_t
sigset_t
stack_t
syscall_arg_t
u_int8_t
u_int16_t
u_int32_t
u_int64_t
ucontext_t
uid_t
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
user_addr_t
user_long_t
user_off_t
user_size_t
user_ssize_t
user_time_t
user_ulong_t
va_list
wchar_t

Unions§

SCIP_ConsNonlinear_BilinTerm__bindgen_ty_1
SCIP_EXPRITER_USERDATA: user data storage type for expression iteration
SCIP_Node__bindgen_ty_1
__mbstate_t
__sigaction_u
sigval
wait

Crate scip_sys

Crate scip_sys Copy item path

Re-exports§

Structs§

Constants§

Statics§

Functions§

Type Aliases§

Unions§

Crate scip_sys