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)
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_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)
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	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 20355 of file scip.h.

#define SCIPallocMemoryArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20357 of file scip.h.

#define SCIPallocClearMemoryArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20359 of file scip.h.

#define SCIPallocMemorySize	(		scip,
			ptr,
			size
	)

Value:

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

Definition at line 20361 of file scip.h.

#define SCIPreallocMemoryArray	(		scip,
			ptr,
			newnum
	)

Value:

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

Definition at line 20363 of file scip.h.

#define SCIPreallocMemorySize	(		scip,
			ptr,
			newsize
	)

Value:

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

Definition at line 20365 of file scip.h.

#define SCIPduplicateMemory	(		scip,
			ptr,
			source
	)

Value:

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

Definition at line 20367 of file scip.h.

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

Value:

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

Definition at line 20369 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 20371 of file scip.h.

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

Definition at line 20372 of file scip.h.

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

Definition at line 20373 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 20374 of file scip.h.

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

Definition at line 20375 of file scip.h.

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

Definition at line 20376 of file scip.h.

#define SCIPallocBlockMemory	(		scip,
			ptr
	)

Value:

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

Definition at line 20383 of file scip.h.

#define SCIPallocBlockMemoryArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20385 of file scip.h.

#define SCIPallocBlockMemorySize	(		scip,
			ptr,
			size
	)

Value:

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

Definition at line 20387 of file scip.h.

#define SCIPallocClearBlockMemoryArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20389 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 20391 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 20393 of file scip.h.

#define SCIPduplicateBlockMemory	(		scip,
			ptr,
			source
	)

Value:

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

Definition at line 20395 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 20397 of file scip.h.

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

Definition at line 20399 of file scip.h.

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

Definition at line 20400 of file scip.h.

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

Definition at line 20401 of file scip.h.

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

Definition at line 20402 of file scip.h.

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

Definition at line 20403 of file scip.h.

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

Definition at line 20404 of file scip.h.

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

Definition at line 20405 of file scip.h.

#define SCIPallocBuffer	(		scip,
			ptr
	)

Value:

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

Definition at line 20412 of file scip.h.

#define SCIPallocBufferArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20414 of file scip.h.

#define SCIPallocClearBufferArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20416 of file scip.h.

#define SCIPreallocBufferArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20418 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 20420 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 20422 of file scip.h.

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

Definition at line 20424 of file scip.h.

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

Definition at line 20425 of file scip.h.

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

Definition at line 20426 of file scip.h.

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

Definition at line 20427 of file scip.h.

#define SCIPallocCleanBuffer	(		scip,
			ptr
	)

Value:

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

Definition at line 20430 of file scip.h.

#define SCIPallocCleanBufferArray	(		scip,
			ptr,
			num
	)

Value:

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

Definition at line 20432 of file scip.h.

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

Definition at line 20434 of file scip.h.

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

Definition at line 20435 of file scip.h.

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

Definition at line 20436 of file scip.h.

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

Definition at line 20437 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

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,