SCIP

Solving Constraint Integer Programs

Macros | Functions
scip.h File Reference
Public API of SCIP » Core API

Detailed Description

SCIP callable library.

Author
Tobias Achterberg
Timo Berthold
Thorsten Koch
Alexander Martin
Marc Pfetsch
Kati Wolter

Definition in file scip.h.

#include <stdio.h>
#include "scip/def.h"
#include "blockmemshell/memory.h"
#include "scip/type_retcode.h"
#include "scip/type_result.h"
#include "scip/type_clock.h"
#include "scip/type_misc.h"
#include "scip/type_timing.h"
#include "scip/type_paramset.h"
#include "scip/type_event.h"
#include "scip/type_lp.h"
#include "scip/type_nlp.h"
#include "scip/type_var.h"
#include "scip/type_prob.h"
#include "scip/type_tree.h"
#include "scip/type_scip.h"
#include "scip/type_bandit.h"
#include "scip/type_branch.h"
#include "scip/type_conflict.h"
#include "scip/type_cons.h"
#include "scip/type_dialog.h"
#include "scip/type_disp.h"
#include "scip/type_heur.h"
#include "scip/type_compr.h"
#include "scip/type_history.h"
#include "scip/type_nodesel.h"
#include "scip/type_presol.h"
#include "scip/type_pricer.h"
#include "scip/type_reader.h"
#include "scip/type_relax.h"
#include "scip/type_sepa.h"
#include "scip/type_table.h"
#include "scip/type_prop.h"
#include "nlpi/type_nlpi.h"
#include "scip/type_concsolver.h"
#include "scip/type_syncstore.h"
#include "scip/pub_bandit.h"
#include "scip/pub_branch.h"
#include "scip/pub_conflict.h"
#include "scip/pub_cons.h"
#include "scip/pub_cutpool.h"
#include "scip/pub_dialog.h"
#include "scip/pub_disp.h"
#include "scip/pub_event.h"
#include "scip/pub_fileio.h"
#include "scip/pub_heur.h"
#include "scip/pub_compr.h"
#include "scip/pub_history.h"
#include "scip/pub_implics.h"
#include "scip/pub_lp.h"
#include "scip/pub_nlp.h"
#include "scip/pub_message.h"
#include "scip/pub_misc.h"
#include "scip/pub_nodesel.h"
#include "scip/pub_paramset.h"
#include "scip/pub_presol.h"
#include "scip/pub_pricer.h"
#include "scip/pub_reader.h"
#include "scip/pub_relax.h"
#include "scip/pub_sepa.h"
#include "scip/pub_prop.h"
#include "scip/pub_sol.h"
#include "scip/pub_table.h"
#include "scip/pub_tree.h"
#include "scip/pub_var.h"
#include "lpi/lpi.h"
#include "nlpi/pub_expr.h"
#include "scip/presolve.h"
#include "scip/cuts.h"
#include "scip/heuristics.h"

Go to the source code of this file.

Macros

#define SCIPdebugMsg   while ( FALSE ) SCIPdebugMessagePrint
 
#define SCIPdebugMsgPrint   while ( FALSE ) SCIPdebugMessagePrint
 
Standard Memory Management Macros
#define SCIPallocMemory(scip, ptr)
 
#define SCIPallocMemoryArray(scip, ptr, num)
 
#define SCIPallocClearMemoryArray(scip, ptr, num)
 
#define SCIPallocMemorySize(scip, ptr, size)
 
#define SCIPreallocMemoryArray(scip, ptr, newnum)
 
#define SCIPreallocMemorySize(scip, ptr, newsize)
 
#define SCIPduplicateMemory(scip, ptr, source)
 
#define SCIPduplicateMemoryArray(scip, ptr, source, num)
 
#define SCIPfreeMemory(scip, ptr)   BMSfreeMemory(ptr)
 
#define SCIPfreeMemoryNull(scip, ptr)   BMSfreeMemoryNull(ptr)
 
#define SCIPfreeMemoryArray(scip, ptr)   BMSfreeMemoryArray(ptr)
 
#define SCIPfreeMemoryArrayNull(scip, ptr)   BMSfreeMemoryArrayNull(ptr)
 
#define SCIPfreeMemorySize(scip, ptr)   BMSfreeMemorySize(ptr)
 
#define SCIPfreeMemorySizeNull(scip, ptr)   BMSfreeMemorySizeNull(ptr)
 
Block Memory Management Macros
#define SCIPallocBlockMemory(scip, ptr)
 
#define SCIPallocBlockMemoryArray(scip, ptr, num)
 
#define SCIPallocBlockMemorySize(scip, ptr, size)
 
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
 
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
 
#define SCIPreallocBlockMemorySize(scip, ptr, oldsize, newsize)
 
#define SCIPduplicateBlockMemory(scip, ptr, source)
 
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
 
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)   ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )
 
#define SCIPfreeBlockMemory(scip, ptr)   BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
 
#define SCIPfreeBlockMemoryNull(scip, ptr)   BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
 
#define SCIPfreeBlockMemoryArray(scip, ptr, num)   BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
 
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)   BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
 
#define SCIPfreeBlockMemorySize(scip, ptr, size)   BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
 
#define SCIPfreeBlockMemorySizeNull(scip, ptr, size)   BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
 
Buffer Memory Management Macros
#define SCIPallocBuffer(scip, ptr)
 
#define SCIPallocBufferArray(scip, ptr, num)
 
#define SCIPallocClearBufferArray(scip, ptr, num)
 
#define SCIPreallocBufferArray(scip, ptr, num)
 
#define SCIPduplicateBuffer(scip, ptr, source)
 
#define SCIPduplicateBufferArray(scip, ptr, source, num)
 
#define SCIPfreeBuffer(scip, ptr)   BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))
 
#define SCIPfreeBufferNull(scip, ptr)   BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))
 
#define SCIPfreeBufferArray(scip, ptr)   BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))
 
#define SCIPfreeBufferArrayNull(scip, ptr)   BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))
 
#define SCIPallocCleanBuffer(scip, ptr)
 
#define SCIPallocCleanBufferArray(scip, ptr, num)
 
#define SCIPfreeCleanBuffer(scip, ptr)   BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))
 
#define SCIPfreeCleanBufferNull(scip, ptr)   BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))
 
#define SCIPfreeCleanBufferArray(scip, ptr)   BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))
 
#define SCIPfreeCleanBufferArrayNull(scip, ptr)   BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))
 

Functions

SCIP_Real SCIPversion (void)
 
int SCIPmajorVersion (void)
 
int SCIPminorVersion (void)
 
int SCIPtechVersion (void)
 
int SCIPsubversion (void)
 
void SCIPprintVersion (SCIP *scip, FILE *file)
 
void SCIPprintBuildOptions (SCIP *scip, FILE *file)
 
void SCIPprintError (SCIP_RETCODE retcode)
 
SCIP_RETCODE SCIPcreate (SCIP **scip)
 
SCIP_RETCODE SCIPfree (SCIP **scip)
 
SCIP_STAGE SCIPgetStage (SCIP *scip)
 
SCIP_RETCODE SCIPprintStage (SCIP *scip, FILE *file)
 
SCIP_STATUS SCIPgetStatus (SCIP *scip)
 
SCIP_RETCODE SCIPprintStatus (SCIP *scip, FILE *file)
 
SCIP_Bool SCIPisTransformed (SCIP *scip)
 
SCIP_Bool SCIPisExactSolve (SCIP *scip)
 
SCIP_Bool SCIPisPresolveFinished (SCIP *scip)
 
SCIP_Bool SCIPhasPerformedPresolve (SCIP *scip)
 
SCIP_Bool SCIPpressedCtrlC (SCIP *scip)
 
SCIP_Bool SCIPisStopped (SCIP *scip)
 
void SCIPenableDebugSol (SCIP *scip)
 
void SCIPdisableDebugSol (SCIP *scip)
 
SCIP_RETCODE SCIPsetMessagehdlr (SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)
 
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr (SCIP *scip)
 
void SCIPsetMessagehdlrLogfile (SCIP *scip, const char *filename)
 
void SCIPsetMessagehdlrQuiet (SCIP *scip, SCIP_Bool quiet)
 
void SCIPwarningMessage (SCIP *scip, const char *formatstr,...)
 
void SCIPprintDebugMessage (SCIP *scip, const char *sourcefile, int sourceline, const char *formatstr,...)
 
void SCIPdebugMessagePrint (SCIP *scip, const char *formatstr,...)
 
void SCIPdialogMessage (SCIP *scip, FILE *file, const char *formatstr,...)
 
void SCIPinfoMessage (SCIP *scip, FILE *file, const char *formatstr,...)
 
void SCIPverbMessage (SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
 
SCIP_VERBLEVEL SCIPgetVerbLevel (SCIP *scip)
 
SCIP_RETCODE SCIPcopyPlugins (SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyProb (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
 
SCIP_RETCODE SCIPcopyOrigProb (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
 
SCIP_RETCODE SCIPenableConsCompression (SCIP *scip)
 
SCIP_Bool SCIPisConsCompressionEnabled (SCIP *scip)
 
SCIP_RETCODE SCIPgetVarCopy (SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
 
SCIP_RETCODE SCIPcopyVars (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global)
 
SCIP_RETCODE SCIPcopyOrigVars (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)
 
SCIP_RETCODE SCIPmergeVariableStatistics (SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
 
SCIP_RETCODE SCIPgetConsCopy (SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyConss (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyOrigConss (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPconvertCutsToConss (SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
 
SCIP_RETCODE SCIPcopyCuts (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
 
SCIP_RETCODE SCIPcopyConflicts (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyImplicationsCliques (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *infeasible, int *nbdchgs, int *ncopied)
 
SCIP_RETCODE SCIPcopyParamSettings (SCIP *sourcescip, SCIP *targetscip)
 
int SCIPgetSubscipDepth (SCIP *scip)
 
void SCIPsetSubscipDepth (SCIP *scip, int newdepth)
 
SCIP_RETCODE SCIPcopy (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyConsCompression (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyOrig (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcopyOrigConsCompression (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
 
SCIP_RETCODE SCIPcheckCopyLimits (SCIP *sourcescip, SCIP_Bool *success)
 
SCIP_RETCODE SCIPcopyLimits (SCIP *sourcescip, SCIP *targetscip)
 
SCIP_RETCODE SCIPaddBoolParam (SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_RETCODE SCIPaddIntParam (SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_RETCODE SCIPaddLongintParam (SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_RETCODE SCIPaddRealParam (SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_RETCODE SCIPaddCharParam (SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_RETCODE SCIPaddStringParam (SCIP *scip, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
 
SCIP_Bool SCIPisParamFixed (SCIP *scip, const char *name)
 
SCIP_PARAM * SCIPgetParam (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPgetBoolParam (SCIP *scip, const char *name, SCIP_Bool *value)
 
SCIP_RETCODE SCIPgetIntParam (SCIP *scip, const char *name, int *value)
 
SCIP_RETCODE SCIPgetLongintParam (SCIP *scip, const char *name, SCIP_Longint *value)
 
SCIP_RETCODE SCIPgetRealParam (SCIP *scip, const char *name, SCIP_Real *value)
 
SCIP_RETCODE SCIPgetCharParam (SCIP *scip, const char *name, char *value)
 
SCIP_RETCODE SCIPgetStringParam (SCIP *scip, const char *name, char **value)
 
SCIP_RETCODE SCIPfixParam (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPunfixParam (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPsetParam (SCIP *scip, const char *name, void *value)
 
SCIP_RETCODE SCIPchgBoolParam (SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
 
SCIP_RETCODE SCIPsetBoolParam (SCIP *scip, const char *name, SCIP_Bool value)
 
SCIP_Bool SCIPisBoolParamValid (SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
 
SCIP_RETCODE SCIPchgIntParam (SCIP *scip, SCIP_PARAM *param, int value)
 
SCIP_RETCODE SCIPsetIntParam (SCIP *scip, const char *name, int value)
 
SCIP_Bool SCIPisIntParamValid (SCIP *scip, SCIP_PARAM *param, int value)
 
SCIP_RETCODE SCIPchgLongintParam (SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
 
SCIP_RETCODE SCIPsetLongintParam (SCIP *scip, const char *name, SCIP_Longint value)
 
SCIP_Bool SCIPisLongintParamValid (SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
 
SCIP_RETCODE SCIPchgRealParam (SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
 
SCIP_RETCODE SCIPsetRealParam (SCIP *scip, const char *name, SCIP_Real value)
 
SCIP_Bool SCIPisRealParamValid (SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
 
SCIP_RETCODE SCIPchgCharParam (SCIP *scip, SCIP_PARAM *param, char value)
 
SCIP_RETCODE SCIPsetCharParam (SCIP *scip, const char *name, char value)
 
SCIP_Bool SCIPisCharParamValid (SCIP *scip, SCIP_PARAM *param, const char value)
 
SCIP_RETCODE SCIPchgStringParam (SCIP *scip, SCIP_PARAM *param, const char *value)
 
SCIP_RETCODE SCIPsetStringParam (SCIP *scip, const char *name, const char *value)
 
SCIP_Bool SCIPisStringParamValid (SCIP *scip, SCIP_PARAM *param, const char *value)
 
SCIP_RETCODE SCIPreadParams (SCIP *scip, const char *filename)
 
SCIP_RETCODE SCIPwriteParam (SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
 
SCIP_RETCODE SCIPwriteParams (SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
 
SCIP_RETCODE SCIPresetParam (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPresetParams (SCIP *scip)
 
SCIP_RETCODE SCIPsetEmphasis (SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
 
SCIP_RETCODE SCIPsetSubscipsOff (SCIP *scip, SCIP_Bool quiet)
 
SCIP_RETCODE SCIPsetHeuristics (SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
 
SCIP_RETCODE SCIPsetPresolving (SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
 
SCIP_RETCODE SCIPsetSeparating (SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
 
SCIP_PARAM ** SCIPgetParams (SCIP *scip)
 
int SCIPgetNParams (SCIP *scip)
 
SCIP_RETCODE SCIPincludeReader (SCIP *scip, const char *name, const char *desc, const char *extension, SCIP_DECL_READERCOPY((*readercopy)), SCIP_DECL_READERFREE((*readerfree)), SCIP_DECL_READERREAD((*readerread)), SCIP_DECL_READERWRITE((*readerwrite)), SCIP_READERDATA *readerdata)
 
SCIP_RETCODE SCIPincludeReaderBasic (SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
 
SCIP_RETCODE SCIPsetReaderCopy (SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
 
SCIP_RETCODE SCIPsetReaderFree (SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
 
SCIP_RETCODE SCIPsetReaderRead (SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
 
SCIP_RETCODE SCIPsetReaderWrite (SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
 
SCIP_READER * SCIPfindReader (SCIP *scip, const char *name)
 
SCIP_READER ** SCIPgetReaders (SCIP *scip)
 
int SCIPgetNReaders (SCIP *scip)
 
SCIP_RETCODE SCIPincludePricer (SCIP *scip, const char *name, const char *desc, int priority, SCIP_Bool delay, SCIP_DECL_PRICERCOPY((*pricercopy)), SCIP_DECL_PRICERFREE((*pricerfree)), SCIP_DECL_PRICERINIT((*pricerinit)), SCIP_DECL_PRICEREXIT((*pricerexit)), SCIP_DECL_PRICERINITSOL((*pricerinitsol)), SCIP_DECL_PRICEREXITSOL((*pricerexitsol)), SCIP_DECL_PRICERREDCOST((*pricerredcost)), SCIP_DECL_PRICERFARKAS((*pricerfarkas)), SCIP_PRICERDATA *pricerdata)
 
SCIP_RETCODE SCIPincludePricerBasic (SCIP *scip, SCIP_PRICER **pricerptr, const char *name, const char *desc, int priority, SCIP_Bool delay, SCIP_DECL_PRICERREDCOST((*pricerredcost)), SCIP_DECL_PRICERFARKAS((*pricerfarkas)), SCIP_PRICERDATA *pricerdata)
 
SCIP_RETCODE SCIPsetPricerCopy (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERCOPY((*pricercopy)))
 
SCIP_RETCODE SCIPsetPricerFree (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERFREE((*pricerfree)))
 
SCIP_RETCODE SCIPsetPricerInit (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINIT((*pricerinit)))
 
SCIP_RETCODE SCIPsetPricerExit (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXIT((*pricerexit)))
 
SCIP_RETCODE SCIPsetPricerInitsol (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINITSOL((*pricerinitsol)))
 
SCIP_RETCODE SCIPsetPricerExitsol (SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXITSOL((*pricerexitsol)))
 
SCIP_PRICER * SCIPfindPricer (SCIP *scip, const char *name)
 
SCIP_PRICER ** SCIPgetPricers (SCIP *scip)
 
int SCIPgetNPricers (SCIP *scip)
 
int SCIPgetNActivePricers (SCIP *scip)
 
SCIP_RETCODE SCIPsetPricerPriority (SCIP *scip, SCIP_PRICER *pricer, int priority)
 
SCIP_RETCODE SCIPactivatePricer (SCIP *scip, SCIP_PRICER *pricer)
 
SCIP_RETCODE SCIPdeactivatePricer (SCIP *scip, SCIP_PRICER *pricer)
 
SCIP_RETCODE SCIPincludeConshdlr (SCIP *scip, const char *name, const char *desc, int sepapriority, int enfopriority, int chckpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_CONSHDLRDATA *conshdlrdata)
 
SCIP_RETCODE SCIPincludeConshdlrBasic (SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
 
SCIP_RETCODE SCIPsetConshdlrSepa (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
 
SCIP_RETCODE SCIPsetConshdlrProp (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
 
SCIP_RETCODE SCIPsetConshdlrEnforelax (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
 
SCIP_RETCODE SCIPsetConshdlrCopy (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
 
SCIP_RETCODE SCIPsetConshdlrFree (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
 
SCIP_RETCODE SCIPsetConshdlrInit (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
 
SCIP_RETCODE SCIPsetConshdlrExit (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
 
SCIP_RETCODE SCIPsetConshdlrInitsol (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
 
SCIP_RETCODE SCIPsetConshdlrExitsol (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
 
SCIP_RETCODE SCIPsetConshdlrInitpre (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
 
SCIP_RETCODE SCIPsetConshdlrExitpre (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
 
SCIP_RETCODE SCIPsetConshdlrPresol (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
 
SCIP_RETCODE SCIPsetConshdlrDelete (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
 
SCIP_RETCODE SCIPsetConshdlrTrans (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
 
SCIP_RETCODE SCIPsetConshdlrInitlp (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
 
SCIP_RETCODE SCIPsetConshdlrResprop (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
 
SCIP_RETCODE SCIPsetConshdlrActive (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
 
SCIP_RETCODE SCIPsetConshdlrDeactive (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
 
SCIP_RETCODE SCIPsetConshdlrEnable (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
 
SCIP_RETCODE SCIPsetConshdlrDisable (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
 
SCIP_RETCODE SCIPsetConshdlrDelvars (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
 
SCIP_RETCODE SCIPsetConshdlrPrint (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
 
SCIP_RETCODE SCIPsetConshdlrParse (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
 
SCIP_RETCODE SCIPsetConshdlrGetVars (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
 
SCIP_RETCODE SCIPsetConshdlrGetNVars (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
 
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
 
SCIP_CONSHDLR * SCIPfindConshdlr (SCIP *scip, const char *name)
 
SCIP_CONSHDLR ** SCIPgetConshdlrs (SCIP *scip)
 
int SCIPgetNConshdlrs (SCIP *scip)
 
SCIP_RETCODE SCIPincludeConflicthdlr (SCIP *scip, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
 
SCIP_RETCODE SCIPincludeConflicthdlrBasic (SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
 
SCIP_RETCODE SCIPsetConflicthdlrCopy (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
 
SCIP_RETCODE SCIPsetConflicthdlrFree (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
 
SCIP_RETCODE SCIPsetConflicthdlrInit (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
 
SCIP_RETCODE SCIPsetConflicthdlrExit (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
 
SCIP_RETCODE SCIPsetConflicthdlrInitsol (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
 
SCIP_RETCODE SCIPsetConflicthdlrExitsol (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))
 
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr (SCIP *scip, const char *name)
 
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs (SCIP *scip)
 
int SCIPgetNConflicthdlrs (SCIP *scip)
 
SCIP_RETCODE SCIPsetConflicthdlrPriority (SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
 
SCIP_RETCODE SCIPincludePresol (SCIP *scip, const char *name, const char *desc, int priority, int maxrounds, SCIP_PRESOLTIMING timing, SCIP_DECL_PRESOLCOPY((*presolcopy)), SCIP_DECL_PRESOLFREE((*presolfree)), SCIP_DECL_PRESOLINIT((*presolinit)), SCIP_DECL_PRESOLEXIT((*presolexit)), SCIP_DECL_PRESOLINITPRE((*presolinitpre)), SCIP_DECL_PRESOLEXITPRE((*presolexitpre)), SCIP_DECL_PRESOLEXEC((*presolexec)), SCIP_PRESOLDATA *presoldata)
 
SCIP_RETCODE SCIPincludePresolBasic (SCIP *scip, SCIP_PRESOL **presolptr, const char *name, const char *desc, int priority, int maxrounds, SCIP_PRESOLTIMING timing, SCIP_DECL_PRESOLEXEC((*presolexec)), SCIP_PRESOLDATA *presoldata)
 
SCIP_RETCODE SCIPsetPresolCopy (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
 
SCIP_RETCODE SCIPsetPresolFree (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
 
SCIP_RETCODE SCIPsetPresolInit (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINIT((*presolinit)))
 
SCIP_RETCODE SCIPsetPresolExit (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXIT((*presolexit)))
 
SCIP_RETCODE SCIPsetPresolInitpre (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINITPRE((*presolinitpre)))
 
SCIP_RETCODE SCIPsetPresolExitpre (SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXITPRE((*presolexitpre)))
 
SCIP_PRESOL * SCIPfindPresol (SCIP *scip, const char *name)
 
SCIP_PRESOL ** SCIPgetPresols (SCIP *scip)
 
int SCIPgetNPresols (SCIP *scip)
 
SCIP_RETCODE SCIPsetPresolPriority (SCIP *scip, SCIP_PRESOL *presol, int priority)
 
SCIP_RETCODE SCIPincludeRelax (SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXCOPY((*relaxcopy)), SCIP_DECL_RELAXFREE((*relaxfree)), SCIP_DECL_RELAXINIT((*relaxinit)), SCIP_DECL_RELAXEXIT((*relaxexit)), SCIP_DECL_RELAXINITSOL((*relaxinitsol)), SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
 
SCIP_RETCODE SCIPincludeRelaxBasic (SCIP *scip, SCIP_RELAX **relaxptr, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
 
SCIP_RETCODE SCIPsetRelaxCopy (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))
 
SCIP_RETCODE SCIPsetRelaxFree (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXFREE((*relaxfree)))
 
SCIP_RETCODE SCIPsetRelaxInit (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))
 
SCIP_RETCODE SCIPsetRelaxExit (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))
 
SCIP_RETCODE SCIPsetRelaxInitsol (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))
 
SCIP_RETCODE SCIPsetRelaxExitsol (SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))
 
SCIP_RELAX * SCIPfindRelax (SCIP *scip, const char *name)
 
SCIP_RELAX ** SCIPgetRelaxs (SCIP *scip)
 
int SCIPgetNRelaxs (SCIP *scip)
 
SCIP_RETCODE SCIPsetRelaxPriority (SCIP *scip, SCIP_RELAX *relax, int priority)
 
SCIP_RETCODE SCIPincludeSepa (SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPACOPY((*sepacopy)), SCIP_DECL_SEPAFREE((*sepafree)), SCIP_DECL_SEPAINIT((*sepainit)), SCIP_DECL_SEPAEXIT((*sepaexit)), SCIP_DECL_SEPAINITSOL((*sepainitsol)), SCIP_DECL_SEPAEXITSOL((*sepaexitsol)), SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
 
SCIP_RETCODE SCIPincludeSepaBasic (SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
 
SCIP_RETCODE SCIPsetSepaCopy (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
 
SCIP_RETCODE SCIPsetSepaFree (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
 
SCIP_RETCODE SCIPsetSepaInit (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
 
SCIP_RETCODE SCIPsetSepaExit (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
 
SCIP_RETCODE SCIPsetSepaInitsol (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
 
SCIP_RETCODE SCIPsetSepaExitsol (SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
 
SCIP_SEPA * SCIPfindSepa (SCIP *scip, const char *name)
 
SCIP_SEPA ** SCIPgetSepas (SCIP *scip)
 
int SCIPgetNSepas (SCIP *scip)
 
SCIP_RETCODE SCIPsetSepaPriority (SCIP *scip, SCIP_SEPA *sepa, int priority)
 
SCIP_Real SCIPgetSepaMinEfficacy (SCIP *scip)
 
SCIP_RETCODE SCIPincludeProp (SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_PROPCOPY((*propcopy)), SCIP_DECL_PROPFREE((*propfree)), SCIP_DECL_PROPINIT((*propinit)), SCIP_DECL_PROPEXIT((*propexit)), SCIP_DECL_PROPINITPRE((*propinitpre)), SCIP_DECL_PROPEXITPRE((*propexitpre)), SCIP_DECL_PROPINITSOL((*propinitsol)), SCIP_DECL_PROPEXITSOL((*propexitsol)), SCIP_DECL_PROPPRESOL((*proppresol)), SCIP_DECL_PROPEXEC((*propexec)), SCIP_DECL_PROPRESPROP((*propresprop)), SCIP_PROPDATA *propdata)
 
SCIP_RETCODE SCIPincludePropBasic (SCIP *scip, SCIP_PROP **propptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, SCIP_DECL_PROPEXEC((*propexec)), SCIP_PROPDATA *propdata)
 
SCIP_RETCODE SCIPsetPropCopy (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
 
SCIP_RETCODE SCIPsetPropFree (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
 
SCIP_RETCODE SCIPsetPropInit (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINIT((*propinit)))
 
SCIP_RETCODE SCIPsetPropExit (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXIT((*propexit)))
 
SCIP_RETCODE SCIPsetPropInitsol (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
 
SCIP_RETCODE SCIPsetPropExitsol (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
 
SCIP_RETCODE SCIPsetPropInitpre (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITPRE((*propinitpre)))
 
SCIP_RETCODE SCIPsetPropExitpre (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITPRE((*propexitpre)))
 
SCIP_RETCODE SCIPsetPropPresol (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
 
SCIP_RETCODE SCIPsetPropResprop (SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
 
SCIP_PROP * SCIPfindProp (SCIP *scip, const char *name)
 
SCIP_PROP ** SCIPgetProps (SCIP *scip)
 
int SCIPgetNProps (SCIP *scip)
 
SCIP_RETCODE SCIPsetPropPriority (SCIP *scip, SCIP_PROP *prop, int priority)
 
SCIP_RETCODE SCIPsetPropPresolPriority (SCIP *scip, SCIP_PROP *prop, int presolpriority)
 
SCIP_RETCODE SCIPincludeConcsolverType (SCIP *scip, const char *name, SCIP_Real prefpriodefault, SCIP_DECL_CONCSOLVERCREATEINST((*concsolvercreateinst)), SCIP_DECL_CONCSOLVERDESTROYINST((*concsolverdestroyinst)), SCIP_DECL_CONCSOLVERINITSEEDS((*concsolverinitseeds)), SCIP_DECL_CONCSOLVEREXEC((*concsolverexec)), SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA((*concsolvercopysolvdata)), SCIP_DECL_CONCSOLVERSTOP((*concsolverstop)), SCIP_DECL_CONCSOLVERSYNCWRITE((*concsolversyncwrite)), SCIP_DECL_CONCSOLVERSYNCREAD((*concsolversyncread)), SCIP_DECL_CONCSOLVERTYPEFREEDATA((*concsolvertypefreedata)), SCIP_CONCSOLVERTYPEDATA *data)
 
SCIP_CONCSOLVERTYPE * SCIPfindConcsolverType (SCIP *scip, const char *name)
 
SCIP_CONCSOLVERTYPE ** SCIPgetConcsolverTypes (SCIP *scip)
 
int SCIPgetNConcsolverTypes (SCIP *scip)
 
SCIP_RETCODE SCIPincludeHeur (SCIP *scip, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEURCOPY((*heurcopy)), SCIP_DECL_HEURFREE((*heurfree)), SCIP_DECL_HEURINIT((*heurinit)), SCIP_DECL_HEUREXIT((*heurexit)), SCIP_DECL_HEURINITSOL((*heurinitsol)), SCIP_DECL_HEUREXITSOL((*heurexitsol)), SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
 
SCIP_RETCODE SCIPincludeHeurBasic (SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
 
SCIP_RETCODE SCIPsetHeurCopy (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
 
SCIP_RETCODE SCIPsetHeurFree (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
 
SCIP_RETCODE SCIPsetHeurInit (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
 
SCIP_RETCODE SCIPsetHeurExit (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
 
SCIP_RETCODE SCIPsetHeurInitsol (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
 
SCIP_RETCODE SCIPsetHeurExitsol (SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
 
SCIP_HEUR * SCIPfindHeur (SCIP *scip, const char *name)
 
SCIP_HEUR ** SCIPgetHeurs (SCIP *scip)
 
int SCIPgetNHeurs (SCIP *scip)
 
SCIP_RETCODE SCIPsetHeurPriority (SCIP *scip, SCIP_HEUR *heur, int priority)
 
SCIP_RETCODE SCIPincludeCompr (SCIP *scip, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPRCOPY((*comprcopy)), SCIP_DECL_COMPRFREE((*comprfree)), SCIP_DECL_COMPRINIT((*comprinit)), SCIP_DECL_COMPREXIT((*comprexit)), SCIP_DECL_COMPRINITSOL((*comprinitsol)), SCIP_DECL_COMPREXITSOL((*comprexitsol)), SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
 
SCIP_RETCODE SCIPincludeComprBasic (SCIP *scip, SCIP_COMPR **compr, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
 
SCIP_RETCODE SCIPsetComprCopy (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
 
SCIP_RETCODE SCIPsetComprFree (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
 
SCIP_RETCODE SCIPsetComprInit (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
 
SCIP_RETCODE SCIPsetComprExit (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
 
SCIP_RETCODE SCIPsetComprInitsol (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
 
SCIP_RETCODE SCIPsetComprExitsol (SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXITSOL((*comprexitsol)))
 
SCIP_COMPR * SCIPfindCompr (SCIP *scip, const char *name)
 
SCIP_COMPR ** SCIPgetComprs (SCIP *scip)
 
int SCIPgetNCompr (SCIP *scip)
 
SCIP_RETCODE SCIPsetComprPriority (SCIP *scip, SCIP_COMPR *compr, int priority)
 
SCIP_RETCODE SCIPcreateDiveset (SCIP *scip, SCIP_DIVESET **diveset, SCIP_HEUR *heur, const char *name, SCIP_Real minreldepth, SCIP_Real maxreldepth, SCIP_Real maxlpiterquot, SCIP_Real maxdiveubquot, SCIP_Real maxdiveavgquot, SCIP_Real maxdiveubquotnosol, SCIP_Real maxdiveavgquotnosol, SCIP_Real lpresolvedomchgquot, int lpsolvefreq, int maxlpiterofs, unsigned int initialseed, SCIP_Bool backtrack, SCIP_Bool onlylpbranchcands, SCIP_Bool specificsos1score, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)))
 
SCIP_RETCODE SCIPincludeEventhdlr (SCIP *scip, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
 
SCIP_RETCODE SCIPincludeEventhdlrBasic (SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
 
SCIP_RETCODE SCIPsetEventhdlrCopy (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))
 
SCIP_RETCODE SCIPsetEventhdlrFree (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
 
SCIP_RETCODE SCIPsetEventhdlrInit (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
 
SCIP_RETCODE SCIPsetEventhdlrExit (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
 
SCIP_RETCODE SCIPsetEventhdlrInitsol (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
 
SCIP_RETCODE SCIPsetEventhdlrExitsol (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
 
SCIP_RETCODE SCIPsetEventhdlrDelete (SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))
 
SCIP_EVENTHDLR * SCIPfindEventhdlr (SCIP *scip, const char *name)
 
SCIP_EVENTHDLR ** SCIPgetEventhdlrs (SCIP *scip)
 
int SCIPgetNEventhdlrs (SCIP *scip)
 
SCIP_RETCODE SCIPincludeNodesel (SCIP *scip, const char *name, const char *desc, int stdpriority, int memsavepriority, SCIP_DECL_NODESELCOPY((*nodeselcopy)), SCIP_DECL_NODESELFREE((*nodeselfree)), SCIP_DECL_NODESELINIT((*nodeselinit)), SCIP_DECL_NODESELEXIT((*nodeselexit)), SCIP_DECL_NODESELINITSOL((*nodeselinitsol)), SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)), SCIP_DECL_NODESELSELECT((*nodeselselect)), SCIP_DECL_NODESELCOMP((*nodeselcomp)), SCIP_NODESELDATA *nodeseldata)
 
SCIP_RETCODE SCIPincludeNodeselBasic (SCIP *scip, SCIP_NODESEL **nodesel, const char *name, const char *desc, int stdpriority, int memsavepriority, SCIP_DECL_NODESELSELECT((*nodeselselect)), SCIP_DECL_NODESELCOMP((*nodeselcomp)), SCIP_NODESELDATA *nodeseldata)
 
SCIP_RETCODE SCIPsetNodeselCopy (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELCOPY((*nodeselcopy)))
 
SCIP_RETCODE SCIPsetNodeselFree (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELFREE((*nodeselfree)))
 
SCIP_RETCODE SCIPsetNodeselInit (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINIT((*nodeselinit)))
 
SCIP_RETCODE SCIPsetNodeselExit (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXIT((*nodeselexit)))
 
SCIP_RETCODE SCIPsetNodeselInitsol (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINITSOL((*nodeselinitsol)))
 
SCIP_RETCODE SCIPsetNodeselExitsol (SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)))
 
SCIP_NODESEL * SCIPfindNodesel (SCIP *scip, const char *name)
 
SCIP_NODESEL ** SCIPgetNodesels (SCIP *scip)
 
int SCIPgetNNodesels (SCIP *scip)
 
SCIP_RETCODE SCIPsetNodeselStdPriority (SCIP *scip, SCIP_NODESEL *nodesel, int priority)
 
SCIP_RETCODE SCIPsetNodeselMemsavePriority (SCIP *scip, SCIP_NODESEL *nodesel, int priority)
 
SCIP_NODESEL * SCIPgetNodesel (SCIP *scip)
 
SCIP_RETCODE SCIPincludeBanditvtable (SCIP *scip, SCIP_BANDITVTABLE **banditvtable, const char *name, SCIP_DECL_BANDITFREE((*banditfree)), SCIP_DECL_BANDITSELECT((*banditselect)), SCIP_DECL_BANDITUPDATE((*banditupdate)), SCIP_DECL_BANDITRESET((*banditreset)))
 
SCIP_BANDITVTABLE * SCIPfindBanditvtable (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPfreeBandit (SCIP *scip, SCIP_BANDIT **bandit)
 
SCIP_RETCODE SCIPresetBandit (SCIP *scip, SCIP_BANDIT *bandit, SCIP_Real *priorities, unsigned int seed)
 
SCIP_RETCODE SCIPincludeBranchrule (SCIP *scip, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_DECL_BRANCHCOPY((*branchcopy)), SCIP_DECL_BRANCHFREE((*branchfree)), SCIP_DECL_BRANCHINIT((*branchinit)), SCIP_DECL_BRANCHEXIT((*branchexit)), SCIP_DECL_BRANCHINITSOL((*branchinitsol)), SCIP_DECL_BRANCHEXITSOL((*branchexitsol)), SCIP_DECL_BRANCHEXECLP((*branchexeclp)), SCIP_DECL_BRANCHEXECEXT((*branchexecext)), SCIP_DECL_BRANCHEXECPS((*branchexecps)), SCIP_BRANCHRULEDATA *branchruledata)
 
SCIP_RETCODE SCIPincludeBranchruleBasic (SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)
 
SCIP_RETCODE SCIPsetBranchruleCopy (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
 
SCIP_RETCODE SCIPsetBranchruleFree (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
 
SCIP_RETCODE SCIPsetBranchruleInit (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
 
SCIP_RETCODE SCIPsetBranchruleExit (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
 
SCIP_RETCODE SCIPsetBranchruleInitsol (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
 
SCIP_RETCODE SCIPsetBranchruleExitsol (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
 
SCIP_RETCODE SCIPsetBranchruleExecLp (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
 
SCIP_RETCODE SCIPsetBranchruleExecExt (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
 
SCIP_RETCODE SCIPsetBranchruleExecPs (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
 
SCIP_BRANCHRULE * SCIPfindBranchrule (SCIP *scip, const char *name)
 
SCIP_BRANCHRULE ** SCIPgetBranchrules (SCIP *scip)
 
int SCIPgetNBranchrules (SCIP *scip)
 
SCIP_RETCODE SCIPsetBranchrulePriority (SCIP *scip, SCIP_BRANCHRULE *branchrule, int priority)
 
SCIP_RETCODE SCIPsetBranchruleMaxdepth (SCIP *scip, SCIP_BRANCHRULE *branchrule, int maxdepth)
 
SCIP_RETCODE SCIPsetBranchruleMaxbounddist (SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
 
SCIP_RETCODE SCIPincludeDisp (SCIP *scip, const char *name, const char *desc, const char *header, SCIP_DISPSTATUS dispstatus, SCIP_DECL_DISPCOPY((*dispcopy)), SCIP_DECL_DISPFREE((*dispfree)), SCIP_DECL_DISPINIT((*dispinit)), SCIP_DECL_DISPEXIT((*dispexit)), SCIP_DECL_DISPINITSOL((*dispinitsol)), SCIP_DECL_DISPEXITSOL((*dispexitsol)), SCIP_DECL_DISPOUTPUT((*dispoutput)), SCIP_DISPDATA *dispdata, int width, int priority, int position, SCIP_Bool stripline)
 
SCIP_DISP * SCIPfindDisp (SCIP *scip, const char *name)
 
SCIP_DISP ** SCIPgetDisps (SCIP *scip)
 
int SCIPgetNDisps (SCIP *scip)
 
SCIP_RETCODE SCIPautoselectDisps (SCIP *scip)
 
void SCIPchgDispMode (SCIP_DISP *disp, SCIP_DISPMODE mode)
 
SCIP_RETCODE SCIPincludeTable (SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
 
SCIP_TABLE * SCIPfindTable (SCIP *scip, const char *name)
 
SCIP_TABLE ** SCIPgetTables (SCIP *scip)
 
int SCIPgetNTables (SCIP *scip)
 
SCIP_RETCODE SCIPincludeNlpi (SCIP *scip, SCIP_NLPI *nlpi)
 
SCIP_NLPI * SCIPfindNlpi (SCIP *scip, const char *name)
 
SCIP_NLPI ** SCIPgetNlpis (SCIP *scip)
 
int SCIPgetNNlpis (SCIP *scip)
 
SCIP_RETCODE SCIPsetNlpiPriority (SCIP *scip, SCIP_NLPI *nlpi, int priority)
 
SCIP_RETCODE SCIPincludeExternalCodeInformation (SCIP *scip, const char *name, const char *description)
 
char ** SCIPgetExternalCodeNames (SCIP *scip)
 
char ** SCIPgetExternalCodeDescriptions (SCIP *scip)
 
int SCIPgetNExternalCodes (SCIP *scip)
 
void SCIPprintExternalCodes (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPincludeDialog (SCIP *scip, SCIP_DIALOG **dialog, SCIP_DECL_DIALOGCOPY((*dialogcopy)), SCIP_DECL_DIALOGEXEC((*dialogexec)), SCIP_DECL_DIALOGDESC((*dialogdesc)), SCIP_DECL_DIALOGFREE((*dialogfree)), const char *name, const char *desc, SCIP_Bool issubmenu, SCIP_DIALOGDATA *dialogdata)
 
SCIP_Bool SCIPexistsDialog (SCIP *scip, SCIP_DIALOG *dialog)
 
SCIP_RETCODE SCIPcaptureDialog (SCIP *scip, SCIP_DIALOG *dialog)
 
SCIP_RETCODE SCIPreleaseDialog (SCIP *scip, SCIP_DIALOG **dialog)
 
SCIP_RETCODE SCIPsetRootDialog (SCIP *scip, SCIP_DIALOG *dialog)
 
SCIP_DIALOG * SCIPgetRootDialog (SCIP *scip)
 
SCIP_RETCODE SCIPaddDialogEntry (SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
 
SCIP_RETCODE SCIPaddDialogInputLine (SCIP *scip, const char *inputline)
 
SCIP_RETCODE SCIPaddDialogHistoryLine (SCIP *scip, const char *inputline)
 
SCIP_RETCODE SCIPstartInteraction (SCIP *scip)
 
SCIP_RETCODE SCIPcreateProb (SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
 
SCIP_RETCODE SCIPcreateProbBasic (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPsetProbDelorig (SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
 
SCIP_RETCODE SCIPsetProbTrans (SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
 
SCIP_RETCODE SCIPsetProbDeltrans (SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
 
SCIP_RETCODE SCIPsetProbInitsol (SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
 
SCIP_RETCODE SCIPsetProbExitsol (SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
 
SCIP_RETCODE SCIPsetProbCopy (SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
 
SCIP_RETCODE SCIPreadProb (SCIP *scip, const char *filename, const char *extension)
 
SCIP_RETCODE SCIPwriteOrigProblem (SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
 
SCIP_RETCODE SCIPwriteTransProblem (SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
 
SCIP_RETCODE SCIPfreeProb (SCIP *scip)
 
SCIP_RETCODE SCIPpermuteProb (SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permuteimplvars, SCIP_Bool permutecontvars)
 
SCIP_PROBDATA * SCIPgetProbData (SCIP *scip)
 
SCIP_RETCODE SCIPsetProbData (SCIP *scip, SCIP_PROBDATA *probdata)
 
const char * SCIPgetProbName (SCIP *scip)
 
SCIP_RETCODE SCIPsetProbName (SCIP *scip, const char *name)
 
SCIP_RETCODE SCIPchgReoptObjective (SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
 
SCIP_OBJSENSE SCIPgetObjsense (SCIP *scip)
 
SCIP_RETCODE SCIPsetObjsense (SCIP *scip, SCIP_OBJSENSE objsense)
 
SCIP_RETCODE SCIPaddObjoffset (SCIP *scip, SCIP_Real addval)
 
SCIP_RETCODE SCIPaddOrigObjoffset (SCIP *scip, SCIP_Real addval)
 
SCIP_Real SCIPgetOrigObjoffset (SCIP *scip)
 
SCIP_Real SCIPgetOrigObjscale (SCIP *scip)
 
SCIP_Real SCIPgetTransObjoffset (SCIP *scip)
 
SCIP_Real SCIPgetTransObjscale (SCIP *scip)
 
SCIP_RETCODE SCIPsetObjlimit (SCIP *scip, SCIP_Real objlimit)
 
SCIP_Real SCIPgetObjlimit (SCIP *scip)
 
SCIP_RETCODE SCIPsetObjIntegral (SCIP *scip)
 
SCIP_Bool SCIPisObjIntegral (SCIP *scip)
 
SCIP_Real SCIPgetObjNorm (SCIP *scip)
 
SCIP_RETCODE SCIPaddVar (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPaddPricedVar (SCIP *scip, SCIP_VAR *var, SCIP_Real score)
 
SCIP_RETCODE SCIPdelVar (SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
 
SCIP_RETCODE SCIPgetVarsData (SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
 
SCIP_VAR ** SCIPgetVars (SCIP *scip)
 
int SCIPgetNVars (SCIP *scip)
 
int SCIPgetNBinVars (SCIP *scip)
 
int SCIPgetNIntVars (SCIP *scip)
 
int SCIPgetNImplVars (SCIP *scip)
 
int SCIPgetNContVars (SCIP *scip)
 
int SCIPgetNObjVars (SCIP *scip)
 
SCIP_VAR ** SCIPgetFixedVars (SCIP *scip)
 
int SCIPgetNFixedVars (SCIP *scip)
 
SCIP_RETCODE SCIPgetOrigVarsData (SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
 
SCIP_VAR ** SCIPgetOrigVars (SCIP *scip)
 
int SCIPgetNOrigVars (SCIP *scip)
 
int SCIPgetNOrigBinVars (SCIP *scip)
 
int SCIPgetNOrigIntVars (SCIP *scip)
 
int SCIPgetNOrigImplVars (SCIP *scip)
 
int SCIPgetNOrigContVars (SCIP *scip)
 
int SCIPgetNTotalVars (SCIP *scip)
 
SCIP_RETCODE SCIPgetSolVarsData (SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
 
SCIP_VAR * SCIPfindVar (SCIP *scip, const char *name)
 
SCIP_Bool SCIPallVarsInProb (SCIP *scip)
 
SCIP_RETCODE SCIPaddCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdelCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_CONS * SCIPfindOrigCons (SCIP *scip, const char *name)
 
SCIP_CONS * SCIPfindCons (SCIP *scip, const char *name)
 
int SCIPgetNUpgrConss (SCIP *scip)
 
int SCIPgetNConss (SCIP *scip)
 
SCIP_CONS ** SCIPgetConss (SCIP *scip)
 
int SCIPgetNOrigConss (SCIP *scip)
 
SCIP_CONS ** SCIPgetOrigConss (SCIP *scip)
 
int SCIPgetNCheckConss (SCIP *scip)
 
SCIP_RETCODE SCIPaddConflict (SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
 
SCIP_RETCODE SCIPclearConflictStore (SCIP *scip, SCIP_EVENT *event)
 
SCIP_RETCODE SCIPaddConsNode (SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
 
SCIP_RETCODE SCIPaddConsLocal (SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
 
SCIP_RETCODE SCIPdelConsNode (SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdelConsLocal (SCIP *scip, SCIP_CONS *cons)
 
SCIP_Real SCIPgetLocalOrigEstimate (SCIP *scip)
 
SCIP_Real SCIPgetLocalTransEstimate (SCIP *scip)
 
SCIP_Real SCIPgetLocalDualbound (SCIP *scip)
 
SCIP_Real SCIPgetLocalLowerbound (SCIP *scip)
 
SCIP_Real SCIPgetNodeDualbound (SCIP *scip, SCIP_NODE *node)
 
SCIP_Real SCIPgetNodeLowerbound (SCIP *scip, SCIP_NODE *node)
 
SCIP_RETCODE SCIPupdateLocalDualbound (SCIP *scip, SCIP_Real newbound)
 
SCIP_RETCODE SCIPupdateLocalLowerbound (SCIP *scip, SCIP_Real newbound)
 
SCIP_RETCODE SCIPupdateNodeDualbound (SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
 
SCIP_RETCODE SCIPupdateNodeLowerbound (SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgChildPrio (SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
 
SCIP_RETCODE SCIPtransformProb (SCIP *scip)
 
SCIP_RETCODE SCIPpresolve (SCIP *scip)
 
SCIP_RETCODE SCIPsolve (SCIP *scip)
 
SCIP_RETCODE SCIPsolveParallel (SCIP *scip)
 
SCIP_RETCODE SCIPsolveConcurrent (SCIP *scip)
 
SCIP_RETCODE SCIPfreeSolve (SCIP *scip, SCIP_Bool restart)
 
SCIP_RETCODE SCIPfreeReoptSolve (SCIP *scip)
 
SCIP_RETCODE SCIPfreeTransform (SCIP *scip)
 
SCIP_RETCODE SCIPinterruptSolve (SCIP *scip)
 
SCIP_RETCODE SCIPrestartSolve (SCIP *scip)
 
SCIP_RETCODE SCIPenableReoptimization (SCIP *scip, SCIP_Bool enable)
 
SCIP_Bool SCIPisReoptEnabled (SCIP *scip)
 
SCIP_RETCODE SCIPgetReoptSolsRun (SCIP *scip, int run, SCIP_SOL **sols, int allocmem, int *nsols)
 
void SCIPresetReoptSolMarks (SCIP *scip)
 
SCIP_RETCODE SCIPcheckReoptRestart (SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
 
SCIP_RETCODE SCIPaddReoptDualBndchg (SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
 
SCIP_SOL * SCIPgetReoptLastOptSol (SCIP *scip)
 
SCIP_RETCODE SCIPgetReoptOldObjCoef (SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
 
SCIP_Bool SCIPisInRestart (SCIP *scip)
 
SCIP_RETCODE SCIPcreateVar (SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
 
SCIP_RETCODE SCIPcreateVarBasic (SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
 
SCIP_RETCODE SCIPwriteVarName (SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
 
SCIP_RETCODE SCIPwriteVarsList (SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
 
SCIP_RETCODE SCIPwriteVarsLinearsum (SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
 
SCIP_RETCODE SCIPwriteVarsPolynomial (SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
 
SCIP_RETCODE SCIPparseVar (SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
 
SCIP_RETCODE SCIPparseVarName (SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
 
SCIP_RETCODE SCIPparseVarsList (SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
 
SCIP_RETCODE SCIPparseVarsLinearsum (SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
 
SCIP_RETCODE SCIPparseVarsPolynomial (SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
 
void SCIPfreeParseVarsPolynomialData (SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
 
SCIP_RETCODE SCIPcaptureVar (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPreleaseVar (SCIP *scip, SCIP_VAR **var)
 
SCIP_RETCODE SCIPchgVarName (SCIP *scip, SCIP_VAR *var, const char *name)
 
SCIP_RETCODE SCIPtransformVar (SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
 
SCIP_RETCODE SCIPtransformVars (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
 
SCIP_RETCODE SCIPgetTransformedVar (SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
 
SCIP_RETCODE SCIPgetTransformedVars (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
 
SCIP_RETCODE SCIPgetNegatedVar (SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
 
SCIP_RETCODE SCIPgetNegatedVars (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
 
SCIP_RETCODE SCIPgetBinvarRepresentative (SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
 
SCIP_RETCODE SCIPgetBinvarRepresentatives (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
 
SCIP_RETCODE SCIPflattenVarAggregationGraph (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPgetProbvarLinearSum (SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
 
SCIP_RETCODE SCIPgetProbvarSum (SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
 
SCIP_RETCODE SCIPgetActiveVars (SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
 
SCIP_Real SCIPgetVarRedcost (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarImplRedcost (SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
 
SCIP_Real SCIPgetVarFarkasCoef (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarLbAtIndex (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
 
SCIP_Real SCIPgetVarUbAtIndex (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
 
SCIP_Real SCIPgetVarBdAtIndex (SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
 
SCIP_Bool SCIPgetVarWasFixedAtIndex (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
 
SCIP_Real SCIPgetVarSol (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPgetVarSols (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
 
SCIP_RETCODE SCIPclearRelaxSolVals (SCIP *scip)
 
SCIP_RETCODE SCIPsetRelaxSolVal (SCIP *scip, SCIP_VAR *var, SCIP_Real val)
 
SCIP_RETCODE SCIPsetRelaxSolVals (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
 
SCIP_RETCODE SCIPsetRelaxSolValsSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool includeslp)
 
SCIP_Bool SCIPisRelaxSolValid (SCIP *scip)
 
SCIP_RETCODE SCIPmarkRelaxSolValid (SCIP *scip, SCIP_Bool includeslp)
 
SCIP_RETCODE SCIPmarkRelaxSolInvalid (SCIP *scip)
 
SCIP_Real SCIPgetRelaxSolVal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetRelaxSolObj (SCIP *scip)
 
SCIP_RETCODE SCIPstartStrongbranch (SCIP *scip, SCIP_Bool enablepropagation)
 
SCIP_RETCODE SCIPendStrongbranch (SCIP *scip)
 
SCIP_RETCODE SCIPgetVarStrongbranchFrac (SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
 
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation (SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
 
SCIP_RETCODE SCIPgetVarStrongbranchInt (SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
 
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac (SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
 
SCIP_RETCODE SCIPgetVarsStrongbranchesInt (SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
 
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat (SCIP *scip, SCIP_BRANCHDIR branchdir)
 
SCIP_RETCODE SCIPgetVarStrongbranchLast (SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
 
SCIP_Longint SCIPgetVarStrongbranchNode (SCIP *scip, SCIP_VAR *var)
 
SCIP_Longint SCIPgetVarStrongbranchLPAge (SCIP *scip, SCIP_VAR *var)
 
int SCIPgetVarNStrongbranchs (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPaddVarLocks (SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
 
SCIP_RETCODE SCIPlockVarCons (SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
 
SCIP_RETCODE SCIPunlockVarCons (SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
 
SCIP_RETCODE SCIPchgVarObj (SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
 
SCIP_RETCODE SCIPaddVarObj (SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
 
SCIP_Real SCIPadjustedVarLb (SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
 
SCIP_Real SCIPadjustedVarUb (SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
 
SCIP_RETCODE SCIPchgVarLb (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarUb (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarLbNode (SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarUbNode (SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarLbGlobal (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarUbGlobal (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarLbLazy (SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
 
SCIP_RETCODE SCIPchgVarUbLazy (SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
 
SCIP_RETCODE SCIPtightenVarLb (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPtightenVarUb (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarFixCons (SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarLbCons (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarUbCons (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferBinvarCons (SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarFixProp (SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarLbProp (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferVarUbProp (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPinferBinvarProp (SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPtightenVarLbGlobal (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_RETCODE SCIPtightenVarUbGlobal (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
 
SCIP_Real SCIPcomputeVarLbGlobal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPcomputeVarUbGlobal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPcomputeVarLbLocal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPcomputeVarUbLocal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarMultaggrLbGlobal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarMultaggrUbGlobal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarMultaggrLbLocal (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarMultaggrUbLocal (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPgetVarClosestVlb (SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
 
SCIP_RETCODE SCIPgetVarClosestVub (SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
 
SCIP_RETCODE SCIPaddVarVlb (SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
 
SCIP_RETCODE SCIPaddVarVub (SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
 
SCIP_RETCODE SCIPaddVarImplication (SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
 
SCIP_RETCODE SCIPaddClique (SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
 
SCIP_RETCODE SCIPcalcCliquePartition (SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
 
SCIP_RETCODE SCIPcalcNegatedCliquePartition (SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
 
SCIP_RETCODE SCIPcleanupCliques (SCIP *scip, SCIP_Bool *infeasible)
 
int SCIPgetNCliques (SCIP *scip)
 
int SCIPgetNCliquesCreated (SCIP *scip)
 
SCIP_CLIQUE ** SCIPgetCliques (SCIP *scip)
 
SCIP_Bool SCIPhaveVarsCommonClique (SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
 
SCIP_RETCODE SCIPwriteCliqueGraph (SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
 
SCIP_RETCODE SCIPremoveVarFromGlobalStructures (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPchgVarBranchFactor (SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
 
SCIP_RETCODE SCIPscaleVarBranchFactor (SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
 
SCIP_RETCODE SCIPaddVarBranchFactor (SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
 
SCIP_RETCODE SCIPchgVarBranchPriority (SCIP *scip, SCIP_VAR *var, int branchpriority)
 
SCIP_RETCODE SCIPupdateVarBranchPriority (SCIP *scip, SCIP_VAR *var, int branchpriority)
 
SCIP_RETCODE SCIPaddVarBranchPriority (SCIP *scip, SCIP_VAR *var, int addpriority)
 
SCIP_RETCODE SCIPchgVarBranchDirection (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
 
SCIP_RETCODE SCIPchgVarType (SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
 
SCIP_RETCODE SCIPfixVar (SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
 
SCIP_RETCODE SCIPaggregateVars (SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
 
SCIP_RETCODE SCIPmultiaggregateVar (SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
 
SCIP_Bool SCIPdoNotAggr (SCIP *scip)
 
SCIP_Bool SCIPdoNotMultaggr (SCIP *scip)
 
SCIP_Bool SCIPdoNotMultaggrVar (SCIP *scip, SCIP_VAR *var)
 
SCIP_Bool SCIPallowDualReds (SCIP *scip)
 
SCIP_Bool SCIPallowObjProp (SCIP *scip)
 
unsigned int SCIPinitializeRandomSeed (SCIP *scip, int initialseedvalue)
 
SCIP_RETCODE SCIPmarkDoNotMultaggrVar (SCIP *scip, SCIP_VAR *var)
 
void SCIPenableVarHistory (SCIP *scip)
 
void SCIPdisableVarHistory (SCIP *scip)
 
SCIP_RETCODE SCIPupdateVarPseudocost (SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
 
SCIP_Real SCIPgetVarPseudocostVal (SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
 
SCIP_Real SCIPgetVarPseudocostValCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
 
SCIP_Real SCIPgetVarPseudocost (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarPseudocostCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarPseudocostCount (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarPseudocostCountCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarPseudocostVariance (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
 
SCIP_Real SCIPcalculatePscostConfidenceBound (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
 
SCIP_Bool SCIPsignificantVarPscostDifference (SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
 
SCIP_Bool SCIPpscostThresholdProbabilityTest (SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
 
SCIP_Bool SCIPisVarPscostRelerrorReliable (SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
 
SCIP_Real SCIPgetVarPseudocostScore (SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
 
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
 
SCIP_Real SCIPgetVarVSIDS (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarVSIDSCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarConflictScore (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarConflictScoreCurrentRun (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarConflictlengthScore (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarAvgConflictlength (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgInferences (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgInferencesCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgInferenceScore (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPinitVarBranchStats (SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
 
SCIP_RETCODE SCIPinitVarValueBranchStats (SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
 
SCIP_Real SCIPgetVarAvgCutoffs (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetVarAvgCutoffScore (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarAvgInferenceCutoffScore (SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
 
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun (SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
 
SCIP_RETCODE SCIPprintVar (SCIP *scip, SCIP_VAR *var, FILE *file)
 
SCIP_Bool SCIPisConflictAnalysisApplicable (SCIP *scip)
 
SCIP_RETCODE SCIPinitConflictAnalysis (SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
 
SCIP_RETCODE SCIPaddConflictLb (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
 
SCIP_RETCODE SCIPaddConflictRelaxedLb (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
 
SCIP_RETCODE SCIPaddConflictUb (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
 
SCIP_RETCODE SCIPaddConflictRelaxedUb (SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
 
SCIP_RETCODE SCIPaddConflictBd (SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
 
SCIP_RETCODE SCIPaddConflictRelaxedBd (SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
 
SCIP_RETCODE SCIPaddConflictBinvar (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPisConflictVarUsed (SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
 
SCIP_Real SCIPgetConflictVarLb (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetConflictVarUb (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPanalyzeConflict (SCIP *scip, int validdepth, SCIP_Bool *success)
 
SCIP_RETCODE SCIPanalyzeConflictCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
 
SCIP_RETCODE SCIPcreateCons (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
 
SCIP_RETCODE SCIPparseCons (SCIP *scip, SCIP_CONS **cons, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
 
SCIP_RETCODE SCIPcaptureCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPreleaseCons (SCIP *scip, SCIP_CONS **cons)
 
SCIP_RETCODE SCIPchgConsName (SCIP *scip, SCIP_CONS *cons, const char *name)
 
SCIP_RETCODE SCIPsetConsInitial (SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
 
SCIP_RETCODE SCIPsetConsSeparated (SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
 
SCIP_RETCODE SCIPsetConsEnforced (SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
 
SCIP_RETCODE SCIPsetConsChecked (SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
 
SCIP_RETCODE SCIPsetConsPropagated (SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
 
SCIP_RETCODE SCIPsetConsLocal (SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
 
SCIP_RETCODE SCIPsetConsModifiable (SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
 
SCIP_RETCODE SCIPsetConsDynamic (SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
 
SCIP_RETCODE SCIPsetConsRemovable (SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
 
SCIP_RETCODE SCIPsetConsStickingAtNode (SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
 
SCIP_RETCODE SCIPupdateConsFlags (SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
 
SCIP_RETCODE SCIPtransformCons (SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
 
SCIP_RETCODE SCIPtransformConss (SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
 
SCIP_RETCODE SCIPgetTransformedCons (SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
 
SCIP_RETCODE SCIPgetTransformedConss (SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
 
SCIP_RETCODE SCIPaddConsAge (SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
 
SCIP_RETCODE SCIPincConsAge (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPresetConsAge (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPenableCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdisableCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPenableConsSeparation (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdisableConsSeparation (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPenableConsPropagation (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdisableConsPropagation (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPmarkConsPropagate (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPunmarkConsPropagate (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPaddConsLocks (SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
 
SCIP_RETCODE SCIPcheckCons (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPenfopsCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPenfolpCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPenforelaxCons (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPinitlpCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
 
SCIP_RETCODE SCIPsepalpCons (SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPsepasolCons (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPpropCons (SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPrespropCons (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPpresolCons (SCIP *scip, SCIP_CONS *cons, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPactiveCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPdeactiveCons (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPprintCons (SCIP *scip, SCIP_CONS *cons, FILE *file)
 
SCIP_RETCODE SCIPgetConsVars (SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
 
SCIP_RETCODE SCIPgetConsNVars (SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
 
SCIP_Bool SCIPhasCurrentNodeLP (SCIP *scip)
 
SCIP_Bool SCIPisLPConstructed (SCIP *scip)
 
SCIP_RETCODE SCIPconstructLP (SCIP *scip, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPflushLP (SCIP *scip)
 
SCIP_LPSOLSTAT SCIPgetLPSolstat (SCIP *scip)
 
SCIP_Bool SCIPisLPPrimalReliable (SCIP *scip)
 
SCIP_Bool SCIPisLPDualReliable (SCIP *scip)
 
SCIP_Bool SCIPisLPRelax (SCIP *scip)
 
SCIP_Real SCIPgetLPObjval (SCIP *scip)
 
SCIP_Real SCIPgetLPColumnObjval (SCIP *scip)
 
SCIP_Real SCIPgetLPLooseObjval (SCIP *scip)
 
SCIP_Real SCIPgetGlobalPseudoObjval (SCIP *scip)
 
SCIP_Real SCIPgetPseudoObjval (SCIP *scip)
 
SCIP_Bool SCIPisRootLPRelax (SCIP *scip)
 
SCIP_Real SCIPgetLPRootObjval (SCIP *scip)
 
SCIP_Real SCIPgetLPRootColumnObjval (SCIP *scip)
 
SCIP_Real SCIPgetLPRootLooseObjval (SCIP *scip)
 
SCIP_RETCODE SCIPgetLPColsData (SCIP *scip, SCIP_COL ***cols, int *ncols)
 
SCIP_COL ** SCIPgetLPCols (SCIP *scip)
 
int SCIPgetNLPCols (SCIP *scip)
 
SCIP_RETCODE SCIPgetLPRowsData (SCIP *scip, SCIP_ROW ***rows, int *nrows)
 
SCIP_ROW ** SCIPgetLPRows (SCIP *scip)
 
int SCIPgetNLPRows (SCIP *scip)
 
SCIP_Bool SCIPallColsInLP (SCIP *scip)
 
SCIP_Bool SCIPisLPSolBasic (SCIP *scip)
 
SCIP_RETCODE SCIPgetLPBasisInd (SCIP *scip, int *basisind)
 
SCIP_RETCODE SCIPgetLPBInvRow (SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
 
SCIP_RETCODE SCIPgetLPBInvCol (SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
 
SCIP_RETCODE SCIPgetLPBInvARow (SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
 
SCIP_RETCODE SCIPgetLPBInvACol (SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
 
SCIP_RETCODE SCIPsumLPRows (SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
 
SCIP_RETCODE SCIPwriteLP (SCIP *scip, const char *filename)
 
SCIP_RETCODE SCIPwriteMIP (SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
 
SCIP_RETCODE SCIPgetLPI (SCIP *scip, SCIP_LPI **lpi)
 
SCIP_RETCODE SCIPprintLPSolutionQuality (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPcomputeLPRelIntPoint (SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
 
SCIP_Real SCIPgetColRedcost (SCIP *scip, SCIP_COL *col)
 
SCIP_Real SCIPgetColFarkasCoef (SCIP *scip, SCIP_COL *col)
 
void SCIPmarkColNotRemovableLocal (SCIP *scip, SCIP_COL *col)
 
SCIP_RETCODE SCIPcreateRowCons (SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateRowSepa (SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateRowUnspec (SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateRow (SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateEmptyRowCons (SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateEmptyRowSepa (SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateEmptyRowUnspec (SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcreateEmptyRow (SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
 
SCIP_RETCODE SCIPcaptureRow (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPreleaseRow (SCIP *scip, SCIP_ROW **row)
 
SCIP_RETCODE SCIPchgRowLhs (SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
 
SCIP_RETCODE SCIPchgRowRhs (SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
 
SCIP_RETCODE SCIPcacheRowExtensions (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPflushRowExtensions (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPaddVarToRow (SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
 
SCIP_RETCODE SCIPaddVarsToRow (SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
 
SCIP_RETCODE SCIPaddVarsToRowSameCoef (SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
 
SCIP_RETCODE SCIPcalcRowIntegralScalar (SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
 
SCIP_RETCODE SCIPmakeRowIntegral (SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
 
void SCIPmarkRowNotRemovableLocal (SCIP *scip, SCIP_ROW *row)
 
int SCIPgetRowNumIntCols (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowMinCoef (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowMaxCoef (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowMinActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowMaxActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPrecalcRowLPActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowLPActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowLPFeasibility (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPrecalcRowPseudoActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowPseudoActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowPseudoFeasibility (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPrecalcRowActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowActivity (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowFeasibility (SCIP *scip, SCIP_ROW *row)
 
SCIP_Real SCIPgetRowSolActivity (SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
 
SCIP_Real SCIPgetRowSolFeasibility (SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPprintRow (SCIP *scip, SCIP_ROW *row, FILE *file)
 
SCIP_Bool SCIPisNLPEnabled (SCIP *scip)
 
void SCIPenableNLP (SCIP *scip)
 
SCIP_Bool SCIPisNLPConstructed (SCIP *scip)
 
SCIP_Bool SCIPhasNLPContinuousNonlinearity (SCIP *scip)
 
SCIP_RETCODE SCIPgetNLPVarsData (SCIP *scip, SCIP_VAR ***vars, int *nvars)
 
SCIP_VAR ** SCIPgetNLPVars (SCIP *scip)
 
int SCIPgetNNLPVars (SCIP *scip)
 
SCIP_RETCODE SCIPgetNLPVarsNonlinearity (SCIP *scip, int *nlcount)
 
SCIP_Real * SCIPgetNLPVarsLbDualsol (SCIP *scip)
 
SCIP_Real * SCIPgetNLPVarsUbDualsol (SCIP *scip)
 
SCIP_RETCODE SCIPgetNLPNlRowsData (SCIP *scip, SCIP_NLROW ***nlrows, int *nnlrows)
 
SCIP_NLROW ** SCIPgetNLPNlRows (SCIP *scip)
 
int SCIPgetNNLPNlRows (SCIP *scip)
 
SCIP_RETCODE SCIPaddNlRow (SCIP *scip, SCIP_NLROW *nlrow)
 
SCIP_RETCODE SCIPflushNLP (SCIP *scip)
 
SCIP_RETCODE SCIPsetNLPInitialGuess (SCIP *scip, SCIP_Real *initialguess)
 
SCIP_RETCODE SCIPsetNLPInitialGuessSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPsolveNLP (SCIP *scip)
 
SCIP_NLPSOLSTAT SCIPgetNLPSolstat (SCIP *scip)
 
SCIP_NLPTERMSTAT SCIPgetNLPTermstat (SCIP *scip)
 
SCIP_RETCODE SCIPgetNLPStatistics (SCIP *scip, SCIP_NLPSTATISTICS *statistics)
 
SCIP_Real SCIPgetNLPObjval (SCIP *scip)
 
SCIP_Bool SCIPhasNLPSolution (SCIP *scip)
 
SCIP_RETCODE SCIPgetNLPFracVars (SCIP *scip, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)
 
SCIP_RETCODE SCIPgetNLPIntPar (SCIP *scip, SCIP_NLPPARAM type, int *ival)
 
SCIP_RETCODE SCIPsetNLPIntPar (SCIP *scip, SCIP_NLPPARAM type, int ival)
 
SCIP_RETCODE SCIPgetNLPRealPar (SCIP *scip, SCIP_NLPPARAM type, SCIP_Real *dval)
 
SCIP_RETCODE SCIPsetNLPRealPar (SCIP *scip, SCIP_NLPPARAM type, SCIP_Real dval)
 
SCIP_RETCODE SCIPgetNLPStringPar (SCIP *scip, SCIP_NLPPARAM type, const char **sval)
 
SCIP_RETCODE SCIPsetNLPStringPar (SCIP *scip, SCIP_NLPPARAM type, const char *sval)
 
SCIP_RETCODE SCIPwriteNLP (SCIP *scip, const char *filename)
 
SCIP_RETCODE SCIPgetNLPI (SCIP *scip, SCIP_NLPI **nlpi, SCIP_NLPIPROBLEM **nlpiproblem)
 
SCIP_RETCODE SCIPstartDiveNLP (SCIP *scip)
 
SCIP_RETCODE SCIPendDiveNLP (SCIP *scip)
 
SCIP_RETCODE SCIPchgVarObjDiveNLP (SCIP *scip, SCIP_VAR *var, SCIP_Real coef)
 
SCIP_RETCODE SCIPchgVarBoundsDiveNLP (SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
 
SCIP_RETCODE SCIPchgVarsBoundsDiveNLP (SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)
 
SCIP_RETCODE SCIPsolveDiveNLP (SCIP *scip)
 
SCIP_RETCODE SCIPcreateNlRow (SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadvars, SCIP_VAR **quadvars, int nquadelems, SCIP_QUADELEM *quadelems, SCIP_EXPRTREE *expression, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
 
SCIP_RETCODE SCIPcreateEmptyNlRow (SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real lhs, SCIP_Real rhs)
 
SCIP_RETCODE SCIPcreateNlRowFromRow (SCIP *scip, SCIP_NLROW **nlrow, SCIP_ROW *row)
 
SCIP_RETCODE SCIPcaptureNlRow (SCIP *scip, SCIP_NLROW *nlrow)
 
SCIP_RETCODE SCIPreleaseNlRow (SCIP *scip, SCIP_NLROW **nlrow)
 
SCIP_RETCODE SCIPchgNlRowLhs (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real lhs)
 
SCIP_RETCODE SCIPchgNlRowRhs (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real rhs)
 
SCIP_RETCODE SCIPchgNlRowConstant (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
 
SCIP_RETCODE SCIPaddLinearCoefToNlRow (SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
 
SCIP_RETCODE SCIPaddLinearCoefsToNlRow (SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
 
SCIP_RETCODE SCIPchgNlRowLinearCoef (SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real coef)
 
SCIP_RETCODE SCIPaddQuadVarToNlRow (SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var)
 
SCIP_RETCODE SCIPaddQuadVarsToNlRow (SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars)
 
SCIP_RETCODE SCIPaddQuadElementToNlRow (SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelem)
 
SCIP_RETCODE SCIPaddQuadElementsToNlRow (SCIP *scip, SCIP_NLROW *nlrow, int nquadelems, SCIP_QUADELEM *quadelems)
 
SCIP_RETCODE SCIPchgNlRowQuadElement (SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelement)
 
SCIP_RETCODE SCIPsetNlRowExprtree (SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRTREE *exprtree)
 
SCIP_RETCODE SCIPsetNlRowExprtreeParam (SCIP *scip, SCIP_NLROW *nlrow, int paramidx, SCIP_Real paramval)
 
SCIP_RETCODE SCIPsetNlRowExprtreeParams (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *paramvals)
 
SCIP_RETCODE SCIPrecalcNlRowNLPActivity (SCIP *scip, SCIP_NLROW *nlrow)
 
SCIP_RETCODE SCIPgetNlRowNLPActivity (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
 
SCIP_RETCODE SCIPgetNlRowNLPFeasibility (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
 
SCIP_RETCODE SCIPrecalcNlRowPseudoActivity (SCIP *scip, SCIP_NLROW *nlrow)
 
SCIP_RETCODE SCIPgetNlRowPseudoActivity (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudoactivity)
 
SCIP_RETCODE SCIPgetNlRowPseudoFeasibility (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudofeasibility)
 
SCIP_RETCODE SCIPrecalcNlRowActivity (SCIP *scip, SCIP_NLROW *nlrow)
 
SCIP_RETCODE SCIPgetNlRowActivity (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
 
SCIP_RETCODE SCIPgetNlRowFeasibility (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
 
SCIP_RETCODE SCIPgetNlRowSolActivity (SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *activity)
 
SCIP_RETCODE SCIPgetNlRowSolFeasibility (SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *feasibility)
 
SCIP_RETCODE SCIPgetNlRowActivityBounds (SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *minactivity, SCIP_Real *maxactivity)
 
SCIP_RETCODE SCIPprintNlRow (SCIP *scip, SCIP_NLROW *nlrow, FILE *file)
 
SCIP_RETCODE SCIPgetExprtreeTransformedVars (SCIP *scip, SCIP_EXPRTREE *tree)
 
SCIP_RETCODE SCIPevalExprtreeSol (SCIP *scip, SCIP_EXPRTREE *tree, SCIP_SOL *sol, SCIP_Real *val)
 
SCIP_RETCODE SCIPevalExprtreeGlobalBounds (SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
 
SCIP_RETCODE SCIPevalExprtreeLocalBounds (SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
 
void SCIPaddSquareLinearization (SCIP *scip, SCIP_Real sqrcoef, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
 
void SCIPaddSquareSecant (SCIP *scip, SCIP_Real sqrcoef, SCIP_Real lb, SCIP_Real ub, SCIP_Real refpoint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
 
void SCIPaddBilinLinearization (SCIP *scip, SCIP_Real bilincoef, SCIP_Real refpointx, SCIP_Real refpointy, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)
 
void SCIPaddBilinMcCormick (SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)
 
void SCIPcomputeBilinEnvelope1 (SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real xcoef, SCIP_Real ycoef, SCIP_Real constant, SCIP_Real *RESTRICT lincoefx, SCIP_Real *RESTRICT lincoefy, SCIP_Real *RESTRICT linconstant, SCIP_Bool *RESTRICT success)
 
void SCIPcomputeBilinEnvelope2 (SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real alpha1, SCIP_Real beta1, SCIP_Real gamma1, SCIP_Real alpha2, SCIP_Real beta2, SCIP_Real gamma2, SCIP_Real *RESTRICT lincoefx, SCIP_Real *RESTRICT lincoefy, SCIP_Real *RESTRICT linconstant, SCIP_Bool *RESTRICT success)
 
SCIP_RETCODE SCIPcreateNlpiProb (SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLROW **nlrows, int nnlrows, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_Real *nlscore, SCIP_Real cutoffbound, SCIP_Bool setobj, SCIP_Bool onlyconvex)
 
SCIP_RETCODE SCIPupdateNlpiProb (SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2nlpiidx, SCIP_VAR **nlpivars, int nlpinvars, SCIP_Real cutoffbound)
 
SCIP_RETCODE SCIPaddNlpiProbRows (SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_ROW **rows, int nrows)
 
SCIP_Real SCIPgetCutEfficacy (SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
 
SCIP_Bool SCIPisCutEfficacious (SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
 
SCIP_Bool SCIPisEfficacious (SCIP *scip, SCIP_Real efficacy)
 
SCIP_Real SCIPgetVectorEfficacyNorm (SCIP *scip, SCIP_Real *vals, int nvals)
 
SCIP_Bool SCIPisCutApplicable (SCIP *scip, SCIP_ROW *cut)
 
EXTERN SCIP_DEPRECATED SCIP_RETCODE SCIPaddCut (SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
 
SCIP_RETCODE SCIPaddRow (SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
 
SCIP_Bool SCIPisCutNew (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPaddPoolCut (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPdelPoolCut (SCIP *scip, SCIP_ROW *row)
 
SCIP_CUT ** SCIPgetPoolCuts (SCIP *scip)
 
int SCIPgetNPoolCuts (SCIP *scip)
 
SCIP_CUTPOOL * SCIPgetGlobalCutpool (SCIP *scip)
 
SCIP_RETCODE SCIPcreateCutpool (SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
 
SCIP_RETCODE SCIPfreeCutpool (SCIP *scip, SCIP_CUTPOOL **cutpool)
 
SCIP_RETCODE SCIPaddRowCutpool (SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
 
SCIP_RETCODE SCIPaddNewRowCutpool (SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
 
SCIP_RETCODE SCIPdelRowCutpool (SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
 
SCIP_RETCODE SCIPseparateCutpool (SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPseparateSolCutpool (SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPaddDelayedPoolCut (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPdelDelayedPoolCut (SCIP *scip, SCIP_ROW *row)
 
SCIP_CUT ** SCIPgetDelayedPoolCuts (SCIP *scip)
 
int SCIPgetNDelayedPoolCuts (SCIP *scip)
 
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool (SCIP *scip)
 
SCIP_RETCODE SCIPseparateSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
 
SCIP_ROW ** SCIPgetCuts (SCIP *scip)
 
int SCIPgetNCuts (SCIP *scip)
 
SCIP_RETCODE SCIPclearCuts (SCIP *scip)
 
SCIP_RETCODE SCIPremoveInefficaciousCuts (SCIP *scip)
 
SCIP_RETCODE SCIPstartDive (SCIP *scip)
 
SCIP_RETCODE SCIPendDive (SCIP *scip)
 
SCIP_RETCODE SCIPchgCutoffboundDive (SCIP *scip, SCIP_Real newcutoffbound)
 
SCIP_RETCODE SCIPchgVarObjDive (SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
 
SCIP_RETCODE SCIPchgVarLbDive (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarUbDive (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPaddRowDive (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPchgRowLhsDive (SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
 
SCIP_RETCODE SCIPchgRowRhsDive (SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
 
SCIP_Real SCIPgetVarObjDive (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarLbDive (SCIP *scip, SCIP_VAR *var)
 
SCIP_Real SCIPgetVarUbDive (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPsolveDiveLP (SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
 
SCIP_Longint SCIPgetLastDivenode (SCIP *scip)
 
SCIP_Bool SCIPinDive (SCIP *scip)
 
SCIP_Bool SCIPinProbing (SCIP *scip)
 
SCIP_RETCODE SCIPstartProbing (SCIP *scip)
 
SCIP_RETCODE SCIPnewProbingNode (SCIP *scip)
 
int SCIPgetProbingDepth (SCIP *scip)
 
SCIP_RETCODE SCIPbacktrackProbing (SCIP *scip, int probingdepth)
 
SCIP_RETCODE SCIPendProbing (SCIP *scip)
 
SCIP_RETCODE SCIPchgVarLbProbing (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_RETCODE SCIPchgVarUbProbing (SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
 
SCIP_Real SCIPgetVarObjProbing (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPfixVarProbing (SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
 
SCIP_RETCODE SCIPchgVarObjProbing (SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
 
SCIP_Bool SCIPisObjChangedProbing (SCIP *scip)
 
SCIP_RETCODE SCIPpropagateProbing (SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
 
SCIP_RETCODE SCIPpropagateProbingImplications (SCIP *scip, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPsolveProbingLP (SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPsolveProbingLPWithPricing (SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPsetProbingLPState (SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
 
SCIP_RETCODE SCIPaddRowProbing (SCIP *scip, SCIP_ROW *row)
 
SCIP_RETCODE SCIPapplyCutsProbing (SCIP *scip, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPsolveProbingRelax (SCIP *scip, SCIP_Bool *cutoff)
 
SCIP_RETCODE SCIPgetDivesetScore (SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)
 
void SCIPupdateDivesetLPStats (SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
 
void SCIPupdateDivesetStats (SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Bool leavewassol)
 
SCIP_RETCODE SCIPgetDiveBoundChanges (SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
 
SCIP_RETCODE SCIPaddDiveBoundChange (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
 
void SCIPgetDiveBoundChangeData (SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
 
void SCIPclearDiveBoundChanges (SCIP *scip)
 
SCIP_RETCODE SCIPgetLPBranchCands (SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
 
int SCIPgetNLPBranchCands (SCIP *scip)
 
int SCIPgetNPrioLPBranchCands (SCIP *scip)
 
SCIP_RETCODE SCIPgetExternBranchCands (SCIP *scip, SCIP_VAR ***externcands, SCIP_Real **externcandssol, SCIP_Real **externcandsscore, int *nexterncands, int *nprioexterncands, int *nprioexternbins, int *nprioexternints, int *nprioexternimpls)
 
int SCIPgetNExternBranchCands (SCIP *scip)
 
int SCIPgetNPrioExternBranchCands (SCIP *scip)
 
int SCIPgetNPrioExternBranchBins (SCIP *scip)
 
int SCIPgetNPrioExternBranchInts (SCIP *scip)
 
int SCIPgetNPrioExternBranchImpls (SCIP *scip)
 
int SCIPgetNPrioExternBranchConts (SCIP *scip)
 
SCIP_RETCODE SCIPaddExternBranchCand (SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
 
void SCIPclearExternBranchCands (SCIP *scip)
 
SCIP_Bool SCIPcontainsExternBranchCand (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPgetPseudoBranchCands (SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
 
int SCIPgetNPseudoBranchCands (SCIP *scip)
 
int SCIPgetNPrioPseudoBranchCands (SCIP *scip)
 
int SCIPgetNPrioPseudoBranchBins (SCIP *scip)
 
int SCIPgetNPrioPseudoBranchInts (SCIP *scip)
 
int SCIPgetNPrioPseudoBranchImpls (SCIP *scip)
 
SCIP_Real SCIPgetBranchScore (SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
 
SCIP_Real SCIPgetBranchScoreMultiple (SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
 
SCIP_Real SCIPgetBranchingPoint (SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
 
SCIP_Real SCIPcalcNodeselPriority (SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
 
SCIP_Real SCIPcalcChildEstimate (SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
 
SCIP_RETCODE SCIPcreateChild (SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
 
SCIP_RETCODE SCIPbranchVar (SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
 
SCIP_RETCODE SCIPbranchVarHole (SCIP *scip, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_NODE **downchild, SCIP_NODE **upchild)
 
SCIP_RETCODE SCIPbranchVarVal (SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
 
SCIP_RETCODE SCIPbranchVarValNary (SCIP *scip, SCIP_VAR *var, SCIP_Real val, int n, SCIP_Real minwidth, SCIP_Real widthfactor, int *nchildren)
 
SCIP_RETCODE SCIPbranchLP (SCIP *scip, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPbranchExtern (SCIP *scip, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPbranchPseudo (SCIP *scip, SCIP_RESULT *result)
 
SCIP_RETCODE SCIPcreateSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateLPSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateNLPSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateRelaxSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreatePseudoSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateCurrentSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreatePartialSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateUnknownSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateOrigSol (SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
 
SCIP_RETCODE SCIPcreateSolCopy (SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
 
SCIP_RETCODE SCIPcreateSolCopyOrig (SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
 
SCIP_RETCODE SCIPcreateFiniteSolCopy (SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
 
SCIP_RETCODE SCIPfreeSol (SCIP *scip, SCIP_SOL **sol)
 
SCIP_RETCODE SCIPlinkLPSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPlinkNLPSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPlinkRelaxSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPlinkPseudoSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPlinkCurrentSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPclearSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPunlinkSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPsetSolVal (SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
 
SCIP_RETCODE SCIPsetSolVals (SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
 
SCIP_RETCODE SCIPincSolVal (SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real incval)
 
SCIP_Real SCIPgetSolVal (SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
 
SCIP_RETCODE SCIPgetSolVals (SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
 
SCIP_Real SCIPgetSolOrigObj (SCIP *scip, SCIP_SOL *sol)
 
SCIP_Real SCIPgetSolTransObj (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPrecomputeSolObj (SCIP *scip, SCIP_SOL *sol)
 
SCIP_Real SCIPtransformObj (SCIP *scip, SCIP_Real obj)
 
SCIP_Real SCIPretransformObj (SCIP *scip, SCIP_Real obj)
 
SCIP_Real SCIPgetSolTime (SCIP *scip, SCIP_SOL *sol)
 
int SCIPgetSolRunnum (SCIP *scip, SCIP_SOL *sol)
 
SCIP_Longint SCIPgetSolNodenum (SCIP *scip, SCIP_SOL *sol)
 
SCIP_HEUR * SCIPgetSolHeur (SCIP *scip, SCIP_SOL *sol)
 
SCIP_Bool SCIPareSolsEqual (SCIP *scip, SCIP_SOL *sol1, SCIP_SOL *sol2)
 
SCIP_RETCODE SCIPadjustImplicitSolVals (SCIP *scip, SCIP_SOL *sol, SCIP_Bool uselprows)
 
SCIP_RETCODE SCIPprintSol (SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
 
SCIP_RETCODE SCIPprintTransSol (SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
 
SCIP_RETCODE SCIPprintMIPStart (SCIP *scip, SCIP_SOL *sol, FILE *file)
 
SCIP_RETCODE SCIPgetDualSolVal (SCIP *scip, SCIP_CONS *cons, SCIP_Real *dualsolval, SCIP_Bool *boundconstraint)
 
SCIP_Bool SCIPisDualSolAvailable (SCIP *scip, SCIP_Bool printreason)
 
SCIP_RETCODE SCIPprintDualSol (SCIP *scip, FILE *file, SCIP_Bool printzeros)
 
SCIP_RETCODE SCIPprintRay (SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
 
int SCIPgetNSols (SCIP *scip)
 
SCIP_SOL ** SCIPgetSols (SCIP *scip)
 
SCIP_SOL * SCIPgetBestSol (SCIP *scip)
 
SCIP_RETCODE SCIPprintBestSol (SCIP *scip, FILE *file, SCIP_Bool printzeros)
 
SCIP_RETCODE SCIPprintBestTransSol (SCIP *scip, FILE *file, SCIP_Bool printzeros)
 
SCIP_RETCODE SCIProundSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
 
SCIP_RETCODE SCIPretransformSol (SCIP *scip, SCIP_SOL *sol)
 
SCIP_RETCODE SCIPreadSol (SCIP *scip, const char *filename)
 
SCIP_RETCODE SCIPreadSolFile (SCIP *scip, const char *filename, SCIP_SOL *sol, SCIP_Bool xml, SCIP_Bool *partial, SCIP_Bool *error)
 
SCIP_RETCODE SCIPaddSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)
 
SCIP_RETCODE SCIPaddSolFree (SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
 
SCIP_RETCODE SCIPaddCurrentSol (SCIP *scip, SCIP_HEUR *heur, SCIP_Bool *stored)
 
SCIP_RETCODE SCIPtrySol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
 
SCIP_RETCODE SCIPtrySolFree (SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
 
SCIP_RETCODE SCIPtryCurrentSol (SCIP *scip, SCIP_HEUR *heur, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
 
SCIP_SOL ** SCIPgetPartialSols (SCIP *scip)
 
int SCIPgetNPartialSols (SCIP *scip)
 
SCIP_RETCODE SCIPcheckSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
 
SCIP_RETCODE SCIPcheckSolOrig (SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
 
void SCIPupdateSolIntegralityViolation (SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol)
 
void SCIPupdateSolBoundViolation (SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
 
void SCIPupdateSolLPRowViolation (SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
 
void SCIPupdateSolConsViolation (SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
 
void SCIPupdateSolLPConsViolation (SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
 
void SCIPactivateSolViolationUpdates (SCIP *scip)
 
void SCIPdeactivateSolViolationUpdates (SCIP *scip)
 
SCIP_Bool SCIPhasPrimalRay (SCIP *scip)
 
SCIP_Real SCIPgetPrimalRayVal (SCIP *scip, SCIP_VAR *var)
 
SCIP_RETCODE SCIPupdatePrimalRay (SCIP *scip, SCIP_SOL *primalray)
 
SCIP_RETCODE SCIPcatchEvent (SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
 
SCIP_RETCODE SCIPdropEvent (SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
 
SCIP_RETCODE SCIPcatchVarEvent (SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
 
SCIP_RETCODE SCIPdropVarEvent (SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
 
SCIP_RETCODE SCIPcatchRowEvent (SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
 
SCIP_RETCODE SCIPdropRowEvent (SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
 
SCIP_NODE * SCIPgetFocusNode (SCIP *scip)
 
SCIP_NODE * SCIPgetCurrentNode (SCIP *scip)
 
int SCIPgetDepth (SCIP *scip)
 
int SCIPgetFocusDepth (SCIP *scip)
 
int SCIPgetPlungeDepth (SCIP *scip)
 
SCIP_NODE * SCIPgetRootNode (SCIP *scip)
 
int SCIPgetEffectiveRootDepth (SCIP *scip)
 
SCIP_Bool SCIPinRepropagation (SCIP *scip)
 
SCIP_RETCODE SCIPgetChildren (SCIP *scip, SCIP_NODE ***children, int *nchildren)
 
int SCIPgetNChildren (SCIP *scip)
 
SCIP_RETCODE SCIPgetSiblings (SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
 
int SCIPgetNSiblings (SCIP *scip)
 
SCIP_RETCODE SCIPgetLeaves (SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
 
int SCIPgetNLeaves (SCIP *scip)
 
int SCIPgetNNodesLeft (SCIP *scip)
 
SCIP_NODE * SCIPgetPrioChild (SCIP *scip)
 
SCIP_NODE * SCIPgetPrioSibling (SCIP *scip)
 
SCIP_NODE * SCIPgetBestChild (SCIP *scip)
 
SCIP_NODE * SCIPgetBestSibling (SCIP *scip)
 
SCIP_NODE * SCIPgetBestLeaf (SCIP *scip)
 
SCIP_NODE * SCIPgetBestNode (SCIP *scip)
 
SCIP_NODE * SCIPgetBestboundNode (SCIP *scip)
 
SCIP_RETCODE SCIPgetOpenNodesData (SCIP *scip, SCIP_NODE ***leaves, SCIP_NODE ***children, SCIP_NODE ***siblings, int *nleaves, int *nchildren, int *nsiblings)
 
SCIP_RETCODE SCIPcutoffNode (SCIP *scip, SCIP_NODE *node)
 
SCIP_RETCODE SCIPrepropagateNode (SCIP *scip, SCIP_NODE *node)
 
int SCIPgetCutoffdepth (SCIP *scip)
 
int SCIPgetRepropdepth (SCIP *scip)
 
SCIP_RETCODE SCIPprintNodeRootPath (SCIP *scip, SCIP_NODE *node, FILE *file)
 
void SCIPsetFocusnodeLP (SCIP *scip, SCIP_Bool solvelp)
 
SCIP_RETCODE SCIPconstructSyncstore (SCIP *scip)
 
SCIP_RETCODE SCIPfreeSyncstore (SCIP *scip)
 
SCIP_SYNCSTORE * SCIPgetSyncstore (SCIP *scip)
 
SCIP_RETCODE SCIPgetReoptChildIDs (SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
 
SCIP_RETCODE SCIPgetReoptLeaveIDs (SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
 
int SCIPgetNReoptnodes (SCIP *scip, SCIP_NODE *node)
 
int SCIPgetNReoptLeaves (SCIP *scip, SCIP_NODE *node)
 
SCIP_REOPTNODE * SCIPgetReoptnode (SCIP *scip, unsigned int id)
 
SCIP_RETCODE SCIPaddReoptnodeBndchg (SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real bound, SCIP_BOUNDTYPE boundtype)
 
SCIP_RETCODE SCIPsetReoptCompression (SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
 
SCIP_RETCODE SCIPaddReoptnodeCons (SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, SCIP_Real lhs, SCIP_Real rhs, int nvars, REOPT_CONSTYPE constype, SCIP_Bool linear)
 
void SCIPgetReoptnodePath (SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int mem, int *nvars, int *nafterdualvars)
 
SCIP_RETCODE SCIPinitRepresentation (SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
 
SCIP_RETCODE SCIPresetRepresentation (SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
 
SCIP_RETCODE SCIPfreeRepresentation (SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
 
SCIP_RETCODE SCIPapplyReopt (SCIP *scip, SCIP_REOPTNODE *reoptnode, unsigned int id, SCIP_Real estimate, SCIP_NODE **childnodes, int *ncreatedchilds, int *naddedconss, int childnodessize, SCIP_Bool *success)
 
SCIP_RETCODE SCIPresetReoptnodeDualcons (SCIP *scip, SCIP_NODE *node)
 
SCIP_RETCODE SCIPsplitReoptRoot (SCIP *scip, int *ncreatedchilds, int *naddedconss)
 
SCIP_Bool SCIPreoptimizeNode (SCIP *scip, SCIP_NODE *node)
 
SCIP_RETCODE SCIPdeleteReoptnode (SCIP *scip, SCIP_REOPTNODE **reoptnode)
 
SCIP_Real SCIPgetReoptSimilarity (SCIP *scip, int run1, int run2)
 
void SCIPgetVarCoefChg (SCIP *scip, int varidx, SCIP_Bool *negated, SCIP_Bool *entering, SCIP_Bool *leaving)
 
int SCIPgetNRuns (SCIP *scip)
 
int SCIPgetNReoptRuns (SCIP *scip)
 
void SCIPaddNNodes (SCIP *scip, SCIP_Longint nnodes)
 
SCIP_Longint SCIPgetNNodes (SCIP *scip)
 
SCIP_Longint SCIPgetNTotalNodes (SCIP *scip)
 
SCIP_Longint SCIPgetNFeasibleLeaves (SCIP *scip)
 
SCIP_Longint SCIPgetNInfeasibleLeaves (SCIP *scip)
 
SCIP_Longint SCIPgetNObjlimLeaves (SCIP *scip)
 
SCIP_Longint SCIPgetNDelayedCutoffs (SCIP *scip)
 
SCIP_Longint SCIPgetNLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNNZs (SCIP *scip)
 
SCIP_Longint SCIPgetNRootLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNRootFirstLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNPrimalLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNPrimalLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNDualLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNDualLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNBarrierLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNBarrierLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNResolveLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNResolveLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNPrimalResolveLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNPrimalResolveLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNDualResolveLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNDualResolveLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNNodeLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNNodeLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNNodeInitLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNNodeInitLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNDivingLPs (SCIP *scip)
 
SCIP_Longint SCIPgetNDivingLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNStrongbranchs (SCIP *scip)
 
SCIP_Longint SCIPgetNStrongbranchLPIterations (SCIP *scip)
 
SCIP_Longint SCIPgetNRootStrongbranchs (SCIP *scip)
 
SCIP_Longint SCIPgetNRootStrongbranchLPIterations (SCIP *scip)
 
int SCIPgetNPriceRounds (SCIP *scip)
 
int SCIPgetNPricevars (SCIP *scip)
 
int SCIPgetNPricevarsFound (SCIP *scip)
 
int SCIPgetNPricevarsApplied (SCIP *scip)
 
int SCIPgetNSepaRounds (SCIP *scip)
 
int SCIPgetNCutsFound (SCIP *scip)
 
int SCIPgetNCutsFoundRound (SCIP *scip)
 
int SCIPgetNCutsApplied (SCIP *scip)
 
SCIP_Longint SCIPgetNConflictConssFound (SCIP *scip)
 
int SCIPgetNConflictConssFoundNode (SCIP *scip)
 
SCIP_Longint SCIPgetNConflictConssApplied (SCIP *scip)
 
int SCIPgetMaxDepth (SCIP *scip)
 
int SCIPgetMaxTotalDepth (SCIP *scip)
 
SCIP_Longint SCIPgetNBacktracks (SCIP *scip)
 
int SCIPgetNActiveConss (SCIP *scip)
 
int SCIPgetNEnabledConss (SCIP *scip)
 
SCIP_Real SCIPgetAvgDualbound (SCIP *scip)
 
SCIP_Real SCIPgetAvgLowerbound (SCIP *scip)
 
SCIP_Real SCIPgetDualbound (SCIP *scip)
 
SCIP_Real SCIPgetLowerbound (SCIP *scip)
 
SCIP_Real SCIPgetDualboundRoot (SCIP *scip)
 
SCIP_Real SCIPgetLowerboundRoot (SCIP *scip)
 
SCIP_Real SCIPgetFirstLPDualboundRoot (SCIP *scip)
 
SCIP_Real SCIPgetFirstLPLowerboundRoot (SCIP *scip)
 
SCIP_Real SCIPgetFirstPrimalBound (SCIP *scip)
 
SCIP_Real SCIPgetPrimalbound (SCIP *scip)
 
SCIP_Real SCIPgetUpperbound (SCIP *scip)
 
SCIP_Real SCIPgetCutoffbound (SCIP *scip)
 
SCIP_RETCODE SCIPupdateCutoffbound (SCIP *scip, SCIP_Real cutoffbound)
 
SCIP_Bool SCIPisPrimalboundSol (SCIP *scip)
 
SCIP_Real SCIPgetGap (SCIP *scip)
 
SCIP_Real SCIPgetTransGap (SCIP *scip)
 
SCIP_Longint SCIPgetNSolsFound (SCIP *scip)
 
SCIP_Longint SCIPgetNLimSolsFound (SCIP *scip)
 
SCIP_Longint SCIPgetNBestSolsFound (SCIP *scip)
 
SCIP_Real SCIPgetAvgPseudocost (SCIP *scip, SCIP_Real solvaldelta)
 
SCIP_Real SCIPgetAvgPseudocostCurrentRun (SCIP *scip, SCIP_Real solvaldelta)
 
SCIP_Real SCIPgetAvgPseudocostCount (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetPseudocostCount (SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
 
SCIP_Real SCIPgetAvgPseudocostScore (SCIP *scip)
 
SCIP_Real SCIPgetPseudocostVariance (SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
 
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun (SCIP *scip)
 
SCIP_Real SCIPgetAvgConflictScore (SCIP *scip)
 
SCIP_Real SCIPgetAvgConflictScoreCurrentRun (SCIP *scip)
 
SCIP_Real SCIPgetAvgConflictlengthScore (SCIP *scip)
 
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun (SCIP *scip)
 
SCIP_Real SCIPgetAvgInferences (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetAvgInferencesCurrentRun (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetAvgInferenceScore (SCIP *scip)
 
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun (SCIP *scip)
 
SCIP_Real SCIPgetAvgCutoffs (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetAvgCutoffsCurrentRun (SCIP *scip, SCIP_BRANCHDIR dir)
 
SCIP_Real SCIPgetAvgCutoffScore (SCIP *scip)
 
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun (SCIP *scip)
 
SCIP_Real SCIPgetDeterministicTime (SCIP *scip)
 
SCIP_RETCODE SCIPprintOrigProblem (SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
 
SCIP_RETCODE SCIPprintTransProblem (SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
 
void SCIPprintStatusStatistics (SCIP *scip, FILE *file)
 
void SCIPprintTimingStatistics (SCIP *scip, FILE *file)
 
void SCIPprintOrigProblemStatistics (SCIP *scip, FILE *file)
 
void SCIPprintTransProblemStatistics (SCIP *scip, FILE *file)
 
void SCIPprintPresolverStatistics (SCIP *scip, FILE *file)
 
void SCIPprintConstraintStatistics (SCIP *scip, FILE *file)
 
void SCIPprintConstraintTimingStatistics (SCIP *scip, FILE *file)
 
void SCIPprintPropagatorStatistics (SCIP *scip, FILE *file)
 
void SCIPprintConflictStatistics (SCIP *scip, FILE *file)
 
void SCIPprintSeparatorStatistics (SCIP *scip, FILE *file)
 
void SCIPprintPricerStatistics (SCIP *scip, FILE *file)
 
void SCIPprintBranchruleStatistics (SCIP *scip, FILE *file)
 
void SCIPprintHeuristicStatistics (SCIP *scip, FILE *file)
 
void SCIPprintCompressionStatistics (SCIP *scip, FILE *file)
 
void SCIPprintLPStatistics (SCIP *scip, FILE *file)
 
void SCIPprintNLPStatistics (SCIP *scip, FILE *file)
 
void SCIPprintRelaxatorStatistics (SCIP *scip, FILE *file)
 
void SCIPprintTreeStatistics (SCIP *scip, FILE *file)
 
void SCIPprintRootStatistics (SCIP *scip, FILE *file)
 
void SCIPprintSolutionStatistics (SCIP *scip, FILE *file)
 
void SCIPprintConcsolverStatistics (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPprintStatistics (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPprintReoptStatistics (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPprintBranchingStatistics (SCIP *scip, FILE *file)
 
SCIP_RETCODE SCIPprintDisplayLine (SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
 
int SCIPgetNImplications (SCIP *scip)
 
SCIP_RETCODE SCIPwriteImplicationConflictGraph (SCIP *scip, const char *filename)
 
void SCIPstoreSolutionGap (SCIP *scip)
 
SCIP_Real SCIPgetTimeOfDay (SCIP *scip)
 
SCIP_RETCODE SCIPcreateClock (SCIP *scip, SCIP_CLOCK **clck)
 
SCIP_RETCODE SCIPcreateCPUClock (SCIP *scip, SCIP_CLOCK **clck)
 
SCIP_RETCODE SCIPcreateWallClock (SCIP *scip, SCIP_CLOCK **clck)
 
SCIP_RETCODE SCIPfreeClock (SCIP *scip, SCIP_CLOCK **clck)
 
SCIP_RETCODE SCIPresetClock (SCIP *scip, SCIP_CLOCK *clck)
 
SCIP_RETCODE SCIPstartClock (SCIP *scip, SCIP_CLOCK *clck)
 
SCIP_RETCODE SCIPstopClock (SCIP *scip, SCIP_CLOCK *clck)
 
SCIP_RETCODE SCIPenableOrDisableStatisticTiming (SCIP *scip)
 
SCIP_RETCODE SCIPstartSolvingTime (SCIP *scip)
 
SCIP_RETCODE SCIPstopSolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetClockTime (SCIP *scip, SCIP_CLOCK *clck)
 
SCIP_RETCODE SCIPsetClockTime (SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
 
SCIP_Real SCIPgetTotalTime (SCIP *scip)
 
SCIP_Real SCIPgetSolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetReadingTime (SCIP *scip)
 
SCIP_Real SCIPgetPresolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetFirstLPTime (SCIP *scip)
 
SCIP_Real SCIPepsilon (SCIP *scip)
 
SCIP_Real SCIPsumepsilon (SCIP *scip)
 
SCIP_Real SCIPfeastol (SCIP *scip)
 
SCIP_Real SCIPlpfeastol (SCIP *scip)
 
SCIP_Real SCIPdualfeastol (SCIP *scip)
 
SCIP_Real SCIPbarrierconvtol (SCIP *scip)
 
SCIP_Real SCIPcutoffbounddelta (SCIP *scip)
 
SCIP_Real SCIPrelaxfeastol (SCIP *scip)
 
SCIP_RETCODE SCIPchgFeastol (SCIP *scip, SCIP_Real feastol)
 
SCIP_RETCODE SCIPchgLpfeastol (SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
 
SCIP_RETCODE SCIPchgDualfeastol (SCIP *scip, SCIP_Real dualfeastol)
 
SCIP_RETCODE SCIPchgBarrierconvtol (SCIP *scip, SCIP_Real barrierconvtol)
 
SCIP_Real SCIPchgRelaxfeastol (SCIP *scip, SCIP_Real relaxfeastol)
 
void SCIPmarkLimitChanged (SCIP *scip)
 
SCIP_Real SCIPinfinity (SCIP *scip)
 
SCIP_Real SCIPgetHugeValue (SCIP *scip)
 
SCIP_Bool SCIPisEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisInfinity (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisHugeValue (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisScalingIntegral (SCIP *scip, SCIP_Real val, SCIP_Real scalar)
 
SCIP_Bool SCIPisFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPceil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPround (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasFloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasCeil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasRound (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasFrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasFloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasCeil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasRound (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasFrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisLbBetter (SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
 
SCIP_Bool SCIPisUbBetter (SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
 
SCIP_Bool SCIPisRelEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
int SCIPconvertRealToInt (SCIP *scip, SCIP_Real real)
 
SCIP_Longint SCIPconvertRealToLongint (SCIP *scip, SCIP_Real real)
 
SCIP_Bool SCIPisUpdateUnreliable (SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
 
void SCIPprintReal (SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
 
SCIP_Bool SCIPparseReal (SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
 
SCIP_RETCODE SCIPcreateRealarray (SCIP *scip, SCIP_REALARRAY **realarray)
 
SCIP_RETCODE SCIPfreeRealarray (SCIP *scip, SCIP_REALARRAY **realarray)
 
SCIP_RETCODE SCIPextendRealarray (SCIP *scip, SCIP_REALARRAY *realarray, int minidx, int maxidx)
 
SCIP_RETCODE SCIPclearRealarray (SCIP *scip, SCIP_REALARRAY *realarray)
 
SCIP_Real SCIPgetRealarrayVal (SCIP *scip, SCIP_REALARRAY *realarray, int idx)
 
SCIP_RETCODE SCIPsetRealarrayVal (SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real val)
 
SCIP_RETCODE SCIPincRealarrayVal (SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real incval)
 
int SCIPgetRealarrayMinIdx (SCIP *scip, SCIP_REALARRAY *realarray)
 
int SCIPgetRealarrayMaxIdx (SCIP *scip, SCIP_REALARRAY *realarray)
 
SCIP_RETCODE SCIPcreateIntarray (SCIP *scip, SCIP_INTARRAY **intarray)
 
SCIP_RETCODE SCIPfreeIntarray (SCIP *scip, SCIP_INTARRAY **intarray)
 
SCIP_RETCODE SCIPextendIntarray (SCIP *scip, SCIP_INTARRAY *intarray, int minidx, int maxidx)
 
SCIP_RETCODE SCIPclearIntarray (SCIP *scip, SCIP_INTARRAY *intarray)
 
int SCIPgetIntarrayVal (SCIP *scip, SCIP_INTARRAY *intarray, int idx)
 
SCIP_RETCODE SCIPsetIntarrayVal (SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
 
SCIP_RETCODE SCIPincIntarrayVal (SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
 
int SCIPgetIntarrayMinIdx (SCIP *scip, SCIP_INTARRAY *intarray)
 
int SCIPgetIntarrayMaxIdx (SCIP *scip, SCIP_INTARRAY *intarray)
 
SCIP_RETCODE SCIPcreateBoolarray (SCIP *scip, SCIP_BOOLARRAY **boolarray)
 
SCIP_RETCODE SCIPfreeBoolarray (SCIP *scip, SCIP_BOOLARRAY **boolarray)
 
SCIP_RETCODE SCIPextendBoolarray (SCIP *scip, SCIP_BOOLARRAY *boolarray, int minidx, int maxidx)
 
SCIP_RETCODE SCIPclearBoolarray (SCIP *scip, SCIP_BOOLARRAY *boolarray)
 
SCIP_Bool SCIPgetBoolarrayVal (SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
 
SCIP_RETCODE SCIPsetBoolarrayVal (SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
 
int SCIPgetBoolarrayMinIdx (SCIP *scip, SCIP_BOOLARRAY *boolarray)
 
int SCIPgetBoolarrayMaxIdx (SCIP *scip, SCIP_BOOLARRAY *boolarray)
 
SCIP_RETCODE SCIPcreatePtrarray (SCIP *scip, SCIP_PTRARRAY **ptrarray)
 
SCIP_RETCODE SCIPfreePtrarray (SCIP *scip, SCIP_PTRARRAY **ptrarray)
 
SCIP_RETCODE SCIPextendPtrarray (SCIP *scip, SCIP_PTRARRAY *ptrarray, int minidx, int maxidx)
 
SCIP_RETCODE SCIPclearPtrarray (SCIP *scip, SCIP_PTRARRAY *ptrarray)
 
void * SCIPgetPtrarrayVal (SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
 
SCIP_RETCODE SCIPsetPtrarrayVal (SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
 
int SCIPgetPtrarrayMinIdx (SCIP *scip, SCIP_PTRARRAY *ptrarray)
 
int SCIPgetPtrarrayMaxIdx (SCIP *scip, SCIP_PTRARRAY *ptrarray)
 
SCIP_RETCODE SCIPcreateDisjointset (SCIP *scip, SCIP_DISJOINTSET **djset, int ncomponents)
 
void SCIPfreeDisjointset (SCIP *scip, SCIP_DISJOINTSET **djset)
 
SCIP_RETCODE SCIPcreateDigraph (SCIP *scip, SCIP_DIGRAPH **digraph, int nnodes)
 
SCIP_RETCODE SCIPcopyDigraph (SCIP *scip, SCIP_DIGRAPH **targetdigraph, SCIP_DIGRAPH *sourcedigraph)
 
SCIP_RETCODE SCIPvalidateSolve (SCIP *scip, SCIP_Real primalreference, SCIP_Real dualreference, SCIP_Real reftol, SCIP_Bool quiet, SCIP_Bool *feasible, SCIP_Bool *primalboundcheck, SCIP_Bool *dualboundcheck)
 
SCIP_RETCODE SCIPcreateRandom (SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed)
 
void SCIPfreeRandom (SCIP *scip, SCIP_RANDNUMGEN **randnumgen)
 
void SCIPsetRandomSeed (SCIP *scip, SCIP_RANDNUMGEN *randnumgen, unsigned int seed)
 
Memory Management Functions
BMS_BLKMEM * SCIPblkmem (SCIP *scip)
 
BMS_BUFMEM * SCIPbuffer (SCIP *scip)
 
BMS_BUFMEM * SCIPcleanbuffer (SCIP *scip)
 
SCIP_Longint SCIPgetMemUsed (SCIP *scip)
 
SCIP_Longint SCIPgetMemTotal (SCIP *scip)
 
SCIP_Longint SCIPgetMemExternEstim (SCIP *scip)
 
int SCIPcalcMemGrowSize (SCIP *scip, int num)
 
SCIP_RETCODE SCIPensureBlockMemoryArray_call (SCIP *scip, void **arrayptr, size_t elemsize, int *arraysize, int minsize)
 
void SCIPprintMemoryDiagnostic (SCIP *scip)
 

Macro Definition Documentation

◆ SCIPallocMemory

#define SCIPallocMemory (   scip,
  ptr 
)
Value:
( (BMSallocMemory((ptr)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSallocMemory
#define BMSallocMemory(ptr)
Definition: memory.h:101
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22551 of file scip.h.

Referenced by SCIPboundstoreCreate(), SCIPincludeConcurrentScipSolvers(), SCIPincludeEventHdlrGlobalbnd(), SCIPincludeHeurSync(), SCIPincludePresolSymbreak(), SCIPincludePropSync(), and SCIPincludeSepaMcf().

◆ SCIPallocMemoryArray

#define SCIPallocMemoryArray (   scip,
  ptr,
  num 
)
Value:
( (BMSallocMemoryArray((ptr), (num)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
BMSallocMemoryArray
#define BMSallocMemoryArray(ptr, num)
Definition: memory.h:105
SCIP_OKAY
Definition: type_retcode.h:33
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22553 of file scip.h.

Referenced by collectSolution(), computeAndConstraintInfos(), extractCapacities(), extractCapacityRows(), extractFlow(), extractFlowRows(), extractNodes(), identifySourcesTargets(), mcfnetworkFill(), SCIPchgVarObjProbing(), SCIPincludeHeurSync(), and tcliquegraphConstructCliqueTable().

◆ SCIPallocClearMemoryArray

#define SCIPallocClearMemoryArray (   scip,
  ptr,
  num 
)
Value:
( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSallocClearMemoryArray
#define BMSallocClearMemoryArray(ptr, num)
Definition: memory.h:107
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22555 of file scip.h.

Referenced by ensureMemorySize(), SCIP_DECL_COMPREXEC(), and SCIPmatrixCreate().

◆ SCIPallocMemorySize

#define SCIPallocMemorySize (   scip,
  ptr,
  size 
)
Value:
( (BMSallocMemorySize((ptr), (size)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSallocMemorySize
#define BMSallocMemorySize(ptr, size)
Definition: memory.h:102
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22557 of file scip.h.

◆ SCIPreallocMemoryArray

#define SCIPreallocMemoryArray (   scip,
  ptr,
  newnum 
)
Value:
( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSreallocMemoryArray
#define BMSreallocMemoryArray(ptr, num)
Definition: memory.h:109
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22559 of file scip.h.

Referenced by addVbound(), collectSolution(), computeAndConstraintInfos(), constructCompression(), createNewArc(), createNewCommodity(), ensureMemorySize(), extractCapacities(), mcfnetworkExtract(), SCIPchgVarObjProbing(), and tcliquegraphEnsureCliqueidsSize().

◆ SCIPreallocMemorySize

#define SCIPreallocMemorySize (   scip,
  ptr,
  newsize 
)
Value:
( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSreallocMemorySize
#define BMSreallocMemorySize(ptr, size)
Definition: memory.h:108
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22561 of file scip.h.

◆ SCIPduplicateMemory

#define SCIPduplicateMemory (   scip,
  ptr,
  source 
)
Value:
( (BMSduplicateMemory((ptr), (source)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
SCIP_NOMEMORY
Definition: type_retcode.h:35
BMSduplicateMemory
#define BMSduplicateMemory(ptr, source)
Definition: memory.h:123

Definition at line 22563 of file scip.h.

◆ SCIPduplicateMemoryArray

#define SCIPduplicateMemoryArray (   scip,
  ptr,
  source,
  num 
)
Value:
( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
? SCIP_NOMEMORY : SCIP_OKAY )
SCIP_OKAY
Definition: type_retcode.h:33
BMSduplicateMemoryArray
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:125
SCIP_NOMEMORY
Definition: type_retcode.h:35

Definition at line 22565 of file scip.h.

Referenced by applyProbing(), computeAndConstraintInfos(), initProblem(), scip::ObjBranchrule::ObjBranchrule(), scip::ObjConshdlr::ObjConshdlr(), scip::ObjDialog::ObjDialog(), scip::ObjDisp::ObjDisp(), scip::ObjEventhdlr::ObjEventhdlr(), scip::ObjHeur::ObjHeur(), scip::ObjNodesel::ObjNodesel(), scip::ObjPresol::ObjPresol(), scip::ObjPricer::ObjPricer(), scip::ObjProp::ObjProp(), scip::ObjReader::ObjReader(), scip::ObjRelax::ObjRelax(), scip::ObjSepa::ObjSepa(), and scip::ObjTable::ObjTable().

◆ SCIPfreeMemory

#define SCIPfreeMemory (   scip,
  ptr 
)    BMSfreeMemory(ptr)

Definition at line 22567 of file scip.h.

Referenced by SCIP_DECL_EVENTFREE(), SCIP_DECL_HEURFREE(), SCIP_DECL_PRESOLFREE(), SCIP_DECL_PROPFREE(), SCIP_DECL_SEPAFREE(), and SCIPboundstoreFree().

◆ SCIPfreeMemoryNull

#define SCIPfreeMemoryNull (   scip,
  ptr 
)    BMSfreeMemoryNull(ptr)

Definition at line 22568 of file scip.h.

◆ SCIPfreeMemoryArray

#define SCIPfreeMemoryArray (   scip,
  ptr 
)    BMSfreeMemoryArray(ptr)

Definition at line 22569 of file scip.h.

Referenced by applyProbing(), freeProblem(), freeSortedvars(), SCIP_DECL_COMPREXIT(), SCIP_DECL_HEURFREE(), SCIP_DECL_NODESELEXITSOL(), SCIP_DECL_NODESELFREE(), SCIPmatrixFree(), SCIPwriteOpb(), scip::ObjBranchrule::~ObjBranchrule(), scip::ObjConshdlr::~ObjConshdlr(), scip::ObjDialog::~ObjDialog(), scip::ObjDisp::~ObjDisp(), scip::ObjEventhdlr::~ObjEventhdlr(), scip::ObjHeur::~ObjHeur(), scip::ObjNodesel::~ObjNodesel(), scip::ObjPresol::~ObjPresol(), scip::ObjPricer::~ObjPricer(), scip::ObjProp::~ObjProp(), scip::ObjReader::~ObjReader(), scip::ObjRelax::~ObjRelax(), scip::ObjSepa::~ObjSepa(), and scip::ObjTable::~ObjTable().

◆ SCIPfreeMemoryArrayNull

#define SCIPfreeMemoryArrayNull (   scip,
  ptr 
)    BMSfreeMemoryArrayNull(ptr)

Definition at line 22570 of file scip.h.

Referenced by freeSortedvars(), mcfnetworkExtract(), mcfnetworkFree(), SCIP_DECL_CONSEXIT(), SCIP_DECL_SEPAEXITSOL(), and tcliquegraphFree().

◆ SCIPfreeMemorySize

#define SCIPfreeMemorySize (   scip,
  ptr 
)    BMSfreeMemorySize(ptr)

Definition at line 22571 of file scip.h.

◆ SCIPfreeMemorySizeNull

#define SCIPfreeMemorySizeNull (   scip,
  ptr 
)    BMSfreeMemorySizeNull(ptr)

Definition at line 22572 of file scip.h.