scip.h File Reference

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_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_prop.h"
#include "nlpi/type_nlpi.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_tree.h"
#include "scip/pub_var.h"
#include "lpi/lpi.h"
#include "nlpi/pub_expr.h"
#include "scip/presolve.h"

Go to the source code of this file.

Macros
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
Miscellaneous Methods
SCIP_Real	SCIPversion (void)
int	SCIPmajorVersion (void)
int	SCIPminorVersion (void)
int	SCIPtechVersion (void)
int	SCIPsubversion (void)
void	SCIPprintVersion (SCIP *scip, FILE *file)
void	SCIPprintError (SCIP_RETCODE retcode)
void	SCIPstoreSolutionGap (SCIP *scip)
General SCIP Methods
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)
Debug Solution Methods
void	SCIPenableDebugSol (SCIP *scip)
void	SCIPdisableDebugSol (SCIP *scip)
Message Output Methods
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	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)
Copy Methods
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 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	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_Bool global)
SCIP_RETCODE	SCIPcopyOrigVars (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap)
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 *success)
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	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)
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	SCIPcopyOrig (SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Parameter Methods
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_RETCODE	SCIPcheckBoolParam (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_RETCODE	SCIPchgLongintParam (SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
SCIP_RETCODE	SCIPsetLongintParam (SCIP *scip, const char *name, SCIP_Longint value)
SCIP_RETCODE	SCIPcheckLongintParam (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_RETCODE	SCIPchgCharParam (SCIP *scip, SCIP_PARAM *param, char value)
SCIP_RETCODE	SCIPsetCharParam (SCIP *scip, const char *name, char value)
SCIP_RETCODE	SCIPcheckCharParam (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_RETCODE	SCIPcheckStringParam (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 User Functionality Methods: Managing Plugins
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_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	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_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	SCIPincludeHeur (SCIP *scip, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, unsigned int 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, unsigned int 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, 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	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)
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)
User Interactive Dialog Methods
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)
Global Problem Methods
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_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)
Local Subproblem Methods
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)
Solve Methods
SCIP_RETCODE	SCIPtransformProb (SCIP *scip)
SCIP_RETCODE	SCIPpresolve (SCIP *scip)
SCIP_RETCODE	SCIPsolve (SCIP *scip)
SCIP_RETCODE	SCIPfreeSolve (SCIP *scip, SCIP_Bool restart)
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	SCIPgetReopSolsRun (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)
Variable Methods
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	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_RETCODE	SCIPsetRelaxSolValsSol (SCIP *scip, SCIP_SOL *sol)
SCIP_Bool	SCIPisRelaxSolValid (SCIP *scip)
SCIP_RETCODE	SCIPmarkRelaxSolValid (SCIP *scip)
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_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)
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)
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)
Conflict Analysis Methods
SCIP_Bool	SCIPisConflictAnalysisApplicable (SCIP *scip)
SCIP_RETCODE	SCIPinitConflictAnalysis (SCIP *scip)
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)
Constraint Methods
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	SCIPinitlpCons (SCIP *scip, SCIP_CONS *cons)
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)
LP Methods
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	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	SCIPcalcMIR (SCIP *scip, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, SCIP_Real maxweight, int *weightinds, int nweightinds, int rowlensum, int *sidetypes, SCIP_Real scale, SCIP_Real *mksetcoefs, SCIP_Bool *mksetcoefsvalid, SCIP_Real *mircoef, SCIP_Real *mirrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
SCIP_RETCODE	SCIPcalcStrongCG (SCIP *scip, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, int *inds, int ninds, SCIP_Real scale, SCIP_Real *mircoef, SCIP_Real *mirrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
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)
LP Column Methods
SCIP_Real	SCIPgetColRedcost (SCIP *scip, SCIP_COL *col)
SCIP_Real	SCIPgetColFarkasCoef (SCIP *scip, SCIP_COL *col)
void	SCIPmarkColNotRemovableLocal (SCIP *scip, SCIP_COL *col)
LP Row Methods
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)
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)
NLP Methods
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)
NLP Diving Methods
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)
NLP Nonlinear Row Methods
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_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)
Expression tree methods
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)
Nonlinear Methods
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)
Cutting Plane Methods
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)
SCIP_RETCODE	SCIPaddCut (SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
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 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_Real	SCIPgetRelaxFeastolFactor (SCIP *scip)
LP Diving Methods
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)
Probing Methods
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_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	SCIPaddRowProbing (SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE	SCIPapplyCutsProbing (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)
Branching Methods
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)
Primal Solution Methods
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	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	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	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 checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE	SCIPtrySolFree (SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, 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 checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE	SCIPcheckSol (SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, 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)
SCIP_Bool	SCIPhasPrimalRay (SCIP *scip)
SCIP_Real	SCIPgetPrimalRayVal (SCIP *scip, SCIP_VAR *var)
Event Methods
Events can only be caught during the operation on the transformed problem. Events on variables can only be caught for transformed variables. If you want to catch an event for an original variable, you have to get the corresponding transformed variable with a call to SCIPgetTransformedVar() and catch the event on the transformed variable.
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)
Tree Methods
SCIP_NODE *	SCIPgetCurrentNode (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)
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)
Reoptimization Methods
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 val, 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, int nvars, REOPT_CONSTYPE constype)
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)
Statistic Methods
int	SCIPgetNRuns (SCIP *scip)
int	SCIPgetNReoptRuns (SCIP *scip)
SCIP_Longint	SCIPgetNNodes (SCIP *scip)
SCIP_Longint	SCIPgetNTotalNodes (SCIP *scip)
int	SCIPgetNNodesLeft (SCIP *scip)
SCIP_Longint	SCIPgetNLPs (SCIP *scip)
SCIP_Longint	SCIPgetNLPIterations (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	SCIPgetDepth (SCIP *scip)
int	SCIPgetFocusDepth (SCIP *scip)
int	SCIPgetDepthLimit (SCIP *scip)
int	SCIPgetMaxDepth (SCIP *scip)
int	SCIPgetMaxTotalDepth (SCIP *scip)
SCIP_Longint	SCIPgetNBacktracks (SCIP *scip)
int	SCIPgetPlungeDepth (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	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	SCIPgetAvgPseudocostScore (SCIP *scip)
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_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)
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)
Timing Methods
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)
Numerical Methods
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_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)
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)
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	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)
Dynamic Arrays
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)

Macro Definition Documentation

#define SCIPallocMemory	(		scip,
			ptr
	)

Value:

( (BMSallocMemory((ptr)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20526 of file scip.h.

#define SCIPallocMemoryArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocMemoryArray((ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20528 of file scip.h.

#define SCIPallocClearMemoryArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20530 of file scip.h.

#define SCIPallocMemorySize	(		scip,
			ptr,
			size
	)

Value:

( (BMSallocMemorySize((ptr), (size)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20532 of file scip.h.

#define SCIPreallocMemoryArray	(		scip,
			ptr,
			newnum
	)

Value:

( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20534 of file scip.h.

#define SCIPreallocMemorySize	(		scip,
			ptr,
			newsize
	)

Value:

( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20536 of file scip.h.

#define SCIPduplicateMemory	(		scip,
			ptr,
			source
	)

Value:

( (BMSduplicateMemory((ptr), (source)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20538 of file scip.h.

#define SCIPduplicateMemoryArray	(		scip,
			ptr,
			source,
			num
	)

Value:

( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20540 of file scip.h.

Referenced by 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(), and scip::ObjSepa::ObjSepa().

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

Definition at line 20542 of file scip.h.

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

Definition at line 20543 of file scip.h.

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

Definition at line 20544 of file scip.h.

Referenced by 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(), and scip::ObjSepa::~ObjSepa().

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

Definition at line 20545 of file scip.h.

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

Definition at line 20546 of file scip.h.

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

Definition at line 20547 of file scip.h.

#define SCIPallocBlockMemory	(		scip,
			ptr
	)

Value:

( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20554 of file scip.h.

#define SCIPallocBlockMemoryArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20556 of file scip.h.

#define SCIPallocBlockMemorySize	(		scip,
			ptr,
			size
	)

Value:

( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20558 of file scip.h.

#define SCIPallocClearBlockMemoryArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocClearBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20560 of file scip.h.

#define SCIPreallocBlockMemoryArray	(		scip,
			ptr,
			oldnum,
			newnum
	)

Value:

( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20562 of file scip.h.

#define SCIPreallocBlockMemorySize	(		scip,
			ptr,
			oldsize,
			newsize
	)

Value:

( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20564 of file scip.h.

#define SCIPduplicateBlockMemory	(		scip,
			ptr,
			source
	)

Value:

( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20566 of file scip.h.

#define SCIPduplicateBlockMemoryArray	(		scip,
			ptr,
			source,
			num
	)

Value:

( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20568 of file scip.h.

#define SCIPensureBlockMemoryArray	(		scip,
			ptr,
			arraysizeptr,
			minsize
	)		( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )

Definition at line 20570 of file scip.h.

#define SCIPfreeBlockMemory	(		scip,
			ptr
	)		BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))

Definition at line 20571 of file scip.h.

#define SCIPfreeBlockMemoryNull	(		scip,
			ptr
	)		BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))

Definition at line 20572 of file scip.h.

#define SCIPfreeBlockMemoryArray	(		scip,
			ptr,
			num
	)		BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))

Definition at line 20573 of file scip.h.

#define SCIPfreeBlockMemoryArrayNull	(		scip,
			ptr,
			num
	)		BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))

Definition at line 20574 of file scip.h.

#define SCIPfreeBlockMemorySize	(		scip,
			ptr,
			size
	)		BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))

Definition at line 20575 of file scip.h.

#define SCIPfreeBlockMemorySizeNull	(		scip,
			ptr,
			size
	)		BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))

Definition at line 20576 of file scip.h.

#define SCIPallocBuffer	(		scip,
			ptr
	)

Value:

( (BMSallocBufferMemory(SCIPbuffer(scip), (ptr)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20583 of file scip.h.

#define SCIPallocBufferArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20585 of file scip.h.

#define SCIPallocClearBufferArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocClearBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20587 of file scip.h.

#define SCIPreallocBufferArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSreallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20589 of file scip.h.

#define SCIPduplicateBuffer	(		scip,
			ptr,
			source
	)

Value:

( (BMSduplicateBufferMemory(SCIPbuffer(scip), (ptr), (source), (size_t)sizeof(**(ptr))) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20591 of file scip.h.

#define SCIPduplicateBufferArray	(		scip,
			ptr,
			source,
			num
	)

Value:

( (BMSduplicateBufferMemoryArray(SCIPbuffer(scip), (ptr), (source), (num)) == NULL) \
                                                       ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20593 of file scip.h.

#define SCIPfreeBuffer	(		scip,
			ptr
	)		BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))

Definition at line 20595 of file scip.h.

#define SCIPfreeBufferNull	(		scip,
			ptr
	)		BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))

Definition at line 20596 of file scip.h.

#define SCIPfreeBufferArray	(		scip,
			ptr
	)		BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))

Definition at line 20597 of file scip.h.

#define SCIPfreeBufferArrayNull	(		scip,
			ptr
	)		BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))

Definition at line 20598 of file scip.h.

#define SCIPallocCleanBuffer	(		scip,
			ptr
	)

Value:

( (BMSallocBufferMemory(SCIPcleanbuffer(scip), (ptr)) == NULL) \
                                                  ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20601 of file scip.h.

#define SCIPallocCleanBufferArray	(		scip,
			ptr,
			num
	)

Value:

( (BMSallocBufferMemoryArray(SCIPcleanbuffer(scip), (ptr), (num)) == NULL) \
                                                  ? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 20603 of file scip.h.

#define SCIPfreeCleanBuffer	(		scip,
			ptr
	)		BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))

Definition at line 20605 of file scip.h.

#define SCIPfreeCleanBufferNull	(		scip,
			ptr
	)		BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))

Definition at line 20606 of file scip.h.

#define SCIPfreeCleanBufferArray	(		scip,
			ptr
	)		BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))

Definition at line 20607 of file scip.h.

#define SCIPfreeCleanBufferArrayNull	(		scip,
			ptr
	)		BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))

Definition at line 20608 of file scip.h.

Function Documentation

SCIP_Real SCIPversion

(

void

)

returns complete SCIP version number in the format "major . minor tech"

Returns

complete SCIP version

int SCIPmajorVersion

(

void

)

returns SCIP major version

Returns

major SCIP version

int SCIPminorVersion

(

void

)

returns SCIP minor version

Returns

minor SCIP version

int SCIPtechVersion

(

void

)

returns SCIP technical version

Returns

technical SCIP version

int SCIPsubversion

(

void

)

returns SCIP sub version number

Returns

subversion SCIP version

void SCIPprintVersion	(	SCIP *	scip,
		FILE *	file
	)

prints a version information line to a file stream via the message handler system

Note

If the message handler is set to a NULL pointer nothing will be printed

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

void SCIPprintError

(

SCIP_RETCODE

retcode

)

prints error message for the given SCIP_RETCODE via the error prints method

Parameters

retcode

SCIP return code causing the error

void SCIPstoreSolutionGap

(

SCIP *

scip

)

update statistical information when a new solution was found

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreate

(

SCIP **

scip

)

creates and initializes SCIP data structures

Note

The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log file and turn off/on the display output, respectively.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Postcondition

After calling this method scip reached the solving stage SCIP_STAGE_INIT

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	pointer to SCIP data structure

SCIP_RETCODE SCIPfree

(

SCIP **

scip

)

frees SCIP data structures

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_FREE

Postcondition

After calling this method SCIP reached the solving stage SCIP_STAGE_FREE

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	pointer to SCIP data structure

SCIP_STAGE SCIPgetStage

(

SCIP *

scip

)

returns current stage of SCIP

Returns

the current SCIP stage

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintStage	(	SCIP *	scip,
		FILE *	file
	)

outputs SCIP stage and solution status if applicable via the message handler

Note

If the message handler is set to a NULL pointer nothing will be printed

If limits have been changed between the solution and the call to this function, the status is recomputed and thus may to correspond to the original status.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_STATUS SCIPgetStatus

(

SCIP *

scip

)

gets solution status

Returns

SCIP solution status

See SCIP_STATUS for a complete list of all possible solving status.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintStatus	(	SCIP *	scip,
		FILE *	file
	)

outputs solution status

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

See SCIP_STATUS for a complete list of all possible solving status.

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_Bool SCIPisTransformed

(

SCIP *

scip

)

returns whether the current stage belongs to the transformed problem space

Returns

Returns TRUE if the SCIP instance is transformed, otherwise FALSE

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisExactSolve

(

SCIP *

scip

)

returns whether the solution process should be probably correct

Note

This feature is not supported yet!

Returns

Returns TRUE if SCIP is exact solving mode, otherwise FALSE

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisPresolveFinished

(

SCIP *

scip

)

returns whether the presolving process would be finished given no more presolving reductions are found in this presolving round

Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current presolving round suffice to trigger another presolving round.

Note

if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE

does not check whether infeasibility or unboundedness was already detected in presolving (which would result in presolving being stopped although the method returns TRUE)

Returns

Returns TRUE if presolving is finished if no further reductions are detected

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhasPerformedPresolve

(

SCIP *

scip

)

returns whether SCIP has performed presolving during the last solve

Returns

Returns TRUE if presolving was performed during the last solve

Parameters

scip	SCIP data structure

SCIP_Bool SCIPpressedCtrlC

(

SCIP *

scip

)

returns whether the user pressed CTRL-C to interrupt the solving process

Returns

Returns TRUE if Ctrl-C was pressed, otherwise FALSE.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisStopped

(

SCIP *

scip

)

returns whether the solving process should be / was stopped before proving optimality; if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields the reason for the premature abort

Returns

Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.

Parameters

scip	SCIP data structure

void SCIPenableDebugSol

(

SCIP *

scip

)

enable debug solution mechanism

the debug solution mechanism allows to trace back the invalidation of a debug solution during the solution process of SCIP. It must be explicitly enabled for the SCIP data structure.

See also

debug.h for more information on debug solution mechanism

Parameters

scip	SCIP data structure

void SCIPdisableDebugSol

(

SCIP *

scip

)

disable solution debugging mechanism

See also

debug.h for more information on debug solution mechanism

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetMessagehdlr	(	SCIP *	scip,
		SCIP_MESSAGEHDLR *	messagehdlr
	)

installs the given message handler, such that all messages are passed to this handler. A messages handler can be created via SCIPmessagehdlrCreate().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).

Parameters

scip	SCIP data structure
messagehdlr	message handler to install, or NULL to suppress all output

SCIP_MESSAGEHDLR* SCIPgetMessagehdlr

(

SCIP *

scip

)

returns the currently installed message handler

Returns

the currently installed message handler, or NULL if messages are currently suppressed

Parameters

scip	SCIP data structure

void SCIPsetMessagehdlrLogfile	(	SCIP *	scip,
		const char *	filename
	)

sets the log file name for the currently installed message handler

Parameters

scip	SCIP data structure
filename	name of log file, or NULL (no log)

void SCIPsetMessagehdlrQuiet	(	SCIP *	scip,
		SCIP_Bool	quiet
	)

sets the currently installed message handler to be quiet (or not)

Parameters

scip	SCIP data structure
quiet	should screen messages be suppressed?

void SCIPwarningMessage	(	SCIP *	scip,
		const char *	formatstr,
			...
	)

prints a warning message via the message handler

Parameters

scip	SCIP data structure
formatstr	format string like in printf() function

void SCIPdialogMessage	(	SCIP *	scip,
		FILE *	file,
		const char *	formatstr,
			...
	)

prints a dialog message that requests user interaction or is a direct response to a user interactive command

Parameters

scip	SCIP data structure
file	file stream to print into, or NULL for stdout
formatstr	format string like in printf() function

Referenced by scip::ObjDialog::SCIP_DECL_DIALOGDESC().

void SCIPinfoMessage	(	SCIP *	scip,
		FILE *	file,
		const char *	formatstr,
			...
	)

prints a message

Parameters

scip	SCIP data structure
file	file stream to print into, or NULL for stdout
formatstr	format string like in printf() function

void SCIPverbMessage	(	SCIP *	scip,
		SCIP_VERBLEVEL	msgverblevel,
		FILE *	file,
		const char *	formatstr,
			...
	)

prints a message depending on the verbosity level

Parameters

scip	SCIP data structure
msgverblevel	verbosity level of this message
file	file stream to print into, or NULL for stdout
formatstr	format string like in printf() function

SCIP_VERBLEVEL SCIPgetVerbLevel

(

SCIP *

scip

)

returns the current message verbosity level

Returns

message verbosity level of SCIP

See also

SCIP_VERBLEVEL for a list of all verbosity levels

Parameters

scip	SCIP data structure

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	copynlpis,
		SCIP_Bool	passmessagehdlr,
		SCIP_Bool *	valid
	)

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

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex. Also, 'passmessagehdlr' should be set to FALSE.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Postcondition

After calling this method targetscip reaches one of the following stages depending on if and when the solution process was interrupted:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
copyreaders	should the file readers be copied
copypricers	should the variable pricers be copied
copyconshdlrs	should the constraint handlers be copied
copyconflicthdlrs	should the conflict handlers be copied
copypresolvers	should the presolvers be copied
copyrelaxators	should the relaxation handler be copied
copyseparators	should the separators be copied
copypropagators	should the propagators be copied
copyheuristics	should the heuristics be copied
copyeventhdlrs	should the event handlers be copied
copynodeselectors	should the node selectors be copied
copybranchrules	should the branchrules be copied
copydisplays	should the display columns be copied
copydialogs	should the dialogs be copied
copynlpis	should the NLPIs be copied
passmessagehdlr	should the message handler be passed
valid	pointer to store whether plugins, in particular all constraint handlers which do not need constraints were validly copied

SCIP_RETCODE SCIPcopyProb	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global,
		const char *	name
	)

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

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Postcondition

After calling this method targetscip reaches one of the following stages depending on if and when the solution process was interrupted:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	create a global or a local copy?
name	problem name

SCIP_RETCODE SCIPcopyOrigProb	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		const char *	name
	)

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

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Postcondition

After calling this method targetscip reaches one of the following stages depending on if and when the solution process was interrupted:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
name	problem name of target

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
	)

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

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

if a new variable was created, this variable will be added to the target-SCIP, but it is not captured

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Note

targetscip stage does not get changed

sourcescip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
sourcevar	source variable
targetvar	pointer to store the target variable
varmap	a hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	should global or local bounds be used?
success	pointer to store whether the copying was successful or not

SCIP_RETCODE SCIPcopyVars	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global
	)

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

Note

the variables are added to the target-SCIP but not captured

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	should global or local bounds be used?

SCIP_RETCODE SCIPcopyOrigVars	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap
	)

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

Note

the variables are added to the target-SCIP but not captured

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL

SCIP_RETCODE SCIPmergeVariableStatistics	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_VAR **	sourcevars,
		SCIP_VAR **	targetvars,
		int	nvars
	)

merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to different SCIP instances.

Note

the notion of source and target is inverted here; sourcescip usually denotes a copied SCIP instance, whereas targetscip denotes the original instance

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
sourcevars	source variables for history merge
targetvars	target variables for history merge
nvars	number of variables in both variable arrays

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

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

Warning

If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may be declared feasible even if it violates this particular constraint. This constellation should only be used, if no LP or pseudo solution can violate the constraint – e.g. if a local constraint is redundant due to the variable's local bounds.

Note

The constraint is not added to the target SCIP. You can check whether a constraint is added by calling SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.)

The constraint is always captured, either during the creation of the copy or after finding the copy of the constraint in the constraint hash map

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
sourcecons	source constraint of the source SCIP
targetcons	pointer to store the created target constraint
sourceconshdlr	source constraint handler for this constraint
varmap	a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
name	name of constraint, or NULL if the name of the source constraint should be used
initial	should the LP relaxation of constraint be in the initial LP?
separate	should the constraint be separated during LP processing?
enforce	should the constraint be enforced during node processing?
check	should the constraint be checked for feasibility?
propagate	should the constraint be propagated during node processing?
local	is constraint only valid locally?
modifiable	is constraint modifiable (subject to column generation)?
dynamic	is constraint subject to aging?
removable	should the relaxation be removed from the LP due to aging or cleanup?
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node?
global	create a global or a local copy?
success	pointer to store whether the copying was successful or not

SCIP_RETCODE SCIPcopyConss	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global,
		SCIP_Bool	enablepricing,
		SCIP_Bool *	valid
	)

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

Note

the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.) You can check whether a constraint is added by calling SCIPconsIsAdded().

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	create a global or a local copy?
enablepricing	should pricing be enabled in copied SCIP instance? If TRUE, the modifiable flag of constraints will be copied.
valid	pointer to store whether all constraints were validly copied

SCIP_RETCODE SCIPcopyOrigConss	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	enablepricing,
		SCIP_Bool *	valid
	)

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

Note

the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.) You can check whether a constraint is added by calling SCIPconsIsAdded().

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
enablepricing	should pricing be enabled in copied SCIP instance? If TRUE, the modifiable flag of constraints will be copied.
valid	pointer to store whether all constraints were validly copied

SCIP_RETCODE SCIPconvertCutsToConss	(	SCIP *	scip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global,
		int *	ncutsadded
	)

convert all active cuts from cutpool to linear constraints

Note

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Note

SCIP stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	create a global or a local copy?
ncutsadded	pointer to store number of added cuts, or NULL

SCIP_RETCODE SCIPcopyCuts	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global,
		int *	ncutsadded
	)

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

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	create a global or a local copy?
ncutsadded	pointer to store number of copied cuts, or NULL

SCIP_RETCODE SCIPcopyImplicationsCliques	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		SCIP_Bool	global,
		SCIP_Bool *	infeasible,
		int *	nbdchgs,
		int *	ncopied
	)

copies implications and cliques of sourcescip to targetscip

This function should be called for a targetscip in transformed stage. It can save time in presolving of the targetscip, since implications and cliques are copied.

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
global	create a global or a local copy?
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL
ncopied	pointer to store number of copied implications and cliques, or NULL

SCIP_RETCODE SCIPcopyParamSettings	(	SCIP *	sourcescip,
		SCIP *	targetscip
	)

copies parameter settings from sourcescip to targetscip

Note

In a multi thread case, you need to lock the copying procedure from outside with a mutex.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_FREE

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure

int SCIPgetSubscipDepth

(

SCIP *

scip

)

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

Returns

Depth of subscip of SCIP is returned.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

SCIP stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

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
	)

copies source SCIP to target SCIP; the copying process is done in the following order: 1) copy the plugins 2) copy the settings 3) create problem data in target-SCIP and copy the problem data of the source-SCIP 4) copy all active variables 5) copy all constraints

Note

all variables and constraints which are created in the target-SCIP are not (user) captured

In a multi thread case, you need to lock the copying procedure from outside with a mutex. Also, 'passmessagehdlr' should be set to FALSE.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
suffix	optional suffix for problem name inside the target SCIP
global	create a global or a local copy?
enablepricing	should pricing be enabled in copied SCIP instance? If TRUE, pricer plugins will be copied and activated, and the modifiable flag of constraints will be respected. If FALSE, valid will be set to FALSE, when there are pricers present
passmessagehdlr	should the message handler be passed
valid	pointer to store whether the copying was valid or not

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
	)

copies source SCIP original problem to target SCIP; the copying process is done in the following order: 1) copy the plugins 2) copy the settings 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP 4) copy all original variables 5) copy all original constraints

Note

all variables and constraints which are created in the target-SCIP are not (user) captured

In a multi thread case, you need to lock the copying procedure from outside with a mutex. Also, 'passmessagehdlr' should be set to FALSE.

Do not change the source SCIP environment during the copying process

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if sourcescip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

This method can be called if targetscip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Note

sourcescip stage does not get changed

targetscip stage does not get changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure
varmap	a hashmap to store the mapping of source variables corresponding target variables, or NULL
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
suffix	suffix which will be added to the names of the target SCIP, might be empty
enablepricing	should pricing be enabled in copied SCIP instance? If TRUE, pricer plugins will be copied and activated, and the modifiable flag of constraints will be respected. If FALSE, valid will be set to FALSE, when there are pricers present
passmessagehdlr	should the message handler be passed
valid	pointer to store whether the copying was valid or not

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
paramdata	locally defined parameter specific data

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
minvalue	minimum value for parameter
maxvalue	maximum value for parameter
paramdata	locally defined parameter specific data

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
minvalue	minimum value for parameter
maxvalue	maximum value for parameter
paramdata	locally defined parameter specific data

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
minvalue	minimum value for parameter
maxvalue	maximum value for parameter
paramdata	locally defined parameter specific data

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
allowedvalues	array with possible parameter values, or NULL if not restricted
paramdata	locally defined parameter specific data

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
desc	description of the parameter
valueptr	pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL
isadvanced	is this parameter an advanced parameter?
defaultvalue	default value of the parameter
paramdata	locally defined parameter specific data

SCIP_Bool SCIPisParamFixed	(	SCIP *	scip,
		const char *	name
	)

gets the fixing status of an existing parameter

Returns

TRUE if the parameter is fixed to a value, otherwise FALSE.

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_PARAM* SCIPgetParam	(	SCIP *	scip,
		const char *	name
	)

returns the pointer to the SCIP parameter with the given name

Returns

pointer to the parameter with the given name

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_RETCODE SCIPgetBoolParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Bool *	value
	)

gets the value of an existing SCIP_Bool parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPgetIntParam	(	SCIP *	scip,
		const char *	name,
		int *	value
	)

gets the value of an existing int parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPgetLongintParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Longint *	value
	)

gets the value of an existing SCIP_Longint parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPgetRealParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Real *	value
	)

gets the value of an existing SCIP_Real parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPgetCharParam	(	SCIP *	scip,
		const char *	name,
		char *	value
	)

gets the value of an existing char parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPgetStringParam	(	SCIP *	scip,
		const char *	name,
		char **	value
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	pointer to store the parameter

SCIP_RETCODE SCIPfixParam	(	SCIP *	scip,
		const char *	name
	)

fixes the value of an existing parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Note

: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because they have to be changed for sub-SCIPs.

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_RETCODE SCIPunfixParam	(	SCIP *	scip,
		const char *	name
	)

unfixes the value of an existing parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_RETCODE SCIPsetParam	(	SCIP *	scip,
		const char *	name,
		void *	value
	)

changes the value of an existing parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPchgBoolParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		SCIP_Bool	value
	)

changes the value of an existing SCIP_Bool parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetBoolParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Bool	value
	)

changes the value of an existing SCIP_Bool parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPcheckBoolParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		SCIP_Bool	value
	)

checks the value of an existing SCIP_Bool parameter; issues a warning message if value was invalid

Returns

SCIP_OKAY is returned if value is valid. Otherwise SCIP_PARAMETERWRONGVAL is returned.

Parameters

scip	SCIP data structure
param	parameter
value	value to check

SCIP_RETCODE SCIPchgIntParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		int	value
	)

changes the value of an existing int parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetIntParam	(	SCIP *	scip,
		const char *	name,
		int	value
	)

changes the value of an existing int parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPchgLongintParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		SCIP_Longint	value
	)

changes the value of an existing SCIP_Longint parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetLongintParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Longint	value
	)

changes the value of an existing SCIP_Longint parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPcheckLongintParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		SCIP_Longint	value
	)

checks parameter value according to the given feasible domain; issues a warning message if value was invalid

Returns

SCIP_OKAY is returned if value is valid. Otherwise SCIP_PARAMETERWRONGVAL is returned.

Parameters

scip	SCIP data structure
param	parameter
value	value to check

SCIP_RETCODE SCIPchgRealParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		SCIP_Real	value
	)

changes the value of an existing SCIP_Real parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetRealParam	(	SCIP *	scip,
		const char *	name,
		SCIP_Real	value
	)

changes the value of an existing SCIP_Real parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPchgCharParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		char	value
	)

changes the value of an existing char parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetCharParam	(	SCIP *	scip,
		const char *	name,
		char	value
	)

changes the value of an existing char parameter

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPcheckCharParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		const char	value
	)

checks parameter value according to the given feasible domain; issues a warning message if value was invalid

Returns

SCIP_OKAY is returned if value is valid. Otherwise SCIP_PARAMETERWRONGVAL is returned.

Parameters

scip	SCIP data structure
param	parameter
value	value to check

SCIP_RETCODE SCIPchgStringParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		const char *	value
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
value	new value of the parameter

SCIP_RETCODE SCIPsetStringParam	(	SCIP *	scip,
		const char *	name,
		const char *	value
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter
value	new value of the parameter

SCIP_RETCODE SCIPcheckStringParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		const char *	value
	)

checks parameter value according to the given feasible domain; issues a warning message if value was invalid

Returns

SCIP_OKAY is returned if value is valid. Otherwise SCIP_PARAMETERWRONGVAL is returned.

Parameters

scip	SCIP data structure
param	parameter
value	value to check

SCIP_RETCODE SCIPreadParams	(	SCIP *	scip,
		const char *	filename
	)

reads parameters from a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
filename	file name

SCIP_RETCODE SCIPwriteParam	(	SCIP *	scip,
		SCIP_PARAM *	param,
		const char *	filename,
		SCIP_Bool	comments,
		SCIP_Bool	onlychanged
	)

writes a single parameter to a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
param	parameter
filename	file name, or NULL for stdout
comments	should parameter descriptions be written as comments?
onlychanged	should only those parameters be written that are changed from their default value?

SCIP_RETCODE SCIPwriteParams	(	SCIP *	scip,
		const char *	filename,
		SCIP_Bool	comments,
		SCIP_Bool	onlychanged
	)

writes all parameters in the parameter set to a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
filename	file name, or NULL for stdout
comments	should parameter descriptions be written as comments?
onlychanged	should only those parameters be written that are changed from their default value?

SCIP_RETCODE SCIPresetParam	(	SCIP *	scip,
		const char *	name
	)

resets a single parameter to its default value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_RETCODE SCIPresetParams

(

SCIP *

scip

)

resets all parameters to their default values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetEmphasis	(	SCIP *	scip,
		SCIP_PARAMEMPHASIS	paramemphasis,
		SCIP_Bool	quiet
	)

sets parameters to

• SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
• SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
• SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
• SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
• SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
• SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
• SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
paramemphasis	parameter settings
quiet	should the parameter be set quiet (no output)

SCIP_RETCODE SCIPsetSubscipsOff	(	SCIP *	scip,
		SCIP_Bool	quiet
	)

sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for auxiliary SCIP instances to avoid recursion

Note

only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	(auxiliary) SCIP data structure
quiet	should the parameter be set quiet (no output)

SCIP_RETCODE SCIPsetHeuristics	(	SCIP *	scip,
		SCIP_PARAMSETTING	paramsetting,
		SCIP_Bool	quiet
	)

sets heuristic parameters values to

• SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
• SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
• SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
• SCIP_PARAMSETTING_OFF which turn off all heuristics

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
paramsetting	parameter settings
quiet	should the parameter be set quiet (no output)

SCIP_RETCODE SCIPsetPresolving	(	SCIP *	scip,
		SCIP_PARAMSETTING	paramsetting,
		SCIP_Bool	quiet
	)

sets presolving parameters to

• SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
• SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
• SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
• SCIP_PARAMSETTING_OFF which turn off all presolving

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
paramsetting	parameter settings
quiet	should the parameter be set quiet (no output)

SCIP_RETCODE SCIPsetSeparating	(	SCIP *	scip,
		SCIP_PARAMSETTING	paramsetting,
		SCIP_Bool	quiet
	)

sets separating parameters to

• SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
• SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
• SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
• SCIP_PARAMSETTING_OFF which turn off all separating

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
paramsetting	parameter settings
quiet	should the parameter be set quiet (no output)

SCIP_PARAM** SCIPgetParams

(

SCIP *

scip

)

returns the array of all available SCIP parameters

Returns

SCIP_PARAM* array, containing all SCIP parameters.

Parameters

scip	SCIP data structure

int SCIPgetNParams

(

SCIP *

scip

)

returns the total number of all available SCIP parameters

Returns

number of all SCIP parameters.

Parameters

scip	SCIP data structure

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
	)

creates a reader and includes it in SCIP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

method has all reader callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeReaderBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of reader
desc	description of reader
extension	file extension that reader processes
readerdata	reader data

SCIP_RETCODE SCIPincludeReaderBasic	(	SCIP *	scip,
		SCIP_READER **	readerptr,
		const char *	name,
		const char *	desc,
		const char *	extension,
		SCIP_READERDATA *	readerdata
	)

creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead

Parameters

scip	SCIP data structure
readerptr	reference to reader pointer, or NULL
name	name of reader
desc	description of reader
extension	file extension that reader processes
readerdata	reader data

SCIP_RETCODE SCIPsetReaderCopy	(	SCIP *	scip,
		SCIP_READER *	reader,
		SCIP_DECL_READERCOPY((*readercopy))
	)

set copy method of reader

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
reader	reader

SCIP_RETCODE SCIPsetReaderFree	(	SCIP *	scip,
		SCIP_READER *	reader,
		SCIP_DECL_READERFREE((*readerfree))
	)

set deinitialization method of reader

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
reader	reader

SCIP_RETCODE SCIPsetReaderRead	(	SCIP *	scip,
		SCIP_READER *	reader,
		SCIP_DECL_READERREAD((*readerread))
	)

set read method of reader

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
reader	reader

SCIP_RETCODE SCIPsetReaderWrite	(	SCIP *	scip,
		SCIP_READER *	reader,
		SCIP_DECL_READERWRITE((*readerwrite))
	)

set write method of reader

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
reader	reader

SCIP_READER* SCIPfindReader	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of reader

SCIP_READER** SCIPgetReaders

(

SCIP *

scip

)

returns the array of currently available readers

Parameters

scip	SCIP data structure

int SCIPgetNReaders

(

SCIP *

scip

)

returns the number of currently available readers

Parameters

scip	SCIP data structure

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
	)

creates a variable pricer and includes it in SCIP To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer(). This should be done during the problem creation stage.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

method has all pricer callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludePricerBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of variable pricer
desc	description of variable pricer
priority	priority of the variable pricer
delay	should the pricer be delayed until no other pricers or already existing problem variables with negative reduced costs are found? if this is set to FALSE it may happen that the pricer produces columns that already exist in the problem (which are also priced in by the default problem variable pricing in the same round)
pricerdata	variable pricer data

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
	)

creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL; if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(), SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(), SCIPsetPricerFarkas();

To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer(). This should be done during the problem creation stage.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead

Parameters

scip	SCIP data structure
pricerptr	reference to a pricer, or NULL
name	name of variable pricer
desc	description of variable pricer
priority	priority of the variable pricer
delay	should the pricer be delayed until no other pricers or already existing problem variables with negative reduced costs are found? if this is set to FALSE it may happen that the pricer produces columns that already exist in the problem (which are also priced in by the default problem variable pricing in the same round)
pricerdata	variable pricer data

SCIP_RETCODE SCIPsetPricerCopy	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICERCOPY((*pricercopy))
	)

sets copy method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_RETCODE SCIPsetPricerFree	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICERFREE((*pricerfree))
	)

sets destructor method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_RETCODE SCIPsetPricerInit	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICERINIT((*pricerinit))
	)

sets initialization method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_RETCODE SCIPsetPricerExit	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICEREXIT((*pricerexit))
	)

sets deinitialization method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_RETCODE SCIPsetPricerInitsol	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICERINITSOL((*pricerinitsol))
	)

sets solving process initialization method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_RETCODE SCIPsetPricerExitsol	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		SCIP_DECL_PRICEREXITSOL((*pricerexitsol))
	)

sets solving process deinitialization method of pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	pricer

SCIP_PRICER* SCIPfindPricer	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of variable pricer

SCIP_PRICER** SCIPgetPricers

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

int SCIPgetNPricers

(

SCIP *

scip

)

returns the number of currently available variable pricers

Parameters

scip	SCIP data structure

int SCIPgetNActivePricers

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetPricerPriority	(	SCIP *	scip,
		SCIP_PRICER *	pricer,
		int	priority
	)

sets the priority of a variable pricer

Parameters

scip	SCIP data structure
pricer	variable pricer
priority	new priority of the variable pricer

SCIP_RETCODE SCIPactivatePricer	(	SCIP *	scip,
		SCIP_PRICER *	pricer
	)

activates pricer to be used for the current problem This method should be called during the problem creation stage for all pricers that are necessary to solve the problem model. The pricers are automatically deactivated when the problem is freed.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	variable pricer

SCIP_RETCODE SCIPdeactivatePricer	(	SCIP *	scip,
		SCIP_PRICER *	pricer
	)

deactivates pricer

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
pricer	variable 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_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
	)

creates a constraint handler and includes it in SCIP.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

method has all constraint handler callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeConshdlrBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of constraint handler
desc	description of constraint handler
sepapriority	priority of the constraint handler for separation
enfopriority	priority of the constraint handler for constraint enforcing
chckpriority	priority of the constraint handler for checking feasibility (and propagation)
sepafreq	frequency for separating cuts; zero means to separate only in the root node
propfreq	frequency for propagating domains; zero means only preprocessing propagation
eagerfreq	frequency for using all instead of only the useful constraints in separation, propagation and enforcement, -1 for no eager evaluations, 0 for first only
maxprerounds	maximal number of presolving rounds the constraint handler participates in (-1: no limit)
delaysepa	should separation method be delayed, if other separators found cuts?
delayprop	should propagation method be delayed, if other propagators found reductions?
needscons	should the constraint handler be skipped, if no constraints are available?
proptiming	positions in the node solving loop where propagation method of constraint handlers should be executed
presoltiming	timing mask of the constraint handler's presolving method
conshdlrdata	constraint handler data

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
	)

creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(), SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(), SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(), SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(), SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(), SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and SCIPsetConshdlrGetDiveBdChgs().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead

Parameters

scip	SCIP data structure
conshdlrptr	reference to a constraint handler pointer, or NULL
name	name of constraint handler
desc	description of constraint handler
enfopriority	priority of the constraint handler for constraint enforcing
chckpriority	priority of the constraint handler for checking feasibility (and propagation)
eagerfreq	frequency for using all instead of only the useful constraints in separation, propagation and enforcement, -1 for no eager evaluations, 0 for first only
needscons	should the constraint handler be skipped, if no constraints are available?
conshdlrdata	constraint handler data

SCIP_RETCODE SCIPsetConshdlrSepa	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSSEPALP((*conssepalp))	,
		SCIP_DECL_CONSSEPASOL((*conssepasol))	,
		int	sepafreq,
		int	sepapriority,
		SCIP_Bool	delaysepa
	)

sets all separation related callbacks/parameters of the constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler
sepafreq	frequency for separating cuts; zero means to separate only in the root node
sepapriority	priority of the constraint handler for separation
delaysepa	should separation method be delayed, if other separators found cuts?

SCIP_RETCODE SCIPsetConshdlrProp	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSPROP((*consprop))	,
		int	propfreq,
		SCIP_Bool	delayprop,
		SCIP_PROPTIMING	proptiming
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler
propfreq	frequency for propagating domains; zero means only preprocessing propagation
delayprop	should propagation method be delayed, if other propagators found reductions?
proptiming	positions in the node solving loop where propagation should be executed

SCIP_RETCODE SCIPsetConshdlrCopy	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy))	,
		SCIP_DECL_CONSCOPY((*conscopy))
	)

sets copy method of both the constraint handler and each associated constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrFree	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSFREE((*consfree))
	)

sets destructor method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrInit	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSINIT((*consinit))
	)

sets initialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrExit	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSEXIT((*consexit))
	)

sets deinitialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrInitsol	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSINITSOL((*consinitsol))
	)

sets solving process initialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrExitsol	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSEXITSOL((*consexitsol))
	)

sets solving process deinitialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrInitpre	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSINITPRE((*consinitpre))
	)

sets preprocessing initialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrExitpre	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSEXITPRE((*consexitpre))
	)

sets preprocessing deinitialization method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrPresol	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSPRESOL((*conspresol))	,
		int	maxprerounds,
		SCIP_PRESOLTIMING	presoltiming
	)

sets presolving method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler
maxprerounds	maximal number of presolving rounds the constraint handler participates in (-1: no limit)
presoltiming	timing mask of the constraint handler's presolving method

SCIP_RETCODE SCIPsetConshdlrDelete	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSDELETE((*consdelete))
	)

sets method of constraint handler to free specific constraint data

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrTrans	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSTRANS((*constrans))
	)

sets method of constraint handler to transform constraint data into data belonging to the transformed problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrInitlp	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSINITLP((*consinitlp))
	)

sets method of constraint handler to initialize LP with relaxations of "initial" constraints

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrResprop	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSRESPROP((*consresprop))
	)

sets propagation conflict resolving method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrActive	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSACTIVE((*consactive))
	)

sets activation notification method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrDeactive	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSDEACTIVE((*consdeactive))
	)

sets deactivation notification method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrEnable	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSENABLE((*consenable))
	)

sets enabling notification method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrDisable	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSDISABLE((*consdisable))
	)

sets disabling notification method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrDelvars	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSDELVARS((*consdelvars))
	)

sets variable deletion method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrPrint	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSPRINT((*consprint))
	)

sets constraint display method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrParse	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSPARSE((*consparse))
	)

sets constraint parsing method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrGetVars	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSGETVARS((*consgetvars))
	)

sets constraint variable getter method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrGetNVars	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSGETNVARS((*consgetnvars))
	)

sets constraint variable number getter method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs))
	)

sets diving enforcement method of constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_CONSHDLR* SCIPfindConshdlr	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of constraint handler

SCIP_CONSHDLR** SCIPgetConshdlrs

(

SCIP *

scip

)

returns the array of currently available constraint handlers

Parameters

scip	SCIP data structure

int SCIPgetNConshdlrs

(

SCIP *

scip

)

returns the number of currently available constraint handlers

Parameters

scip	SCIP data structure

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
	)

creates a conflict handler and includes it in SCIP

Note

method has all conflict handler callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of conflict handler
desc	description of conflict handler
priority	priority of the conflict handler
conflicthdlrdata	conflict handler data

SCIP_RETCODE SCIPincludeConflicthdlrBasic	(	SCIP *	scip,
		SCIP_CONFLICTHDLR **	conflicthdlrptr,
		const char *	name,
		const char *	desc,
		int	priority,
		SCIP_DECL_CONFLICTEXEC((*conflictexec))	,
		SCIP_CONFLICTHDLRDATA *	conflicthdlrdata
	)

creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(), SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(), and SCIPsetConflicthdlrExitsol()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead

Parameters

scip	SCIP data structure
conflicthdlrptr	reference to a conflict handler pointer, or NULL
name	name of conflict handler
desc	description of conflict handler
priority	priority of the conflict handler
conflicthdlrdata	conflict handler data

SCIP_RETCODE SCIPsetConflicthdlrCopy	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTCOPY((*conflictcopy))
	)

set copy method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_RETCODE SCIPsetConflicthdlrFree	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTFREE((*conflictfree))
	)

set destructor of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_RETCODE SCIPsetConflicthdlrInit	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTINIT((*conflictinit))
	)

set initialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_RETCODE SCIPsetConflicthdlrExit	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTEXIT((*conflictexit))
	)

set deinitialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_RETCODE SCIPsetConflicthdlrInitsol	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))
	)

set solving process initialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_RETCODE SCIPsetConflicthdlrExitsol	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))
	)

set solving process deinitialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

SCIP_CONFLICTHDLR* SCIPfindConflicthdlr	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of conflict handler

SCIP_CONFLICTHDLR** SCIPgetConflicthdlrs

(

SCIP *

scip

)

returns the array of currently available conflict handlers

Parameters

scip	SCIP data structure

int SCIPgetNConflicthdlrs

(

SCIP *

scip

)

returns the number of currently available conflict handlers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetConflicthdlrPriority	(	SCIP *	scip,
		SCIP_CONFLICTHDLR *	conflicthdlr,
		int	priority
	)

sets the priority of a conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler
priority	new priority of the conflict handler

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
	)

creates a presolver and includes it in SCIP

Note

method has all presolver callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludePresolBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of presolver
desc	description of presolver
priority	priority of the presolver (>= 0: before, < 0: after constraint handlers)
maxrounds	maximal number of presolving rounds the presolver participates in (-1: no limit)
timing	timing mask of the presolver
presoldata	presolver data

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
	)

Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(), SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().

Note

if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead

Parameters

scip	SCIP data structure
presolptr	reference to presolver, or NULL
name	name of presolver
desc	description of presolver
priority	priority of the presolver (>= 0: before, < 0: after constraint handlers)
maxrounds	maximal number of presolving rounds the presolver participates in (-1: no limit)
timing	timing mask of the presolver
presoldata	presolver data

SCIP_RETCODE SCIPsetPresolCopy	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLCOPY((*presolcopy))
	)

sets copy method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_RETCODE SCIPsetPresolFree	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLFREE((*presolfree))
	)

sets destructor method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_RETCODE SCIPsetPresolInit	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLINIT((*presolinit))
	)

sets initialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_RETCODE SCIPsetPresolExit	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLEXIT((*presolexit))
	)

sets deinitialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_RETCODE SCIPsetPresolInitpre	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLINITPRE((*presolinitpre))
	)

sets solving process initialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_RETCODE SCIPsetPresolExitpre	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		SCIP_DECL_PRESOLEXITPRE((*presolexitpre))
	)

sets solving process deinitialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

SCIP_PRESOL* SCIPfindPresol	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of presolver

SCIP_PRESOL** SCIPgetPresols

(

SCIP *

scip

)

returns the array of currently available presolvers

Parameters

scip	SCIP data structure

int SCIPgetNPresols

(

SCIP *

scip

)

returns the number of currently available presolvers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetPresolPriority	(	SCIP *	scip,
		SCIP_PRESOL *	presol,
		int	priority
	)

sets the priority of a presolver

Parameters

scip	SCIP data structure
presol	presolver
priority	new priority of the presolver

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
	)

creates a relaxation handler and includes it in SCIP

Note

method has all relaxation handler callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeRelaxBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of relaxation handler
desc	description of relaxation handler
priority	priority of the relaxation handler (negative: after LP, non-negative: before LP)
freq	frequency for calling relaxation handler
relaxdata	relaxation handler data

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
	)

creates a relaxation handler and includes it in SCIP. All non fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(), SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead

Parameters

scip	SCIP data structure
relaxptr	reference to relaxation pointer, or NULL
name	name of relaxation handler
desc	description of relaxation handler
priority	priority of the relaxation handler (negative: after LP, non-negative: before LP)
freq	frequency for calling relaxation handler
relaxdata	relaxation handler data

SCIP_RETCODE SCIPsetRelaxCopy	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXCOPY((*relaxcopy))
	)

sets copy method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RETCODE SCIPsetRelaxFree	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXFREE((*relaxfree))
	)

sets destructor method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RETCODE SCIPsetRelaxInit	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXINIT((*relaxinit))
	)

sets initialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RETCODE SCIPsetRelaxExit	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXEXIT((*relaxexit))
	)

sets deinitialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RETCODE SCIPsetRelaxInitsol	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXINITSOL((*relaxinitsol))
	)

sets solving process initialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RETCODE SCIPsetRelaxExitsol	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		SCIP_DECL_RELAXEXITSOL((*relaxexitsol))
	)

sets solving process deinitialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

SCIP_RELAX* SCIPfindRelax	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of relaxation handler

SCIP_RELAX** SCIPgetRelaxs

(

SCIP *

scip

)

returns the array of currently available relaxation handlers

Parameters

scip	SCIP data structure

int SCIPgetNRelaxs

(

SCIP *

scip

)

returns the number of currently available relaxation handlers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetRelaxPriority	(	SCIP *	scip,
		SCIP_RELAX *	relax,
		int	priority
	)

sets the priority of a relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler
priority	new priority of the relaxation handler

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
	)

creates a separator and includes it in SCIP.

Note

method has all separator callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeSepaBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of separator
desc	description of separator
priority	priority of separator (>= 0: before, < 0: after constraint handlers)
freq	frequency for calling separator
maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation
usessubscip	does the separator use a secondary SCIP instance?
delay	should separator be delayed, if other separators found cuts?
sepadata	separator data

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
	)

creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(), SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead

Parameters

scip	SCIP data structure
sepa	reference to a separator, or NULL
name	name of separator
desc	description of separator
priority	priority of separator (>= 0: before, < 0: after constraint handlers)
freq	frequency for calling separator
maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation
usessubscip	does the separator use a secondary SCIP instance?
delay	should separator be delayed, if other separators found cuts?
sepadata	separator data

SCIP_RETCODE SCIPsetSepaCopy	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPACOPY((*sepacopy))
	)

sets copy method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_RETCODE SCIPsetSepaFree	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPAFREE((*sepafree))
	)

sets destructor method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_RETCODE SCIPsetSepaInit	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPAINIT((*sepainit))
	)

sets initialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_RETCODE SCIPsetSepaExit	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPAEXIT((*sepaexit))
	)

sets deinitialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_RETCODE SCIPsetSepaInitsol	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPAINITSOL((*sepainitsol))
	)

sets solving process initialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_RETCODE SCIPsetSepaExitsol	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		SCIP_DECL_SEPAEXITSOL((*sepaexitsol))
	)

sets solving process deinitialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

SCIP_SEPA* SCIPfindSepa	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of separator

SCIP_SEPA** SCIPgetSepas

(

SCIP *

scip

)

returns the array of currently available separators

Parameters

scip	SCIP data structure

int SCIPgetNSepas

(

SCIP *

scip

)

returns the number of currently available separators

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetSepaPriority	(	SCIP *	scip,
		SCIP_SEPA *	sepa,
		int	priority
	)

sets the priority of a separator

Parameters

scip	SCIP data structure
sepa	separator
priority	new priority of the separator

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
	)

creates a propagator and includes it in SCIP.

Note

method has all propagator callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludePropBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of propagator
desc	description of propagator
priority	priority of the propagator (>= 0: before, < 0: after constraint handlers)
freq	frequency for calling propagator
delay	should propagator be delayed, if other propagators found reductions?
timingmask	positions in the node solving loop where propagator should be executed
presolpriority	presolving priority of the propagator (>= 0: before, < 0: after constraint handlers)
presolmaxrounds	maximal number of presolving rounds the propagator participates in (-1: no limit)
presoltiming	timing mask of the propagator's presolving method
propdata	propagator data

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
	)

creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(), SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(), SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead

Parameters

scip	SCIP data structure
propptr	reference to a propagator pointer, or NULL
name	name of propagator
desc	description of propagator
priority	priority of the propagator (>= 0: before, < 0: after constraint handlers)
freq	frequency for calling propagator
delay	should propagator be delayed, if other propagators found reductions?
timingmask	positions in the node solving loop where propagators should be executed
propdata	propagator data

SCIP_RETCODE SCIPsetPropCopy	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPCOPY((*propcopy))
	)

sets copy method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropFree	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPFREE((*propfree))
	)

sets destructor method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropInit	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPINIT((*propinit))
	)

sets initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropExit	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPEXIT((*propexit))
	)

sets deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropInitsol	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPINITSOL((*propinitsol))
	)

sets solving process initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropExitsol	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPEXITSOL((*propexitsol))
	)

sets solving process deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropInitpre	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPINITPRE((*propinitpre))
	)

sets preprocessing initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropExitpre	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPEXITPRE((*propexitpre))
	)

sets preprocessing deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropPresol	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPPRESOL((*proppresol))	,
		int	presolpriority,
		int	presolmaxrounds,
		SCIP_PRESOLTIMING	presoltiming
	)

sets presolving method of propagator

Parameters

scip	SCIP data structure
prop	propagator
presolpriority	presolving priority of the propagator (>= 0: before, < 0: after constraint handlers)
presolmaxrounds	maximal number of presolving rounds the propagator participates in (-1: no limit)
presoltiming	timing mask of the propagator's presolving method

SCIP_RETCODE SCIPsetPropResprop	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPRESPROP((*propresprop))
	)

sets propagation conflict resolving callback of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_PROP* SCIPfindProp	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of propagator

SCIP_PROP** SCIPgetProps

(

SCIP *

scip

)

returns the array of currently available propagators

Parameters

scip	SCIP data structure

int SCIPgetNProps

(

SCIP *

scip

)

returns the number of currently available propagators

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetPropPriority	(	SCIP *	scip,
		SCIP_PROP *	prop,
		int	priority
	)

sets the priority of a propagator

Parameters

scip	SCIP data structure
prop	propagator
priority	new priority of the propagator

SCIP_RETCODE SCIPsetPropPresolPriority	(	SCIP *	scip,
		SCIP_PROP *	prop,
		int	presolpriority
	)

sets the presolving priority of a propagator

Parameters

scip	SCIP data structure
prop	propagator
presolpriority	new presol priority of the propagator

SCIP_RETCODE SCIPincludeHeur	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		char	dispchar,
		int	priority,
		int	freq,
		int	freqofs,
		int	maxdepth,
		unsigned int	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
	)

creates a primal heuristic and includes it in SCIP.

Note

method has all heuristic callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions if you seek for a method which is less likely to change in future releases

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
name	name of primal heuristic
desc	description of primal heuristic
dispchar	display character of primal heuristic
priority	priority of the primal heuristic
freq	frequency for calling primal heuristic
freqofs	frequency offset for calling primal heuristic
maxdepth	maximal depth level to call heuristic at (-1: no limit)
timingmask	positions in the node solving loop where heuristic should be executed; see definition of SCIP_HeurTiming for possible values
usessubscip	does the heuristic use a secondary SCIP instance?
heurdata	primal heuristic data

SCIP_RETCODE SCIPincludeHeurBasic	(	SCIP *	scip,
		SCIP_HEUR **	heur,
		const char *	name,
		const char *	desc,
		char	dispchar,
		int	priority,
		int	freq,
		int	freqofs,
		int	maxdepth,
		unsigned int	timingmask,
		SCIP_Bool	usessubscip,
		SCIP_DECL_HEUREXEC((*heurexec))	,
		SCIP_HEURDATA *	heurdata
	)

creates a primal heuristic and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e. g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(), SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead

Parameters

scip	SCIP data structure
heur	pointer to the heuristic
name	name of primal heuristic
desc	description of primal heuristic
dispchar	display character of primal heuristic
priority	priority of the primal heuristic
freq	frequency for calling primal heuristic
freqofs	frequency offset for calling primal heuristic
maxdepth	maximal depth level to call heuristic at (-1: no limit)
timingmask	positions in the node solving loop where heuristic should be executed; see definition of SCIP_HeurTiming for possible values
usessubscip	does the heuristic use a secondary SCIP instance?
heurdata	primal heuristic data

SCIP_RETCODE SCIPsetHeurCopy	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEURCOPY((*heurcopy))
	)

sets copy method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_RETCODE SCIPsetHeurFree	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEURFREE((*heurfree))
	)

sets destructor method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_RETCODE SCIPsetHeurInit	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEURINIT((*heurinit))
	)

sets initialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_RETCODE SCIPsetHeurExit	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEUREXIT((*heurexit))
	)

sets deinitialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_RETCODE SCIPsetHeurInitsol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEURINITSOL((*heurinitsol))
	)

sets solving process initialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_RETCODE SCIPsetHeurExitsol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_DECL_HEUREXITSOL((*heurexitsol))
	)

sets solving process deinitialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

SCIP_HEUR* SCIPfindHeur	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of primal heuristic

SCIP_HEUR** SCIPgetHeurs

(

SCIP *

scip

)

returns the array of currently available primal heuristics

Parameters

scip	SCIP data structure

int SCIPgetNHeurs

(

SCIP *

scip

)

returns the number of currently available primal heuristics

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetHeurPriority	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		int	priority
	)

sets the priority of a primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic
priority	new priority of the primal heuristic

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
	)

creates a tree compression and includes it in SCIP.

Note

method has all compression callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of tree compression
desc	description of tree compression
priority	priority of the tree compression
minnnodes	minimal number of nodes to call compression
comprdata	tree compression data

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
	)

creates a tree compression and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e. g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(), SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead

Parameters

scip	SCIP data structure
compr	pointer to tree compression
name	name of tree compression
desc	description of tree compression
priority	priority of the tree compression
minnnodes	minimal number of nodes to call the compression
comprdata	tree compression data

SCIP_RETCODE SCIPsetComprCopy	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPRCOPY((*comprcopy))
	)

sets copy method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_RETCODE SCIPsetComprFree	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPRFREE((*comprfree))
	)

sets destructor method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_RETCODE SCIPsetComprInit	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPRINIT((*comprinit))
	)

sets initialization method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_RETCODE SCIPsetComprExit	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPREXIT((*comprexit))
	)

sets deinitialization method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_RETCODE SCIPsetComprInitsol	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPRINITSOL((*comprinitsol))
	)

sets solving process initialization method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_RETCODE SCIPsetComprExitsol	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		SCIP_DECL_COMPREXITSOL((*comprexitsol))
	)

sets solving process deinitialization method of tree compression

Parameters

scip	SCIP data structure
compr	tree compression

SCIP_COMPR* SCIPfindCompr	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of tree compression

SCIP_COMPR** SCIPgetComprs

(

SCIP *

scip

)

returns the array of currently available tree compression

Parameters

scip	SCIP data structure

int SCIPgetNCompr

(

SCIP *

scip

)

returns the number of currently available tree compression

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetComprPriority	(	SCIP *	scip,
		SCIP_COMPR *	compr,
		int	priority
	)

set the priority of a tree compression method

Parameters

scip	SCIP data structure
compr	compression
priority	new priority of the tree compression

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,
		SCIP_Bool	backtrack,
		SCIP_Bool	onlylpbranchcands,
		SCIP_Bool	specificsos1score,
		SCIP_DECL_DIVESETGETSCORE((*divesetgetscore))
	)

create a diving set associated with a primal heuristic. The primal heuristic needs to be included before this method can be called. The diveset is installed in the array of divesets of the heuristic and can be retrieved later by accessing SCIPheurGetDivesets()

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
diveset	pointer to created diving heuristic settings, or NULL if not needed
heur	primal heuristic to which the diveset belongs
name	name for the diveset, or NULL if the name of the heuristic should be used
minreldepth	minimal relative depth to start diving
maxreldepth	maximal relative depth to start diving
maxlpiterquot	maximal fraction of diving LP iterations compared to node LP iterations
maxdiveubquot	maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
maxdiveavgquot	maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
maxdiveubquotnosol	maximal UBQUOT when no solution was found yet (0.0: no limit)
maxdiveavgquotnosol	maximal AVGQUOT when no solution was found yet (0.0: no limit)
lpresolvedomchgquot	percentage of immediate domain changes during probing to trigger LP resolve
lpsolvefreq	LP solve frequency for (0: only if enough domain reductions are found by propagation)
maxlpiterofs	additional number of allowed LP iterations
backtrack	use one level of backtracking if infeasibility is encountered?
onlylpbranchcands	should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
specificsos1score	should SOS1 variables be scored by the diving heuristics specific score function; otherwise use the score function of the SOS1 constraint handler

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
	)

creates an event handler and includes it in SCIP

Note

method has all event handler callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of event handler
desc	description of event handler
eventhdlrdata	event handler data

SCIP_RETCODE SCIPincludeEventhdlrBasic	(	SCIP *	scip,
		SCIP_EVENTHDLR **	eventhdlrptr,
		const char *	name,
		const char *	desc,
		SCIP_DECL_EVENTEXEC((*eventexec))	,
		SCIP_EVENTHDLRDATA *	eventhdlrdata
	)

creates an event handler and includes it in SCIP with all its non-fundamental callbacks set to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(), SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead

Parameters

scip	SCIP data structure
eventhdlrptr	reference to an event handler, or NULL
name	name of event handler
desc	description of event handler
eventhdlrdata	event handler data

SCIP_RETCODE SCIPsetEventhdlrCopy	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTCOPY((*eventcopy))
	)

sets copy callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrFree	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTFREE((*eventfree))
	)

sets deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrInit	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTINIT((*eventinit))
	)

sets initialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrExit	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTEXIT((*eventexit))
	)

sets deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrInitsol	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTINITSOL((*eventinitsol))
	)

sets solving process initialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrExitsol	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTEXITSOL((*eventexitsol))
	)

sets solving process deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_RETCODE SCIPsetEventhdlrDelete	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_DECL_EVENTDELETE((*eventdelete))
	)

sets callback of the event handler to free specific event data

Parameters

scip	scip instance
eventhdlr	event handler

SCIP_EVENTHDLR* SCIPfindEventhdlr	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of event handler

SCIP_EVENTHDLR** SCIPgetEventhdlrs

(

SCIP *

scip

)

returns the array of currently available event handlers

Parameters

scip	SCIP data structure

int SCIPgetNEventhdlrs

(

SCIP *

scip

)

returns the number of currently available event handlers

Parameters

scip	SCIP data structure

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
	)

creates a node selector and includes it in SCIP.

Note

method has all node selector callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of node selector
desc	description of node selector
stdpriority	priority of the node selector in standard mode
memsavepriority	priority of the node selector in memory saving mode
nodeseldata	node selector data

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
	)

Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(), SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead

Parameters

scip	SCIP data structure
nodesel	reference to a node selector, or NULL
name	name of node selector
desc	description of node selector
stdpriority	priority of the node selector in standard mode
memsavepriority	priority of the node selector in memory saving mode
nodeseldata	node selector data

SCIP_RETCODE SCIPsetNodeselCopy	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELCOPY((*nodeselcopy))
	)

sets copy method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_RETCODE SCIPsetNodeselFree	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELFREE((*nodeselfree))
	)

sets destructor method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_RETCODE SCIPsetNodeselInit	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELINIT((*nodeselinit))
	)

sets initialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_RETCODE SCIPsetNodeselExit	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELEXIT((*nodeselexit))
	)

sets deinitialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_RETCODE SCIPsetNodeselInitsol	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELINITSOL((*nodeselinitsol))
	)

sets solving process initialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_RETCODE SCIPsetNodeselExitsol	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		SCIP_DECL_NODESELEXITSOL((*nodeselexitsol))
	)

sets solving process deinitialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

SCIP_NODESEL* SCIPfindNodesel	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of node selector

SCIP_NODESEL** SCIPgetNodesels

(

SCIP *

scip

)

returns the array of currently available node selectors

Parameters

scip	SCIP data structure

int SCIPgetNNodesels

(

SCIP *

scip

)

returns the number of currently available node selectors

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetNodeselStdPriority	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		int	priority
	)

sets the priority of a node selector in standard mode

Parameters

scip	SCIP data structure
nodesel	node selector
priority	new standard priority of the node selector

SCIP_RETCODE SCIPsetNodeselMemsavePriority	(	SCIP *	scip,
		SCIP_NODESEL *	nodesel,
		int	priority
	)

sets the priority of a node selector in memory saving mode

Parameters

scip	SCIP data structure
nodesel	node selector
priority	new memory saving priority of the node selector

SCIP_NODESEL* SCIPgetNodesel

(

SCIP *

scip

)

returns the currently used node selector

Parameters

scip	SCIP data structure

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
	)

creates a branching rule and includes it in SCIP

Note

method has all branching rule callbacks as arguments and is thus changed every time a new callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions if you seek for a method which is less likely to change in future releases

Parameters

scip	SCIP data structure
name	name of branching rule
desc	description of branching rule
priority	priority of the branching rule
maxdepth	maximal depth level, up to which this branching rule should be used (or -1)
maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
branchruledata	branching rule data

SCIP_RETCODE SCIPincludeBranchruleBasic	(	SCIP *	scip,
		SCIP_BRANCHRULE **	branchruleptr,
		const char *	name,
		const char *	desc,
		int	priority,
		int	maxdepth,
		SCIP_Real	maxbounddist,
		SCIP_BRANCHRULEDATA *	branchruledata
	)

creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL. Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(), SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(), SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().

Note

if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead

Parameters

scip	SCIP data structure
branchruleptr	pointer to branching rule, or NULL
name	name of branching rule
desc	description of branching rule
priority	priority of the branching rule
maxdepth	maximal depth level, up to which this branching rule should be used (or -1)
maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
branchruledata	branching rule data

SCIP_RETCODE SCIPsetBranchruleCopy	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHCOPY((*branchcopy))
	)

sets copy method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleFree	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHFREE((*branchfree))
	)

sets destructor method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleInit	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHINIT((*branchinit))
	)

sets initialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleExit	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHEXIT((*branchexit))
	)

sets deinitialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleInitsol	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHINITSOL((*branchinitsol))
	)

sets solving process initialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleExitsol	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHEXITSOL((*branchexitsol))
	)

sets solving process deinitialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleExecLp	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHEXECLP((*branchexeclp))
	)

sets branching execution method for fractional LP solutions

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleExecExt	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHEXECEXT((*branchexecext))
	)

sets branching execution method for external candidates

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_RETCODE SCIPsetBranchruleExecPs	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_DECL_BRANCHEXECPS((*branchexecps))
	)

sets branching execution method for not completely fixed pseudo solutions

Parameters

scip	SCIP data structure
branchrule	branching rule

SCIP_BRANCHRULE* SCIPfindBranchrule	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of branching rule

SCIP_BRANCHRULE** SCIPgetBranchrules

(

SCIP *

scip

)

returns the array of currently available branching rules

Parameters

scip	SCIP data structure

int SCIPgetNBranchrules

(

SCIP *

scip

)

returns the number of currently available branching rules

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetBranchrulePriority	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		int	priority
	)

sets the priority of a branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule
priority	new priority of the branching rule

SCIP_RETCODE SCIPsetBranchruleMaxdepth	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		int	maxdepth
	)

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

Parameters

scip	SCIP data structure
branchrule	branching rule
maxdepth	new maxdepth of the branching rule

SCIP_RETCODE SCIPsetBranchruleMaxbounddist	(	SCIP *	scip,
		SCIP_BRANCHRULE *	branchrule,
		SCIP_Real	maxbounddist
	)

sets maximal relative distance from current node's dual bound to primal bound for applying branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule
maxbounddist	new maxbounddist of the branching rule

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
	)

creates a display column and includes it in SCIP

Parameters

scip	SCIP data structure
name	name of display column
desc	description of display column
header	head line of display column
dispstatus	display activation status of display column
dispdata	display column data
width	width of display column (no. of chars used)
priority	priority of display column
position	relative position of display column
stripline	should the column be separated with a line from its right neighbor?

SCIP_DISP* SCIPfindDisp	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of display column

SCIP_DISP** SCIPgetDisps

(

SCIP *

scip

)

returns the array of currently available display columns

Parameters

scip	SCIP data structure

int SCIPgetNDisps

(

SCIP *

scip

)

returns the number of currently available display columns

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPautoselectDisps

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeNlpi	(	SCIP *	scip,
		SCIP_NLPI *	nlpi
	)

includes an NLPI in SCIP

Parameters

scip	SCIP data structure
nlpi	NLPI data structure

SCIP_NLPI* SCIPfindNlpi	(	SCIP *	scip,
		const char *	name
	)

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

Parameters

scip	SCIP data structure
name	name of NLPI

SCIP_NLPI** SCIPgetNlpis

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

int SCIPgetNNlpis

(

SCIP *

scip

)

returns the number of currently available NLPIs

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetNlpiPriority	(	SCIP *	scip,
		SCIP_NLPI *	nlpi,
		int	priority
	)

sets the priority of an NLPI

Parameters

scip	SCIP data structure
nlpi	NLPI
priority	new priority of the NLPI

SCIP_RETCODE SCIPincludeExternalCodeInformation	(	SCIP *	scip,
		const char *	name,
		const char *	description
	)

includes information about an external code linked into the SCIP library

Parameters

scip	SCIP data structure
name	name of external code
description	description of external code, or NULL

char** SCIPgetExternalCodeNames

(

SCIP *

scip

)

returns an array of names of currently included external codes

Parameters

scip	SCIP data structure

char** SCIPgetExternalCodeDescriptions

(

SCIP *

scip

)

returns an array of the descriptions of currently included external codes

Note

some descriptions may be NULL

Parameters

scip	SCIP data structure

int SCIPgetNExternalCodes

(

SCIP *

scip

)

returns the number of currently included information on external codes

Parameters

scip	SCIP data structure

void SCIPprintExternalCodes	(	SCIP *	scip,
		FILE *	file
	)

prints information on external codes to a file stream via the message handler system

Note

If the message handler is set to a NULL pointer nothing will be printed

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

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
	)

creates and includes dialog

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dialog	pointer to store the dialog
name	name of dialog: command name appearing in parent's dialog menu
desc	description of dialog used if description output method is NULL
issubmenu	is the dialog a submenu?
dialogdata	user defined dialog data

SCIP_Bool SCIPexistsDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

returns if the dialog already exists

Returns

TRUE is returned if the dialog exits, otherwise FALSE.

Parameters

scip	SCIP data structure
dialog	dialog

SCIP_RETCODE SCIPcaptureDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

captures a dialog

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dialog	dialog

SCIP_RETCODE SCIPreleaseDialog	(	SCIP *	scip,
		SCIP_DIALOG **	dialog
	)

releases a dialog

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dialog	pointer to the dialog

SCIP_RETCODE SCIPsetRootDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dialog	dialog to be the root

SCIP_DIALOG* SCIPgetRootDialog

(

SCIP *

scip

)

returns the root dialog of SCIP's interactive user shell

Returns

the root dialog of SCIP's interactive user shell is returned.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddDialogEntry	(	SCIP *	scip,
		SCIP_DIALOG *	dialog,
		SCIP_DIALOG *	subdialog
	)

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

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dialog	dialog to extend, or NULL for root dialog
subdialog	subdialog to add as menu entry in dialog

SCIP_RETCODE SCIPaddDialogInputLine	(	SCIP *	scip,
		const char *	inputline
	)

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

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
inputline	input line to add

SCIP_RETCODE SCIPaddDialogHistoryLine	(	SCIP *	scip,
		const char *	inputline
	)

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

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
inputline	input line to add

SCIP_RETCODE SCIPstartInteraction

(

SCIP *

scip

)

starts interactive mode of SCIP by executing the root dialog

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_FREE

Postcondition

After calling this method SCIP reaches one of the following stages depending on if and when the interactive shell was closed:

• SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
• SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
• SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
• SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
• SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
• SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
• SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_FREE

Postcondition

After calling this method, SCIP reaches the following stage:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
name	problem name
probdata	user problem data set by the reader

SCIP_RETCODE SCIPcreateProbBasic	(	SCIP *	scip,
		const char *	name
	)

creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE) all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(), SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and SCIPsetProbCopy() If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_FREE

Postcondition

After calling this method, SCIP reaches the following stage:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
name	problem name

SCIP_RETCODE SCIPsetProbDelorig	(	SCIP *	scip,
		SCIP_DECL_PROBDELORIG((*probdelorig))
	)

sets callback to free user data of original problem

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbTrans	(	SCIP *	scip,
		SCIP_DECL_PROBTRANS((*probtrans))
	)

sets callback to create user data of transformed problem by transforming original user data

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbDeltrans	(	SCIP *	scip,
		SCIP_DECL_PROBDELTRANS((*probdeltrans))
	)

sets callback to free user data of transformed problem

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbInitsol	(	SCIP *	scip,
		SCIP_DECL_PROBINITSOL((*probinitsol))
	)

sets solving process initialization callback of transformed data

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbExitsol	(	SCIP *	scip,
		SCIP_DECL_PROBEXITSOL((*probexitsol))
	)

sets solving process deinitialization callback of transformed data

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbCopy	(	SCIP *	scip,
		SCIP_DECL_PROBCOPY((*probcopy))
	)

sets callback to copy user data to a subscip

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPreadProb	(	SCIP *	scip,
		const char *	filename,
		const char *	extension
	)

reads problem from file and initializes all solving data structures

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Postcondition

After the method was called, SCIP is in one of the following stages:

• SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
• SCIP_STAGE_PROBLEM if the problem file was successfully read

Parameters

scip	SCIP data structure
filename	problem file name
extension	extension of the desired file reader, or NULL if file extension should be used

SCIP_RETCODE SCIPwriteOrigProblem	(	SCIP *	scip,
		const char *	filename,
		const char *	extension,
		SCIP_Bool	genericnames
	)

writes original problem to file

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
filename	output file (or NULL for standard output)
extension	extension of the desired file reader, or NULL if file extension should be used
genericnames	use generic variable and constraint names?

SCIP_RETCODE SCIPwriteTransProblem	(	SCIP *	scip,
		const char *	filename,
		const char *	extension,
		SCIP_Bool	genericnames
	)

writes transformed problem which are valid in the current node to file

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Note

If you want the write all constraints (including the once which are redundant for example), you need to set the parameter <write/allconss> to TRUE

Parameters

scip	SCIP data structure
filename	output file (or NULL for standard output)
extension	extension of the desired file reader, or NULL if file extension should be used
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPfreeProb

(

SCIP *

scip

)

frees problem and solution process data

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_FREE

Postcondition

After this method was called, SCIP is in the following stage:

• SCIP_STAGE_INIT

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPpermuteProb	(	SCIP *	scip,
		unsigned int	randseed,
		SCIP_Bool	permuteconss,
		SCIP_Bool	permutebinvars,
		SCIP_Bool	permuteintvars,
		SCIP_Bool	permuteimplvars,
		SCIP_Bool	permutecontvars
	)

permutes parts of the problem data structure

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED

Parameters

scip	SCIP data structure
randseed	seed value for random generator
permuteconss	should the list of constraints in each constraint handler be permuted?
permutebinvars	should the list of binary variables be permuted?
permuteintvars	should the list of integer variables be permuted?
permuteimplvars	should the list of implicit integer variables be permuted?
permutecontvars	should the list of continuous integer variables be permuted?

SCIP_PROBDATA* SCIPgetProbData

(

SCIP *

scip

)

gets user problem data

Returns

a SCIP_PROBDATA pointer, or NULL if no problem data was allocated

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbData	(	SCIP *	scip,
		SCIP_PROBDATA *	probdata
	)

sets user problem data

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
probdata	user problem data to use

const char* SCIPgetProbName

(

SCIP *

scip

)

returns name of the current problem instance

Returns

name of the current problem instance

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbName	(	SCIP *	scip,
		const char *	name
	)

sets name of the current problem instance

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
name	name to be set

SCIP_OBJSENSE SCIPgetObjsense

(

SCIP *

scip

)

returns objective sense of original problem

Returns

objective sense of original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjsense	(	SCIP *	scip,
		SCIP_OBJSENSE	objsense
	)

sets objective sense of problem

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
objsense	new objective sense

SCIP_RETCODE SCIPaddObjoffset	(	SCIP *	scip,
		SCIP_Real	addval
	)

adds offset of objective function

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
addval	value to add to objective offset

SCIP_RETCODE SCIPaddOrigObjoffset	(	SCIP *	scip,
		SCIP_Real	addval
	)

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

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
addval	value to add to objective offset

SCIP_Real SCIPgetOrigObjoffset

(

SCIP *

scip

)

returns the objective offset of the original problem

Returns

the objective offset of the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetOrigObjscale

(

SCIP *

scip

)

returns the objective scale of the original problem

Returns

the objective scale of the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransObjoffset

(

SCIP *

scip

)

returns the objective offset of the transformed problem

Returns

the objective offset of the transformed problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransObjscale

(

SCIP *

scip

)

returns the objective scale of the transformed problem

Returns

the objective scale of the transformed problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjlimit	(	SCIP *	scip,
		SCIP_Real	objlimit
	)

sets limit on objective function, such that only solutions better than this limit are accepted

Note

SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune all branch-and-bound nodes with dual bound equal or worse to the objective limit. However, SCIP will also collect solutions with objective value worse than the objective limit and use them to run improvement heuristics on them.

If SCIP can prove that there exists no solution with a strictly better objective value, the solving status will normally be infeasible (the objective limit is interpreted as part of the problem). The only exception is that by chance, SCIP found a solution with the same objective value and thus proved the optimality of this solution, resulting in solution status optimal.

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
objlimit	new primal objective limit

SCIP_Real SCIPgetObjlimit

(

SCIP *

scip

)

returns current limit on objective function

Returns

the current objective limit of the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjIntegral

(

SCIP *

scip

)

informs SCIP, that the objective value is always integral in every feasible solution

Returns

SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisObjIntegral

(

SCIP *

scip

)

returns whether the objective value is known to be integral in every feasible solution

Returns

TRUE, if objective value is known to be always integral, otherwise FALSE

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetObjNorm

(

SCIP *

scip

)

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

Returns

the Euclidean norm of the transformed objective function vector

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

adds variable to the problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to add

SCIP_RETCODE SCIPaddPricedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	score
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to add
score	pricing score of variable (the larger, the better the variable)

SCIP_RETCODE SCIPdelVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool *	deleted
	)

removes variable from the problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	variable to delete
deleted	pointer to store whether variable was successfully marked to be deleted

SCIP_RETCODE SCIPgetVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

gets variables of the problem along with the numbers of different variable types; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Note

Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR** SCIPgetVars

(

SCIP *

scip

)

gets array with active problem variables

Returns

array with active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Warning

If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned by this method.

Note

Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure

int SCIPgetNVars

(

SCIP *

scip

)

gets number of active problem variables

Returns

the number of active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNBinVars

(

SCIP *

scip

)

gets number of binary active problem variables

Returns

the number of binary active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNIntVars

(

SCIP *

scip

)

gets number of integer active problem variables

Returns

the number of integer active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNImplVars

(

SCIP *

scip

)

gets number of implicit integer active problem variables

Returns

the number of implicit integer active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNContVars

(

SCIP *

scip

)

gets number of continuous active problem variables

Returns

the number of continuous active problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNObjVars

(

SCIP *

scip

)

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

Note

In case of the original problem the number of variables is counted. In case of the transformed problem the number of variables is just returned since it is stored internally

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_VAR** SCIPgetFixedVars

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNFixedVars

(

SCIP *

scip

)

gets number of fixed or aggregated problem variables

Returns

the number of fixed or aggregated problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetOrigVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR** SCIPgetOrigVars

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNOrigVars

(

SCIP *

scip

)

gets number of original problem variables

Returns

the number of original problem variables

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNOrigBinVars

(

SCIP *

scip

)

gets number of binary variables in the original problem

Returns

the number of binary variables in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNOrigIntVars

(

SCIP *

scip

)

gets the number of integer variables in the original problem

Returns

the number of integer variables in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNOrigImplVars

(

SCIP *

scip

)

gets number of implicit integer variables in the original problem

Returns

the number of implicit integer variables in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNOrigContVars

(

SCIP *

scip

)

gets number of continuous variables in the original problem

Returns

the number of continuous variables in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNTotalVars

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetSolVarsData	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
sol	primal solution that selects the problem space, NULL for current solution
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR* SCIPfindVar	(	SCIP *	scip,
		const char *	name
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
name	name of variable to find

SCIP_Bool SCIPallVarsInProb

(

SCIP *

scip

)

returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables, that will be added in pricing and improve the objective value

Returns

TRUE, if all potential variables exist in the problem; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
cons	constraint to add

SCIP_RETCODE SCIPdelCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint to delete

SCIP_CONS* SCIPfindOrigCons	(	SCIP *	scip,
		const char *	name
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
name	name of constraint to find

SCIP_CONS* SCIPfindCons	(	SCIP *	scip,
		const char *	name
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
name	name of constraint to find

int SCIPgetNUpgrConss

(

SCIP *

scip

)

gets number of upgraded constraints

Returns

number of upgraded constraints

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNConss

(

SCIP *

scip

)

gets total number of globally valid constraints currently in the problem

Returns

total number of globally valid constraints currently in the problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_CONS** SCIPgetConss

(

SCIP *

scip

)

gets array of globally valid constraints currently in the problem

Returns

array of globally valid constraints currently in the problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Warning

If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is accessed via this method) gets resized. This can invalid the pointer which is returned by this method.

Parameters

scip	SCIP data structure

int SCIPgetNOrigConss

(

SCIP *

scip

)

gets total number of constraints in the original problem

Returns

total number of constraints in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_CONS** SCIPgetOrigConss

(

SCIP *

scip

)

gets array of constraints in the original problem

Returns

array of constraints in the original problem

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNCheckConss

(

SCIP *

scip

)

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

Returns

returns the number of check constraints

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddConsNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_CONS *	cons,
		SCIP_NODE *	validnode
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to add constraint to
cons	constraint to add
validnode	node at which the constraint is valid, or NULL

SCIP_RETCODE SCIPaddConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_NODE *	validnode
	)

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

If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode". If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to the given node. If a local constraint is added to the root node, it is added to the global problem instead.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Note

The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is the case due internal data structures and performance issues. In such a case you should try to realize your issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.

Parameters

scip	SCIP data structure
cons	constraint to add
validnode	node at which the constraint is valid, or NULL

SCIP_RETCODE SCIPdelConsNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_CONS *	cons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to disable constraint in
cons	constraint to locally delete

SCIP_RETCODE SCIPdelConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint to locally delete

SCIP_Real SCIPgetLocalOrigEstimate

(

SCIP *

scip

)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalTransEstimate

(

SCIP *

scip

)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalDualbound

(

SCIP *

scip

)

gets dual bound of current node

Returns

dual bound of current node

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalLowerbound

(

SCIP *

scip

)

gets lower bound of current node in transformed problem

Returns

lower bound of current node in transformed problem

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetNodeDualbound	(	SCIP *	scip,
		SCIP_NODE *	node
	)

gets dual bound of given node

Returns

dual bound of a given node

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to get dual bound for

SCIP_Real SCIPgetNodeLowerbound	(	SCIP *	scip,
		SCIP_NODE *	node
	)

gets lower bound of given node in transformed problem

Returns

lower bound of given node in transformed problem

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to get dual bound for

SCIP_RETCODE SCIPupdateLocalDualbound	(	SCIP *	scip,
		SCIP_Real	newbound
	)

if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in original problem space), sets the current node's dual bound to the new value

Note

the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
newbound	new dual bound for the node (if it's tighter than the old one)

SCIP_RETCODE SCIPupdateLocalLowerbound	(	SCIP *	scip,
		SCIP_Real	newbound
	)

if given value is larger than the current node's lower bound (in transformed problem), sets the current node's lower bound to the new value

Note

the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
newbound	new lower bound for the node (if it's larger than the old one)

SCIP_RETCODE SCIPupdateNodeDualbound	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_Real	newbound
	)

if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound, sets the node's dual bound to the new value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to update dual bound for
newbound	new dual bound for the node (if it's tighter than the old one)

SCIP_RETCODE SCIPupdateNodeLowerbound	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_Real	newbound
	)

if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound to the new value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to update lower bound for
newbound	new lower bound for the node (if it's larger than the old one)

SCIP_RETCODE SCIPchgChildPrio	(	SCIP *	scip,
		SCIP_NODE *	child,
		SCIP_Real	priority
	)

change the node selection priority of the given child

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
child	child to update the node selection priority
priority	node selection priority value

SCIP_RETCODE SCIPtransformProb

(

SCIP *

scip

)

initializes solving data structures and transforms problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS
• SCIP_STAGE_FREE

Postcondition

When calling this method in the SCIP_STAGE_PROBLEM stage, the SCIP stage is changed to SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPpresolve

(

SCIP *

scip

)

transforms and presolves problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED

Postcondition

After calling this method SCIP reaches one of the following stages:

• SCIP_STAGE_PRESOLVING if the presolving process was interrupted
• SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
• SCIP_STAGE_SOLVED if the problem was solved during presolving

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsolve

(

SCIP *

scip

)

transforms, presolves, and solves problem

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Postcondition

After calling this method SCIP reaches one of the following stages depending on if and when the solution process was interrupted:

• SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
• SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
• SCIP_STAGE_SOLVED if the solving process was not interrupted

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPfreeSolve	(	SCIP *	scip,
		SCIP_Bool	restart
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Postcondition

If this method is called in SCIP stage SCIP_STAGE_INIT or SCIP_STAGE_PROBLEM, the stage of SCIP is not changed; otherwise, the SCIP stage is changed to SCIP_STAGE_TRANSFORMED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
restart	should certain data be preserved for improved restarting?

SCIP_RETCODE SCIPfreeTransform

(

SCIP *

scip

)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Postcondition

After calling this method SCIP reaches one of the following stages:

• SCIP_STAGE_INIT if the method was called from SCIP stage SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPinterruptSolve

(

SCIP *

scip

)

informs SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has been solved)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

the SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPrestartSolve

(

SCIP *

scip

)

informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has been solved)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Note

the SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPenableReoptimization	(	SCIP *	scip,
		SCIP_Bool	enable
	)

include specific heuristics and branching rules for reoptimization

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
enable	enable reoptimization (TRUE) or disable it (FALSE)

SCIP_Bool SCIPisReoptEnabled

(

SCIP *

scip

)

returns whether reoptimization is enabled or not

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetReopSolsRun	(	SCIP *	scip,
		int	run,
		SCIP_SOL **	sols,
		int	allocmem,
		int *	nsols
	)

returns the stored solutions corresponding to a given run

Parameters

scip	SCIP data structue
run	number of the run
sols	array to store solutions
allocmem	allocated size of the array
nsols	number of solutions

void SCIPresetReoptSolMarks

(

SCIP *

scip

)

mark all stored solutions as not updated

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcheckReoptRestart	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_Bool *	restart
	)

check if the reoptimization process should be restarted

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	current node of the branch and bound tree (or NULL)
restart	pointer to store of the reoptimitation process should be restarted

SCIP_RETCODE SCIPaddReoptDualBndchg	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Real	oldbound
	)

save bound change based on dual information in the reoptimization tree

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
node	node of the search tree
var	variable whose bound changed
newbound	new bound of the variable
oldbound	old bound of the variable

SCIP_SOL* SCIPgetReoptLastOptSol

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetReoptOldObjCoef	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	run,
		SCIP_Real *	objcoef
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable
run	number of the run
objcoef	pointer to store the objective coefficient

SCIP_Bool SCIPisInRestart

(

SCIP *

scip

)

returns whether we are in the restarting phase

Returns

TRUE, if we are in the restarting phase; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

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
	)

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

Warning

When doing column generation and the original problem is a maximization problem, notice that SCIP will transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the original objective function value of variables created during the solving process has to be multiplied by -1, too.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()

Parameters

scip	SCIP data structure
var	pointer to variable object
name	name of variable, or NULL for automatic name creation
lb	lower bound of variable
ub	upper bound of variable
obj	objective function value
vartype	type of variable
initial	should var's column be present in the initial root LP?
removable	is var's column removable from the LP (due to aging or cleanup)?
vardata	user data for this specific variable, or NULL

SCIP_RETCODE SCIPcreateVarBasic	(	SCIP *	scip,
		SCIP_VAR **	var,
		const char *	name,
		SCIP_Real	lb,
		SCIP_Real	ub,
		SCIP_Real	obj,
		SCIP_VARTYPE	vartype
	)

creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(), SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable;

Warning

When doing column generation and the original problem is a maximization problem, notice that SCIP will transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the original objective function value of variables created during the solving process has to be multiplied by -1, too.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()

Parameters

scip	SCIP data structure
var	pointer to variable object
name	name of variable, or NULL for automatic name creation
lb	lower bound of variable
ub	upper bound of variable
obj	objective function value
vartype	type of variable

SCIP_RETCODE SCIPwriteVarName	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR *	var,
		SCIP_Bool	type
	)

outputs the variable name to the file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
var	variable to output
type	should the variable type be also posted

SCIP_RETCODE SCIPwriteVarsList	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Bool	type,
		char	delimiter
	)

print the given list of variables to output stream separated by the given delimiter character;

i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;

the method SCIPparseVarsList() can parse such a string

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
vars	variable array to output
nvars	number of variables
type	should the variable type be also posted
delimiter	character which is used for delimitation

SCIP_RETCODE SCIPwriteVarsLinearsum	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		int	nvars,
		SCIP_Bool	type
	)

print the given variables and coefficients as linear sum in the following form c1 <x1> + c2 <x2> ... + cn <xn>

This string can be parsed by the method SCIPparseVarsLinearsum().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
vars	variable array to output
vals	array of coefficients or NULL if all coefficients are 1.0
nvars	number of variables
type	should the variable type be also posted

SCIP_RETCODE SCIPwriteVarsPolynomial	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR ***	monomialvars,
		SCIP_Real **	monomialexps,
		SCIP_Real *	monomialcoefs,
		int *	monomialnvars,
		int	nmonomials,
		SCIP_Bool	type
	)

print the given monomials as polynomial in the following form c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...

This string can be parsed by the method SCIPparseVarsPolynomial().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
monomialvars	arrays with variables for each monomial
monomialexps	arrays with variable exponents, or NULL if always 1.0
monomialcoefs	array with monomial coefficients
monomialnvars	array with number of variables for each monomial
nmonomials	number of monomials
type	should the variable type be also posted

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
	)

parses variable information (in cip format) out of a string; if the parsing process was successful a variable is created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	pointer to store the problem variable
str	string to parse
initial	should var's column be present in the initial root LP?
removable	is var's column removable from the LP (due to aging or cleanup)?
vardata	user data for this specific variable
endptr	pointer to store the final string position if successful
success	pointer store if the paring process was successful

SCIP_RETCODE SCIPparseVarName	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR **	var,
		char **	endptr
	)

parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable exits and returns the position where the parsing stopped

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
str	string to parse
var	pointer to store the problem variable, or NULL if it does not exit
endptr	pointer to store the final string position if successful

SCIP_RETCODE SCIPparseVarsList	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR **	vars,
		int *	nvars,
		int	varssize,
		int *	requiredsize,
		char **	endptr,
		char	delimiter,
		SCIP_Bool *	success
	)

parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.

If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding integer; the reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP memory functions).

Parameters

scip	SCIP data structure
str	string to parse
vars	array to store the parsed variable
nvars	pointer to store number of parsed variables
varssize	size of the variable array
requiredsize	pointer to store the required array size for the active variables
endptr	pointer to store the final string position if successful
delimiter	character which is used for delimitation
success	pointer to store the whether the parsing was successful or not

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
	)

parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>) (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.

If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding integer; the reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP memory functions).

Parameters

scip	SCIP data structure
str	string to parse
vars	array to store the parsed variables
vals	array to store the parsed coefficients
nvars	pointer to store number of parsed variables
varssize	size of the variable array
requiredsize	pointer to store the required array size for the active variables
endptr	pointer to store the final string position if successful
success	pointer to store the whether the parsing was successful or not

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
	)

parse the given string as polynomial of variables and coefficients (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...) (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE

The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since they use buffer memory that is intended for short term use only.

Parsing is stopped at the end of string (indicated by the \0-character) or when no more monomials are recognized.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
str	string to parse
monomialvars	pointer to store arrays with variables for each monomial
monomialexps	pointer to store arrays with variable exponents
monomialcoefs	pointer to store array with monomial coefficients
monomialnvars	pointer to store array with number of variables for each monomial
nmonomials	pointer to store number of parsed monomials
endptr	pointer to store the final string position if successful
success	pointer to store the whether the parsing was successful or not

void SCIPfreeParseVarsPolynomialData	(	SCIP *	scip,
		SCIP_VAR ****	monomialvars,
		SCIP_Real ***	monomialexps,
		SCIP_Real **	monomialcoefs,
		int **	monomialnvars,
		int	nmonomials
	)

frees memory allocated when parsing a polynomial from a string

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
monomialvars	pointer to store arrays with variables for each monomial
monomialexps	pointer to store arrays with variable exponents
monomialcoefs	pointer to store array with monomial coefficients
monomialnvars	pointer to store array with number of variables for each monomial
nmonomials	pointer to store number of parsed monomials

SCIP_RETCODE SCIPcaptureVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

increases usage counter of variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	variable to capture

SCIP_RETCODE SCIPreleaseVar	(	SCIP *	scip,
		SCIP_VAR **	var
	)

decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

the pointer of the variable will be NULLed

Parameters

scip	SCIP data structure
var	pointer to variable

SCIP_RETCODE SCIPchgVarName	(	SCIP *	scip,
		SCIP_VAR *	var,
		const char *	name
	)

changes the name of a variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_PROBLEM

Note

to get the current name of a variable, use SCIPvarGetName() from pub_var.h

Parameters

scip	SCIP data structure
var	variable
name	new name of constraint

SCIP_RETCODE SCIPtransformVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	transvar
	)

gets and captures transformed variable of a given variable; if the variable is not yet transformed, a new transformed variable for this variable is created

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get/create transformed variable for
transvar	pointer to store the transformed variable

SCIP_RETCODE SCIPtransformVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	transvars
	)

gets and captures transformed variables for an array of variables; if a variable of the array is not yet transformed, a new transformed variable for this variable is created; it is possible to call this method with vars == transvars

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nvars	number of variables to get/create transformed variables for
vars	array with variables to get/create transformed variables for
transvars	array to store the transformed variables

SCIP_RETCODE SCIPgetTransformedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	transvar
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	variable to get transformed variable for
transvar	pointer to store the transformed variable

SCIP_RETCODE SCIPgetTransformedVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	transvars
	)

gets corresponding transformed variables for an array of variables; stores NULL in a transvars slot, if the transformed variable is not yet existing; it is possible to call this method with vars == transvars, but remember that variables that are not yet transformed will be replaced with NULL

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
nvars	number of variables to get transformed variables for
vars	array with variables to get transformed variables for
transvars	array to store the transformed variables

SCIP_RETCODE SCIPgetNegatedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	negvar
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	variable to get negated variable for
negvar	pointer to store the negated variable

SCIP_RETCODE SCIPgetNegatedVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	negvars
	)

gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing; in difference to SCIPcreateVar, the negated variable must not be released (unless captured explicitly)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
nvars	number of variables to get negated variables for
vars	array of variables to get negated variables for
negvars	array to store the negated variables

SCIP_RETCODE SCIPgetBinvarRepresentative	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	repvar,
		SCIP_Bool *	negated
	)

gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	binary variable to get binary representative for
repvar	pointer to store the binary representative
negated	pointer to store whether the negation of an active variable was returned

SCIP_RETCODE SCIPgetBinvarRepresentatives	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	repvars,
		SCIP_Bool *	negated
	)

gets binary variables that are equal to the given binary variables, and which are either active, fixed, or multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
nvars	number of binary variables to get representatives for
vars	binary variables to get binary representatives for
repvars	array to store the binary representatives
negated	array to store whether the negation of an active variable was returned

SCIP_RETCODE SCIPflattenVarAggregationGraph	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_RETCODE SCIPgetProbvarLinearSum	(	SCIP *	scip,
		SCIP_VAR **	vars,
		SCIP_Real *	scalars,
		int *	nvars,
		int	varssize,
		SCIP_Real *	constant,
		int *	requiredsize,
		SCIP_Bool	mergemultiples
	)

Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of active variables, that is b_1*y_1 + ... + b_m*y_m + d.

If the number of needed active variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable representation is stored in the variable array, scalar array and constant.

The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP functions).

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the given entries are overwritten.

That method can be used to convert a single variables into variable space of active variables. Therefore call the method with the linear sum 1.0*x + 0.0.

Parameters

scip	SCIP data structure
vars	variable array x_1, ..., x_n in the linear sum which will be overwritten by the variable array y_1, ..., y_m in the linear sum w.r.t. active variables
scalars	scalars a_1, ..., a_n in linear sum which will be overwritten to the scalars b_1, ..., b_m in the linear sum of the active variables
nvars	pointer to number of variables in the linear sum which will be overwritten by the number of variables in the linear sum corresponding to the active variables
varssize	available slots in vars and scalars array which is needed to check if the array are large enough for the linear sum w.r.t. active variables
constant	pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m + d w.r.t. the active variables
requiredsize	pointer to store the required array size for the linear sum w.r.t. the active variables
mergemultiples	should multiple occurrences of a var be replaced by a single coeff?

SCIP_RETCODE SCIPgetProbvarSum	(	SCIP *	scip,
		SCIP_VAR **	var,
		SCIP_Real *	scalar,
		SCIP_Real *	constant
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	pointer to problem variable x in sum a*x + c
scalar	pointer to scalar a in sum a*x + c
constant	pointer to constant c in sum a*x + c

SCIP_RETCODE SCIPgetActiveVars	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int *	nvars,
		int	varssize,
		int *	requiredsize
	)

return for given variables all their active counterparts; all active variables will be pairwise different

Note

It does not hold that the first output variable is the active variable for the first input variable.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
vars	variable array with given variables and as output all active variables, if enough slots exist
nvars	number of given variables, and as output number of active variables, if enough slots exist
varssize	available slots in vars array
requiredsize	pointer to store the required array size for the active variables

SCIP_Real SCIPgetVarRedcost	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the reduced costs of the variable in the current node's LP relaxation; the current node has to have a feasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP

SCIP_Real SCIPgetVarImplRedcost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	varfixing
	)

returns the implied reduced costs of the variable in the current node's LP relaxation; the current node has to have a feasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP
varfixing	FALSE if for x == 0, TRUE for x == 1

SCIP_Real SCIPgetVarFarkasCoef	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the Farkas coefficient of the variable in the current node's LP relaxation; the current node has to have an infeasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP

SCIP_Real SCIPgetVarSol	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets solution value for variable in current node

Returns

solution value for variable in current node

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get solution value for

SCIP_RETCODE SCIPgetVarSols	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

gets solution values of multiple variables in current node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nvars	number of variables to get solution value for
vars	array with variables to get value for
vals	array to store solution values of variables

SCIP_RETCODE SCIPclearRelaxSolVals

(

SCIP *

scip

)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetRelaxSolVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

sets the value of the given variable in the global relaxation solution; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; You can use SCIPclearRelaxSolVals() to set all values to zero, initially; after setting all solution values, you have to call SCIPmarkRelaxSolValid() to inform SCIP that the stored solution is valid

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to set value for
val	solution value of variable

SCIP_RETCODE SCIPsetRelaxSolVals	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

sets the values of the given variables in the global relaxation solution; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; the solution is automatically cleared, s.t. all other variables get value 0.0

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nvars	number of variables to set relaxation solution value for
vars	array with variables to set value for
vals	array with solution values of variables

SCIP_RETCODE SCIPsetRelaxSolValsSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

sets the values of the variables in the global relaxation solution to the values in the given primal solution; the relaxation solution can be filled by the relaxation hanlders and might be used by heuristics and for separation

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal relaxation solution

SCIP_Bool SCIPisRelaxSolValid

(

SCIP *

scip

)

returns whether the relaxation solution is valid

Returns

TRUE, if the relaxation solution is valid; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPmarkRelaxSolValid

(

SCIP *

scip

)

informs SCIP, that the relaxation solution is valid

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPmarkRelaxSolInvalid

(

SCIP *

scip

)

informs SCIP, that the relaxation solution is invalid

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetRelaxSolVal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets the relaxation solution value of the given variable

Returns

the relaxation solution value of the given variable

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get value for

SCIP_Real SCIPgetRelaxSolObj

(

SCIP *

scip

)

gets the relaxation solution objective value

Returns

the objective value of the relaxation solution

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartStrongbranch	(	SCIP *	scip,
		SCIP_Bool	enablepropagation
	)

start strong branching - call before any strong branching

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created which allow to perform propagation but also creates some overhead

Parameters

scip	SCIP data structure
enablepropagation	should propagation be done before solving the strong branching LP?

SCIP_RETCODE SCIPendStrongbranch

(

SCIP *

scip

)

end strong branching - call after any strong branching

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

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
	)

gets strong branching information on column variable with fractional value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
itlim	iteration limit for strong branchings
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

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
	)

gets strong branching information with previous domain propagation on column variable

Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch(); after strong branching was done for all candidate variables, the strong branching mode must be ended by SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be enabled in the SCIPstartStrongbranch() call.

Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds can be specified by the parameter maxproprounds.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Warning

When using this method, LP banching candidates and solution values must be copied beforehand, because they are updated w.r.t. the strong branching LP solution.

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
solval	value of the variable in the current LP solution
lpobjval	LP objective value of the current LP solution
itlim	iteration limit for strong branchings
maxproprounds	maximum number of propagation rounds (-1: no limit, -2: parameter settings)
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
ndomredsdown	pointer to store the number of domain reductions down, or NULL
ndomredsup	pointer to store the number of domain reductions up, or NULL
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)
newlbs	array to store valid lower bounds for all active variables, or NULL
newubs	array to store valid upper bounds for all active variables, or NULL

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
	)

gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch is (val -1.0) and the up brach ins (val +1.0)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
itlim	iteration limit for strong branchings
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

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
	)

gets strong branching information on column variables with fractional values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	variables to get strong branching values for
nvars	number of variables
itlim	iteration limit for strong branchings
down	stores dual bounds after branching variables down
up	stores dual bounds after branching variables up
downvalid	stores whether the returned down values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
upvalid	stores whether the returned up values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
downinf	array to store whether the downward branches are infeasible, or NULL
upinf	array to store whether the upward branches are infeasible, or NULL
downconflict	array to store whether conflict constraints were created for infeasible downward branches, or NULL
upconflict	array to store whether conflict constraints were created for infeasible upward branches, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

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
	)

gets strong branching information on column variables with integral values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	variables to get strong branching values for
nvars	number of variables
itlim	iteration limit for strong branchings
down	stores dual bounds after branching variables down
up	stores dual bounds after branching variables up
downvalid	stores whether the returned down values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
upvalid	stores whether the returned up values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
downinf	array to store whether the downward branches are infeasible, or NULL
upinf	array to store whether the upward branches are infeasible, or NULL
downconflict	array to store whether conflict constraints were created for infeasible downward branches, or NULL
upconflict	array to store whether conflict constraints were created for infeasible upward branches, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

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
	)

gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call; returns values of SCIP_INVALID, if strong branching was not yet called on the given variable; keep in mind, that the returned old values may have nothing to do with the current LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	variable to get last strong branching values for
down	stores dual bound after branching column down, or NULL
up	stores dual bound after branching column up, or NULL
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
solval	stores LP solution value of variable at last strong branching call, or NULL
lpobjval	stores LP objective value at last strong branching call, or NULL

SCIP_Longint SCIPgetVarStrongbranchNode	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	variable to get last strong branching node for

SCIP_Longint SCIPgetVarStrongbranchLPAge	(	SCIP *	scip,
		SCIP_VAR *	var
	)

if strong branching was already applied on the variable at the current node, returns the number of LPs solved after the LP where the strong branching on this variable was applied; if strong branching was not yet applied on the variable at the current node, returns INT_MAX

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	variable to get strong branching LP age for

int SCIPgetVarNStrongbranchs	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	variable to get last strong branching node for

SCIP_RETCODE SCIPaddVarLocks	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	nlocksdown,
		int	nlocksup
	)

adds given values to lock numbers of variable for rounding

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	problem variable
nlocksdown	modification in number of rounding down locks
nlocksup	modification in number of rounding up locks

SCIP_RETCODE SCIPlockVarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_CONS *	cons,
		SCIP_Bool	lockdown,
		SCIP_Bool	lockup
	)

locks rounding of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	problem variable
cons	constraint
lockdown	should the rounding be locked in downwards direction?
lockup	should the rounding be locked in upwards direction?

SCIP_RETCODE SCIPunlockVarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_CONS *	cons,
		SCIP_Bool	lockdown,
		SCIP_Bool	lockup
	)

unlocks rounding of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	problem variable
cons	constraint
lockdown	should the rounding be locked in downwards direction?
lockup	should the rounding be locked in upwards direction?

SCIP_RETCODE SCIPchgVarObj	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newobj
	)

changes variable's objective value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
var	variable to change the objective value for
newobj	new objective value

SCIP_RETCODE SCIPaddVarObj	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	addobj
	)

adds value to variable's objective value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
var	variable to change the objective value for
addobj	additional objective value

SCIP_Real SCIPadjustedVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lb
	)

returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value; does not change the bounds of the variable

Returns

adjusted lower bound for the given variable; the bound of the variable is not changed

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	variable to adjust the bound for
lb	lower bound value to adjust

SCIP_Real SCIPadjustedVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	ub
	)

returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value; does not change the bounds of the variable

Returns

adjusted upper bound for the given variable; the bound of the variable is not changed

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	variable to adjust the bound for
ub	upper bound value to adjust

SCIP_RETCODE SCIPchgVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to change bound at, or NULL for current node
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to change bound at, or NULL for current node
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbLazy	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lazylb
	)

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

lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need to be put into the LP explicitly.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP

Parameters

scip	SCIP data structure
var	problem variable
lazylb	the lazy lower bound to be set

SCIP_RETCODE SCIPchgVarUbLazy	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lazyub
	)

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

lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need to be put into the LP explicitly.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP

Parameters

scip	SCIP data structure
var	problem variable
lazyub	the lazy lower bound to be set

SCIP_RETCODE SCIPtightenVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPtightenVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

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
	)

fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Note

In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling SCIPinferVarUbCons

If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via SCIPgetVars()) gets resorted.

During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
fixedval	new value for fixation
infercons	constraint that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

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
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
infercons	constraint that deduced the bound change, or NULL
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

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
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
infercons	constraint that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferBinvarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	fixedval,
		SCIP_CONS *	infercons,
		int	inferinfo,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	binary variable to fix
fixedval	value to fix binary variable to
infercons	constraint that deduced the fixing
inferinfo	user information for inference to help resolving the conflict
infeasible	pointer to store whether the fixing is infeasible
tightened	pointer to store whether the fixing tightened the local bounds, or NULL

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
	)

fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Note

In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling SCIPinferVarUbProp

If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via SCIPgetVars()) gets resorted.

During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
fixedval	new value for fixation
inferprop	propagator that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

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
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
inferprop	propagator that deduced the bound change, or NULL
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

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
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
inferprop	propagator that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferBinvarProp	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	fixedval,
		SCIP_PROP *	inferprop,
		int	inferinfo,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	binary variable to fix
fixedval	value to fix binary variable to
inferprop	propagator that deduced the fixing
inferinfo	user information for inference to help resolving the conflict
infeasible	pointer to store whether the fixing is infeasible
tightened	pointer to store whether the fixing tightened the local bounds, or NULL

SCIP_RETCODE SCIPtightenVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPtightenVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning

If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_Real SCIPcomputeVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

This global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.

Returns

the global lower bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

This global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.

Returns

the global upper bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarLbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

This local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.

Returns

the local lower bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarUbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

This local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.

Returns

the local upper bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPgetVarMultaggrLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing

calling this function for a non-multi-aggregated variable is not allowed

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPgetVarMultaggrUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing

calling this function for a non-multi-aggregated variable is not allowed

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPgetVarMultaggrLbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing

calling this function for a non-multi-aggregated variable is not allowed

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPgetVarMultaggrUbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing

calling this function for a non-multi-aggregated variable is not allowed

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_RETCODE SCIPgetVarClosestVlb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_SOL *	sol,
		SCIP_Real *	closestvlb,
		int *	closestvlbidx
	)

returns solution value and index of variable lower bound that is closest to the variable's value in the given primal solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is available

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	active problem variable
sol	primal solution, or NULL for LP solution
closestvlb	pointer to store the value of the closest variable lower bound
closestvlbidx	pointer to store the index of the closest variable lower bound

SCIP_RETCODE SCIPgetVarClosestVub	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_SOL *	sol,
		SCIP_Real *	closestvub,
		int *	closestvubidx
	)

returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution; or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	active problem variable
sol	primal solution, or NULL for LP solution
closestvub	pointer to store the value of the closest variable lower bound
closestvubidx	pointer to store the index of the closest variable lower bound

SCIP_RETCODE SCIPaddVarVlb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR *	vlbvar,
		SCIP_Real	vlbcoef,
		SCIP_Real	vlbconstant,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
vlbvar	variable z in x >= b*z + d
vlbcoef	coefficient b in x >= b*z + d
vlbconstant	constant d in x >= b*z + d
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPaddVarVub	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR *	vubvar,
		SCIP_Real	vubcoef,
		SCIP_Real	vubconstant,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
vubvar	variable z in x <= b*z + d
vubcoef	coefficient b in x <= b*z + d
vubconstant	constant d in x <= b*z + d
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

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
	)

informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b; also adds the corresponding implication or variable bound to the implied variable; if the implication is conflicting, the variable is fixed to the opposite value; if the variable is already fixed to the given value, the implication is performed immediately; if the implication is redundant with respect to the variables' global bounds, it is ignored

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
varfixing	FALSE if y should be added in implications for x == 0, TRUE for x == 1
implvar	variable y in implication y <= b or y >= b
impltype	type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER)
implbound	bound b in implication y <= b or y >= b
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPaddClique	(	SCIP *	scip,
		SCIP_VAR **	vars,
		SCIP_Bool *	values,
		int	nvars,
		SCIP_Bool	isequation,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
values	values of the variables in the clique; NULL to use TRUE for all vars
nvars	number of variables in the clique
isequation	is the clique an equation or an inequality?
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPcalcCliquePartition	(	SCIP *const	scip,
		SCIP_VAR **const	vars,
		int const	nvars,
		int *const	cliquepartition,
		int *const	ncliques
	)

calculates a partition of the given set of binary variables into cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same clique; the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; for each clique at most 1 variables can be set to TRUE in a feasible solution;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
nvars	number of variables in the clique
cliquepartition	array of length nvars to store the clique partition
ncliques	pointer to store the number of cliques actually contained in the partition

SCIP_RETCODE SCIPcalcNegatedCliquePartition	(	SCIP *const	scip,
		SCIP_VAR **const	vars,
		int const	nvars,
		int *const	cliquepartition,
		int *const	ncliques
	)

calculates a partition of the given set of binary variables into negated cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same negated clique; the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
nvars	number of variables in the clique
cliquepartition	array of length nvars to store the clique partition
ncliques	pointer to store the number of cliques actually contained in the partition

SCIP_RETCODE SCIPcleanupCliques	(	SCIP *	scip,
		SCIP_Bool *	infeasible
	)

force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()

Returns

SCIP_OKAY if everything worked, otherwise a suitable error code is passed

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
infeasible	pointer to store if cleanup detected infeasibility

int SCIPgetNCliques

(

SCIP *

scip

)

gets the number of cliques in the clique table

Returns

number of cliques in the clique table

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_CLIQUE** SCIPgetCliques

(

SCIP *

scip

)

gets the array of cliques in the clique table

Returns

array of cliques in the clique table

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhaveVarsCommonClique	(	SCIP *	scip,
		SCIP_VAR *	var1,
		SCIP_Bool	value1,
		SCIP_VAR *	var2,
		SCIP_Bool	value2,
		SCIP_Bool	regardimplics
	)

returns whether there is a clique that contains both given variable/value pairs; the variables must be active binary variables; if regardimplics is FALSE, only the cliques in the clique table are looked at; if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded

Returns

TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Note

a variable with it's negated variable are NOT! in a clique

a variable with itself are in a clique

Parameters

scip	SCIP data structure
var1	first variable
value1	value of first variable
var2	second variable
value2	value of second variable
regardimplics	should the implication graph also be searched for a clique?

SCIP_RETCODE SCIPwriteCliqueGraph	(	SCIP *	scip,
		const char *	fname,
		SCIP_Bool	writenodeweights
	)

writes the clique graph to a gml file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Note

there can be duplicated arcs in the output file

If writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges between such nodes are written.

Parameters

scip	SCIP data structure
fname	name of file
writenodeweights	should we write weights of nodes?

SCIP_RETCODE SCIPremoveVarFromGlobalStructures	(	SCIP *	scip,
		SCIP_VAR *	var
	)

Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds. This is an advanced method which should be used with care.

Returns

SCIP_OKAY if everything worked, otherwise a suitable error code is passed

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
var	variable to remove from global structures

SCIP_RETCODE SCIPchgVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	branchfactor
	)

sets the branch factor of the variable; this value can be used in the branching methods to scale the score values of the variables; higher factor leads to a higher probability that this variable is chosen for branching

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
branchfactor	factor to weigh variable's branching score with

SCIP_RETCODE SCIPscaleVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	scale
	)

scales the branch factor of the variable with the given value

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
scale	factor to scale variable's branching factor with

SCIP_RETCODE SCIPaddVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	addfactor
	)

adds the given value to the branch factor of the variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
addfactor	value to add to the branch factor of the variable

SCIP_RETCODE SCIPchgVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	branchpriority
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

the default branching priority is 0

Parameters

scip	SCIP data structure
var	problem variable
branchpriority	branch priority of the variable

SCIP_RETCODE SCIPupdateVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	branchpriority
	)

changes the branch priority of the variable to the given value, if it is larger than the current priority

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
branchpriority	new branch priority of the variable, if it is larger than current priority

SCIP_RETCODE SCIPaddVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	addpriority
	)

adds the given value to the branch priority of the variable

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
addpriority	value to add to the branch priority of the variable

SCIP_RETCODE SCIPchgVarBranchDirection	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	branchdirection
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	problem variable
branchdirection	preferred branch direction of the variable (downwards, upwards, auto)

SCIP_RETCODE SCIPchgVarType	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VARTYPE	vartype,
		SCIP_Bool *	infeasible
	)

changes type of variable in the problem;

Warning

This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING

Note

If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the corresponding transformed variable is changed; the type of the original variable does not change

If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get adjusted w.r.t. to integrality information

Parameters

scip	SCIP data structure
var	variable to change the bound for
vartype	new type of variable
infeasible	pointer to store whether an infeasibility was detected (, due to integrality condition of the new variable type)

SCIP_RETCODE SCIPfixVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	fixedval,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	fixed
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to fix
fixedval	value to fix variable to
infeasible	pointer to store whether the fixing is infeasible
fixed	pointer to store whether the fixing was performed (variable was unfixed)

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
	)

From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid. In the first step, the equality is transformed into an equality with active problem variables a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0, of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible infeasibility) otherwise. In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.

The output flags have the following meaning:

• infeasible: the problem is infeasible
• redundant: the equality can be deleted from the constraint set
• aggregated: the aggregation was successfully performed (the variables were not aggregated before)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
varx	variable x in equality a*x + b*y == c
vary	variable y in equality a*x + b*y == c
scalarx	multiplier a in equality a*x + b*y == c
scalary	multiplier b in equality a*x + b*y == c
rhs	right hand side c in equality a*x + b*y == c
infeasible	pointer to store whether the aggregation is infeasible
redundant	pointer to store whether the equality is (now) redundant
aggregated	pointer to store whether the aggregation was successful

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
	)

converts variable into multi-aggregated variable; this changes the variable array returned from SCIPgetVars() and SCIPgetVarsData();

Warning

The integrality condition is not checked anymore on the multi-aggregated variable. You must not multi-aggregate an integer variable without being sure, that integrality on the aggregation variables implies integrality on the aggregated variable.

The output flags have the following meaning:

• infeasible: the problem is infeasible
• aggregated: the aggregation was successfully performed (the variables were not aggregated before)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can only be called if scip is in stage SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
var	variable x to aggregate
naggvars	number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c
aggvars	variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c
scalars	multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c
constant	constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c
infeasible	pointer to store whether the aggregation is infeasible
aggregated	pointer to store whether the aggregation was successful

SCIP_Bool SCIPdoNotAggr

(

SCIP *

scip

)

returns whether aggregation of variables is not allowed

Parameters

scip	SCIP data structure

SCIP_Bool SCIPdoNotMultaggr

(

SCIP *

scip

)

returns whether multi-aggregation is disabled

Parameters

scip	SCIP data structure

SCIP_Bool SCIPdoNotMultaggrVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns whether variable is not allowed to be multi-aggregated

Parameters

scip	SCIP data structure
var	variable x to aggregate

SCIP_Bool SCIPallowDualReds

(

SCIP *

scip

)

returns whether dual reductions propagation methods and presolvers is allowed

Parameters

scip	SCIP data structure

SCIP_Bool SCIPallowObjProp

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPmarkDoNotMultaggrVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

marks the variable that it must not be multi-aggregated

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE

Note

There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not multi-aggregated that this is will be the case.

Parameters

scip	SCIP data structure
var	variable to delete

void SCIPenableVarHistory

(

SCIP *

scip

)

enables the collection of statistics for a variable

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

void SCIPdisableVarHistory

(

SCIP *

scip

)

disables the collection of any statistic for a variable

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPupdateVarPseudocost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta,
		SCIP_Real	objdelta,
		SCIP_Real	weight
	)

updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the variable's solution value and resulting change of "objdelta" in the in the LP's objective value; the update is ignored, if the objective value difference is infinite

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value
objdelta	difference of new LP's objective value - old LP's objective value
weight	weight in (0,1] of this update in pseudo cost sum

SCIP_Real SCIPgetVarPseudocostVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta
	)

gets the variable's pseudo cost value for the given change of the variable's LP value

Returns

the variable's pseudo cost value for the given change of the variable's LP value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetVarPseudocostValCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta
	)

gets the variable's pseudo cost value for the given change of the variable's LP value, only using the pseudo cost information of the current run

Returns

the variable's pseudo cost value for the given change of the variable's LP value, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetVarPseudocost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's pseudo cost value for the given direction

Returns

the variable's pseudo cost value for the given direction

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's pseudo cost value for the given direction, only using the pseudo cost information of the current run

Returns

the variable's pseudo cost value for the given direction, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCount	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's (possible fractional) number of pseudo cost updates for the given direction

Returns

the variable's (possible fractional) number of pseudo cost updates for the given direction

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCountCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's (possible fractional) number of pseudo cost updates for the given direction, only using the pseudo cost information of the current run

Returns

the variable's (possible fractional) number of pseudo cost updates for the given direction, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostVariance	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir,
		SCIP_Bool	onlycurrentrun
	)

get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run

Returns

returns the (corrected) variance of pseudo code information collected so far.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)
onlycurrentrun	only for pseudo costs of current branch and bound run

SCIP_Real SCIPcalculatePscostConfidenceBound	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir,
		SCIP_Bool	onlycurrentrun,
		SCIP_CONFIDENCELEVEL	clevel
	)

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

The confidence bound denotes the interval borders , which contains the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability of 2 * clevel - 1.

Returns

value of confidence bound for this variable

Parameters

scip	SCIP data structure
var	variable in question
dir	the branching direction for the confidence bound
onlycurrentrun	should only the current run be taken into account
clevel	confidence level for the interval

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
	)

check if variable pseudo-costs have a significant difference in location. The significance depends on the choice of clevel and on the kind of tested hypothesis. The one-sided hypothesis, which should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the unknown location means of the underlying pseudo-cost distributions of x and y.

This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually better than x (despite the current information), meaning that y can be expected to yield branching decisions as least as good as x in the long run. If the method returns TRUE, the current history information is sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average) than y.

Note

The order of x and y matters for the one-sided hypothesis

set onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.

Returns

TRUE if the hypothesis can be safely rejected at the given confidence level

Parameters

scip	SCIP data structure
varx	variable x
fracx	the fractionality of variable x
vary	variable y
fracy	the fractionality of variable y
dir	branching direction
clevel	confidence level for rejecting hypothesis
onesided	should a one-sided hypothesis y >= x be tested?

SCIP_Bool SCIPpscostThresholdProbabilityTest	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	frac,
		SCIP_Real	threshold,
		SCIP_BRANCHDIR	dir,
		SCIP_CONFIDENCELEVEL	clevel
	)

tests at a given confidence level whether the variable pseudo-costs only have a small probability to exceed a threshold. This is useful to determine if past observations provide enough evidence to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement of at least threshold.

Note

use clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if the estimated probability to exceed threshold is less than 25 %.

See also

SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels of confidence.

Returns

TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than threshold at the given confidence level clevel.

Parameters

scip	SCIP data structure
var	variable x
frac	the fractionality of variable x
threshold	the threshold to test against
dir	branching direction
clevel	confidence level for rejecting hypothesis

SCIP_Bool SCIPisVarPscostRelerrorReliable	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	threshold,
		SCIP_CONFIDENCELEVEL	clevel
	)

check if the current pseudo cost relative error in a direction violates the given threshold. The Relative Error is calculated at a specific confidence level

Returns

TRUE if relative error in variable pseudo costs is smaller than threshold

Parameters

scip	SCIP data structure
var	variable in question
threshold	threshold for relative errors to be considered reliable (enough)
clevel	a given confidence level

SCIP_Real SCIPgetVarPseudocostScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solval
	)

gets the variable's pseudo cost score value for the given LP solution value

Returns

the variable's pseudo cost score value for the given LP solution value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
solval	variable's LP solution value

SCIP_Real SCIPgetVarPseudocostScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solval
	)

gets the variable's pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run

Returns

the variable's pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
solval	variable's LP solution value

SCIP_Real SCIPgetVarVSIDS	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's VSIDS value

Returns

the variable's VSIDS value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarVSIDSCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's VSIDS value only using conflicts of the current run

Returns

the variable's VSIDS value only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarConflictScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict score value

Returns

the variable's conflict score value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict score value only using conflicts of the current run

Returns

the variable's conflict score value only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictlengthScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict length score

Returns

the variable's conflict length score

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict length score only using conflicts of the current run

Returns

the variable's conflict length score only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgConflictlength	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's average conflict length

Returns

the variable's average conflict length

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferences	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned

Returns

the average number of inferences found after branching on the variable in given direction

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferencesCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned

Returns

the average number of inferences found after branching on the variable in given direction in the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferenceScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average inference score value

Returns

the variable's average inference score value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average inference score value only using inferences of the current run

Returns

the variable's average inference score value only using inferences of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

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
	)

initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores of a variable to the given values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable which should be initialized
downpscost	value to which pseudocosts for downwards branching should be initialized
uppscost	value to which pseudocosts for upwards branching should be initialized
downvsids	value to which VSIDS score for downwards branching should be initialized
upvsids	value to which VSIDS score for upwards branching should be initialized
downconflen	value to which conflict length score for downwards branching should be initialized
upconflen	value to which conflict length score for upwards branching should be initialized
downinfer	value to which inference counter for downwards branching should be initialized
upinfer	value to which inference counter for upwards branching should be initialized
downcutoff	value to which cutoff counter for downwards branching should be initialized
upcutoff	value to which cutoff counter for upwards branching should be initialized

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
	)

initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable which should be initialized
value	domain value, or SCIP_UNKNOWN
downvsids	value to which VSIDS score for downwards branching should be initialized
upvsids	value to which VSIDS score for upwards branching should be initialized
downconflen	value to which conflict length score for downwards branching should be initialized
upconflen	value to which conflict length score for upwards branching should be initialized
downinfer	value to which inference counter for downwards branching should be initialized
upinfer	value to which inference counter for upwards branching should be initialized
downcutoff	value to which cutoff counter for downwards branching should be initialized
upcutoff	value to which cutoff counter for upwards branching should be initialized

SCIP_Real SCIPgetVarAvgCutoffs	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned

Returns

the average number of cutoffs found after branching on the variable in given direction

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgCutoffsCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned

Returns

the average number of cutoffs found after branching on the variable in given direction in the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgCutoffScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average cutoff score value

Returns

the variable's average cutoff score value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average cutoff score value, only using cutoffs of the current run

Returns

the variable's average cutoff score value, only using cutoffs of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgInferenceCutoffScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	cutoffweight
	)

returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given factor

Returns

the variable's average inference/cutoff score value

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
cutoffweight	factor to weigh average number of cutoffs in branching score

SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	cutoffweight
	)

returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given factor, only using inferences and cutoffs of the current run

Returns

the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	problem variable
cutoffweight	factor to weigh average number of cutoffs in branching score

SCIP_RETCODE SCIPprintVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		FILE *	file
	)

outputs variable information to file stream via the message system

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

If the message handler is set to a NULL pointer nothing will be printed

Parameters

scip	SCIP data structure
var	problem variable
file	output file (or NULL for standard output)

SCIP_Bool SCIPisConflictAnalysisApplicable

(

SCIP *

scip

)

return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied

Returns

return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPinitConflictAnalysis

(

SCIP *

scip

)

initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddConflictLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx
	)

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

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called for each lower bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose lower bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedlb
	)

adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose lower bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedlb	the relaxed lower bound

SCIP_RETCODE SCIPaddConflictUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx
	)

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

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for each upper bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedub
	)

adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedub	the relaxed upper bound

SCIP_RETCODE SCIPaddConflictBd	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx
	)

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

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called for each bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedBd	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedbd
	)

adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed) bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedbd	the relaxed bound

SCIP_RETCODE SCIPaddConflictBinvar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

adds changed bound of fixed binary variable to the conflict analysis' candidate storage; this method should be called in one of the following two cases:

1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called for each binary variable, whose current fixing led to the deduction of the given conflict bound.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	binary variable whose changed bound should be added to conflict queue

SCIP_RETCODE SCIPisConflictVarUsed	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Bool *	used
	)

checks if the given variable is already part of the current conflict set or queued for resolving with the same or even stronger bound

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
used	pointer to store if the variable is already used

SCIP_Real SCIPgetConflictVarLb	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetConflictVarUb	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	problem variable

SCIP_RETCODE SCIPanalyzeConflict	(	SCIP *	scip,
		int	validdepth,
		SCIP_Bool *	success
	)

analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons() instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
validdepth	minimal depth level at which the initial conflict set is valid
success	pointer to store whether a conflict constraint was created, or NULL

SCIP_RETCODE SCIPanalyzeConflictCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	success
	)

analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

SCIP stage does not get changed

Parameters

scip	SCIP data structure
cons	constraint that detected the conflict
success	pointer to store whether a conflict constraint was created, or NULL

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
	)

creates and captures a constraint of the given constraint handler

Warning

If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may be declared feasible even if it violates this particular constraint. This constellation should only be used, if no LP or pseudo solution can violate the constraint – e.g. if a local constraint is redundant due to the variable's local bounds.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to constraint
name	name of constraint
conshdlr	constraint handler for this constraint
consdata	data for this specific constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

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
	)

parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is creates and captures;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Warning

If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may be declared feasible even if it violates this particular constraint. This constellation should only be used, if no LP or pseudo solution can violate the constraint – e.g. if a local constraint is redundant due to the variable's local bounds.

Parameters

scip	SCIP data structure
cons	pointer to store constraint
str	string to parse for constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.
success	pointer to store if the paring process was successful

SCIP_RETCODE SCIPcaptureCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

increases usage counter of constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint to capture

SCIP_RETCODE SCIPreleaseCons	(	SCIP *	scip,
		SCIP_CONS **	cons
	)

decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

the pointer of the constraint will be NULLed

Parameters

scip	SCIP data structure
cons	pointer to constraint

SCIP_RETCODE SCIPchgConsName	(	SCIP *	scip,
		SCIP_CONS *	cons,
		const char *	name
	)

change constraint name

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM

Note

to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h

Parameters

scip	SCIP data structure
cons	constraint
name	new name of constraint

SCIP_RETCODE SCIPsetConsInitial	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	initial
	)

sets the initial flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
initial	new value

SCIP_RETCODE SCIPsetConsSeparated	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	separate
	)

sets the separate flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
separate	new value

SCIP_RETCODE SCIPsetConsEnforced	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	enforce
	)

sets the enforce flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
enforce	new value

SCIP_RETCODE SCIPsetConsChecked	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	check
	)

sets the check flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
check	new value

SCIP_RETCODE SCIPsetConsPropagated	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	propagate
	)

sets the propagate flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
propagate	new value

SCIP_RETCODE SCIPsetConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	local
	)

sets the local flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
local	new value

SCIP_RETCODE SCIPsetConsModifiable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	modifiable
	)

sets the modifiable flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
cons	constraint
modifiable	new value

SCIP_RETCODE SCIPsetConsDynamic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	dynamic
	)

sets the dynamic flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
dynamic	new value

SCIP_RETCODE SCIPsetConsRemovable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	removable
	)

sets the removable flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
removable	new value

SCIP_RETCODE SCIPsetConsStickingAtNode	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	stickingatnode
	)

sets the stickingatnode flag of the given constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint
stickingatnode	new value

SCIP_RETCODE SCIPupdateConsFlags	(	SCIP *	scip,
		SCIP_CONS *	cons0,
		SCIP_CONS *	cons1
	)

updates the flags of the first constraint according to the ones of the second constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons0	constraint that should stay
cons1	constraint that should be deleted

SCIP_RETCODE SCIPtransformCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS **	transcons
	)

gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed, a new transformed constraint for this constraint is created

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cons	constraint to get/create transformed constraint for
transcons	pointer to store the transformed constraint

SCIP_RETCODE SCIPtransformConss	(	SCIP *	scip,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS **	transconss
	)

gets and captures transformed constraints for an array of constraints; if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created; it is possible to call this method with conss == transconss

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nconss	number of constraints to get/create transformed constraints for
conss	array with constraints to get/create transformed constraints for
transconss	array to store the transformed constraints

SCIP_RETCODE SCIPgetTransformedCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS **	transcons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
cons	constraint to get the transformed constraint for
transcons	pointer to store the transformed constraint

SCIP_RETCODE SCIPgetTransformedConss	(	SCIP *	scip,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS **	transconss
	)

gets corresponding transformed constraints for an array of constraints; stores NULL in a transconss slot, if the transformed constraint is not yet existing; it is possible to call this method with conss == transconss, but remember that constraints that are not yet transformed will be replaced with NULL

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
nconss	number of constraints to get the transformed constraints for
conss	constraints to get the transformed constraints for
transconss	array to store the transformed constraints

SCIP_RETCODE SCIPaddConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	deltaage
	)

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

• in constraint separation, if no cut was found for this constraint,
• in constraint enforcing, if constraint was feasible, and
• in constraint propagation, if no domain reduction was deduced;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint
deltaage	value to add to the constraint's age

SCIP_RETCODE SCIPincConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

increases age of constraint by 1.0; should be called

• in constraint separation, if no cut was found for this constraint,
• in constraint enforcing, if constraint was feasible, and
• in constraint propagation, if no domain reduction was deduced;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPresetConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

resets age of constraint to zero; should be called

• in constraint separation, if a cut was found for this constraint,
• in constraint enforcing, if the constraint was violated, and
• in constraint propagation, if a domain reduction was deduced;

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's separation, propagation, and enforcing capabilities

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableConsSeparation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's separation capabilities

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableConsSeparation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableConsPropagation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's propagation capabilities

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableConsPropagation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPmarkConsPropagate	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

marks constraint to be propagated

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Note

if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPunmarkConsPropagate	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

unmarks the constraint to be propagated

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPaddConsLocks	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	nlockspos,
		int	nlocksneg
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
cons	constraint
nlockspos	increase in number of rounding locks for constraint
nlocksneg	increase in number of rounding locks for constraint's negation

SCIP_RETCODE SCIPcheckCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool	printreason,
		SCIP_RESULT *	result
	)

checks single constraint for feasibility of the given solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cons	constraint to check
sol	primal CIP solution
checkintegrality	Has integrality to be checked?
checklprows	Do constraints represented by rows in the current LP have to be checked?
printreason	Should the reason for the violation be printed?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPenfopsCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	solinfeasible,
		SCIP_Bool	objinfeasible,
		SCIP_RESULT *	result
	)

enforces single constraint for a given pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to enforce
solinfeasible	was the solution already declared infeasible by a constraint handler?
objinfeasible	is the solution infeasible anyway due to violating lower objective bound?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPenfolpCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	solinfeasible,
		SCIP_RESULT *	result
	)

enforces single constraint for a given LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to enforce
solinfeasible	was the solution already declared infeasible by a constraint handler?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPinitlpCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls LP initialization method for single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to initialize

SCIP_RETCODE SCIPsepalpCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RESULT *	result
	)

calls separation method of single constraint for LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to separate
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPsepasolCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_RESULT *	result
	)

calls separation method of single constraint for given primal solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to separate
sol	primal solution that should be separated
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPpropCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_PROPTIMING	proptiming,
		SCIP_RESULT *	result
	)

calls domain propagation method of single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to propagate
proptiming	current point in the node solving loop
result	pointer to store the result of the callback method

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
	)

resolves propagation conflict of single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to resolve conflict for
infervar	the conflict variable whose bound change has to be resolved
inferinfo	the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call
boundtype	the type of the changed bound (lower or upper bound)
bdchgidx	the index of the bound change, representing the point of time where the change took place
relaxedbd	the relaxed bound which is sufficient to be explained
result	pointer to store the result of the callback method

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
	)

presolves of single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING

Note

This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to presolve
nrounds	number of presolving rounds already done
presoltiming	presolving timing(s) to be performed
nnewfixedvars	number of variables fixed since the last call to the presolving method
nnewaggrvars	number of variables aggregated since the last call to the presolving method
nnewchgvartypes	number of variable type changes since the last call to the presolving method
nnewchgbds	number of variable bounds tightened since the last call to the presolving method
nnewholes	number of domain holes added since the last call to the presolving method
nnewdelconss	number of deleted constraints since the last call to the presolving method
nnewaddconss	number of added constraints since the last call to the presolving method
nnewupgdconss	number of upgraded constraints since the last call to the presolving method
nnewchgcoefs	number of changed coefficients since the last call to the presolving method
nnewchgsides	number of changed left or right hand sides since the last call to the presolving method
nfixedvars	pointer to count total number of variables fixed of all presolvers
naggrvars	pointer to count total number of variables aggregated of all presolvers
nchgvartypes	pointer to count total number of variable type changes of all presolvers
nchgbds	pointer to count total number of variable bounds tightened of all presolvers
naddholes	pointer to count total number of domain holes added of all presolvers
ndelconss	pointer to count total number of deleted constraints of all presolvers
naddconss	pointer to count total number of added constraints of all presolvers
nupgdconss	pointer to count total number of upgraded constraints of all presolvers
nchgcoefs	pointer to count total number of changed coefficients of all presolvers
nchgsides	pointer to count total number of changed left/right hand sides of all presolvers
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPactiveCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls constraint activation notification method of single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to notify

SCIP_RETCODE SCIPdeactiveCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls constraint deactivation notification method of single constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to notify

SCIP_RETCODE SCIPprintCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		FILE *	file
	)

outputs constraint information to file stream via the message handler system

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

If the message handler is set to a NULL pointer nothing will be printed.

The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a newline character.

Parameters

scip	SCIP data structure
cons	constraint
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPgetConsVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR **	vars,
		int	varssize,
		SCIP_Bool *	success
	)

method to collect the variables of a constraint

If the number of variables is greater than the available slots in the variable array, nothing happens except that the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables a constraint has in its scope.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The success pointer indicates if all variables were copied into the vars arrray.

It might be that a constraint handler does not support this functionality, in that case the success pointer is set to FALSE.

Parameters

scip	SCIP data structure
cons	constraint for which the variables are wanted
vars	array to store the involved variable of the constraint
varssize	available slots in vars array which is needed to check if the array is large enough
success	pointer to store whether the variables are successfully copied

SCIP_RETCODE SCIPgetConsNVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nvars,
		SCIP_Bool *	success
	)

method to collect the number of variables of a constraint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Note

The success pointer indicates if the contraint handler was able to return the number of variables

It might be that a constraint handler does not support this functionality, in that case the success pointer is set to FALSE

Parameters

scip	SCIP data structure
cons	constraint for which the number of variables is wanted
nvars	pointer to store the number of variables
success	pointer to store whether the constraint successfully returned the number of variables

SCIP_Bool SCIPhasCurrentNodeLP

(

SCIP *

scip

)

returns, whether the LP was or is to be solved in the current node

Returns

whether the LP was or is to be solved in the current node.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPConstructed

(

SCIP *

scip

)

returns, whether the LP of the current node is already constructed

Returns

whether the LP of the current node is already constructed.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPconstructLP	(	SCIP *	scip,
		SCIP_Bool *	cutoff
	)

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

Warning

Contructing the LP might change the amount of variables known in the transformed problem and therefore also the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to call one of the later method after this one

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
cutoff	pointer to store whether the node can be cut off

SCIP_RETCODE SCIPflushLP

(

SCIP *

scip

)

makes sure that the LP of the current node is flushed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_LPSOLSTAT SCIPgetLPSolstat

(

SCIP *

scip

)

gets solution status of current LP

Returns

the solution status of current LP.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPRelax

(

SCIP *

scip

)

returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound

Returns

whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPObjval

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Note

This method returns the objective value of the current LP solution, which might be primal or dual infeasible if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPColumnObjval

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPLooseObjval

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetGlobalPseudoObjval

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPseudoObjval

(

SCIP *

scip

)

gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the objective function) local bound

Returns

the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the objective function) local bound.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisRootLPRelax

(

SCIP *

scip

)

returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound

Returns

whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootObjval

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootColumnObjval

(

SCIP *

scip

)

gets part of the objective value of the root node LP that results from COLUMN variables only; returns SCIP_INVALID if the root node LP was not (yet) solved

Returns

the part of the objective value of the root node LP that results from COLUMN variables only; or SCIP_INVALID if the root node LP was not (yet) solved.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootLooseObjval

(

SCIP *

scip

)

gets part of the objective value of the root node LP that results from LOOSE variables only; returns SCIP_INVALID if the root node LP was not (yet) solved

Returns

the part of the objective value of the root node LP that results from LOOSE variables only; or SCIP_INVALID if the root node LP was not (yet) solved.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPColsData	(	SCIP *	scip,
		SCIP_COL ***	cols,
		int *	ncols
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
cols	pointer to store the array of LP columns, or NULL
ncols	pointer to store the number of LP columns, or NULL

SCIP_COL** SCIPgetLPCols

(

SCIP *

scip

)

gets current LP columns

Returns

the current LP columns.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNLPCols

(

SCIP *

scip

)

gets current number of LP columns

Returns

the current number of LP columns.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPRowsData	(	SCIP *	scip,
		SCIP_ROW ***	rows,
		int *	nrows
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
rows	pointer to store the array of LP rows, or NULL
nrows	pointer to store the number of LP rows, or NULL

SCIP_ROW** SCIPgetLPRows

(

SCIP *

scip

)

gets current LP rows

Returns

the current LP rows.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNLPRows

(

SCIP *

scip

)

gets current number of LP rows

Returns

the current number of LP rows.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPallColsInLP

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPSolBasic

(

SCIP *

scip

)

returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis

Returns

whether the current LP solution is basic, i.e. is defined by a valid simplex basis.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPBasisInd	(	SCIP *	scip,
		int *	basisind
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
basisind	pointer to store basis indices ready to keep number of rows entries

SCIP_RETCODE SCIPgetLPBInvRow	(	SCIP *	scip,
		int	r,
		SCIP_Real *	coefs,
		int *	inds,
		int *	ninds
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
r	row number
coefs	array to store the coefficients of the row
inds	array to store the non-zero indices, or NULL
ninds	pointer to store the number of non-zero indices, or NULL (-1: if we do not store sparsity informations)

SCIP_RETCODE SCIPgetLPBInvCol	(	SCIP *	scip,
		int	c,
		SCIP_Real *	coefs,
		int *	inds,
		int *	ninds
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
c	column number of B^-1; this is NOT the number of the column in the LP returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd() to get the array which links the B^-1 column numbers to the row and column numbers of the LP! c must be between 0 and nrows-1, since the basis has the size nrows * nrows
coefs	array to store the coefficients of the column
inds	array to store the non-zero indices, or NULL
ninds	pointer to store the number of non-zero indices, or NULL (-1: if we do not store sparsity informations)

SCIP_RETCODE SCIPgetLPBInvARow	(	SCIP *	scip,
		int	r,
		SCIP_Real *	binvrow,
		SCIP_Real *	coefs,
		int *	inds,
		int *	ninds
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
r	row number
binvrow	row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL
coefs	array to store the coefficients of the row
inds	array to store the non-zero indices, or NULL
ninds	pointer to store the number of non-zero indices, or NULL (-1: if we do not store sparsity informations)

SCIP_RETCODE SCIPgetLPBInvACol	(	SCIP *	scip,
		int	c,
		SCIP_Real *	coefs,
		int *	inds,
		int *	ninds
	)

gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A), i.e., it computes B^-1 * A_c with A_c being the c'th column of A

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
c	column number which can be accessed by SCIPcolGetLPPos()
coefs	array to store the coefficients of the column
inds	array to store the non-zero indices, or NULL
ninds	pointer to store the number of non-zero indices, or NULL (-1: if we do not store sparsity informations)

SCIP_RETCODE SCIPsumLPRows	(	SCIP *	scip,
		SCIP_Real *	weights,
		SCIP_REALARRAY *	sumcoef,
		SCIP_Real *	sumlhs,
		SCIP_Real *	sumrhs
	)

calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding LP row are swapped in the summation

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
weights	row weights in row summation
sumcoef	array to store sum coefficients indexed by variables' probindex
sumlhs	pointer to store the left hand side of the row summation
sumrhs	pointer to store the right hand side of the row summation

SCIP_RETCODE SCIPcalcMIR	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Real	boundswitch,
		SCIP_Bool	usevbds,
		SCIP_Bool	allowlocal,
		SCIP_Bool	fixintegralrhs,
		int *	boundsfortrans,
		SCIP_BOUNDTYPE *	boundtypesfortrans,
		int	maxmksetcoefs,
		SCIP_Real	maxweightrange,
		SCIP_Real	minfrac,
		SCIP_Real	maxfrac,
		SCIP_Real *	weights,
		SCIP_Real	maxweight,
		int *	weightinds,
		int	nweightinds,
		int	rowlensum,
		int *	sidetypes,
		SCIP_Real	scale,
		SCIP_Real *	mksetcoefs,
		SCIP_Bool *	mksetcoefsvalid,
		SCIP_Real *	mircoef,
		SCIP_Real *	mirrhs,
		SCIP_Real *	cutactivity,
		SCIP_Bool *	success,
		SCIP_Bool *	cutislocal,
		int *	cutrank
	)

calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these rows cannot participate in a MIR cut.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
sol	the solution that should be separated, or NULL for LP solution
boundswitch	fraction of domain up to which lower bound is used in transformation
usevbds	should variable bounds be used in bound transformation?
allowlocal	should local information allowed to be used, resulting in a local cut?
fixintegralrhs	should complementation tried to be adjusted such that rhs gets fractional?
boundsfortrans	bounds that should be used for transformed variables: vlb_idx/vub_idx, -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound; NULL for using closest bound for all variables
boundtypesfortrans	type of bounds that should be used for transformed variables; NULL for using closest bound for all variables
maxmksetcoefs	maximal number of nonzeros allowed in aggregated base inequality
maxweightrange	maximal valid range max(|weights|)/min(|weights|) of row weights
minfrac	minimal fractionality of rhs to produce MIR cut for
maxfrac	maximal fractionality of rhs to produce MIR cut for
weights	row weights in row summation; some weights might be set to zero
maxweight	largest magnitude of weights; set to -1.0 if sparsity information is unknown
weightinds	sparsity pattern of weights; size nrowinds; NULL if sparsity info is unknown
nweightinds	number of nonzeros in weights; -1 if rowinds is NULL
rowlensum	total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown
sidetypes	specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices
scale	additional scaling factor multiplied to all rows
mksetcoefs	array to store mixed knapsack set coefficients: size nvars; or NULL
mksetcoefsvalid	pointer to store whether mixed knapsack set coefficients are valid; or NULL
mircoef	array to store MIR coefficients: must be of size SCIPgetNVars()
mirrhs	pointer to store the right hand side of the MIR row
cutactivity	pointer to store the activity of the resulting cut
success	pointer to store whether the returned coefficients are a valid MIR cut
cutislocal	pointer to store whether the returned cut is only valid locally
cutrank	pointer to store the rank of the returned cut; or NULL

SCIP_RETCODE SCIPcalcStrongCG	(	SCIP *	scip,
		SCIP_Real	boundswitch,
		SCIP_Bool	usevbds,
		SCIP_Bool	allowlocal,
		int	maxmksetcoefs,
		SCIP_Real	maxweightrange,
		SCIP_Real	minfrac,
		SCIP_Real	maxfrac,
		SCIP_Real *	weights,
		int *	inds,
		int	ninds,
		SCIP_Real	scale,
		SCIP_Real *	mircoef,
		SCIP_Real *	mirrhs,
		SCIP_Real *	cutactivity,
		SCIP_Bool *	success,
		SCIP_Bool *	cutislocal,
		int *	cutrank
	)

calculates a strong CG cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these rows cannot participate in a MIR cut.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
boundswitch	fraction of domain up to which lower bound is used in transformation
usevbds	should variable bounds be used in bound transformation?
allowlocal	should local information allowed to be used, resulting in a local cut?
maxmksetcoefs	maximal number of nonzeros allowed in aggregated base inequality
maxweightrange	maximal valid range max(|weights|)/min(|weights|) of row weights
minfrac	minimal fractionality of rhs to produce strong CG cut for
maxfrac	maximal fractionality of rhs to produce strong CG cut for
weights	row weights in row summation; some weights might be set to zero
inds	indices of non-zero entries in weights array, or NULL
ninds	number of indices of non-zero entries in weights array, -1 if inds is NULL
scale	additional scaling factor multiplied to all rows
mircoef	array to store strong CG coefficients: must be of size SCIPgetNVars()
mirrhs	pointer to store the right hand side of the strong CG row
cutactivity	pointer to store the activity of the resulting cut
success	pointer to store whether the returned coefficients are a valid strong CG cut
cutislocal	pointer to store whether the returned cut is only valid locally
cutrank	pointer to store the rank of the returned cut; or NULL

SCIP_RETCODE SCIPwriteLP	(	SCIP *	scip,
		const char *	filename
	)

writes current LP to a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
filename	file name

SCIP_RETCODE SCIPwriteMIP	(	SCIP *	scip,
		const char *	filename,
		SCIP_Bool	genericnames,
		SCIP_Bool	origobj,
		SCIP_Bool	lazyconss
	)

writes MIP relaxation of the current branch-and-bound node to a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
filename	file name
genericnames	should generic names like x_i and row_j be used in order to avoid troubles with reserved symbols?
origobj	should the original objective function be used?
lazyconss	output removable rows as lazy constraints?

SCIP_RETCODE SCIPgetLPI	(	SCIP *	scip,
		SCIP_LPI **	lpi
	)

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

Warning

You have to make sure, that the full internal state of the LPI does not change or is recovered completely after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make sure, the internal solution status is recovered completely at the end of your method. This can be achieved by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.

Make also sure, that all parameter values that you have changed are set back to their original values.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
lpi	pointer to store the LP interface

SCIP_RETCODE SCIPprintLPSolutionQuality	(	SCIP *	scip,
		FILE *	file
	)

Displays quality information about the current LP solution. An LP solution need to be available. Information printed is subject to what the LP solver supports

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_FREE

See SCIP_STAGE for a complete list of all possible solving stages.

Note

The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPcomputeLPRelIntPoint	(	SCIP *	scip,
		SCIP_Bool	relaxrows,
		SCIP_Bool	inclobjcutoff,
		SCIP_Real	timelimit,
		int	iterlimit,
		SCIP_SOL **	point
	)

compute relative interior point to current LP

See also

SCIPlpComputeRelIntPoint

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
relaxrows	should the rows be relaxed
inclobjcutoff	should a row for the objective cutoff be included
timelimit	time limit for LP solver
iterlimit	iteration limit for LP solver
point	relative interior point on exit

SCIP_Real SCIPgetColRedcost	(	SCIP *	scip,
		SCIP_COL *	col
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

SCIP_Real SCIPgetColFarkasCoef	(	SCIP *	scip,
		SCIP_COL *	col
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

void SCIPmarkColNotRemovableLocal	(	SCIP *	scip,
		SCIP_COL *	col
	)

marks a column to be not removable from the LP in the current node

Precondition

this method can be called in the following stage of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

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
	)

creates and captures an LP row from a constraint handler

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
conshdlr	constraint handler that creates the row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

creates and captures an LP row from a separator

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
sepa	separator that creates the row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

creates and captures an LP row from an unspecified source

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

creates and captures an LP row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Deprecated:

Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
conshdlr	constraint handler that creates the row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
sepa	separator that creates the row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

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
	)

creates and captures an LP row without any coefficients

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Deprecated:

Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcaptureRow	(	SCIP *	scip,
		SCIP_ROW *	row
	)

increases usage counter of LP row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	row to capture

SCIP_RETCODE SCIPreleaseRow	(	SCIP *	scip,
		SCIP_ROW **	row
	)

decreases usage counter of LP row, and frees memory if necessary

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
row	pointer to LP row

SCIP_RETCODE SCIPchgRowLhs	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	lhs
	)

changes left hand side of LP row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
lhs	new left hand side

SCIP_RETCODE SCIPchgRowRhs	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	rhs
	)

changes right hand side of LP row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
rhs	new right hand side

SCIP_RETCODE SCIPcacheRowExtensions	(	SCIP *	scip,
		SCIP_ROW *	row
	)

informs row, that all subsequent additions of variables to the row should be cached and not directly applied; after all additions were applied, SCIPflushRowExtensions() must be called; while the caching of row extensions is activated, information methods of the row give invalid results; caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase the performance

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPflushRowExtensions	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPaddVarToRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Note

In case calling this method in the enforcement process of an lp solution, it might be that some variables, that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP. For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was violated, the linear relaxation might not be violated anymore.)

Parameters

scip	SCIP data structure
row	LP row
var	problem variable
val	value of coefficient

SCIP_RETCODE SCIPaddVarsToRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
nvars	number of variables to add to the row
vars	problem variables to add
vals	values of coefficients

SCIP_RETCODE SCIPaddVarsToRowSameCoef	(	SCIP *	scip,
		SCIP_ROW *	row,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real	val
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
nvars	number of variables to add to the row
vars	problem variables to add
val	unique value of all coefficients

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
mindelta	minimal relative allowed difference of scaled coefficient s*c and integral i
maxdelta	maximal relative allowed difference of scaled coefficient s*c and integral i
maxdnom	maximal denominator allowed in rational numbers
maxscale	maximal allowed scalar
usecontvars	should the coefficients of the continuous variables also be made integral?
intscalar	pointer to store scalar that would make the coefficients integral, or NULL
success	stores whether returned value is valid

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
	)

tries to scale row, s.t. all coefficients (of integer variables) become integral

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
mindelta	minimal relative allowed difference of scaled coefficient s*c and integral i
maxdelta	maximal relative allowed difference of scaled coefficient s*c and integral i
maxdnom	maximal denominator allowed in rational numbers
maxscale	maximal value to scale row with
usecontvars	should the coefficients of the continuous variables also be made integral?
success	stores whether row could be made rational

void SCIPmarkRowNotRemovableLocal	(	SCIP *	scip,
		SCIP_ROW *	row
	)

marks a row to be not removable from the LP in the current node

Precondition

this method can be called in the following stage of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMinCoef	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

minimal absolute value of row vector's non-zero coefficients

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMaxCoef	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

maximal absolute value of row vector's non-zero coefficients

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMinActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMaxActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowLPActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

recalculates the activity of a row in the last LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowLPActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the activity of a row in the last LP solution

Returns

activity of a row in the last LP solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowLPFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the feasibility of a row in the last LP solution

Returns

the feasibility of a row in the last LP solution: negative value means infeasibility

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowPseudoActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

recalculates the activity of a row for the current pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowPseudoActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the activity of a row for the current pseudo solution

Returns

the activity of a row for the current pseudo solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowPseudoFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

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

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowSolActivity	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_SOL *	sol
	)

returns the activity of a row for the given primal solution

Returns

the activitiy of a row for the given primal solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
sol	primal CIP solution

SCIP_Real SCIPgetRowSolFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_SOL *	sol
	)

returns the feasibility of a row for the given primal solution

Returns

the feasibility of a row for the given primal solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
sol	primal CIP solution

SCIP_RETCODE SCIPprintRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		FILE *	file
	)

output row to file stream via the message handler system

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
row	LP row
file	output file (or NULL for standard output)

SCIP_Bool SCIPisNLPEnabled

(

SCIP *

scip

)

returns whether the NLP relaxation has been enabled

If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin. To check whether an NLP is existing, use SCIPisNLPConstructed().

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

See also

SCIPenableNLP

Parameters

scip	SCIP data structure

void SCIPenableNLP

(

SCIP *

scip

)

marks that there are constraints that are representable by nonlinear rows

This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.

The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisNLPConstructed

(

SCIP *

scip

)

returns, whether an NLP has been constructed

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhasNLPContinuousNonlinearity

(

SCIP *

scip

)

returns whether the NLP has a continuous variable in a nonlinear term

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars
	)

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
vars	pointer to store the array of NLP variables, or NULL
nvars	pointer to store the number of NLP variables, or NULL

SCIP_VAR** SCIPgetNLPVars

(

SCIP *

scip

)

gets array with variables of the NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNNLPVars

(

SCIP *

scip

)

gets current number of variables in NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPVarsNonlinearity	(	SCIP *	scip,
		int *	nlcount
	)

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlcount	an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables

SCIP_Real* SCIPgetNLPVarsLbDualsol

(

SCIP *

scip

)

returns dual solution values associated with lower bounds of NLP variables

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real* SCIPgetNLPVarsUbDualsol

(

SCIP *

scip

)

returns dual solution values associated with upper bounds of NLP variables

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPNlRowsData	(	SCIP *	scip,
		SCIP_NLROW ***	nlrows,
		int *	nnlrows
	)

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrows	pointer to store the array of NLP nonlinear rows, or NULL
nnlrows	pointer to store the number of NLP nonlinear rows, or NULL

SCIP_NLROW** SCIPgetNLPNlRows

(

SCIP *

scip

)

gets array with nonlinear rows of the NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNNLPNlRows

(

SCIP *

scip

)

gets current number of nonlinear rows in NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	nonlinear row to add to NLP

SCIP_RETCODE SCIPflushNLP

(

SCIP *

scip

)

makes sure that the NLP of the current node is flushed

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetNLPInitialGuess	(	SCIP *	scip,
		SCIP_Real *	initialguess
	)

sets or clears initial primal guess for NLP solution (start point for NLP solver)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
initialguess	values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point

SCIP_RETCODE SCIPsetNLPInitialGuessSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

sets initial primal guess for NLP solution (start point for NLP solver)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	solution which values should be taken as initial guess, or NULL for LP solution

SCIP_RETCODE SCIPsolveNLP

(

SCIP *

scip

)

solves the current NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NLPSOLSTAT SCIPgetNLPSolstat

(

SCIP *

scip

)

gets solution status of current NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NLPTERMSTAT SCIPgetNLPTermstat

(

SCIP *

scip

)

gets termination status of last NLP solve

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPStatistics	(	SCIP *	scip,
		SCIP_NLPSTATISTICS *	statistics
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
statistics	pointer to store statistics

SCIP_Real SCIPgetNLPObjval

(

SCIP *

scip

)

gets objective value of current NLP

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhasNLPSolution

(

SCIP *

scip

)

indicates whether a feasible solution for the current NLP is available thus, returns whether the solution status <= feasible

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPFracVars	(	SCIP *	scip,
		SCIP_VAR ***	fracvars,
		SCIP_Real **	fracvarssol,
		SCIP_Real **	fracvarsfrac,
		int *	nfracvars,
		int *	npriofracvars
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
fracvars	pointer to store the array of NLP fractional variables, or NULL
fracvarssol	pointer to store the array of NLP fractional variables solution values, or NULL
fracvarsfrac	pointer to store the array of NLP fractional variables fractionalities, or NULL
nfracvars	pointer to store the number of NLP fractional variables , or NULL
npriofracvars	pointer to store the number of NLP fractional variables with maximal branching priority, or NULL

SCIP_RETCODE SCIPgetNLPIntPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		int *	ival
	)

gets integer parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
ival	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPIntPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		int	ival
	)

sets integer parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
ival	parameter value

SCIP_RETCODE SCIPgetNLPRealPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		SCIP_Real *	dval
	)

gets floating point parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
dval	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPRealPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		SCIP_Real	dval
	)

sets floating point parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
dval	parameter value

SCIP_RETCODE SCIPgetNLPStringPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		const char **	sval
	)

gets string parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
sval	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPStringPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		const char *	sval
	)

sets string parameter of NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
type	parameter number
sval	parameter value

SCIP_RETCODE SCIPwriteNLP	(	SCIP *	scip,
		const char *	filename
	)

writes current NLP to a file

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
filename	file name

SCIP_RETCODE SCIPgetNLPI	(	SCIP *	scip,
		SCIP_NLPI **	nlpi,
		SCIP_NLPIPROBLEM **	nlpiproblem
	)

gets the NLP interface and problem used by the SCIP NLP; with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;

Warning

You have to make sure, that the full internal state of the NLPI does not change or is recovered completely after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution status is recovered completely at the end of your method. Additionally you have to resolve the NLP with SCIPnlpiSolve() in order to reinstall the internal solution status.

Make also sure, that all parameter values that you have changed are set back to their original values.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlpi	pointer to store the NLP solver interface
nlpiproblem	pointer to store the NLP solver interface problem

SCIP_RETCODE SCIPstartDiveNLP

(

SCIP *

scip

)

initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPendDiveNLP

(

SCIP *

scip

)

ends NLP diving

Resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgVarObjDiveNLP	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes linear objective coefficient of a variable in diving NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable which coefficient to change
coef	new value for coefficient

SCIP_RETCODE SCIPchgVarBoundsDiveNLP	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lb,
		SCIP_Real	ub
	)

changes bounds of a variable in diving NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable which bounds to change
lb	new lower bound
ub	new upper bound

SCIP_RETCODE SCIPchgVarsBoundsDiveNLP	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	lbs,
		SCIP_Real *	ubs
	)

changes bounds of a set of variables in diving NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nvars	number of variables which bounds to changes
vars	variables which bounds to change
lbs	new lower bounds
ubs	new upper bounds

SCIP_RETCODE SCIPsolveDiveNLP

(

SCIP *

scip

)

solves diving NLP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

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
	)

creates and captures an NLP row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	buffer to store pointer to nonlinear row
name	name of nonlinear row
constant	constant
nlinvars	number of linear variables
linvars	linear variables, or NULL if nlinvars == 0
lincoefs	linear coefficients, or NULL if nlinvars == 0
nquadvars	number of variables in quadratic term
quadvars	variables in quadratic terms, or NULL if nquadvars == 0
nquadelems	number of elements in quadratic term
quadelems	elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0
expression	nonlinear expression, or NULL
lhs	left hand side
rhs	right hand side

SCIP_RETCODE SCIPcreateEmptyNlRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs
	)

creates and captures an NLP nonlinear row without any coefficients

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row
name	name of nonlinear row
lhs	left hand side
rhs	right hand side

SCIP_RETCODE SCIPcreateNlRowFromRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow,
		SCIP_ROW *	row
	)

creates and captures an NLP row from a linear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row
row	the linear row to copy

SCIP_RETCODE SCIPcaptureNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

increases usage counter of NLP nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	nonlinear row to capture

SCIP_RETCODE SCIPreleaseNlRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow
	)

decreases usage counter of NLP nonlinear row, and frees memory if necessary

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row

SCIP_RETCODE SCIPchgNlRowLhs	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	lhs
	)

changes left hand side of NLP nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
lhs	new left hand side

SCIP_RETCODE SCIPchgNlRowRhs	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	rhs
	)

changes right hand side of NLP nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
rhs	new right hand side

SCIP_RETCODE SCIPchgNlRowConstant	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	constant
	)

changes constant of NLP nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
constant	new value for constant

SCIP_RETCODE SCIPaddLinearCoefToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

adds variable with a linear coefficient to the nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
var	problem variable
val	value of coefficient in linear part of row

SCIP_RETCODE SCIPaddLinearCoefsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

adds variables with linear coefficients to the row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
nvars	number of variables to add to the row
vars	problem variables to add
vals	values of coefficients in linear part of row

SCIP_RETCODE SCIPchgNlRowLinearCoef	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes linear coefficient of a variables in a row

Setting the coefficient to 0.0 means that it is removed from the row the variable does not need to exists before.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
var	variable
coef	new value of coefficient

SCIP_RETCODE SCIPaddQuadVarToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var
	)

adds quadratic variable to the nonlinear row

After adding a quadratic variable, it can be used to add quadratic elements.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
var	problem variable

SCIP_RETCODE SCIPaddQuadVarsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nvars,
		SCIP_VAR **	vars
	)

adds quadratic variables to the nonlinear row

After adding quadratic variables, they can be used to add quadratic elements.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
nvars	number of problem variables
vars	problem variables

SCIP_RETCODE SCIPaddQuadElementToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_QUADELEM	quadelem
	)

add a quadratic element to the nonlinear row

Variable indices of the quadratic element need to be relative to quadratic variables array of row.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
quadelem	quadratic element

SCIP_RETCODE SCIPaddQuadElementsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nquadelems,
		SCIP_QUADELEM *	quadelems
	)

adds quadratic elements to the nonlinear row

Variable indices of the quadratic elements need to be relative to quadratic variables array of row.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
nquadelems	number of quadratic elements
quadelems	quadratic elements

SCIP_RETCODE SCIPchgNlRowQuadElement	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_QUADELEM	quadelement
	)

changes coefficient in quadratic part of a row

Setting the coefficient in the quadelement to 0.0 means that it is removed from the row the element does not need to exists before.

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
quadelement	new quadratic element, or update for existing one

SCIP_RETCODE SCIPsetNlRowExprtree	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_EXPRTREE *	exprtree
	)

sets or deletes expression tree in the nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
exprtree	expression tree, or NULL

SCIP_RETCODE SCIPsetNlRowExprtreeParam	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	paramidx,
		SCIP_Real	paramval
	)

sets a parameter of expression tree in the nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
paramidx	index of parameter in expression tree
paramval	new value of parameter in expression tree

SCIP_RETCODE SCIPsetNlRowExprtreeParams	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	paramvals
	)

sets parameters of expression tree in the nonlinear row

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
paramvals	new values of parameter in expression tree

SCIP_RETCODE SCIPrecalcNlRowNLPActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowNLPActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	activity
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowNLPFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	feasibility
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPrecalcNlRowPseudoActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowPseudoActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	pseudoactivity
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
pseudoactivity	pointer to store pseudo activity value

SCIP_RETCODE SCIPgetNlRowPseudoFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	pseudofeasibility
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
pseudofeasibility	pointer to store pseudo feasibility value

SCIP_RETCODE SCIPrecalcNlRowActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	activity
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	feasibility
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPgetNlRowSolActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_SOL *	sol,
		SCIP_Real *	activity
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
sol	primal CIP solution, or NULL for NLP solution of pseudo solution
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowSolFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_SOL *	sol,
		SCIP_Real *	feasibility
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
sol	primal CIP solution
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPgetNlRowActivityBounds	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	minactivity,
		SCIP_Real *	maxactivity
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
minactivity	buffer to store minimal activity, or NULL
maxactivity	buffer to store maximal activity, or NULL

SCIP_RETCODE SCIPprintNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		FILE *	file
	)

output nonlinear row to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
nlrow	NLP row
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPgetExprtreeTransformedVars	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree
	)

replaces array of variables in expression tree by corresponding transformed variables

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree

SCIP_RETCODE SCIPevalExprtreeSol	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_SOL *	sol,
		SCIP_Real *	val
	)

evaluates an expression tree for a primal solution or LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
sol	a solution, or NULL for current LP solution
val	buffer to store value

SCIP_RETCODE SCIPevalExprtreeGlobalBounds	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_Real	infinity,
		SCIP_INTERVAL *	val
	)

evaluates an expression tree w.r.t. current global bounds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
infinity	value to use for infinity
val	buffer to store result

SCIP_RETCODE SCIPevalExprtreeLocalBounds	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_Real	infinity,
		SCIP_INTERVAL *	val
	)

evaluates an expression tree w.r.t. current local bounds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
infinity	value to use for infinity
val	buffer to store result

void SCIPaddSquareLinearization	(	SCIP *	scip,
		SCIP_Real	sqrcoef,
		SCIP_Real	refpoint,
		SCIP_Bool	isint,
		SCIP_Real *	lincoef,
		SCIP_Real *	linconstant,
		SCIP_Bool *	success
	)

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

Parameters

scip	SCIP data structure
sqrcoef	coefficient of square term
refpoint	point where to linearize
isint	whether corresponding variable is a discrete variable, and thus linearization could be moved
lincoef	buffer to add coefficient of linearization
linconstant	buffer to add constant of linearization
success	buffer to set to FALSE if linearization has failed due to large numbers

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
	)

computes coefficients of secant of a square term

Parameters

scip	SCIP data structure
sqrcoef	coefficient of square term
lb	lower bound on variable
ub	upper bound on variable
refpoint	point for which to compute value of linearization
lincoef	buffer to add coefficient of secant
linconstant	buffer to add constant of secant
success	buffer to set to FALSE if secant has failed due to large numbers or unboundedness

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
	)

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

Parameters

scip	SCIP data structure
bilincoef	coefficient of bilinear term
refpointx	point where to linearize first variable
refpointy	point where to linearize second variable
lincoefx	buffer to add coefficient of first variable in linearization
lincoefy	buffer to add coefficient of second variable in linearization
linconstant	buffer to add constant of linearization
success	buffer to set to FALSE if linearization has failed due to large numbers

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
	)

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

Parameters

scip	SCIP data structure
bilincoef	coefficient of bilinear term
lbx	lower bound on first variable
ubx	upper bound on first variable
refpointx	reference point for first variable
lby	lower bound on second variable
uby	upper bound on second variable
refpointy	reference point for second variable
overestimate	whether to compute an overestimator instead of an underestimator
lincoefx	buffer to add coefficient of first variable in linearization
lincoefy	buffer to add coefficient of second variable in linearization
linconstant	buffer to add constant of linearization
success	buffer to set to FALSE if linearization has failed due to large numbers

SCIP_Real SCIPgetCutEfficacy	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution, or NULL for current LP solution
cut	separated cut

SCIP_Bool SCIPisCutEfficacious	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut
	)

returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy

Returns

TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy, otherwise FALSE

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution, or NULL for current LP solution
cut	separated cut

SCIP_Bool SCIPisEfficacious	(	SCIP *	scip,
		SCIP_Real	efficacy
	)

checks, if the given cut's efficacy is larger than the minimal cut efficacy

Returns

TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE

Parameters

scip	SCIP data structure
efficacy	efficacy of the cut

SCIP_Real SCIPgetVectorEfficacyNorm	(	SCIP *	scip,
		SCIP_Real *	vals,
		int	nvals
	)

calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter

Returns

the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter

Parameters

scip	SCIP data structure
vals	array of values
nvals	number of values

SCIP_Bool SCIPisCutApplicable	(	SCIP *	scip,
		SCIP_ROW *	cut
	)

indicates whether a cut is applicable

If the cut has only one variable and this method returns FALSE, it may still be possible that the cut can be added to the LP (as a row instead of a boundchange), but it will be a very weak cut. The user is asked to avoid such cuts.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Returns

whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon

Parameters

scip	SCIP data structure
cut	separated cut

SCIP_RETCODE SCIPaddCut	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut,
		SCIP_Bool	forcecut,
		SCIP_Bool *	infeasible
	)

adds cut to separation storage

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution that was separated, or NULL for LP solution
cut	separated cut
forcecut	should the cut be forced to enter the LP?
infeasible	pointer to store whether cut has been detected to be infeasible for local bounds

SCIP_RETCODE SCIPaddPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

if not already existing, adds row to global cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_RETCODE SCIPdelPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

removes the row from the global cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_CUT** SCIPgetPoolCuts

(

SCIP *

scip

)

gets current cuts in the global cut pool

Returns

the current cuts in the global cut pool

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNPoolCuts

(

SCIP *

scip

)

gets current number of rows in the global cut pool

Returns

the current number of rows in the global cut pool

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_CUTPOOL* SCIPgetGlobalCutpool

(

SCIP *

scip

)

gets the global cut pool used by SCIP

Returns

the global cut pool used by SCIP

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL **	cutpool,
		int	agelimit
	)

creates a cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	pointer to store cut pool
agelimit	maximum age a cut can reach before it is deleted from the pool

SCIP_RETCODE SCIPfreeCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL **	cutpool
	)

frees a cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
cutpool	pointer to store cut pool

SCIP_RETCODE SCIPaddRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
row	cutting plane to add

SCIP_RETCODE SCIPaddNewRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
row	cutting plane to add

SCIP_RETCODE SCIPdelRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

removes the LP row from a cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
cutpool	cut pool
row	row to remove

SCIP_RETCODE SCIPseparateCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_RESULT *	result
	)

separates cuts from a cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPseparateSolCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_SOL *	sol,
		SCIP_RESULT *	result
	)

separates cuts w.r.t. given solution from a cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
sol	solution to be separated
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPaddDelayedPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_RETCODE SCIPdelDelayedPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

removes the row from the delayed global cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_CUT** SCIPgetDelayedPoolCuts

(

SCIP *

scip

)

gets current cuts in the delayed global cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNDelayedPoolCuts

(

SCIP *

scip

)

gets current number of rows in the delayed global cut pool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_CUTPOOL* SCIPgetDelayedGlobalCutpool

(

SCIP *

scip

)

gets the delayed global cut pool used by SCIP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPseparateSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	pretendroot,
		SCIP_Bool	onlydelayed,
		SCIP_Bool *	delayed,
		SCIP_Bool *	cutoff
	)

separates the given primal solution or the current LP solution by calling the separators and constraint handlers' separation methods; the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and SCIPgetNCuts(); after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the separation storage; it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts afterwards

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution that should be separated, or NULL for LP solution
pretendroot	should the cut separators be called as if we are at the root node?
onlydelayed	should only separators be called that were delayed in the previous round?
delayed	pointer to store whether a separator was delayed
cutoff	pointer to store whether the node can be cut off

SCIP_ROW** SCIPgetCuts

(

SCIP *

scip

)

gets the array of cuts currently stored in the separation storage

Returns

the array of cuts currently stored in the separation storage

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNCuts

(

SCIP *

scip

)

get current number of cuts in the separation storage

Returns

the current number of cuts in the separation storage

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPclearCuts

(

SCIP *

scip

)

clears the separation storage

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPremoveInefficaciousCuts

(

SCIP *

scip

)

removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetRelaxFeastolFactor

(

SCIP *

scip

)

returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver

Gives value of separating/feastolfac parameter.

Returns

factor on cut infeasibility to limit feasibility tolerance for relaxation solver

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartDive

(

SCIP *

scip

)

initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note

diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from numerical troubles during the last LP solve; because of this, most users will want to call this method only if SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPendDive

(

SCIP *

scip

)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgCutoffboundDive	(	SCIP *	scip,
		SCIP_Real	newcutoffbound
	)

changes cutoffbound in current dive

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
newcutoffbound	new cutoffbound

SCIP_RETCODE SCIPchgVarObjDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newobj
	)

changes variable's objective value in current dive

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the objective value for
newobj	new objective value

SCIP_RETCODE SCIPchgVarLbDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes variable's lower bound in current dive

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes variable's upper bound in current dive

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPaddRowDive	(	SCIP *	scip,
		SCIP_ROW *	row
	)

adds a row to the LP in current dive

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to be added

SCIP_RETCODE SCIPchgRowLhsDive	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	newlhs
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to change the lhs for
newlhs	new value for lhs

SCIP_RETCODE SCIPchgRowRhsDive	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	newrhs
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to change the lhs for
newrhs	new value for rhs

SCIP_Real SCIPgetVarObjDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's objective value in current dive

Returns

the variable's objective value in current dive.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_Real SCIPgetVarLbDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's lower bound in current dive

Returns

the variable's lower bound in current dive.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_Real SCIPgetVarUbDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's upper bound in current dive

Returns

the variable's upper bound in current dive.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_RETCODE SCIPsolveDiveLP	(	SCIP *	scip,
		int	itlim,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP of the current dive; no separation or pricing is applied

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note

be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL, compare the explanation of SCIPstartDive()

Parameters

scip	SCIP data structure
itlim	maximal number of LP iterations to perform, or -1 for no limit
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the diving LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_Longint SCIPgetLastDivenode

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinDive

(

SCIP *

scip

)

returns whether we are in diving mode

Returns

whether we are in diving mode.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinProbing

(

SCIP *

scip

)

returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped via SCIPendProbing()

Returns

TRUE, if SCIP is currently in probing mode, otherwise FALSE

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartProbing

(

SCIP *

scip

)

initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Note

The collection of variable statistics is turned off during probing. If these statistics should be collected during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPnewProbingNode

(

SCIP *

scip

)

creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path with a call to SCIPbacktrackProbing(); using a sub node for each set of probing bound changes can improve conflict analysis

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetProbingDepth

(

SCIP *

scip

)

returns the current probing depth

Returns

the probing depth, i.e. the number of probing sub nodes existing in the probing path

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPbacktrackProbing	(	SCIP *	scip,
		int	probingdepth
	)

undoes all changes to the problem applied in probing up to the given probing depth; the changes of the probing node of the given probing depth are the last ones that remain active; changes that were applied before calling SCIPnewProbingNode() cannot be undone

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
probingdepth	probing depth of the node in the probing path that should be reactivated

SCIP_RETCODE SCIPendProbing

(

SCIP *

scip

)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgVarLbProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_Real SCIPgetVarObjProbing	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's objective value in current probing

Returns

the variable's objective value in current probing.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_RETCODE SCIPfixVarProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	fixedval
	)

injects a change of variable's bounds into current probing node to fix the variable to the specified value; the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated like deductions instead of branching decisions

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to change the bound for
fixedval	value to fix variable to

SCIP_RETCODE SCIPchgVarObjProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newobj
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

The variable needs to be a column variable.

Parameters

scip	SCIP data structure
var	variable to change the objective for
newobj	new objective function value

SCIP_RETCODE SCIPpropagateProbing	(	SCIP *	scip,
		int	maxproprounds,
		SCIP_Bool *	cutoff,
		SCIP_Longint *	ndomredsfound
	)

applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
maxproprounds	maximal number of propagation rounds (-1: no limit, 0: parameter settings)
cutoff	pointer to store whether the probing node can be cut off
ndomredsfound	pointer to store the number of domain reductions found, or NULL

SCIP_RETCODE SCIPpropagateProbingImplications	(	SCIP *	scip,
		SCIP_Bool *	cutoff
	)

applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; only propagations of the binary variables fixed at the current probing node that are triggered by the implication graph and the clique table are applied; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutoff	pointer to store whether the probing node can be cut off

SCIP_RETCODE SCIPsolveProbingLP	(	SCIP *	scip,
		int	itlim,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied

The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
itlim	maximal number of LP iterations to perform, or -1 for no limit
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the probing LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_RETCODE SCIPsolveProbingLPWithPricing	(	SCIP *	scip,
		SCIP_Bool	pretendroot,
		SCIP_Bool	displayinfo,
		int	maxpricerounds,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing until the LP is solved to optimality; no separation is applied

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
pretendroot	should the pricers be called as if we are at the root node?
displayinfo	should info lines be displayed after each pricing round?
maxpricerounds	maximal number of pricing rounds (-1: no limit); a finite limit means that the LP might not be solved to optimality!
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the probing LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_RETCODE SCIPaddRowProbing	(	SCIP *	scip,
		SCIP_ROW *	row
	)

adds a row to the LP in the current probing node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to be added

SCIP_RETCODE SCIPapplyCutsProbing	(	SCIP *	scip,
		SCIP_Bool *	cutoff
	)

applies the cuts in the separation storage to the LP and clears the storage afterwards; this method can only be applied during probing; the user should resolve the probing LP afterwards in order to get a new solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutoff	pointer to store whether an empty domain was created

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
	)

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

Parameters

scip	SCIP data structure
diveset	general diving settings
divetype	represents different methods for a dive set to explore the next children
divecand	the candidate for which the branching direction is requested
divecandsol	LP solution value of the candidate
divecandfrac	fractionality of the candidate
candscore	pointer to store the candidate score
roundup	pointer to store whether preferred direction for diving is upwards

void SCIPupdateDivesetLPStats	(	SCIP *	scip,
		SCIP_DIVESET *	diveset,
		SCIP_Longint	niterstoadd
	)

update diveset LP statistics, should be called after every LP solved by this diving heuristic

Parameters

scip	SCIP data structure
diveset	diving settings
niterstoadd	additional number of LP iterations to be added

void SCIPupdateDivesetStats	(	SCIP *	scip,
		SCIP_DIVESET *	diveset,
		int	nprobingnodes,
		int	nbacktracks,
		SCIP_Longint	nsolsfound,
		SCIP_Longint	nbestsolsfound,
		SCIP_Bool	leavewassol
	)

update diveset statistics and global diveset statistics

Parameters

scip	SCIP data structure
diveset	diveset to be reset
nprobingnodes	the number of probing nodes explored this time
nbacktracks	the number of backtracks during probing this time
nsolsfound	the number of solutions found
nbestsolsfound	the number of best solutions found
leavewassol	was a solution found at the leaf?

SCIP_RETCODE SCIPgetDiveBoundChanges	(	SCIP *	scip,
		SCIP_DIVESET *	diveset,
		SCIP_SOL *	sol,
		SCIP_Bool *	success,
		SCIP_Bool *	infeasible
	)

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

the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by the dive set. Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the solution values in the solution sol and the current local bounds of the variables. A diving bound change is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().

After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child and one for the alternative.

See also

SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.

The method stops after the first constraint handler was successful

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
diveset	diving settings to control scoring
sol	current solution of diving mode
success	pointer to store whether constraint handler successfully found a variable
infeasible	pointer to store whether the current node was detected to be infeasible

SCIP_RETCODE SCIPaddDiveBoundChange	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir,
		SCIP_Real	value,
		SCIP_Bool	preferred
	)

adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a bound change for the preferred direction or not

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to apply the bound change to
dir	direction of the bound change
value	value to adjust this variable bound to
preferred	is this a bound change for the preferred child?

void SCIPgetDiveBoundChangeData	(	SCIP *	scip,
		SCIP_VAR ***	variables,
		SCIP_BRANCHDIR **	directions,
		SCIP_Real **	values,
		int *	ndivebdchgs,
		SCIP_Bool	preferred
	)

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
variables	pointer to store variables for the specified direction
directions	pointer to store the branching directions
values	pointer to store bound change values
ndivebdchgs	pointer to store the number of dive bound changes
preferred	should the dive bound changes for the preferred child be output?

void SCIPclearDiveBoundChanges

(

SCIP *

scip

)

clear the dive bound change data structures

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	lpcands,
		SCIP_Real **	lpcandssol,
		SCIP_Real **	lpcandsfrac,
		int *	nlpcands,
		int *	npriolpcands,
		int *	nfracimplvars
	)

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

Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1

branching rules should always select the branching candidate among the first npriolpcands of the candidate list

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
lpcands	pointer to store the array of LP branching candidates, or NULL
lpcandssol	pointer to store the array of LP candidate solution values, or NULL
lpcandsfrac	pointer to store the array of LP candidate fractionalities, or NULL
nlpcands	pointer to store the number of LP branching candidates, or NULL
npriolpcands	pointer to store the number of candidates with maximal priority, or NULL
nfracimplvars	pointer to store the number of fractional implicit integer variables, or NULL

int SCIPgetNLPBranchCands

(

SCIP *

scip

)

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

Returns

the number of branching candidates for LP solution branching (number of fractional variables).

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioLPBranchCands

(

SCIP *

scip

)

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

Returns

the number of branching candidates with maximal priority for LP solution branching.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetExternBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	externcands,
		SCIP_Real **	externcandssol,
		SCIP_Real **	externcandsscore,
		int *	nexterncands,
		int *	nprioexterncands,
		int *	nprioexternbins,
		int *	nprioexternints,
		int *	nprioexternimpls
	)

gets external branching candidates along with solution values, scores, and number of branching candidates; these branching candidates can be used by relaxations or nonlinear constraint handlers; branching rules should always select the branching candidate among the first nprioexterncands of the candidate list

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note

Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure
externcands	pointer to store the array of extern branching candidates, or NULL
externcandssol	pointer to store the array of extern candidate solution values, or NULL
externcandsscore	pointer to store the array of extern candidate scores, or NULL
nexterncands	pointer to store the number of extern branching candidates, or NULL
nprioexterncands	pointer to store the number of candidates with maximal priority, or NULL
nprioexternbins	pointer to store the number of binary candidates with maximal priority, or NULL
nprioexternints	pointer to store the number of integer candidates with maximal priority, or NULL
nprioexternimpls	pointer to store the number of implicit integer candidates with maximal priority, or NULL

int SCIPgetNExternBranchCands

(

SCIP *

scip

)

gets number of external branching candidates

Returns

the number of external branching candidates.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchCands

(

SCIP *

scip

)

gets number of external branching candidates with maximal branch priority

Returns

the number of external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchBins

(

SCIP *

scip

)

gets number of binary external branching candidates with maximal branch priority

Returns

the number of binary external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchInts

(

SCIP *

scip

)

gets number of integer external branching candidates with maximal branch priority

Returns

the number of integer external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchImpls

(

SCIP *

scip

)

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

Returns

the number of implicit integer external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchConts

(

SCIP *

scip

)

gets number of continuous external branching candidates with maximal branch priority

Returns

the number of continuous external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddExternBranchCand	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	score,
		SCIP_Real	solval
	)

insert variable, its score and its solution value into the external branching candidate storage the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to insert
score	score of external candidate, e.g. infeasibility
solval	value of the variable in the current solution

void SCIPclearExternBranchCands

(

SCIP *

scip

)

removes all external candidates from the storage for external branching

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPcontainsExternBranchCand	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to look for

SCIP_RETCODE SCIPgetPseudoBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	pseudocands,
		int *	npseudocands,
		int *	npriopseudocands
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
pseudocands	pointer to store the array of pseudo branching candidates, or NULL
npseudocands	pointer to store the number of pseudo branching candidates, or NULL
npriopseudocands	pointer to store the number of candidates with maximal priority, or NULL

int SCIPgetNPseudoBranchCands

(

SCIP *

scip

)

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

Returns

the number branching candidates for pseudo solution branching (non-fixed variables).

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchCands

(

SCIP *

scip

)

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

Returns

the number of branching candidates with maximal branch priority for pseudo solution branching.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchBins

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchInts

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchImpls

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetBranchScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	downgain,
		SCIP_Real	upgain
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching factor should be applied, or NULL
downgain	prediction of objective gain for rounding downwards
upgain	prediction of objective gain for rounding upwards

SCIP_Real SCIPgetBranchScoreMultiple	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	nchildren,
		SCIP_Real *	gains
	)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching factor should be applied, or NULL
nchildren	number of children that the branching will create
gains	prediction of objective gain for each child

SCIP_Real SCIPgetBranchingPoint	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	suggestion
	)

computes a branching point for a continuous or discrete variable

See also

SCIPbranchGetBranchingPoint

Returns

the branching point for a continuous or discrete variable.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching point should be computed
suggestion	suggestion for branching point, or SCIP_INVALID if no suggestion

SCIP_Real SCIPcalcNodeselPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	branchdir,
		SCIP_Real	targetvalue
	)

calculates the node selection priority for moving the given variable's LP value to the given target value; this node selection priority can be given to the SCIPcreateChild() call

Returns

the node selection priority for moving the given variable's LP value to the given target value.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable on which the branching is applied
branchdir	type of branching that was performed: upwards, downwards, or fixed; fixed should only be used, when both bounds changed
targetvalue	new value of the variable in the child node

SCIP_Real SCIPcalcChildEstimate	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	targetvalue
	)

calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given branching; this estimate can be given to the SCIPcreateChild() call

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable on which the branching is applied
targetvalue	new value of the variable in the child node

SCIP_RETCODE SCIPcreateChild	(	SCIP *	scip,
		SCIP_NODE **	node,
		SCIP_Real	nodeselprio,
		SCIP_Real	estimate
	)

creates a child node of the focus node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
node	pointer to node data structure
nodeselprio	node selection priority of new node
estimate	estimate for (transformed) objective value of best feasible solution in subtree

SCIP_RETCODE SCIPbranchVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_NODE **	downchild,
		SCIP_NODE **	eqchild,
		SCIP_NODE **	upchild
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
downchild	pointer to return the left child with variable rounded down, or NULL
eqchild	pointer to return the middle child with variable fixed, or NULL
upchild	pointer to return the right child with variable rounded up, or NULL

SCIP_RETCODE SCIPbranchVarHole	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	left,
		SCIP_Real	right,
		SCIP_NODE **	downchild,
		SCIP_NODE **	upchild
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
left	left side of the domain hole
right	right side of the domain hole
downchild	pointer to return the left child (x <= left), or NULL
upchild	pointer to return the right child (x >= right), or NULL

SCIP_RETCODE SCIPbranchVarVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val,
		SCIP_NODE **	downchild,
		SCIP_NODE **	eqchild,
		SCIP_NODE **	upchild
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
val	value to branch on
downchild	pointer to return the left child with variable rounded down, or NULL
eqchild	pointer to return the middle child with variable fixed, or NULL
upchild	pointer to return the right child with variable rounded up, or NULL

SCIP_RETCODE SCIPbranchVarValNary	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val,
		int	n,
		SCIP_Real	minwidth,
		SCIP_Real	widthfactor,
		int *	nchildren
	)

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

Branches on variable x such that up to n/2 children are created on each side of the usual branching value. The branching value is selected as in SCIPbranchVarVal(). The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes. If n is odd, one child with domain width 'width' and having the branching value in the middle is created. Otherwise, two children with domain width 'width' and being left and right of the branching value are created. Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance from the first nodes. The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value. If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.

Giving a large value for widthfactor results in creating children with small domain when close to the branching value and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3 results in a ternary branching where the branching variable is mostly fixed in the middle child. Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width (except for one child if the branching value is not in the middle).

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
val	value to branch on
n	attempted number of children to be created, must be >= 2
minwidth	minimal domain width in children
widthfactor	multiplier for children domain width with increasing distance from val, must be >= 1.0
nchildren	pointer to store number of created children, or NULL

SCIP_RETCODE SCIPbranchLP	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPbranchExtern	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPbranchPseudo	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPcreateSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to zero

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateLPSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateNLPSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current NLP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateRelaxSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current relaxation solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreatePseudoSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateCurrentSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateUnknownSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to unknown values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateOrigSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution living in the original problem space, initialized to zero; a solution in original space allows to set original variables to values that would be invalid in the transformed problem due to preprocessing fixings or aggregations

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateSolCopy	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_SOL *	sourcesol
	)

creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked if it should stay unaffected from changes in the LP or pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
sourcesol	primal CIP solution to copy

SCIP_RETCODE SCIPcreateSolCopyOrig	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_SOL *	sourcesol
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	pointer to store the solution
sourcesol	primal CIP solution to copy

SCIP_RETCODE SCIPcreateFiniteSolCopy	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_SOL *	sourcesol,
		SCIP_Bool *	success
	)

creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values; the copy is always defined in the original variable space; success indicates whether the objective value of the solution was changed by removing infinite values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
sol	pointer to store the solution
sourcesol	primal CIP solution to copy
success	does the finite solution have the same objective value?

SCIP_RETCODE SCIPfreeSol	(	SCIP *	scip,
		SCIP_SOL **	sol
	)

frees primal CIP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	pointer to the solution

SCIP_RETCODE SCIPlinkLPSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current LP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkNLPSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current NLP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkRelaxSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current relaxation solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkPseudoSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkCurrentSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current LP or pseudo solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPclearSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

clears a primal solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPunlinkSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

stores solution values of variables in solution's own array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPsetSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

sets value of variable in primal CIP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution
var	variable to add to solution
val	solution value of variable

SCIP_RETCODE SCIPsetSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

sets values of multiple variables in primal CIP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution
nvars	number of variables to set solution value for
vars	array with variables to add to solution
vals	array with solution values of variables

SCIP_RETCODE SCIPincSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var,
		SCIP_Real	incval
	)

increases value of variable in primal CIP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution
var	variable to increase solution value for
incval	increment for solution value of variable

SCIP_Real SCIPgetSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var
	)

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

Returns

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

Precondition

In case the solution pointer sol is NULL, that means it is asked for the LP or pseudo solution, this method can only be called if scip is in the solving stage SCIP_STAGE_SOLVING. In any other case, this method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
var	variable to get value for

SCIP_RETCODE SCIPgetSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

gets values of multiple variables in primal CIP solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
nvars	number of variables to get solution value for
vars	array with variables to get value for
vals	array to store solution values of variables

SCIP_Real SCIPgetSolOrigObj	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo objective value

SCIP_Real SCIPgetSolTransObj	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo objective value

SCIP_RETCODE SCIPrecomputeSolObj	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

recomputes the objective value of an original solution, e.g., when transferring solutions from the solution pool (objective coefficients might have changed in the meantime)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_SOLVING

SCIP_Real SCIPtransformObj	(	SCIP *	scip,
		SCIP_Real	obj
	)

maps original space objective value into transformed objective value

Returns

transformed objective value

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
obj	original space objective value to transform

SCIP_Real SCIPretransformObj	(	SCIP *	scip,
		SCIP_Real	obj
	)

maps transformed objective value into original space

Returns

objective value into original space

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
obj	transformed objective value to retransform in original space

SCIP_Real SCIPgetSolTime	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

gets clock time, when this solution was found

Returns

clock time, when this solution was found

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

int SCIPgetSolRunnum	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

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

Returns

branch and bound run number, where this solution was found

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_Longint SCIPgetSolNodenum	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_HEUR* SCIPgetSolHeur	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_Bool SCIPareSolsEqual	(	SCIP *	scip,
		SCIP_SOL *	sol1,
		SCIP_SOL *	sol2
	)

returns whether two given solutions are exactly equal

Returns

returns whether two given solutions are exactly equal

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol1	first primal CIP solution
sol2	second primal CIP solution

SCIP_RETCODE SCIPadjustImplicitSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	uselprows
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution
uselprows	should LP row information be considered for none-objective variables

SCIP_RETCODE SCIPprintSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution in original problem space to the given file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

In case the solution pointer sol is NULL (askinking for the current LP/pseudo solution), this method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

In case the solution pointer sol is not NULL, this method can be called if scip is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintTransSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution in transformed problem space to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintDualSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs dual solution from LP solver to file stream

Note

This only works if no presolving has been performed, which can be checked by calling method SCIPhasPerformedPresolve().

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintRay	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution representing a ray in original problem space to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure
sol	primal solution representing ray
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

int SCIPgetNSols

(

SCIP *

scip

)

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

Returns

number of feasible primal solutions stored in the solution storage in case the problem is transformed; or number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_SOL** SCIPgetSols

(

SCIP *

scip

)

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

Returns

array of feasible primal solutions

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_SOL* SCIPgetBestSol

(

SCIP *

scip

)

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

Returns

best feasible primal solution so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintBestSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs best feasible primal solution found so far to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREE

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintBestTransSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs best feasible primal solution found so far in transformed variables to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREE

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIProundSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	success
	)

try to round given solution

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution
success	pointer to store whether rounding was successful

SCIP_RETCODE SCIPretransformSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

retransforms solution to original problem space

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
sol	primal CIP solution

SCIP_RETCODE SCIPreadSol	(	SCIP *	scip,
		const char *	filename
	)

reads a given solution file, problem has to be transformed in advance

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
filename	name of the input file

SCIP_RETCODE SCIPaddSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	stored
	)

adds feasible primal solution to solution storage by copying it

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_FREETRANS

Note

Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	primal CIP solution
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPaddSolFree	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_Bool *	stored
	)

adds primal solution to solution storage, frees the solution afterwards

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_FREETRANS

Note

Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	pointer to primal CIP solution; is cleared in function call
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPaddCurrentSol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_Bool *	stored
	)

adds current LP/pseudo solution to solution storage

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
heur	heuristic that found the solution
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPtrySol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks solution for feasibility; if possible, adds it to storage by copying

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	primal CIP solution
printreason	Should all reasons of violations be printed?
checkbounds	Should the bounds of the variables be checked?
checkintegrality	Has integrality to be checked?
checklprows	Do constraints represented by rows in the current LP have to be checked?
stored	stores whether given solution was feasible and good enough to keep

SCIP_RETCODE SCIPtrySolFree	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks primal solution; if feasible, adds it to storage; solution is freed afterwards

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Note

Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	pointer to primal CIP solution; is cleared in function call
printreason	Should all reasons of violations be printed?
checkbounds	Should the bounds of the variables be checked?
checkintegrality	Has integrality to be checked?
checklprows	Do constraints represented by rows in the current LP have to be checked?
stored	stores whether solution was feasible and good enough to keep

SCIP_RETCODE SCIPtryCurrentSol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_Bool	printreason,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks current LP/pseudo solution for feasibility; if possible, adds it to storage

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
heur	heuristic that found the solution
printreason	Should all reasons of violations be printed?
checkintegrality	Has integrality to be checked?
checklprows	Do constraints represented by rows in the current LP have to be checked?
stored	stores whether given solution was feasible and good enough to keep

SCIP_RETCODE SCIPcheckSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	feasible
	)

checks solution for feasibility without adding it to the solution store

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
sol	primal CIP solution
printreason	Should all reasons of violations be printed?
checkbounds	Should the bounds of the variables be checked?
checkintegrality	Has integrality to be checked?
checklprows	Do constraints represented by rows in the current LP have to be checked?
feasible	stores whether given solution is feasible

SCIP_RETCODE SCIPcheckSolOrig	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	feasible,
		SCIP_Bool	printreason,
		SCIP_Bool	completely
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
sol	primal CIP solution
feasible	stores whether given solution is feasible
printreason	should the reason for the violation be printed?
completely	should all violations be checked?

SCIP_Bool SCIPhasPrimalRay

(

SCIP *

scip

)

return whether a primal ray is stored that proves unboundedness of the LP relaxation

Returns

return whether a primal ray is stored that proves unboundedness of the LP relaxation

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPrimalRayVal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets value of given variable in primal ray causing unboundedness of the LP relaxation; should only be called if such a ray is stored (check with SCIPhasPrimalRay())

Returns

value of given variable in primal ray causing unboundedness of the LP relaxation

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
var	variable to get value for

SCIP_RETCODE SCIPcatchEvent	(	SCIP *	scip,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

catches a global (not variable or row dependent) event

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropEvent	(	SCIP *	scip,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

drops a global event (stops to track event)

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchEvent(), or -1

SCIP_RETCODE SCIPcatchVarEvent	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	transformed variable to catch event for
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropVarEvent	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
var	transformed variable to drop event for
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchVarEvent(), or -1

SCIP_RETCODE SCIPcatchRowEvent	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
row	linear row to catch event for
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropRowEvent	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
row	linear row to drop event for
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchVarEvent(), or -1

SCIP_NODE* SCIPgetCurrentNode

(

SCIP *

scip

)

gets current node in the tree

Returns

the current node of the search tree

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetRootNode

(

SCIP *

scip

)

gets the root node of the tree

Returns

the root node of the search tree

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetEffectiveRootDepth

(

SCIP *

scip

)

gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node to the unprocessed nodes.

Returns

effective root depth

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinRepropagation

(

SCIP *

scip

)

returns whether the current node is already solved and only propagated again

Returns

TRUE is returned if SCIP performance repropagation, otherwise FALSE.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetChildren	(	SCIP *	scip,
		SCIP_NODE ***	children,
		int *	nchildren
	)

gets children of focus node along with the number of children

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
children	pointer to store children array, or NULL if not needed
nchildren	pointer to store number of children, or NULL if not needed

int SCIPgetNChildren

(

SCIP *

scip

)

gets number of children of focus node

Returns

number of children of the focus node

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetSiblings	(	SCIP *	scip,
		SCIP_NODE ***	siblings,
		int *	nsiblings
	)

gets siblings of focus node along with the number of siblings

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
siblings	pointer to store siblings array, or NULL if not needed
nsiblings	pointer to store number of siblings, or NULL if not needed

int SCIPgetNSiblings

(

SCIP *

scip

)

gets number of siblings of focus node

Returns

the number of siblings of focus node

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLeaves	(	SCIP *	scip,
		SCIP_NODE ***	leaves,
		int *	nleaves
	)

gets leaves of the tree along with the number of leaves

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
leaves	pointer to store leaves array, or NULL if not needed
nleaves	pointer to store number of leaves, or NULL if not needed

int SCIPgetNLeaves

(

SCIP *

scip

)

gets number of leaves in the tree

Returns

the number of leaves in the tree

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetPrioChild

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetPrioSibling

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestChild

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestSibling

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestLeaf

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestNode

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestboundNode

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetOpenNodesData	(	SCIP *	scip,
		SCIP_NODE ***	leaves,
		SCIP_NODE ***	children,
		SCIP_NODE ***	siblings,
		int *	nleaves,
		int *	nchildren,
		int *	nsiblings
	)

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
leaves	pointer to store the leaves, or NULL if not needed
children	pointer to store the children, or NULL if not needed
siblings	pointer to store the siblings, or NULL if not needed
nleaves	pointer to store the number of leaves, or NULL
nchildren	pointer to store the number of children, or NULL
nsiblings	pointer to store the number of siblings, or NULL

SCIP_RETCODE SCIPcutoffNode	(	SCIP *	scip,
		SCIP_NODE *	node
	)

cuts off node and whole sub tree from branch and bound tree

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node that should be cut off

SCIP_RETCODE SCIPrepropagateNode	(	SCIP *	scip,
		SCIP_NODE *	node
	)

marks the given node to be propagated again the next time a node of its subtree is processed

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node that should be propagated again

int SCIPgetCutoffdepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetRepropdepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintNodeRootPath	(	SCIP *	scip,
		SCIP_NODE *	node,
		FILE *	file
	)

prints all branching decisions on variables from the root to the given node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node data
file	output file (or NULL for standard output)

void SCIPsetFocusnodeLP	(	SCIP *	scip,
		SCIP_Bool	solvelp
	)

sets whether the LP should be solved at the focus node

Note

In order to have an effect, this method needs to be called after a node is focused but before the LP is solved.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
solvelp	should the LP be solved?

SCIP_RETCODE SCIPgetReoptChildIDs	(	SCIP *	scip,
		SCIP_NODE *	node,
		unsigned int *	ids,
		int	mem,
		int *	nids
	)

return the ids of child nodes stored in the reoptimization tree

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
node	node of the search tree
ids	array to store the ids of child nodes
mem	allocated memory
nids	number of child nodes

SCIP_RETCODE SCIPgetReoptLeaveIDs	(	SCIP *	scip,
		SCIP_NODE *	node,
		unsigned int *	ids,
		int	mem,
		int *	nids
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data strcuture
node	node of the search tree
ids	array of ids
mem	allocated memory
nids	number of child nodes

int SCIPgetNReoptnodes	(	SCIP *	scip,
		SCIP_NODE *	node
	)

returns the number of nodes in the reoptimization tree induced by node; if node == NULL, the method returns the number of nodes of the whole reoptimization tree.

Parameters

scip	SCIP data structure
node	node of the search tree

int SCIPgetNReoptLeaves	(	SCIP *	scip,
		SCIP_NODE *	node
	)

returns the number of leave nodes of the subtree induced by node; if node == NULL, the method returns the number of leaf nodes of the whole reoptimization tree.

Parameters

scip	SCIP data structure
node	node of the search tree

SCIP_REOPTNODE* SCIPgetReoptnode	(	SCIP *	scip,
		unsigned int	id
	)

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

Parameters

scip	SCIP data structure
id	unique id

SCIP_RETCODE SCIPaddReoptnodeBndchg	(	SCIP *	scip,
		SCIP_REOPTNODE *	reoptnode,
		SCIP_VAR *	var,
		SCIP_Real	val,
		SCIP_BOUNDTYPE	boundtype
	)

add a variable bound change to a given reoptnode

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
reoptnode	node of the reoptimization tree
var	variable pointer
val	value of the variable
boundtype	bound type of the variable value

SCIP_RETCODE SCIPsetReoptCompression	(	SCIP *	scip,
		SCIP_REOPTNODE **	representation,
		int	nrepresentatives,
		SCIP_Bool *	success
	)

set the representation as the new search frontier

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED

Parameters

scip	SCIP data structure
representation	array of representatives
nrepresentatives	number of representatives
success	pointer to store the result

SCIP_RETCODE SCIPaddReoptnodeCons	(	SCIP *	scip,
		SCIP_REOPTNODE *	reoptnode,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		int	nvars,
		REOPT_CONSTYPE	constype
	)

add stored constraint to a reoptimization node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED

Parameters

scip	SCIP data structure
reoptnode	node of the reoptimization tree
vars	array of variables
vals	array of variable bounds
nvars	number of variables
constype	type of the constraint

void SCIPgetReoptnodePath	(	SCIP *	scip,
		SCIP_REOPTNODE *	reoptnode,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		SCIP_BOUNDTYPE *	boundtypes,
		int	mem,
		int *	nvars,
		int *	nafterdualvars
	)

return the branching path stored in the reoptree at ID id

Parameters

scip	SCIP data structure
reoptnode	node of the reoptimization tree
vars	array of variables
vals	array of variable bounds
boundtypes	array of bound types
mem	allocated memory
nvars	number of variables
nafterdualvars	number of variables directly after the first based on dual information

SCIP_RETCODE SCIPinitRepresentation	(	SCIP *	scip,
		SCIP_REOPTNODE **	representatives,
		int	nrepresentatives
	)

initialize a set of empty reoptimization nodes

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED

Parameters

scip	SCIP data structure
representatives	array of representatives
nrepresentatives	number of representatives

SCIP_RETCODE SCIPresetRepresentation	(	SCIP *	scip,
		SCIP_REOPTNODE **	representatives,
		int	nrepresentatives
	)

reset a set of initialized reoptimization nodes

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED

Parameters

scip	SCIP data structure
representatives	array of representatives
nrepresentatives	number of representatives

SCIP_RETCODE SCIPfreeRepresentation	(	SCIP *	scip,
		SCIP_REOPTNODE **	representatives,
		int	nrepresentatives
	)

free a set of initialized reoptimization nodes

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_PRESOLVED

Parameters

scip	SCIP data structure
representatives	array of representatives
nrepresentatives	number of representatives

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
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
reoptnode	node to reactivate
id	unique id of the reoptimization node
estimate	estimate of the child nodes that should be created
childnodes	array to store the created child nodes
ncreatedchilds	pointer to store number of created child nodes
naddedconss	pointer to store number of generated constraints
childnodessize	available size of childnodes array
success	pointer store the result

SCIP_RETCODE SCIPresetReoptnodeDualcons	(	SCIP *	scip,
		SCIP_NODE *	node
	)

remove the stored information about bound changes based in dual information

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
node	node of the search tree

SCIP_RETCODE SCIPsplitReoptRoot	(	SCIP *	scip,
		int *	ncreatedchilds,
		int *	naddedconss
	)

splits the root into several nodes and moves the child nodes of the root to one of the created nodes

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
ncreatedchilds	pointer to store the number of created nodes
naddedconss	pointer to store the number added constraints

SCIP_Bool SCIPreoptimizeNode	(	SCIP *	scip,
		SCIP_NODE *	node
	)

returns if a node should be reoptimized

Parameters

scip	SCIP data structure
node	node of the search tree

SCIP_RETCODE SCIPdeleteReoptnode	(	SCIP *	scip,
		SCIP_REOPTNODE **	reoptnode
	)

deletes the given reoptimization node

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
reoptnode	node of the reoptimization tree

SCIP_Real SCIPgetReoptSimilarity	(	SCIP *	scip,
		int	run1,
		int	run2
	)

return the similarity between two objective functions

Parameters

scip	SCIP data structure
run1	number of run
run2	number of run

void SCIPgetVarCoefChg	(	SCIP *	scip,
		int	varidx,
		SCIP_Bool *	negated,
		SCIP_Bool *	entering,
		SCIP_Bool *	leaving
	)

check the changes of teh variable coefficient in the objective function

Parameters

scip	SCIP data structure
varidx	index of variable
negated	coefficient changed the sign
entering	coefficient gets non-zero coefficient
leaving	coefficient gets zero coefficient

int SCIPgetNRuns

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNReoptRuns

(

SCIP *

scip

)

gets number of reoptimization runs performed, including the current run

Returns

the number of reoptimization runs performed, including the current run

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodes

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNTotalNodes

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure

int SCIPgetNNodesLeft

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLPs

(

SCIP *

scip

)

gets total number of LPs solved so far

Returns

the total number of LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootFirstLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalLPs

(

SCIP *

scip

)

gets total number of primal LPs solved so far

Returns

the total number of primal LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalLPIterations

(

SCIP *

scip

)

gets total number of iterations used so far in primal simplex

Returns

total number of iterations used so far in primal simplex

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualLPs

(

SCIP *

scip

)

gets total number of dual LPs solved so far

Returns

the total number of dual LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualLPIterations

(

SCIP *

scip

)

gets total number of iterations used so far in dual simplex

Returns

the total number of iterations used so far in dual simplex

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBarrierLPs

(

SCIP *

scip

)

gets total number of barrier LPs solved so far

Returns

the total number of barrier LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBarrierLPIterations

(

SCIP *

scip

)

gets total number of iterations used so far in barrier algorithm

Returns

the total number of iterations used so far in barrier algorithm

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNResolveLPs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNResolveLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalResolveLPs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalResolveLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualResolveLPs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualResolveLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeLPs

(

SCIP *

scip

)

gets total number of LPs solved so far for node relaxations

Returns

the total number of LPs solved so far for node relaxations

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeInitLPs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeInitLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDivingLPs

(

SCIP *

scip

)

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

Returns

total number of LPs solved so far during diving and probing

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDivingLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNStrongbranchs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNStrongbranchLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootStrongbranchs

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootStrongbranchLPIterations

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNPriceRounds

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNPricevars

(

SCIP *

scip

)

get current number of variables in the pricing store

Returns

the current number of variables in the pricing store

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNPricevarsFound

(

SCIP *

scip

)

get total number of pricing variables found so far

Returns

the total number of pricing variables found so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNPricevarsApplied

(

SCIP *

scip

)

get total number of pricing variables applied to the LPs

Returns

the total number of pricing variables applied to the LPs

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNSepaRounds

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNCutsFound

(

SCIP *

scip

)

get total number of cuts found so far

Returns

the total number of cuts found so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNCutsFoundRound

(

SCIP *

scip

)

get number of cuts found so far in current separation round

Returns

the number of cuts found so far in current separation round

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

int SCIPgetNCutsApplied

(

SCIP *

scip

)

get total number of cuts applied to the LPs

Returns

the total number of cuts applied to the LPs

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNConflictConssFound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetNConflictConssFoundNode

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNConflictConssApplied

(

SCIP *

scip

)

get total number of conflict constraints added to the problem

Returns

the total number of conflict constraints added to the problem

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetDepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetFocusDepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetDepthLimit

(

SCIP *

scip

)

gets maximal allowed tree depth

Returns

gets maximal allowed tree depth

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetMaxDepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetMaxTotalDepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBacktracks

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

int SCIPgetPlungeDepth

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNActiveConss

(

SCIP *

scip

)

gets total number of active constraints at the current node

Returns

the total number of active constraints at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNEnabledConss

(

SCIP *

scip

)

gets total number of enabled constraints at the current node

Returns

the total number of enabled constraints at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgDualbound

(

SCIP *

scip

)

gets average dual bound of all unprocessed nodes for original problem

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgLowerbound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetDualbound

(

SCIP *

scip

)

gets global dual bound

Returns

the global dual bound

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLowerbound

(

SCIP *

scip

)

gets global lower (dual) bound in transformed problem

Returns

the global lower (dual) bound in transformed problem

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetDualboundRoot

(

SCIP *

scip

)

gets dual bound of the root node for the original problem

Returns

the dual bound of the root node for the original problem

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLowerboundRoot

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPDualboundRoot

(

SCIP *

scip

)

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

Returns

the dual bound for the original problem of the first LP solve at the root node

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPLowerboundRoot

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPrimalbound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetUpperbound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetCutoffbound

(

SCIP *

scip

)

gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the objective value is always integral, the cutoff bound is (nearly) one less than the upper bound; additionally, due to objective function domain propagation, the cutoff bound can be further reduced

Returns

global cutoff bound in transformed problem

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPupdateCutoffbound	(	SCIP *	scip,
		SCIP_Real	cutoffbound
	)

updates the cutoff bound

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Note

using this method in the solving stage can lead to an erroneous SCIP solving status; in particular, if a solution not respecting the cutoff bound was found before installing a cutoff bound which renders the remaining problem infeasible, this solution may be reported as optimal

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING

Note

the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())

Parameters

scip	SCIP data structure
cutoffbound	new cutoff bound

SCIP_Bool SCIPisPrimalboundSol

(

SCIP *

scip

)

returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound was set from the user as objective limit

Returns

TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetGap

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransGap

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNSolsFound

(

SCIP *

scip

)

gets number of feasible primal solutions found so far

Returns

the number of feasible primal solutions found so far

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLimSolsFound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBestSolsFound

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgPseudocost	(	SCIP *	scip,
		SCIP_Real	solvaldelta
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetAvgPseudocostCurrentRun	(	SCIP *	scip,
		SCIP_Real	solvaldelta
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetAvgPseudocostCount	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgPseudocostCountCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgPseudocostScore

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictScore

(

SCIP *

scip

)

gets the average conflict score value over all variables

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictScoreCurrentRun

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictlengthScore

(

SCIP *

scip

)

gets the average inference score value over all variables

Returns

the average inference score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgInferences	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgInferencesCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgInferenceScore

(

SCIP *

scip

)

gets the average inference score value over all variables

Returns

the average inference score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgInferenceScoreCurrentRun

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgCutoffs	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgCutoffsCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgCutoffScore

(

SCIP *

scip

)

gets the average cutoff score value over all variables

Returns

the average cutoff score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgCutoffScoreCurrentRun

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintOrigProblem	(	SCIP *	scip,
		FILE *	file,
		const char *	extension,
		SCIP_Bool	genericnames
	)

outputs original problem to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
extension	file format (or NULL for default CIP format)
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPprintTransProblem	(	SCIP *	scip,
		FILE *	file,
		const char *	extension,
		SCIP_Bool	genericnames
	)

outputs transformed problem of the current node to file stream

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
extension	file format (or NULL for default CIP format)
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPprintStatistics	(	SCIP *	scip,
		FILE *	file
	)

outputs solving statistics

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Note

If limits have been changed between the solution and the call to this function, the status is recomputed and thus may to correspond to the original status.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPprintReoptStatistics	(	SCIP *	scip,
		FILE *	file
	)

outputs reoptimization statistics

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPprintBranchingStatistics	(	SCIP *	scip,
		FILE *	file
	)

outputs history statistics about branchings on variables

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPprintDisplayLine	(	SCIP *	scip,
		FILE *	file,
		SCIP_VERBLEVEL	verblevel,
		SCIP_Bool	endline
	)

outputs node information display line

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
verblevel	minimal verbosity level to actually display the information line
endline	should the line be terminated with a newline symbol?

int SCIPgetNImplications

(

SCIP *

scip

)

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

Returns

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

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPwriteImplicationConflictGraph	(	SCIP *	scip,
		const char *	filename
	)

stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE

Deprecated:

because binary implications are now stored as cliques

Parameters

scip	SCIP data structure
filename	file name, or NULL for stdout

SCIP_Real SCIPgetTimeOfDay

(

SCIP *

scip

)

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

Returns

the current time of day in seconds (standard time zone).

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock using the default clock type

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPcreateCPUClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock counting the CPU user seconds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPcreateWallClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock counting the wall clock seconds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPfreeClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

frees a clock

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPresetClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

resets the time measurement of a clock to zero and completely stops the clock

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPstartClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

starts the time measurement of a clock

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPstopClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

stops the time measurement of a clock

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPenableOrDisableStatisticTiming

(

SCIP *

scip

)

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

Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing, set the parameter to FALSE.

Note

: The (pre-)solving time clocks which are relevant for the output during (pre-)solving are not affected by this method

See also

: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartSolvingTime

(

SCIP *

scip

)

starts the current solving time

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstopSolvingTime

(

SCIP *

scip

)

stops the current solving time in seconds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED
• SCIP_STAGE_EXITSOLVE
• SCIP_STAGE_FREETRANS

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetClockTime	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

gets the measured time of a clock in seconds

Returns

the measured time of a clock in seconds.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPsetClockTime	(	SCIP *	scip,
		SCIP_CLOCK *	clck,
		SCIP_Real	sec
	)

sets the measured time of a clock to the given value in seconds

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer
sec	time in seconds to set the clock's timer to

SCIP_Real SCIPgetTotalTime

(

SCIP *

scip

)

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

Returns

the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetSolvingTime

(

SCIP *

scip

)

gets the current solving time in seconds

Returns

the current solving time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetReadingTime

(

SCIP *

scip

)

gets the current reading time in seconds

Returns

the current reading time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_PROBLEM
• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPresolvingTime

(

SCIP *

scip

)

gets the current presolving time in seconds

Returns

the current presolving time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPTime

(

SCIP *

scip

)

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

Returns

the solving time for the first LP in the root node in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

• SCIP_STAGE_TRANSFORMING
• SCIP_STAGE_TRANSFORMED
• SCIP_STAGE_INITPRESOLVE
• SCIP_STAGE_PRESOLVING
• SCIP_STAGE_EXITPRESOLVE
• SCIP_STAGE_PRESOLVED
• SCIP_STAGE_INITSOLVE
• SCIP_STAGE_SOLVING
• SCIP_STAGE_SOLVED

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPepsilon

(

SCIP *

scip

)

returns value treated as zero

Returns

value treated as zero

Parameters

scip	SCIP data structure

SCIP_Real SCIPsumepsilon

(

SCIP *

scip

)

returns value treated as zero for sums of floating point values

Returns

value treated as zero for sums of floating point values

Parameters

scip	SCIP data structure

SCIP_Real SCIPfeastol

(

SCIP *

scip

)

returns feasibility tolerance for constraints

Returns

feasibility tolerance for constraints

Parameters

scip	SCIP data structure

SCIP_Real SCIPlpfeastol

(

SCIP *

scip

)

returns primal feasibility tolerance of LP solver

Returns

primal feasibility tolerance of LP solver

Parameters

scip	SCIP data structure

SCIP_Real SCIPdualfeastol

(

SCIP *

scip

)

returns feasibility tolerance for reduced costs

Returns

feasibility tolerance for reduced costs

Parameters

scip	SCIP data structure

SCIP_Real SCIPbarrierconvtol

(

SCIP *

scip

)

returns convergence tolerance used in barrier algorithm

Returns

convergence tolerance used in barrier algorithm

Parameters

scip	SCIP data structure

SCIP_Real SCIPcutoffbounddelta

(

SCIP *

scip

)

return the cutoff bound delta

Returns

cutoff bound data

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgFeastol	(	SCIP *	scip,
		SCIP_Real	feastol
	)

sets the feasibility tolerance for constraints

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
feastol	new feasibility tolerance for constraints

SCIP_RETCODE SCIPchgLpfeastol	(	SCIP *	scip,
		SCIP_Real	lpfeastol,
		SCIP_Bool	printnewvalue
	)

sets the primal feasibility tolerance of LP solver

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
lpfeastol	new primal feasibility tolerance of LP solver
printnewvalue	should "numerics/lpfeastol = ..." be printed?

SCIP_RETCODE SCIPchgDualfeastol	(	SCIP *	scip,
		SCIP_Real	dualfeastol
	)

sets the feasibility tolerance for reduced costs

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dualfeastol	new feasibility tolerance for reduced costs

SCIP_RETCODE SCIPchgBarrierconvtol	(	SCIP *	scip,
		SCIP_Real	barrierconvtol
	)

sets the convergence tolerance used in barrier algorithm

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
barrierconvtol	new convergence tolerance used in barrier algorithm

void SCIPmarkLimitChanged

(

SCIP *

scip

)

marks that some limit parameter was changed

Parameters

scip	SCIP data structure

SCIP_Real SCIPinfinity

(

SCIP *

scip

)

returns value treated as infinity

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetHugeValue

(

SCIP *

scip

)

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

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if values are in range of epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than epsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than epsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than epsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than epsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisInfinity	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is (positive) infinite

Parameters

scip	SCIP data structure
val	value to be compared against infinity

SCIP_Bool SCIPisHugeValue	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is huge and should be handled separately (e.g., in activity computation)

Parameters

scip	SCIP data structure
val	value to be checked whether it is huge

SCIP_Bool SCIPisZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range epsilon of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is integral within epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisScalingIntegral	(	SCIP *	scip,
		SCIP_Real	val,
		SCIP_Real	scalar
	)

checks whether the product val * scalar is integral in epsilon scaled by scalar

Parameters

scip	SCIP data structure
val	unscaled value to check for scaled integrality
scalar	value to scale val with for checking for integrality

SCIP_Bool SCIPisFracIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if given fractional part is smaller than epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfloor	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value + epsilon down to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPceil	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - epsilon up to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPround	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value to the nearest integer with epsilon tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfrac	(	SCIP *	scip,
		SCIP_Real	val
	)

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

Parameters

scip	SCIP data structure
val	value to return fractional part for

SCIP_Bool SCIPisSumEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if values are in range of sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than sumepsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than sumepsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than sumepsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than sumepsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range sumepsilon of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisSumPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than sumepsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisSumNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -sumepsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference val1 and val2 is lower than feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than feastol

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -feastol

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range feasibility tolerance of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is integral within the LP feasibility bounds

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasFracIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if given fractional part is smaller than feastol

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasFloor	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value + feasibility tolerance down to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasCeil	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - feasibility tolerance up to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasRound	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value to the nearest integer in feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasFrac	(	SCIP *	scip,
		SCIP_Real	val
	)

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

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisDualfeasEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of dual feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisDualfeasLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference val1 and val2 is lower than dual feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisDualfeasLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisDualfeasGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisDualfeasGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisDualfeasZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range dual feasibility tolerance of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisDualfeasPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than dual feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisDualfeasNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -dual feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisDualfeasIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is integral within the LP dual feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisDualfeasFracIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if given fractional part is smaller than dual feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPdualfeasFloor	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value + dual feasibility tolerance down to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPdualfeasCeil	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - dual feasibility tolerance up to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPdualfeasRound	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value to the nearest integer in dual feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPdualfeasFrac	(	SCIP *	scip,
		SCIP_Real	val
	)

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

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisLbBetter	(	SCIP *	scip,
		SCIP_Real	newlb,
		SCIP_Real	oldlb,
		SCIP_Real	oldub
	)

checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one

Parameters

scip	SCIP data structure
newlb	new lower bound
oldlb	old lower bound
oldub	old upper bound

SCIP_Bool SCIPisUbBetter	(	SCIP *	scip,
		SCIP_Real	newub,
		SCIP_Real	oldlb,
		SCIP_Real	oldub
	)

checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one

Parameters

scip	SCIP data structure
newub	new upper bound
oldlb	old lower bound
oldub	old upper bound

SCIP_Bool SCIPisRelEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is lower than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is lower than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

int SCIPconvertRealToInt	(	SCIP *	scip,
		SCIP_Real	real
	)

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

Parameters

scip	SCIP data structure
real	double bound to convert

SCIP_Longint SCIPconvertRealToLongint	(	SCIP *	scip,
		SCIP_Real	real
	)

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

Parameters

scip	SCIP data structure
real	double bound to convert

SCIP_Bool SCIPisUpdateUnreliable	(	SCIP *	scip,
		SCIP_Real	newvalue,
		SCIP_Real	oldvalue
	)

Checks, if an iteratively updated value is reliable or should be recomputed from scratch. This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high absolute value during the optimization process which is later reduced significantly. In this case, the last digits were canceled out when increasing the value and are random after decreasing it. We do not consider the cancellations which can occur during increasing the absolute value because they just cannot be expressed using fixed precision floating point arithmetic, anymore. In order to get more reliable values, the idea is to always store the last reliable value, where increasing the absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared against the last reliable one with this method, checking whether it was decreased by a factor of at least "lp/recompfac" and should be recomputed.

Parameters

scip	SCIP data structure
newvalue	new value after update
oldvalue	old value, i.e., last reliable value

void SCIPprintReal	(	SCIP *	scip,
		FILE *	file,
		SCIP_Real	val,
		int	width,
		int	precision
	)

outputs a real number, or "+infinity", or "-infinity" to a file

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
val	value to print
width	width of the field
precision	number of significant digits printed

BMS_BLKMEM* SCIPblkmem

(

SCIP *

scip

)

returns block memory to use at the current time

Returns

the block memory to use at the current time.

Parameters

scip	SCIP data structure

BMS_BUFMEM* SCIPbuffer

(

SCIP *

scip

)

returns buffer memory for short living temporary objects

Returns

the buffer memory for short living temporary objects

Parameters

scip	SCIP data structure

BMS_BUFMEM* SCIPcleanbuffer

(

SCIP *

scip

)

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

Returns

the buffer memory for short living temporary objects initialized to all zero

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetMemUsed

(

SCIP *

scip

)

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

Returns

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

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetMemExternEstim

(

SCIP *

scip

)

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

Returns

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

Parameters

scip	SCIP data structure

int SCIPcalcMemGrowSize	(	SCIP *	scip,
		int	num
	)

calculate memory size for dynamically allocated arrays

Returns

the memory size for dynamically allocated arrays.

Parameters

scip	SCIP data structure
num	minimum number of entries to store

SCIP_RETCODE SCIPensureBlockMemoryArray_call	(	SCIP *	scip,
		void **	arrayptr,
		size_t	elemsize,
		int *	arraysize,
		int	minsize
	)

extends a dynamically allocated block memory array to be able to store at least the given number of elements; use SCIPensureBlockMemoryArray() define to call this method!

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
arrayptr	pointer to dynamically sized array
elemsize	size in bytes of each element in array
arraysize	pointer to current array size
minsize	required minimal array size

void SCIPprintMemoryDiagnostic

(

SCIP *

scip

)

prints output about used memory

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateRealarray	(	SCIP *	scip,
		SCIP_REALARRAY **	realarray
	)

creates a dynamic array of real values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	pointer to store the real array

SCIP_RETCODE SCIPfreeRealarray	(	SCIP *	scip,
		SCIP_REALARRAY **	realarray
	)

frees a dynamic array of real values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	pointer to the real array

SCIP_RETCODE SCIPextendRealarray	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	minidx,
		int	maxidx
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearRealarray	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

clears a dynamic real array

Returns

clears a dynamic real array

Parameters

scip	SCIP data structure
realarray	dynamic real array

SCIP_Real SCIPgetRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx
	)

gets value of entry in dynamic array

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to get value for

SCIP_RETCODE SCIPsetRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx,
		SCIP_Real	val
	)

sets value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to set value for
val	value to set array index to

SCIP_RETCODE SCIPincRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx,
		SCIP_Real	incval
	)

increases value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to increase value for
incval	value to increase array index

int SCIPgetRealarrayMinIdx	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

returns the minimal index of all stored non-zero elements

Returns

the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
realarray	dynamic real array

int SCIPgetRealarrayMaxIdx	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

returns the maximal index of all stored non-zero elements

Returns

the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
realarray	dynamic real array

SCIP_RETCODE SCIPcreateIntarray	(	SCIP *	scip,
		SCIP_INTARRAY **	intarray
	)

creates a dynamic array of int values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	pointer to store the int array

SCIP_RETCODE SCIPfreeIntarray	(	SCIP *	scip,
		SCIP_INTARRAY **	intarray
	)

frees a dynamic array of int values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	pointer to the int array

SCIP_RETCODE SCIPextendIntarray	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	minidx,
		int	maxidx
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearIntarray	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

clears a dynamic int array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array

int SCIPgetIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx
	)

gets value of entry in dynamic array

Returns

value of entry in dynamic array

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to get value for

SCIP_RETCODE SCIPsetIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx,
		int	val
	)

sets value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to set value for
val	value to set array index to

SCIP_RETCODE SCIPincIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx,
		int	incval
	)

increases value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to increase value for
incval	value to increase array index

int SCIPgetIntarrayMinIdx	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

returns the minimal index of all stored non-zero elements

Returns

the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
intarray	dynamic int array

int SCIPgetIntarrayMaxIdx	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

returns the maximal index of all stored non-zero elements

Returns

the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
intarray	dynamic int array

SCIP_RETCODE SCIPcreateBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY **	boolarray
	)

creates a dynamic array of bool values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	pointer to store the bool array

SCIP_RETCODE SCIPfreeBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY **	boolarray
	)

frees a dynamic array of bool values

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	pointer to the bool array

SCIP_RETCODE SCIPextendBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	minidx,
		int	maxidx
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

clears a dynamic bool array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

SCIP_Bool SCIPgetBoolarrayVal	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	idx
	)

gets value of entry in dynamic array

Returns

value of entry in dynamic array at position idx

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
idx	array index to get value for

SCIP_RETCODE SCIPsetBoolarrayVal	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	idx,
		SCIP_Bool	val
	)

sets value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
idx	array index to set value for
val	value to set array index to

int SCIPgetBoolarrayMinIdx	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

returns the minimal index of all stored non-zero elements

Returns

the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

int SCIPgetBoolarrayMaxIdx	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

returns the maximal index of all stored non-zero elements

Returns

the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

SCIP_RETCODE SCIPcreatePtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY **	ptrarray
	)

creates a dynamic array of pointers

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	pointer to store the int array

SCIP_RETCODE SCIPfreePtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY **	ptrarray
	)

frees a dynamic array of pointers

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	pointer to the int array

SCIP_RETCODE SCIPextendPtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	minidx,
		int	maxidx
	)

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

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearPtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

clears a dynamic pointer array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array

void* SCIPgetPtrarrayVal	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	idx
	)

gets value of entry in dynamic array

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
idx	array index to get value for

SCIP_RETCODE SCIPsetPtrarrayVal	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	idx,
		void *	val
	)

sets value of entry in dynamic array

Returns

SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
idx	array index to set value for
val	value to set array index to

int SCIPgetPtrarrayMinIdx	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

returns the minimal index of all stored non-zero elements

Returns

the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
ptrarray	dynamic ptr array

int SCIPgetPtrarrayMaxIdx	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

returns the maximal index of all stored non-zero elements

Returns

the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
ptrarray	dynamic ptr array