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

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	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	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	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	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	SCIPchgStringParam (SCIP scip, SCIP_PARAM param, const char *value)

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

SCIP_RETCODE	SCIPreadParams (SCIP scip, const char filename)

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 delaypresol, SCIP_Bool needscons, SCIP_PROPTIMING timingmask, 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_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 timingmask)

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

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_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_Bool delay, 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_Bool delay, 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_Bool presoldelay, 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_Bool presoldelay)

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

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 writeimplications, SCIP_Bool writenodeweights)

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_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	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_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, 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 coef)

SCIP_RETCODE	SCIPgetLPBInvCol (SCIP scip, int c, SCIP_Real coef)

SCIP_RETCODE	SCIPgetLPBInvARow (SCIP scip, int r, SCIP_Real binvrow, SCIP_Real *coef)

SCIP_RETCODE	SCIPgetLPBInvACol (SCIP scip, int c, SCIP_Real coef)

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, 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, 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_RETCODE	SCIPfixVarProbing (SCIP scip, SCIP_VAR var, SCIP_Real fixedval)

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)

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

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)

Statistic Methods
int	SCIPgetNRuns (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	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	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	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)

SCIP_Bool	SCIPisUpdateUnreliable (SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)

void	SCIPprintReal (SCIP scip, FILE file, SCIP_Real val, int width, int precision)

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)

Memory Management
#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)

#define	SCIPallocBlockMemory(scip, ptr)

#define	SCIPallocBlockMemoryArray(scip, ptr, num)

#define	SCIPallocBlockMemorySize(scip, ptr, size)

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

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

#define	SCIPallocBuffer(scip, ptr) SCIPallocBufferSize(scip, (void)(ptr), (int)sizeof((ptr)))

#define	SCIPallocBufferArray(scip, ptr, num) SCIPallocBufferSize(scip, (void*)(ptr), (num)(int)sizeof(**(ptr)))

#define	SCIPreallocBufferArray(scip, ptr, num) SCIPreallocBufferSize(scip, (void*)(ptr), (num)(int)sizeof(**(ptr)))

#define	SCIPduplicateBuffer(scip, ptr, source) SCIPduplicateBufferSize(scip, (void)(ptr), source, (int)sizeof((ptr)))

#define	SCIPduplicateBufferArray(scip, ptr, source, num) SCIPduplicateBufferSize(scip, (void*)(ptr), source, (num)(int)sizeof(**(ptr)))

#define	SCIPfreeBuffer(scip, ptr) SCIPfreeBufferSize(scip, (void**)(ptr), 0)

#define	SCIPfreeBufferNull(scip, ptr) { if( *(ptr) != NULL ) SCIPfreeBuffer(scip, ptr); }

#define	SCIPfreeBufferArray(scip, ptr) SCIPfreeBufferSize(scip, (void**)(ptr), 0)

#define	SCIPfreeBufferArrayNull(scip, ptr) { if( *(ptr) != NULL ) SCIPfreeBufferArray(scip, ptr); }

BMS_BLKMEM *	SCIPblkmem (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)

SCIP_RETCODE	SCIPallocBufferSize (SCIP scip, void *ptr, int size)

SCIP_RETCODE	SCIPduplicateBufferSize (SCIP scip, void ptr, const void source, int size)

SCIP_RETCODE	SCIPreallocBufferSize (SCIP scip, void *ptr, int size)

void	SCIPfreeBufferSize (SCIP scip, void *ptr, int dummysize)

void	SCIPprintMemoryDiagnostic (SCIP *scip)

Macro Definition Documentation

#define SCIPallocMemory	(	scip,
		ptr
	)

Value:

( (BMSallocMemory((ptr)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18979 of file scip.h.

#define SCIPallocMemoryArray	(	scip,
		ptr,
		num
	)

Value:

( (BMSallocMemoryArray((ptr), (num)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18981 of file scip.h.

#define SCIPallocClearMemoryArray	(	scip,
		ptr,
		num
	)

Value:

( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18983 of file scip.h.

#define SCIPallocMemorySize	(	scip,
		ptr,
		size
	)

Value:

( (BMSallocMemorySize((ptr), (size)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18985 of file scip.h.

#define SCIPreallocMemoryArray	(	scip,
		ptr,
		newnum
	)

Value:

( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18987 of file scip.h.

#define SCIPreallocMemorySize	(	scip,
		ptr,
		newsize
	)

Value:

( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18989 of file scip.h.

#define SCIPduplicateMemory	(	scip,
		ptr,
		source
	)

Value:

( (BMSduplicateMemory((ptr), (source)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 18991 of file scip.h.

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

Value:

( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

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

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

Definition at line 18997 of file scip.h.

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

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

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

Definition at line 19000 of file scip.h.

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

Definition at line 19001 of file scip.h.

#define SCIPallocBlockMemory	(	scip,
		ptr
	)

Value:

( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 19003 of file scip.h.

#define SCIPallocBlockMemoryArray	(	scip,
		ptr,
		num
	)

Value:

( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 19005 of file scip.h.

#define SCIPallocBlockMemorySize	(	scip,
		ptr,
		size
	)

Value:

( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

Definition at line 19007 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 19009 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 19012 of file scip.h.

#define SCIPduplicateBlockMemory	(	scip,
		ptr,
		source
	)

Value:

( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \

? SCIP_NOMEMORY : SCIP_OKAY )

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

#define SCIPensureBlockMemoryArray	(	scip,
		ptr,
		arraysizeptr,
		minsize
	)

Value:

( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), \

(arraysizeptr), (minsize))) )

Definition at line 19021 of file scip.h.

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

Definition at line 19024 of file scip.h.

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

Definition at line 19025 of file scip.h.

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

Definition at line 19026 of file scip.h.

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

Definition at line 19027 of file scip.h.

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

Definition at line 19029 of file scip.h.

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

Definition at line 19030 of file scip.h.

#define SCIPallocBuffer	(	scip,
		ptr
	)	SCIPallocBufferSize(scip, (void)(ptr), (int)sizeof((ptr)))

Definition at line 19033 of file scip.h.

#define SCIPallocBufferArray	(	scip,
		ptr,
		num
	)	SCIPallocBufferSize(scip, (void*)(ptr), (num)(int)sizeof(**(ptr)))

Definition at line 19034 of file scip.h.

#define SCIPreallocBufferArray	(	scip,
		ptr,
		num
	)	SCIPreallocBufferSize(scip, (void*)(ptr), (num)(int)sizeof(**(ptr)))

Definition at line 19035 of file scip.h.

#define SCIPduplicateBuffer	(	scip,
		ptr,
		source
	)	SCIPduplicateBufferSize(scip, (void)(ptr), source, (int)sizeof((ptr)))

Definition at line 19036 of file scip.h.

#define SCIPduplicateBufferArray	(	scip,
		ptr,
		source,
		num
	)	SCIPduplicateBufferSize(scip, (void*)(ptr), source, (num)(int)sizeof(**(ptr)))

Definition at line 19037 of file scip.h.

#define SCIPfreeBuffer	(	scip,
		ptr
	)	SCIPfreeBufferSize(scip, (void**)(ptr), 0)

Definition at line 19039 of file scip.h.

#define SCIPfreeBufferNull	(	scip,
		ptr
	)	{ if( *(ptr) != NULL ) SCIPfreeBuffer(scip, ptr); }

Definition at line 19040 of file scip.h.

#define SCIPfreeBufferArray	(	scip,
		ptr
	)	SCIPfreeBufferSize(scip, (void**)(ptr), 0)

Definition at line 19041 of file scip.h.

#define SCIPfreeBufferArrayNull	(	scip,
		ptr
	)	{ if( *(ptr) != NULL ) SCIPfreeBufferArray(scip, ptr); }

Definition at line 19042 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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

SCIP_STAGE_PROBLEM

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

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

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

Note: the variables are added to the target-SCIP but not captured; In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

SCIP_STAGE_PROBLEM

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

SCIP_RETCODE SCIPgetConsCopy	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_CONS *	sourcecons,
		SCIP_CONS **	targetcons,
		SCIP_CONSHDLR *	sourceconshdlr,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		const char *	name,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode,
		SCIP_Bool	global,
		SCIP_Bool *	success
	)

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

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

Note: The constraint is not added to the target SCIP. You can check whether a constraint is added by calling SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.); The constraint is always captured, either during the creation of the copy or after finding the copy of the constraint in the constraint hash map; In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

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

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

Note: the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.) You can check whether a constraint is added by calling SCIPconsIsAdded().; In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

SCIP_STAGE_PROBLEM

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

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

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

Note: the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already added.) You can check whether a constraint is added by calling SCIPconsIsAdded().; In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

SCIP_STAGE_PROBLEM

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

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

convert all active cuts from cutpool to linear constraints

Note: Do not change the source SCIP environment during the copying process

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

Precondition

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

Note: SCIP stage does not get changed

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

Parameters

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

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

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

Note: In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

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

copies implications and cliques of sourcescip to targetscip

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

Note: In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

SCIP_RETCODE SCIPcopyParamSettings	(	SCIP *	sourcescip,
		SCIP *	targetscip
	)

copies parameter settings from sourcescip to targetscip

Note: In a multi thread case, you need to lock the copying procedure from outside with a mutex.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

sourcescip	source SCIP data structure
targetscip	target SCIP data structure

int SCIPgetSubscipDepth ( SCIP * scip )

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

Returns: Depth of subscip of SCIP is returned.

Precondition

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

Note: SCIP stage does not get changed

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcopy	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		const char *	suffix,
		SCIP_Bool	global,
		SCIP_Bool	enablepricing,
		SCIP_Bool	passmessagehdlr,
		SCIP_Bool *	valid
	)

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

Note: all variables and constraints which are created in the target-SCIP are not (user) captured; In a multi thread case, you need to lock the copying procedure from outside with a mutex. Also, 'passmessagehdlr' should be set to FALSE.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

SCIP_RETCODE SCIPcopyOrig	(	SCIP *	sourcescip,
		SCIP *	targetscip,
		SCIP_HASHMAP *	varmap,
		SCIP_HASHMAP *	consmap,
		const char *	suffix,
		SCIP_Bool	enablepricing,
		SCIP_Bool	passmessagehdlr,
		SCIP_Bool *	valid
	)

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

Note: all variables and constraints which are created in the target-SCIP are not (user) captured; In a multi thread case, you need to lock the copying procedure from outside with a mutex. Also, 'passmessagehdlr' should be set to FALSE.; Do not change the source SCIP environment during the copying process

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

Precondition

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

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

Note: sourcescip stage does not get changed; targetscip stage does not get changed

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

Parameters

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

SCIP_RETCODE SCIPaddBoolParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		SCIP_Bool *	valueptr,
		SCIP_Bool	isadvanced,
		SCIP_Bool	defaultvalue,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

SCIP_RETCODE SCIPaddIntParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int *	valueptr,
		SCIP_Bool	isadvanced,
		int	defaultvalue,
		int	minvalue,
		int	maxvalue,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

SCIP_RETCODE SCIPaddLongintParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		SCIP_Longint *	valueptr,
		SCIP_Bool	isadvanced,
		SCIP_Longint	defaultvalue,
		SCIP_Longint	minvalue,
		SCIP_Longint	maxvalue,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

SCIP_RETCODE SCIPaddRealParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		SCIP_Real *	valueptr,
		SCIP_Bool	isadvanced,
		SCIP_Real	defaultvalue,
		SCIP_Real	minvalue,
		SCIP_Real	maxvalue,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

SCIP_RETCODE SCIPaddCharParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		char *	valueptr,
		SCIP_Bool	isadvanced,
		char	defaultvalue,
		const char *	allowedvalues,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

SCIP_RETCODE SCIPaddStringParam	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		char **	valueptr,
		SCIP_Bool	isadvanced,
		const char *	defaultvalue,
		SCIP_DECL_PARAMCHGD((*paramchgd))	,
		SCIP_PARAMDATA *	paramdata
	)

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

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

Parameters

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

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

gets the fixing status of an existing parameter

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

Parameters

scip	SCIP data structure
name	name of the parameter

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

returns the pointer to the SCIP parameter with the given name

Returns: pointer to the parameter with the given name

Parameters

scip	SCIP data structure
name	name of the parameter

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

gets the value of an existing SCIP_Bool parameter

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

Parameters

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

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

gets the value of an existing int parameter

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

Parameters

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

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

gets the value of an existing SCIP_Longint parameter

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

Parameters

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

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

gets the value of an existing SCIP_Real parameter

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

Parameters

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

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

gets the value of an existing char parameter

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

Parameters

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

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

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

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

Parameters

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

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

fixes the value of an existing parameter

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

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

Parameters

scip	SCIP data structure
name	name of the parameter

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

unfixes the value of an existing parameter

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

Parameters

scip	SCIP data structure
name	name of the parameter

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

changes the value of an existing parameter

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

Parameters

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

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

changes the value of an existing SCIP_Bool parameter

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

Parameters

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

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

changes the value of an existing SCIP_Bool parameter

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

Parameters

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

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

changes the value of an existing int parameter

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

Parameters

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

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

changes the value of an existing int parameter

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

Parameters

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

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

changes the value of an existing SCIP_Longint parameter

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

Parameters

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

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

changes the value of an existing SCIP_Longint parameter

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

Parameters

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

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

changes the value of an existing SCIP_Real parameter

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

Parameters

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

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

changes the value of an existing SCIP_Real parameter

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

Parameters

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

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

changes the value of an existing char parameter

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

Parameters

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

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

changes the value of an existing char parameter

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

Parameters

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

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

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

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

Parameters

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

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

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

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

Parameters

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

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

reads parameters from a file

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

Parameters

scip	SCIP data structure
filename	file name

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

writes all parameters in the parameter set to a file

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

Parameters

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

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

resets a single parameter to its default value

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

Parameters

scip	SCIP data structure
name	name of the parameter

SCIP_RETCODE SCIPresetParams ( SCIP * scip )

resets all parameters to their default values

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

Parameters

scip	SCIP data structure

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

sets parameters to

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

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

Parameters

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

SCIP_RETCODE SCIPsetSubscipsOff	(	SCIP *	scip,
		SCIP_Bool	quiet
	)

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

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

Parameters

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

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

sets heuristic parameters values to

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

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

Parameters

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

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

sets presolving parameters to

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

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

Parameters

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

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

sets separating parameters to

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

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

Parameters

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

SCIP_PARAM** SCIPgetParams ( SCIP * scip )

returns the array of all available SCIP parameters

Returns: SCIP_PARAM* array, containing all SCIP parameters.

Parameters

scip	SCIP data structure

int SCIPgetNParams ( SCIP * scip )

returns the total number of all available SCIP parameters

Returns: number of all SCIP parameters.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeReader	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		const char *	extension,
		SCIP_DECL_READERCOPY((*readercopy))	,
		SCIP_DECL_READERFREE((*readerfree))	,
		SCIP_DECL_READERREAD((*readerread))	,
		SCIP_DECL_READERWRITE((*readerwrite))	,
		SCIP_READERDATA *	readerdata
	)

creates a reader and includes it in SCIP

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

Precondition

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

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

Parameters

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

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

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

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

Precondition

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

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

Parameters

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

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

set copy method of reader

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

Precondition

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

Parameters

scip	SCIP data structure
reader	reader

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

set deinitialization method of reader

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

Precondition

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

Parameters

scip	SCIP data structure
reader	reader

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

set read method of reader

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

Precondition

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

Parameters

scip	SCIP data structure
reader	reader

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

set write method of reader

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

Precondition

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

Parameters

scip	SCIP data structure
reader	reader

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

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

Parameters

scip	SCIP data structure
name	name of reader

SCIP_READER** SCIPgetReaders ( SCIP * scip )

returns the array of currently available readers

Parameters

scip	SCIP data structure

int SCIPgetNReaders ( SCIP * scip )

returns the number of currently available readers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludePricer	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		SCIP_Bool	delay,
		SCIP_DECL_PRICERCOPY((*pricercopy))	,
		SCIP_DECL_PRICERFREE((*pricerfree))	,
		SCIP_DECL_PRICERINIT((*pricerinit))	,
		SCIP_DECL_PRICEREXIT((*pricerexit))	,
		SCIP_DECL_PRICERINITSOL((*pricerinitsol))	,
		SCIP_DECL_PRICEREXITSOL((*pricerexitsol))	,
		SCIP_DECL_PRICERREDCOST((*pricerredcost))	,
		SCIP_DECL_PRICERFARKAS((*pricerfarkas))	,
		SCIP_PRICERDATA *	pricerdata
	)

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

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

Precondition

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

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

Parameters

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

SCIP_RETCODE SCIPincludePricerBasic	(	SCIP *	scip,
		SCIP_PRICER **	pricerptr,
		const char *	name,
		const char *	desc,
		int	priority,
		SCIP_Bool	delay,
		SCIP_DECL_PRICERREDCOST((*pricerredcost))	,
		SCIP_DECL_PRICERFARKAS((*pricerfarkas))	,
		SCIP_PRICERDATA *	pricerdata
	)

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

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

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

Precondition

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

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

Parameters

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

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

sets copy method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

sets destructor method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

sets initialization method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

sets deinitialization method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

sets solving process initialization method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

sets solving process deinitialization method of pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	pricer

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

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

Parameters

scip	SCIP data structure
name	name of variable pricer

SCIP_PRICER** SCIPgetPricers ( SCIP * scip )

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

Parameters

scip	SCIP data structure

int SCIPgetNPricers ( SCIP * scip )

returns the number of currently available variable pricers

Parameters

scip	SCIP data structure

int SCIPgetNActivePricers ( SCIP * scip )

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

Parameters

scip	SCIP data structure

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

sets the priority of a variable pricer

Parameters

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

SCIP_RETCODE SCIPactivatePricer	(	SCIP *	scip,
		SCIP_PRICER *	pricer
	)

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

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
pricer	variable pricer

SCIP_RETCODE SCIPdeactivatePricer	(	SCIP *	scip,
		SCIP_PRICER *	pricer
	)

deactivates pricer

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

Precondition

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

Parameters

scip	SCIP data structure
pricer	variable pricer

SCIP_RETCODE SCIPincludeConshdlr	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	sepapriority,
		int	enfopriority,
		int	chckpriority,
		int	sepafreq,
		int	propfreq,
		int	eagerfreq,
		int	maxprerounds,
		SCIP_Bool	delaysepa,
		SCIP_Bool	delayprop,
		SCIP_Bool	delaypresol,
		SCIP_Bool	needscons,
		SCIP_PROPTIMING	timingmask,
		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_CONSHDLRDATA *	conshdlrdata
	)

creates a constraint handler and includes it in SCIP.

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

Precondition

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

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

Parameters

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

SCIP_RETCODE SCIPincludeConshdlrBasic	(	SCIP *	scip,
		SCIP_CONSHDLR **	conshdlrptr,
		const char *	name,
		const char *	desc,
		int	enfopriority,
		int	chckpriority,
		int	eagerfreq,
		SCIP_Bool	needscons,
		SCIP_DECL_CONSENFOLP((*consenfolp))	,
		SCIP_DECL_CONSENFOPS((*consenfops))	,
		SCIP_DECL_CONSCHECK((*conscheck))	,
		SCIP_DECL_CONSLOCK((*conslock))	,
		SCIP_CONSHDLRDATA *	conshdlrdata
	)

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

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

Precondition

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

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

Parameters

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

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

sets all separation related callbacks/parameters of the constraint handler

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

Precondition

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

Parameters

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

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

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

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

Precondition

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

Parameters

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

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

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

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets destructor method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets initialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets deinitialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets solving process initialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets solving process deinitialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets preprocessing initialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets preprocessing deinitialization method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

SCIP_RETCODE SCIPsetConshdlrPresol	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_DECL_CONSPRESOL((*conspresol))	,
		int	maxprerounds,
		SCIP_Bool	delaypresol
	)

sets presolving method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler
maxprerounds	maximal number of presolving rounds the constraint handler participates in (-1: no limit)
delaypresol	should presolving method be delayed, if other presolvers found reductions?

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

sets method of constraint handler to free specific constraint data

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

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

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

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

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets propagation conflict resolving method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets activation notification method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets deactivation notification method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets enabling notification method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets disabling notification method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets variable deletion method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets constraint display method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets constraint parsing method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets constraint variable getter method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

sets constraint variable number getter method of constraint handler

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

Precondition

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

Parameters

scip	SCIP data structure
conshdlr	constraint handler

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

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

Parameters

scip	SCIP data structure
name	name of constraint handler

SCIP_CONSHDLR** SCIPgetConshdlrs ( SCIP * scip )

returns the array of currently available constraint handlers

Parameters

scip	SCIP data structure

int SCIPgetNConshdlrs ( SCIP * scip )

returns the number of currently available constraint handlers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeConflicthdlr	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		SCIP_DECL_CONFLICTCOPY((*conflictcopy))	,
		SCIP_DECL_CONFLICTFREE((*conflictfree))	,
		SCIP_DECL_CONFLICTINIT((*conflictinit))	,
		SCIP_DECL_CONFLICTEXIT((*conflictexit))	,
		SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))	,
		SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))	,
		SCIP_DECL_CONFLICTEXEC((*conflictexec))	,
		SCIP_CONFLICTHDLRDATA *	conflicthdlrdata
	)

creates a conflict handler and includes it in SCIP

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

Parameters

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

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

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

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

Parameters

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

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

set copy method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

set destructor of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

set initialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

set deinitialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

set solving process initialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

set solving process deinitialization method of conflict handler

Parameters

scip	SCIP data structure
conflicthdlr	conflict handler

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

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

Parameters

scip	SCIP data structure
name	name of conflict handler

SCIP_CONFLICTHDLR** SCIPgetConflicthdlrs ( SCIP * scip )

returns the array of currently available conflict handlers

Parameters

scip	SCIP data structure

int SCIPgetNConflicthdlrs ( SCIP * scip )

returns the number of currently available conflict handlers

Parameters

scip	SCIP data structure

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

sets the priority of a conflict handler

Parameters

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

SCIP_RETCODE SCIPincludePresol	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		int	maxrounds,
		SCIP_Bool	delay,
		SCIP_DECL_PRESOLCOPY((*presolcopy))	,
		SCIP_DECL_PRESOLFREE((*presolfree))	,
		SCIP_DECL_PRESOLINIT((*presolinit))	,
		SCIP_DECL_PRESOLEXIT((*presolexit))	,
		SCIP_DECL_PRESOLINITPRE((*presolinitpre))	,
		SCIP_DECL_PRESOLEXITPRE((*presolexitpre))	,
		SCIP_DECL_PRESOLEXEC((*presolexec))	,
		SCIP_PRESOLDATA *	presoldata
	)

creates a presolver and includes it in SCIP

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

Parameters

scip	SCIP data structure
name	name of presolver
desc	description of presolver
priority	priority of the presolver (>= 0: before, < 0: after constraint handlers)
maxrounds	maximal number of presolving rounds the presolver participates in (-1: no limit)
delay	should presolver be delayed, if other presolvers found reductions?
presoldata	presolver data

SCIP_RETCODE SCIPincludePresolBasic	(	SCIP *	scip,
		SCIP_PRESOL **	presolptr,
		const char *	name,
		const char *	desc,
		int	priority,
		int	maxrounds,
		SCIP_Bool	delay,
		SCIP_DECL_PRESOLEXEC((*presolexec))	,
		SCIP_PRESOLDATA *	presoldata
	)

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

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

Parameters

scip	SCIP data structure
presolptr	reference to presolver, or NULL
name	name of presolver
desc	description of presolver
priority	priority of the presolver (>= 0: before, < 0: after constraint handlers)
maxrounds	maximal number of presolving rounds the presolver participates in (-1: no limit)
delay	should presolver be delayed, if other presolvers found reductions?
presoldata	presolver data

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

sets copy method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

sets destructor method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

sets initialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

sets deinitialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

sets solving process initialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

sets solving process deinitialization method of presolver

Parameters

scip	SCIP data structure
presol	presolver

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

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

Parameters

scip	SCIP data structure
name	name of presolver

SCIP_PRESOL** SCIPgetPresols ( SCIP * scip )

returns the array of currently available presolvers

Parameters

scip	SCIP data structure

int SCIPgetNPresols ( SCIP * scip )

returns the number of currently available presolvers

Parameters

scip	SCIP data structure

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

sets the priority of a presolver

Parameters

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

SCIP_RETCODE SCIPincludeRelax	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_DECL_RELAXCOPY((*relaxcopy))	,
		SCIP_DECL_RELAXFREE((*relaxfree))	,
		SCIP_DECL_RELAXINIT((*relaxinit))	,
		SCIP_DECL_RELAXEXIT((*relaxexit))	,
		SCIP_DECL_RELAXINITSOL((*relaxinitsol))	,
		SCIP_DECL_RELAXEXITSOL((*relaxexitsol))	,
		SCIP_DECL_RELAXEXEC((*relaxexec))	,
		SCIP_RELAXDATA *	relaxdata
	)

creates a relaxation handler and includes it in SCIP

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

Parameters

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

SCIP_RETCODE SCIPincludeRelaxBasic	(	SCIP *	scip,
		SCIP_RELAX **	relaxptr,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_DECL_RELAXEXEC((*relaxexec))	,
		SCIP_RELAXDATA *	relaxdata
	)

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

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

Parameters

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

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

sets copy method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

sets destructor method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

sets initialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

sets deinitialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

sets solving process initialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

sets solving process deinitialization method of relaxation handler

Parameters

scip	SCIP data structure
relax	relaxation handler

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

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

Parameters

scip	SCIP data structure
name	name of relaxation handler

SCIP_RELAX** SCIPgetRelaxs ( SCIP * scip )

returns the array of currently available relaxation handlers

Parameters

scip	SCIP data structure

int SCIPgetNRelaxs ( SCIP * scip )

returns the number of currently available relaxation handlers

Parameters

scip	SCIP data structure

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

sets the priority of a relaxation handler

Parameters

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

SCIP_RETCODE SCIPincludeSepa	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_Real	maxbounddist,
		SCIP_Bool	usessubscip,
		SCIP_Bool	delay,
		SCIP_DECL_SEPACOPY((*sepacopy))	,
		SCIP_DECL_SEPAFREE((*sepafree))	,
		SCIP_DECL_SEPAINIT((*sepainit))	,
		SCIP_DECL_SEPAEXIT((*sepaexit))	,
		SCIP_DECL_SEPAINITSOL((*sepainitsol))	,
		SCIP_DECL_SEPAEXITSOL((*sepaexitsol))	,
		SCIP_DECL_SEPAEXECLP((*sepaexeclp))	,
		SCIP_DECL_SEPAEXECSOL((*sepaexecsol))	,
		SCIP_SEPADATA *	sepadata
	)

creates a separator and includes it in SCIP.

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

Parameters

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

SCIP_RETCODE SCIPincludeSepaBasic	(	SCIP *	scip,
		SCIP_SEPA **	sepa,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_Real	maxbounddist,
		SCIP_Bool	usessubscip,
		SCIP_Bool	delay,
		SCIP_DECL_SEPAEXECLP((*sepaexeclp))	,
		SCIP_DECL_SEPAEXECSOL((*sepaexecsol))	,
		SCIP_SEPADATA *	sepadata
	)

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

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

Parameters

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

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

sets copy method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

sets destructor method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

sets initialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

sets deinitialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

sets solving process initialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

sets solving process deinitialization method of separator

Parameters

scip	SCIP data structure
sepa	separator

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

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

Parameters

scip	SCIP data structure
name	name of separator

SCIP_SEPA** SCIPgetSepas ( SCIP * scip )

returns the array of currently available separators

Parameters

scip	SCIP data structure

int SCIPgetNSepas ( SCIP * scip )

returns the number of currently available separators

Parameters

scip	SCIP data structure

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

sets the priority of a separator

Parameters

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

SCIP_RETCODE SCIPincludeProp	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_Bool	delay,
		SCIP_PROPTIMING	timingmask,
		int	presolpriority,
		int	presolmaxrounds,
		SCIP_Bool	presoldelay,
		SCIP_DECL_PROPCOPY((*propcopy))	,
		SCIP_DECL_PROPFREE((*propfree))	,
		SCIP_DECL_PROPINIT((*propinit))	,
		SCIP_DECL_PROPEXIT((*propexit))	,
		SCIP_DECL_PROPINITPRE((*propinitpre))	,
		SCIP_DECL_PROPEXITPRE((*propexitpre))	,
		SCIP_DECL_PROPINITSOL((*propinitsol))	,
		SCIP_DECL_PROPEXITSOL((*propexitsol))	,
		SCIP_DECL_PROPPRESOL((*proppresol))	,
		SCIP_DECL_PROPEXEC((*propexec))	,
		SCIP_DECL_PROPRESPROP((*propresprop))	,
		SCIP_PROPDATA *	propdata
	)

creates a propagator and includes it in SCIP.

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

Parameters

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

SCIP_RETCODE SCIPincludePropBasic	(	SCIP *	scip,
		SCIP_PROP **	propptr,
		const char *	name,
		const char *	desc,
		int	priority,
		int	freq,
		SCIP_Bool	delay,
		SCIP_PROPTIMING	timingmask,
		SCIP_DECL_PROPEXEC((*propexec))	,
		SCIP_PROPDATA *	propdata
	)

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

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

Parameters

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

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

sets copy method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets destructor method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets solving process initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets solving process deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets preprocessing initialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

sets preprocessing deinitialization method of propagator

Parameters

scip	SCIP data structure
prop	propagator

SCIP_RETCODE SCIPsetPropPresol	(	SCIP *	scip,
		SCIP_PROP *	prop,
		SCIP_DECL_PROPPRESOL((*proppresol))	,
		int	presolpriority,
		int	presolmaxrounds,
		SCIP_Bool	presoldelay
	)

sets presolving method of propagator

Parameters

scip	SCIP data structure
prop	propagator
presolpriority	presolving priority of the propagator (>= 0: before, < 0: after constraint handlers)
presolmaxrounds	maximal number of presolving rounds the propagator participates in (-1: no limit)
presoldelay	should presolving be delayed, if other presolvers found reductions?

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

sets propagation conflict resolving callback of propagator

Parameters

scip	SCIP data structure
prop	propagator

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

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

Parameters

scip	SCIP data structure
name	name of propagator

SCIP_PROP** SCIPgetProps ( SCIP * scip )

returns the array of currently available propagators

Parameters

scip	SCIP data structure

int SCIPgetNProps ( SCIP * scip )

returns the number of currently available propagators

Parameters

scip	SCIP data structure

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

sets the priority of a propagator

Parameters

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

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

sets the presolving priority of a propagator

Parameters

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

SCIP_RETCODE SCIPincludeHeur	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		char	dispchar,
		int	priority,
		int	freq,
		int	freqofs,
		int	maxdepth,
		unsigned int	timingmask,
		SCIP_Bool	usessubscip,
		SCIP_DECL_HEURCOPY((*heurcopy))	,
		SCIP_DECL_HEURFREE((*heurfree))	,
		SCIP_DECL_HEURINIT((*heurinit))	,
		SCIP_DECL_HEUREXIT((*heurexit))	,
		SCIP_DECL_HEURINITSOL((*heurinitsol))	,
		SCIP_DECL_HEUREXITSOL((*heurexitsol))	,
		SCIP_DECL_HEUREXEC((*heurexec))	,
		SCIP_HEURDATA *	heurdata
	)

creates a primal heuristic and includes it in SCIP.

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

Parameters

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

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

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

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

Parameters

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

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

sets copy method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

sets destructor method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

sets initialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

sets deinitialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

sets solving process initialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

sets solving process deinitialization method of primal heuristic

Parameters

scip	SCIP data structure
heur	primal heuristic

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

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

Parameters

scip	SCIP data structure
name	name of primal heuristic

SCIP_HEUR** SCIPgetHeurs ( SCIP * scip )

returns the array of currently available primal heuristics

Parameters

scip	SCIP data structure

int SCIPgetNHeurs ( SCIP * scip )

returns the number of currently available primal heuristics

Parameters

scip	SCIP data structure

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

sets the priority of a primal heuristic

Parameters

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

SCIP_RETCODE SCIPincludeEventhdlr	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		SCIP_DECL_EVENTCOPY((*eventcopy))	,
		SCIP_DECL_EVENTFREE((*eventfree))	,
		SCIP_DECL_EVENTINIT((*eventinit))	,
		SCIP_DECL_EVENTEXIT((*eventexit))	,
		SCIP_DECL_EVENTINITSOL((*eventinitsol))	,
		SCIP_DECL_EVENTEXITSOL((*eventexitsol))	,
		SCIP_DECL_EVENTDELETE((*eventdelete))	,
		SCIP_DECL_EVENTEXEC((*eventexec))	,
		SCIP_EVENTHDLRDATA *	eventhdlrdata
	)

creates an event handler and includes it in SCIP

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

Parameters

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

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

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

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

Parameters

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

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

sets copy callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets initialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets solving process initialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets solving process deinitialization callback of the event handler

Parameters

scip	scip instance
eventhdlr	event handler

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

sets callback of the event handler to free specific event data

Parameters

scip	scip instance
eventhdlr	event handler

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

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

Parameters

scip	SCIP data structure
name	name of event handler

SCIP_EVENTHDLR** SCIPgetEventhdlrs ( SCIP * scip )

returns the array of currently available event handlers

Parameters

scip	SCIP data structure

int SCIPgetNEventhdlrs ( SCIP * scip )

returns the number of currently available event handlers

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeNodesel	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	stdpriority,
		int	memsavepriority,
		SCIP_DECL_NODESELCOPY((*nodeselcopy))	,
		SCIP_DECL_NODESELFREE((*nodeselfree))	,
		SCIP_DECL_NODESELINIT((*nodeselinit))	,
		SCIP_DECL_NODESELEXIT((*nodeselexit))	,
		SCIP_DECL_NODESELINITSOL((*nodeselinitsol))	,
		SCIP_DECL_NODESELEXITSOL((*nodeselexitsol))	,
		SCIP_DECL_NODESELSELECT((*nodeselselect))	,
		SCIP_DECL_NODESELCOMP((*nodeselcomp))	,
		SCIP_NODESELDATA *	nodeseldata
	)

creates a node selector and includes it in SCIP.

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

Parameters

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

SCIP_RETCODE SCIPincludeNodeselBasic	(	SCIP *	scip,
		SCIP_NODESEL **	nodesel,
		const char *	name,
		const char *	desc,
		int	stdpriority,
		int	memsavepriority,
		SCIP_DECL_NODESELSELECT((*nodeselselect))	,
		SCIP_DECL_NODESELCOMP((*nodeselcomp))	,
		SCIP_NODESELDATA *	nodeseldata
	)

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

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

Parameters

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

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

sets copy method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

sets destructor method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

sets initialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

sets deinitialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

sets solving process initialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

sets solving process deinitialization method of node selector

Parameters

scip	SCIP data structure
nodesel	node selector

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

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

Parameters

scip	SCIP data structure
name	name of node selector

SCIP_NODESEL** SCIPgetNodesels ( SCIP * scip )

returns the array of currently available node selectors

Parameters

scip	SCIP data structure

int SCIPgetNNodesels ( SCIP * scip )

returns the number of currently available node selectors

Parameters

scip	SCIP data structure

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

sets the priority of a node selector in standard mode

Parameters

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

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

sets the priority of a node selector in memory saving mode

Parameters

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

SCIP_NODESEL* SCIPgetNodesel ( SCIP * scip )

returns the currently used node selector

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeBranchrule	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		int	priority,
		int	maxdepth,
		SCIP_Real	maxbounddist,
		SCIP_DECL_BRANCHCOPY((*branchcopy))	,
		SCIP_DECL_BRANCHFREE((*branchfree))	,
		SCIP_DECL_BRANCHINIT((*branchinit))	,
		SCIP_DECL_BRANCHEXIT((*branchexit))	,
		SCIP_DECL_BRANCHINITSOL((*branchinitsol))	,
		SCIP_DECL_BRANCHEXITSOL((*branchexitsol))	,
		SCIP_DECL_BRANCHEXECLP((*branchexeclp))	,
		SCIP_DECL_BRANCHEXECEXT((*branchexecext))	,
		SCIP_DECL_BRANCHEXECPS((*branchexecps))	,
		SCIP_BRANCHRULEDATA *	branchruledata
	)

creates a branching rule and includes it in SCIP

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

Parameters

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

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

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

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

Parameters

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

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

sets copy method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets destructor method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets initialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets deinitialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets solving process initialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets solving process deinitialization method of branching rule

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets branching execution method for fractional LP solutions

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets branching execution method for external candidates

Parameters

scip	SCIP data structure
branchrule	branching rule

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

sets branching execution method for not completely fixed pseudo solutions

Parameters

scip	SCIP data structure
branchrule	branching rule

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

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

Parameters

scip	SCIP data structure
name	name of branching rule

SCIP_BRANCHRULE** SCIPgetBranchrules ( SCIP * scip )

returns the array of currently available branching rules

Parameters

scip	SCIP data structure

int SCIPgetNBranchrules ( SCIP * scip )

returns the number of currently available branching rules

Parameters

scip	SCIP data structure

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

sets the priority of a branching rule

Parameters

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

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

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

Parameters

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

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

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

Parameters

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

SCIP_RETCODE SCIPincludeDisp	(	SCIP *	scip,
		const char *	name,
		const char *	desc,
		const char *	header,
		SCIP_DISPSTATUS	dispstatus,
		SCIP_DECL_DISPCOPY((*dispcopy))	,
		SCIP_DECL_DISPFREE((*dispfree))	,
		SCIP_DECL_DISPINIT((*dispinit))	,
		SCIP_DECL_DISPEXIT((*dispexit))	,
		SCIP_DECL_DISPINITSOL((*dispinitsol))	,
		SCIP_DECL_DISPEXITSOL((*dispexitsol))	,
		SCIP_DECL_DISPOUTPUT((*dispoutput))	,
		SCIP_DISPDATA *	dispdata,
		int	width,
		int	priority,
		int	position,
		SCIP_Bool	stripline
	)

creates a display column and includes it in SCIP

Parameters

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

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

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

Parameters

scip	SCIP data structure
name	name of display column

SCIP_DISP** SCIPgetDisps ( SCIP * scip )

returns the array of currently available display columns

Parameters

scip	SCIP data structure

int SCIPgetNDisps ( SCIP * scip )

returns the number of currently available display columns

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPautoselectDisps ( SCIP * scip )

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPincludeNlpi	(	SCIP *	scip,
		SCIP_NLPI *	nlpi
	)

includes an NLPI in SCIP

Parameters

scip	SCIP data structure
nlpi	NLPI data structure

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

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

Parameters

scip	SCIP data structure
name	name of NLPI

SCIP_NLPI** SCIPgetNlpis ( SCIP * scip )

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

Parameters

scip	SCIP data structure

int SCIPgetNNlpis ( SCIP * scip )

returns the number of currently available NLPIs

Parameters

scip	SCIP data structure

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

sets the priority of an NLPI

Parameters

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

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

includes information about an external code linked into the SCIP library

Parameters

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

char** SCIPgetExternalCodeNames ( SCIP * scip )

returns an array of names of currently included external codes

Parameters

scip	SCIP data structure

char** SCIPgetExternalCodeDescriptions ( SCIP * scip )

returns an array of the descriptions of currently included external codes

Note: some descriptions may be NULL

Parameters

scip	SCIP data structure

int SCIPgetNExternalCodes ( SCIP * scip )

returns the number of currently included information on external codes

Parameters

scip	SCIP data structure

void SCIPprintExternalCodes	(	SCIP *	scip,
		FILE *	file
	)

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

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

Parameters

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

SCIP_RETCODE SCIPincludeDialog	(	SCIP *	scip,
		SCIP_DIALOG **	dialog,
		SCIP_DECL_DIALOGCOPY((*dialogcopy))	,
		SCIP_DECL_DIALOGEXEC((*dialogexec))	,
		SCIP_DECL_DIALOGDESC((*dialogdesc))	,
		SCIP_DECL_DIALOGFREE((*dialogfree))	,
		const char *	name,
		const char *	desc,
		SCIP_Bool	issubmenu,
		SCIP_DIALOGDATA *	dialogdata
	)

creates and includes dialog

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

Parameters

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

SCIP_Bool SCIPexistsDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

returns if the dialog already exists

Returns: TRUE is returned if the dialog exits, otherwise FALSE.

Parameters

scip	SCIP data structure
dialog	dialog

SCIP_RETCODE SCIPcaptureDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

captures a dialog

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

Parameters

scip	SCIP data structure
dialog	dialog

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

releases a dialog

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

Parameters

scip	SCIP data structure
dialog	pointer to the dialog

SCIP_RETCODE SCIPsetRootDialog	(	SCIP *	scip,
		SCIP_DIALOG *	dialog
	)

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

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

Parameters

scip	SCIP data structure
dialog	dialog to be the root

SCIP_DIALOG* SCIPgetRootDialog ( SCIP * scip )

returns the root dialog of SCIP's interactive user shell

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

Parameters

scip	SCIP data structure

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

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

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

Parameters

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

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

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

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

Parameters

scip	SCIP data structure
inputline	input line to add

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

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

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

Parameters

scip	SCIP data structure
inputline	input line to add

SCIP_RETCODE SCIPstartInteraction ( SCIP * scip )

starts interactive mode of SCIP by executing the root dialog

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

Precondition

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

Postcondition

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

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

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateProb	(	SCIP *	scip,
		const char *	name,
		SCIP_DECL_PROBDELORIG((*probdelorig))	,
		SCIP_DECL_PROBTRANS((*probtrans))	,
		SCIP_DECL_PROBDELTRANS((*probdeltrans))	,
		SCIP_DECL_PROBINITSOL((*probinitsol))	,
		SCIP_DECL_PROBEXITSOL((*probexitsol))	,
		SCIP_DECL_PROBCOPY((*probcopy))	,
		SCIP_PROBDATA *	probdata
	)

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

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

Precondition

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

Postcondition

After calling this method, SCIP reaches the following stage:

SCIP_STAGE_PROBLEM

Parameters

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

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

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

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

Precondition

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

Postcondition

After calling this method, SCIP reaches the following stage:

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
name	problem name

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

sets callback to free user data of original problem

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

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

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

sets callback to free user data of transformed problem

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

sets solving process initialization callback of transformed data

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

sets solving process deinitialization callback of transformed data

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

sets callback to copy user data to a subscip

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure

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

reads problem from file and initializes all solving data structures

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

Precondition

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

Postcondition

After the method was called, SCIP is in one of the following stages: -SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)

ref SCIP_STAGE_PROBLEM if the problem file was successfully read

Parameters

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

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

writes original problem to file

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

Precondition

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

Parameters

scip	SCIP data structure
filename	output file (or NULL for standard output)
extension	extension of the desired file reader, or NULL if file extension should be used
genericnames	use generic variable and constraint names?

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

writes transformed problem which are valid in the current node to file

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

Precondition

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

Note: If you want the write all constraints (including the once which are redundant for example), you need to set the parameter <write/allconss> to TRUE

Parameters

scip	SCIP data structure
filename	output file (or NULL for standard output)
extension	extension of the desired file reader, or NULL if file extension should be used
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPfreeProb ( SCIP * scip )

frees problem and solution process data

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

Precondition

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

Postcondition

After this method was called, SCIP is in the following stage:

SCIP_STAGE_INIT

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPpermuteProb	(	SCIP *	scip,
		unsigned int	randseed,
		SCIP_Bool	permuteconss,
		SCIP_Bool	permutebinvars,
		SCIP_Bool	permuteintvars,
		SCIP_Bool	permuteimplvars,
		SCIP_Bool	permutecontvars
	)

permutes parts of the problem data structure

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

Precondition

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

Parameters

scip	SCIP data structure
randseed	seed value for random generator
permuteconss	should the list of constraints in each constraint handler be permuted?
permutebinvars	should the list of binary variables be permuted?
permuteintvars	should the list of integer variables be permuted?
permuteimplvars	should the list of implicit integer variables be permuted?
permutecontvars	should the list of continuous integer variables be permuted?

SCIP_PROBDATA* SCIPgetProbData ( SCIP * scip )

gets user problem data

Returns: a SCIP_PROBDATA pointer, or NULL if no problem data was allocated

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetProbData	(	SCIP *	scip,
		SCIP_PROBDATA *	probdata
	)

sets user problem data

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

Precondition

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

Parameters

scip	SCIP data structure
probdata	user problem data to use

const char* SCIPgetProbName ( SCIP * scip )

returns name of the current problem instance

Returns: name of the current problem instance

Precondition

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

Parameters

scip	SCIP data structure

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

sets name of the current problem instance

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

Precondition

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

Parameters

scip	SCIP data structure
name	name to be set

SCIP_OBJSENSE SCIPgetObjsense ( SCIP * scip )

returns objective sense of original problem

Returns: objective sense of original problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjsense	(	SCIP *	scip,
		SCIP_OBJSENSE	objsense
	)

sets objective sense of problem

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
objsense	new objective sense

SCIP_RETCODE SCIPaddObjoffset	(	SCIP *	scip,
		SCIP_Real	addval
	)

adds offset of objective function

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

Precondition

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

SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
addval	value to add to objective offset

SCIP_RETCODE SCIPaddOrigObjoffset	(	SCIP *	scip,
		SCIP_Real	addval
	)

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

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

Precondition

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

SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
addval	value to add to objective offset

SCIP_Real SCIPgetOrigObjoffset ( SCIP * scip )

returns the objective offset of the original problem

Returns: the objective offset of the original problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetOrigObjscale ( SCIP * scip )

returns the objective scale of the original problem

Returns: the objective scale of the original problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransObjoffset ( SCIP * scip )

returns the objective offset of the transformed problem

Returns: the objective offset of the transformed problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransObjscale ( SCIP * scip )

returns the objective scale of the transformed problem

Returns: the objective scale of the transformed problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjlimit	(	SCIP *	scip,
		SCIP_Real	objlimit
	)

sets limit on objective function, such that only solutions better than this limit are accepted

Note: SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune all branch-and-bound nodes with dual bound equal or worse to the objective limit. However, SCIP will also collect solutions with objective value worse than the objective limit and use them to run improvement heuristics on them.; If SCIP can prove that there exists no solution with a strictly better objective value, the solving status will normally be infeasible (the objective limit is interpreted as part of the problem). The only exception is that by chance, SCIP found a solution with the same objective value and thus proved the optimality of this solution, resulting in solution status optimal.

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

Precondition

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

Parameters

scip	SCIP data structure
objlimit	new primal objective limit

SCIP_Real SCIPgetObjlimit ( SCIP * scip )

returns current limit on objective function

Returns: the current objective limit of the original problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetObjIntegral ( SCIP * scip )

informs SCIP, that the objective value is always integral in every feasible solution

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

Precondition

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

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisObjIntegral ( SCIP * scip )

returns whether the objective value is known to be integral in every feasible solution

Returns: TRUE, if objective value is known to be always integral, otherwise FALSE

Precondition

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

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetObjNorm ( SCIP * scip )

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

Returns: the Euclidean norm of the transformed objective function vector

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

adds variable to the problem

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to add

SCIP_RETCODE SCIPaddPricedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	score
	)

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

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

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to add
score	pricing score of variable (the larger, the better the variable)

SCIP_RETCODE SCIPdelVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool *	deleted
	)

removes variable from the problem

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to delete
deleted	pointer to store whether variable was successfully marked to be deleted

SCIP_RETCODE SCIPgetVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

gets variables of the problem along with the numbers of different variable types; data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()

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

Precondition

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

Note: Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR** SCIPgetVars ( SCIP * scip )

gets array with active problem variables

Returns: array with active problem variables

Precondition

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

Warning: If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned by this method.

Note: Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure

int SCIPgetNVars ( SCIP * scip )

gets number of active problem variables

Returns: the number of active problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNBinVars ( SCIP * scip )

gets number of binary active problem variables

Returns: the number of binary active problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNIntVars ( SCIP * scip )

gets number of integer active problem variables

Returns: the number of integer active problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNImplVars ( SCIP * scip )

gets number of implicit integer active problem variables

Returns: the number of implicit integer active problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNContVars ( SCIP * scip )

gets number of continuous active problem variables

Returns: the number of continuous active problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNObjVars ( SCIP * scip )

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

Note: In case of the original problem the number of variables is counted. In case of the transformed problem the number of variables is just returned since it is stored internally

Returns: the number of active problem variables with a non-zero objective coefficient

Precondition

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

Parameters

scip	SCIP data structure

SCIP_VAR** SCIPgetFixedVars ( SCIP * scip )

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

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

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNFixedVars ( SCIP * scip )

gets number of fixed or aggregated problem variables

Returns: the number of fixed or aggregated problem variables

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetOrigVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR** SCIPgetOrigVars ( SCIP * scip )

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

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

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNOrigVars ( SCIP * scip )

gets number of original problem variables

Returns: the number of original problem variables

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNOrigBinVars ( SCIP * scip )

gets number of binary variables in the original problem

Returns: the number of binary variables in the original problem

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNOrigIntVars ( SCIP * scip )

gets the number of integer variables in the original problem

Returns: the number of integer variables in the original problem

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNOrigImplVars ( SCIP * scip )

gets number of implicit integer variables in the original problem

Returns: the number of implicit integer variables in the original problem

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNOrigContVars ( SCIP * scip )

gets number of continuous variables in the original problem

Returns: the number of continuous variables in the original problem

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNTotalVars ( SCIP * scip )

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

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

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetSolVarsData	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR ***	vars,
		int *	nvars,
		int *	nbinvars,
		int *	nintvars,
		int *	nimplvars,
		int *	ncontvars
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
sol	primal solution that selects the problem space, NULL for current solution
vars	pointer to store variables array or NULL if not needed
nvars	pointer to store number of variables or NULL if not needed
nbinvars	pointer to store number of binary variables or NULL if not needed
nintvars	pointer to store number of integer variables or NULL if not needed
nimplvars	pointer to store number of implicit integral vars or NULL if not needed
ncontvars	pointer to store number of continuous variables or NULL if not needed

SCIP_VAR* SCIPfindVar	(	SCIP *	scip,
		const char *	name
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
name	name of variable to find

SCIP_Bool SCIPallVarsInProb ( SCIP * scip )

returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables, that will be added in pricing and improve the objective value

Returns: TRUE, if all potential variables exist in the problem; FALSE, otherwise

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
cons	constraint to add

SCIP_RETCODE SCIPdelCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
cons	constraint to delete

SCIP_CONS* SCIPfindOrigCons	(	SCIP *	scip,
		const char *	name
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
name	name of constraint to find

SCIP_CONS* SCIPfindCons	(	SCIP *	scip,
		const char *	name
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
name	name of constraint to find

int SCIPgetNUpgrConss ( SCIP * scip )

gets number of upgraded constraints

Returns: number of upgraded constraints

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNConss ( SCIP * scip )

gets total number of globally valid constraints currently in the problem

Returns: total number of globally valid constraints currently in the problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_CONS** SCIPgetConss ( SCIP * scip )

gets array of globally valid constraints currently in the problem

Returns: array of globally valid constraints currently in the problem

Precondition

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

Warning: If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is accessed via this method) gets resized. This can invalid the pointer which is returned by this method.

Parameters

scip	SCIP data structure

int SCIPgetNOrigConss ( SCIP * scip )

gets total number of constraints in the original problem

Returns: total number of constraints in the original problem

Precondition

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

Parameters

scip	SCIP data structure

SCIP_CONS** SCIPgetOrigConss ( SCIP * scip )

gets array of constraints in the original problem

Returns: array of constraints in the original problem

Precondition

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

Parameters

scip	SCIP data structure

int SCIPgetNCheckConss ( SCIP * scip )

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

Returns: returns the number of check constraints

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddConsNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_CONS *	cons,
		SCIP_NODE *	validnode
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
node	node to add constraint to
cons	constraint to add
validnode	node at which the constraint is valid, or NULL

SCIP_RETCODE SCIPaddConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_NODE *	validnode
	)

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

If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode". If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to the given node. If a local constraint is added to the root node, it is added to the global problem instead.

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

Precondition

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

Note: The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is the case due internal data structures and performance issues. In such a case you should try to realize your issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.

Parameters

scip	SCIP data structure
cons	constraint to add
validnode	node at which the constraint is valid, or NULL

SCIP_RETCODE SCIPdelConsNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_CONS *	cons
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
node	node to disable constraint in
cons	constraint to locally delete

SCIP_RETCODE SCIPdelConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
cons	constraint to locally delete

SCIP_Real SCIPgetLocalOrigEstimate ( SCIP * scip )

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

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

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalTransEstimate ( SCIP * scip )

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

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

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalDualbound ( SCIP * scip )

gets dual bound of current node

Returns: dual bound of current node

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLocalLowerbound ( SCIP * scip )

gets lower bound of current node in transformed problem

Returns: lower bound of current node in transformed problem

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetNodeDualbound	(	SCIP *	scip,
		SCIP_NODE *	node
	)

gets dual bound of given node

Returns: dual bound of a given node

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to get dual bound for

SCIP_Real SCIPgetNodeLowerbound	(	SCIP *	scip,
		SCIP_NODE *	node
	)

gets lower bound of given node in transformed problem

Returns: lower bound of given node in transformed problem

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to get dual bound for

SCIP_RETCODE SCIPupdateLocalDualbound	(	SCIP *	scip,
		SCIP_Real	newbound
	)

if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in original problem space), sets the current node's dual bound to the new value

Note: the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.

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

Precondition

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

Parameters

scip	SCIP data structure
newbound	new dual bound for the node (if it's tighter than the old one)

SCIP_RETCODE SCIPupdateLocalLowerbound	(	SCIP *	scip,
		SCIP_Real	newbound
	)

if given value is larger than the current node's lower bound (in transformed problem), sets the current node's lower bound to the new value

Note: the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.

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

Precondition

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

Parameters

scip	SCIP data structure
newbound	new lower bound for the node (if it's larger than the old one)

SCIP_RETCODE SCIPupdateNodeDualbound	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_Real	newbound
	)

if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound, sets the node's dual bound to the new value

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

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to update dual bound for
newbound	new dual bound for the node (if it's tighter than the old one)

SCIP_RETCODE SCIPupdateNodeLowerbound	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_Real	newbound
	)

if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound to the new value

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

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to update lower bound for
newbound	new lower bound for the node (if it's larger than the old one)

SCIP_RETCODE SCIPchgChildPrio	(	SCIP *	scip,
		SCIP_NODE *	child,
		SCIP_Real	priority
	)

change the node selection priority of the given child

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

Precondition

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

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
child	child to update the node selection priority
priority	node selection priority value

SCIP_RETCODE SCIPtransformProb ( SCIP * scip )

initializes solving data structures and transforms problem

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

Precondition

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

Postcondition: When calling this method in the SCIP_STAGE_PROBLEM stage, the SCIP stage is changed to SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPpresolve ( SCIP * scip )

transforms and presolves problem

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

Precondition

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

Postcondition

After calling this method SCIP reaches one of the following stages:

SCIP_STAGE_PRESOLVING if the presolving process was interrupted
SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
SCIP_STAGE_SOLVED if the problem was solved during presolving

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsolve ( SCIP * scip )

transforms, presolves, and solves problem

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

Precondition

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

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

SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
SCIP_STAGE_SOLVED if the solving process was not interrupted

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPfreeSolve	(	SCIP *	scip,
		SCIP_Bool	restart
	)

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

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

Precondition

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

Postcondition: If this method is called in SCIP stage SCIP_STAGE_INIT or SCIP_STAGE_PROBLEM, the stage of SCIP is not changed; otherwise, the SCIP stage is changed to SCIP_STAGE_TRANSFORMED

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

Parameters

scip	SCIP data structure
restart	should certain data be preserved for improved restarting?

SCIP_RETCODE SCIPfreeTransform ( SCIP * scip )

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

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

Precondition

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

Postcondition

After calling this method SCIP reaches one of the following stages:

SCIP_STAGE_INIT if the method was called from SCIP stage SCIP_STAGE_INIT
SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPinterruptSolve ( SCIP * scip )

informs SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has been solved)

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

Precondition

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

Note: the SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPrestartSolve ( SCIP * scip )

informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has been solved)

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

Precondition

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

Note: the SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisInRestart ( SCIP * scip )

returns whether we are in the restarting phase

Returns: TRUE, if we are in the restarting phase; FALSE, otherwise

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateVar	(	SCIP *	scip,
		SCIP_VAR **	var,
		const char *	name,
		SCIP_Real	lb,
		SCIP_Real	ub,
		SCIP_Real	obj,
		SCIP_VARTYPE	vartype,
		SCIP_Bool	initial,
		SCIP_Bool	removable,
		SCIP_DECL_VARDELORIG((*vardelorig))	,
		SCIP_DECL_VARTRANS((*vartrans))	,
		SCIP_DECL_VARDELTRANS((*vardeltrans))	,
		SCIP_DECL_VARCOPY((*varcopy))	,
		SCIP_VARDATA *	vardata
	)

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

Warning: When doing column generation and the original problem is a maximization problem, notice that SCIP will transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the original objective function value of variables created during the solving process has to be multiplied by -1, too.

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

Precondition

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

Note: the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()

Parameters

scip	SCIP data structure
var	pointer to variable object
name	name of variable, or NULL for automatic name creation
lb	lower bound of variable
ub	upper bound of variable
obj	objective function value
vartype	type of variable
initial	should var's column be present in the initial root LP?
removable	is var's column removable from the LP (due to aging or cleanup)?
vardata	user data for this specific variable, or NULL

SCIP_RETCODE SCIPcreateVarBasic	(	SCIP *	scip,
		SCIP_VAR **	var,
		const char *	name,
		SCIP_Real	lb,
		SCIP_Real	ub,
		SCIP_Real	obj,
		SCIP_VARTYPE	vartype
	)

creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(), SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable;

Warning: When doing column generation and the original problem is a maximization problem, notice that SCIP will transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the original objective function value of variables created during the solving process has to be multiplied by -1, too.

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

Precondition

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

Note: the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()

Parameters

scip	SCIP data structure
var	pointer to variable object
name	name of variable, or NULL for automatic name creation
lb	lower bound of variable
ub	upper bound of variable
obj	objective function value
vartype	type of variable

SCIP_RETCODE SCIPwriteVarName	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR *	var,
		SCIP_Bool	type
	)

outputs the variable name to the file stream

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

Precondition

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

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
var	variable to output
type	should the variable type be also posted

SCIP_RETCODE SCIPwriteVarsList	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Bool	type,
		char	delimiter
	)

print the given list of variables to output stream separated by the given delimiter character;

i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;

the method SCIPparseVarsList() can parse such a string

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

Precondition

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

Note: The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
vars	variable array to output
nvars	number of variables
type	should the variable type be also posted
delimiter	character which is used for delimitation

SCIP_RETCODE SCIPwriteVarsLinearsum	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		int	nvars,
		SCIP_Bool	type
	)

print the given variables and coefficients as linear sum in the following form c1 <x1> + c2 <x2> ... + cn <xn>

This string can be parsed by the method SCIPparseVarsLinearsum().

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

Precondition

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

Note: The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
vars	variable array to output
vals	array of coefficients or NULL if all coefficients are 1.0
nvars	number of variables
type	should the variable type be also posted

SCIP_RETCODE SCIPwriteVarsPolynomial	(	SCIP *	scip,
		FILE *	file,
		SCIP_VAR ***	monomialvars,
		SCIP_Real **	monomialexps,
		SCIP_Real *	monomialcoefs,
		int *	monomialnvars,
		int	nmonomials,
		SCIP_Bool	type
	)

print the given monomials as polynomial in the following form c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...

This string can be parsed by the method SCIPparseVarsPolynomial().

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

Precondition

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

Note: The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file, or NULL for stdout
monomialvars	arrays with variables for each monomial
monomialexps	arrays with variable exponents, or NULL if always 1.0
monomialcoefs	array with monomial coefficients
monomialnvars	array with number of variables for each monomial
nmonomials	number of monomials
type	should the variable type be also posted

SCIP_RETCODE SCIPparseVar	(	SCIP *	scip,
		SCIP_VAR **	var,
		const char *	str,
		SCIP_Bool	initial,
		SCIP_Bool	removable,
		SCIP_DECL_VARCOPY((*varcopy))	,
		SCIP_DECL_VARDELORIG((*vardelorig))	,
		SCIP_DECL_VARTRANS((*vartrans))	,
		SCIP_DECL_VARDELTRANS((*vardeltrans))	,
		SCIP_VARDATA *	vardata,
		char **	endptr,
		SCIP_Bool *	success
	)

parses variable information (in cip format) out of a string; if the parsing process was successful a variable is created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary variable

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

Precondition

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

Parameters

scip	SCIP data structure
var	pointer to store the problem variable
str	string to parse
initial	should var's column be present in the initial root LP?
removable	is var's column removable from the LP (due to aging or cleanup)?
vardata	user data for this specific variable
endptr	pointer to store the final string position if successfully
success	pointer store if the paring process was successful

SCIP_RETCODE SCIPparseVarName	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR **	var,
		char **	endptr
	)

parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable exits and returns the position where the parsing stopped

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

Precondition

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

Parameters

scip	SCIP data structure
str	string to parse
var	pointer to store the problem variable, or NULL if it does not exit
endptr	pointer to store the final string position if successfully

SCIP_RETCODE SCIPparseVarsList	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR **	vars,
		int *	nvars,
		int	varssize,
		int *	requiredsize,
		char **	endptr,
		char	delimiter,
		SCIP_Bool *	success
	)

parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE

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

Precondition

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

Note: the pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist; If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding integer; the reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP memory functions).

Parameters

scip	SCIP data structure
str	string to parse
vars	array to store the parsed variable
nvars	pointer to store number of parsed variables
varssize	size of the variable array
requiredsize	pointer to store the required array size for the active variables
endptr	pointer to store the final string position if successfully
delimiter	character which is used for delimitation
success	pointer to store the whether the parsing was successfully or not

SCIP_RETCODE SCIPparseVarsLinearsum	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		int *	nvars,
		int	varssize,
		int *	requiredsize,
		char **	endptr,
		SCIP_Bool *	success
	)

parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>) (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE

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

Precondition

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

Note: the pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist; If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding integer; the reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP memory functions).

Parameters

scip	SCIP data structure
str	string to parse
vars	array to store the parsed variables
vals	array to store the parsed coefficients
nvars	pointer to store number of parsed variables
varssize	size of the variable array
requiredsize	pointer to store the required array size for the active variables
endptr	pointer to store the final string position if successfully
success	pointer to store the whether the parsing was successfully or not

SCIP_RETCODE SCIPparseVarsPolynomial	(	SCIP *	scip,
		const char *	str,
		SCIP_VAR ****	monomialvars,
		SCIP_Real ***	monomialexps,
		SCIP_Real **	monomialcoefs,
		int **	monomialnvars,
		int *	nmonomials,
		char **	endptr,
		SCIP_Bool *	success
	)

parse the given string as polynomial of variables and coefficients (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...) (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE

The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since they use buffer memory that is intended for short term use only.

Parsing is stopped at the end of string (indicated by the \0-character) or when no more monomials are recognized.

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

Precondition

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

Parameters

scip	SCIP data structure
str	string to parse
monomialvars	pointer to store arrays with variables for each monomial
monomialexps	pointer to store arrays with variable exponents
monomialcoefs	pointer to store array with monomial coefficients
monomialnvars	pointer to store array with number of variables for each monomial
nmonomials	pointer to store number of parsed monomials
endptr	pointer to store the final string position if successfully
success	pointer to store the whether the parsing was successfully or not

void SCIPfreeParseVarsPolynomialData	(	SCIP *	scip,
		SCIP_VAR ****	monomialvars,
		SCIP_Real ***	monomialexps,
		SCIP_Real **	monomialcoefs,
		int **	monomialnvars,
		int	nmonomials
	)

frees memory allocated when parsing a polynomial from a string

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

Precondition

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

Parameters

scip	SCIP data structure
monomialvars	pointer to store arrays with variables for each monomial
monomialexps	pointer to store arrays with variable exponents
monomialcoefs	pointer to store array with monomial coefficients
monomialnvars	pointer to store array with number of variables for each monomial
nmonomials	pointer to store number of parsed monomials

SCIP_RETCODE SCIPcaptureVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

increases usage counter of variable

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to capture

SCIP_RETCODE SCIPreleaseVar	(	SCIP *	scip,
		SCIP_VAR **	var
	)

decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed

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

Precondition

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

Note: the pointer of the variable will be NULLed

Parameters

scip	SCIP data structure
var	pointer to variable

SCIP_RETCODE SCIPchgVarName	(	SCIP *	scip,
		SCIP_VAR *	var,
		const char *	name
	)

changes the name of a variable

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

Precondition: This method can only be called if scip is in stage SCIP_STAGE_PROBLEM

Note: to get the current name of a variable, use SCIPvarGetName() from pub_var.h

Parameters

scip	SCIP data structure
var	variable
name	new name of constraint

SCIP_RETCODE SCIPtransformVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	transvar
	)

gets and captures transformed variable of a given variable; if the variable is not yet transformed, a new transformed variable for this variable is created

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to get/create transformed variable for
transvar	pointer to store the transformed variable

SCIP_RETCODE SCIPtransformVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	transvars
	)

gets and captures transformed variables for an array of variables; if a variable of the array is not yet transformed, a new transformed variable for this variable is created; it is possible to call this method with vars == transvars

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of variables to get/create transformed variables for
vars	array with variables to get/create transformed variables for
transvars	array to store the transformed variables

SCIP_RETCODE SCIPgetTransformedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	transvar
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to get transformed variable for
transvar	pointer to store the transformed variable

SCIP_RETCODE SCIPgetTransformedVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	transvars
	)

gets corresponding transformed variables for an array of variables; stores NULL in a transvars slot, if the transformed variable is not yet existing; it is possible to call this method with vars == transvars, but remember that variables that are not yet transformed will be replaced with NULL

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of variables to get transformed variables for
vars	array with variables to get transformed variables for
transvars	array to store the transformed variables

SCIP_RETCODE SCIPgetNegatedVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	negvar
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to get negated variable for
negvar	pointer to store the negated variable

SCIP_RETCODE SCIPgetNegatedVars	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	negvars
	)

gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of variables to get negated variables for
vars	array of variables to get negated variables for
negvars	array to store the negated variables

SCIP_RETCODE SCIPgetBinvarRepresentative	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR **	repvar,
		SCIP_Bool *	negated
	)

gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable

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

Precondition

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

Parameters

scip	SCIP data structure
var	binary variable to get binary representative for
repvar	pointer to store the binary representative
negated	pointer to store whether the negation of an active variable was returned

SCIP_RETCODE SCIPgetBinvarRepresentatives	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_VAR **	repvars,
		SCIP_Bool *	negated
	)

gets binary variables that are equal to the given binary variables, and which are either active, fixed, or multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of binary variables to get representatives for
vars	binary variables to get binary representatives for
repvars	array to store the binary representatives
negated	array to store whether the negation of an active variable was returned

SCIP_RETCODE SCIPflattenVarAggregationGraph	(	SCIP *	scip,
		SCIP_VAR *	var
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
var	problem variable

SCIP_RETCODE SCIPgetProbvarLinearSum	(	SCIP *	scip,
		SCIP_VAR **	vars,
		SCIP_Real *	scalars,
		int *	nvars,
		int	varssize,
		SCIP_Real *	constant,
		int *	requiredsize,
		SCIP_Bool	mergemultiples
	)

Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of active variables, that is b_1*y_1 + ... + b_m*y_m + d.

If the number of needed active variables is greater than the available slots in the variable array, nothing happens except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable representation is stored in the variable array, scalar array and constant.

The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP functions).

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

Precondition

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

Note: The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the given entries are overwritten.; That method can be used to convert a single variables into variable space of active variables. Therefore call the method with the linear sum 1.0*x + 0.0.

Parameters

scip	SCIP data structure
vars	variable array x_1, ..., x_n in the linear sum which will be overwritten by the variable array y_1, ..., y_m in the linear sum w.r.t. active variables
scalars	scalars a_1, ..., a_n in linear sum which will be overwritten to the scalars b_1, ..., b_m in the linear sum of the active variables
nvars	pointer to number of variables in the linear sum which will be overwritten by the number of variables in the linear sum corresponding to the active variables
varssize	available slots in vars and scalars array which is needed to check if the array are large enough for the linear sum w.r.t. active variables
constant	pointer to constant c in linear sum a_1x_1 + ... + a_nx_n + c which will chnage to constant d in the linear sum b_1y_1 + ... + b_my_m + d w.r.t. the active variables
requiredsize	pointer to store the required array size for the linear sum w.r.t. the active variables
mergemultiples	should multiple occurrences of a var be replaced by a single coeff?

SCIP_RETCODE SCIPgetProbvarSum	(	SCIP *	scip,
		SCIP_VAR **	var,
		SCIP_Real *	scalar,
		SCIP_Real *	constant
	)

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

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

Precondition

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

Parameters

scip	SCIP data structure
var	pointer to problem variable x in sum a*x + c
scalar	pointer to scalar a in sum a*x + c
constant	pointer to constant c in sum a*x + c

SCIP_RETCODE SCIPgetActiveVars	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int *	nvars,
		int	varssize,
		int *	requiredsize
	)

return for given variables all their active counterparts; all active variables will be pairwise different

Note: It does not hold that the first output variable is the active variable for the first input variable.

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

Precondition

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

Parameters

scip	SCIP data structure
vars	variable array with given variables and as output all active variables, if enough slots exist
nvars	number of given variables, and as output number of active variables, if enough slots exist
varssize	available slots in vars array
requiredsize	pointer to store the required array size for the active variables

SCIP_Real SCIPgetVarRedcost	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the reduced costs of the variable in the current node's LP relaxation; the current node has to have a feasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP

SCIP_Real SCIPgetVarImplRedcost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	varfixing
	)

returns the implied reduced costs of the variable in the current node's LP relaxation; the current node has to have a feasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP
varfixing	FALSE if for x == 0, TRUE for x == 1

SCIP_Real SCIPgetVarFarkasCoef	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the Farkas coefficient of the variable in the current node's LP relaxation; the current node has to have an infeasible LP.

returns SCIP_INVALID if the variable is active but not in the current LP; returns 0 if the variable has been aggregated out or fixed in presolving.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	variable to get reduced costs, should be a column in current node LP

SCIP_Real SCIPgetVarSol	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets solution value for variable in current node

Returns: solution value for variable in current node

Precondition

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

Parameters

scip	SCIP data structure
var	variable to get solution value for

SCIP_RETCODE SCIPgetVarSols	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

gets solution values of multiple variables in current node

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of variables to get solution value for
vars	array with variables to get value for
vals	array to store solution values of variables

SCIP_RETCODE SCIPclearRelaxSolVals ( SCIP * scip )

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

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

Precondition

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

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetRelaxSolVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

sets the value of the given variable in the global relaxation solution; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; You can use SCIPclearRelaxSolVals() to set all values to zero, initially; after setting all solution values, you have to call SCIPmarkRelaxSolValid() to inform SCIP that the stored solution is valid

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

Precondition

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

Parameters

scip	SCIP data structure
var	variable to set value for
val	solution value of variable

SCIP_RETCODE SCIPsetRelaxSolVals	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

sets the values of the given variables in the global relaxation solution; this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; the solution is automatically cleared, s.t. all other variables get value 0.0

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

Precondition

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

Parameters

scip	SCIP data structure
nvars	number of variables to set relaxation solution value for
vars	array with variables to set value for
vals	array with solution values of variables

SCIP_RETCODE SCIPsetRelaxSolValsSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

sets the values of the variables in the global relaxation solution to the values in the given primal solution; the relaxation solution can be filled by the relaxation hanlders and might be used by heuristics and for separation

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal relaxation solution

SCIP_Bool SCIPisRelaxSolValid ( SCIP * scip )

returns whether the relaxation solution is valid

Returns: TRUE, if the relaxation solution is valid; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPmarkRelaxSolValid ( SCIP * scip )

informs SCIP, that the relaxation solution is valid

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPmarkRelaxSolInvalid ( SCIP * scip )

informs SCIP, that the relaxation solution is invalid

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetRelaxSolVal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets the relaxation solution value of the given variable

Returns: the relaxation solution value of the given variable

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get value for

SCIP_Real SCIPgetRelaxSolObj ( SCIP * scip )

gets the relaxation solution objective value

Returns: the objective value of the relaxation solution

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartStrongbranch	(	SCIP *	scip,
		SCIP_Bool	enablepropagation
	)

start strong branching - call before any strong branching

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created which allow to perform propagation but also creates some overhead

Parameters

scip	SCIP data structure
enablepropagation	should propagation be done before solving the strong branching LP?

SCIP_RETCODE SCIPendStrongbranch ( SCIP * scip )

end strong branching - call after any strong branching

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetVarStrongbranchFrac	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	itlim,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Bool *	downinf,
		SCIP_Bool *	upinf,
		SCIP_Bool *	downconflict,
		SCIP_Bool *	upconflict,
		SCIP_Bool *	lperror
	)

gets strong branching information on column variable with fractional value

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
itlim	iteration limit for strong branchings
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solval,
		SCIP_Real	lpobjval,
		int	itlim,
		int	maxproprounds,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Bool *	downinf,
		SCIP_Bool *	upinf,
		SCIP_Bool *	downconflict,
		SCIP_Bool *	upconflict,
		SCIP_Bool *	lperror,
		SCIP_Real *	newlbs,
		SCIP_Real *	newubs
	)

gets strong branching information with previous domain propagation on column variable

Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch(); after strong branching was done for all candidate variables, the strong branching mode must be ended by SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be enabled in the SCIPstartStrongbranch() call.

Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds can be specified by the parameter maxproprounds.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Warning: When using this method, LP banching candidates and solution values must be copied beforehand, because they are updated w.r.t. the strong branching LP solution.

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
solval	value of the variable in the current LP solution
lpobjval	LP objective value of the current LP solution
itlim	iteration limit for strong branchings
maxproprounds	maximum number of propagation rounds (-1: no limit, -2: parameter settings)
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)
newlbs	array to store valid lower bounds for all active variables, or NULL
newubs	array to store valid upper bounds for all active variables, or NULL

SCIP_RETCODE SCIPgetVarStrongbranchInt	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	itlim,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Bool *	downinf,
		SCIP_Bool *	upinf,
		SCIP_Bool *	downconflict,
		SCIP_Bool *	upconflict,
		SCIP_Bool *	lperror
	)

gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch is (val -1.0) and the up brach ins (val +1.0)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.

Parameters

scip	SCIP data structure
var	variable to get strong branching values for
itlim	iteration limit for strong branchings
down	stores dual bound after branching column down
up	stores dual bound after branching column up
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
downinf	pointer to store whether the downwards branch is infeasible, or NULL
upinf	pointer to store whether the upwards branch is infeasible, or NULL
downconflict	pointer to store whether a conflict constraint was created for an infeasible downwards branch, or NULL
upconflict	pointer to store whether a conflict constraint was created for an infeasible upwards branch, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

SCIP_RETCODE SCIPgetVarsStrongbranchesFrac	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int	nvars,
		int	itlim,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Bool *	downinf,
		SCIP_Bool *	upinf,
		SCIP_Bool *	downconflict,
		SCIP_Bool *	upconflict,
		SCIP_Bool *	lperror
	)

gets strong branching information on column variables with fractional values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
vars	variables to get strong branching values for
nvars	number of variables
itlim	iteration limit for strong branchings
down	stores dual bounds after branching variables down
up	stores dual bounds after branching variables up
downvalid	stores whether the returned down values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
upvalid	stores whether the returned up values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
downinf	array to store whether the downward branches are infeasible, or NULL
upinf	array to store whether the upward branches are infeasible, or NULL
downconflict	array to store whether conflict constraints were created for infeasible downward branches, or NULL
upconflict	array to store whether conflict constraints were created for infeasible upward branches, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

SCIP_RETCODE SCIPgetVarsStrongbranchesInt	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int	nvars,
		int	itlim,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Bool *	downinf,
		SCIP_Bool *	upinf,
		SCIP_Bool *	downconflict,
		SCIP_Bool *	upconflict,
		SCIP_Bool *	lperror
	)

gets strong branching information on column variables with integral values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
vars	variables to get strong branching values for
nvars	number of variables
itlim	iteration limit for strong branchings
down	stores dual bounds after branching variables down
up	stores dual bounds after branching variables up
downvalid	stores whether the returned down values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
upvalid	stores whether the returned up values are valid dual bounds, or NULL; otherwise, they can only be used as an estimate value
downinf	array to store whether the downward branches are infeasible, or NULL
upinf	array to store whether the upward branches are infeasible, or NULL
downconflict	array to store whether conflict constraints were created for infeasible downward branches, or NULL
upconflict	array to store whether conflict constraints were created for infeasible upward branches, or NULL
lperror	pointer to store whether an unresolved LP error occurred or the solving process should be stopped (e.g., due to a time limit)

SCIP_RETCODE SCIPgetVarStrongbranchLast	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real *	down,
		SCIP_Real *	up,
		SCIP_Bool *	downvalid,
		SCIP_Bool *	upvalid,
		SCIP_Real *	solval,
		SCIP_Real *	lpobjval
	)

gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call; returns values of SCIP_INVALID, if strong branching was not yet called on the given variable; keep in mind, that the returned old values may have nothing to do with the current LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get last strong branching values for
down	stores dual bound after branching column down, or NULL
up	stores dual bound after branching column up, or NULL
downvalid	stores whether the returned down value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
upvalid	stores whether the returned up value is a valid dual bound, or NULL; otherwise, it can only be used as an estimate value
solval	stores LP solution value of variable at last strong branching call, or NULL
lpobjval	stores LP objective value at last strong branching call, or NULL

SCIP_Longint SCIPgetVarStrongbranchNode	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets node number of the last node in current branch and bound run, where strong branching was used on the given variable, or -1 if strong branching was never applied to the variable in current run

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get last strong branching node for

SCIP_Longint SCIPgetVarStrongbranchLPAge	(	SCIP *	scip,
		SCIP_VAR *	var
	)

if strong branching was already applied on the variable at the current node, returns the number of LPs solved after the LP where the strong branching on this variable was applied; if strong branching was not yet applied on the variable at the current node, returns INT_MAX

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get strong branching LP age for

int SCIPgetVarNStrongbranchs	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets number of times, strong branching was applied in current run on the given variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get last strong branching node for

SCIP_RETCODE SCIPaddVarLocks	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	nlocksdown,
		int	nlocksup
	)

adds given values to lock numbers of variable for rounding

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
nlocksdown	modification in number of rounding down locks
nlocksup	modification in number of rounding up locks

SCIP_RETCODE SCIPlockVarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_CONS *	cons,
		SCIP_Bool	lockdown,
		SCIP_Bool	lockup
	)

locks rounding of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
cons	constraint
lockdown	should the rounding be locked in downwards direction?
lockup	should the rounding be locked in upwards direction?

SCIP_RETCODE SCIPunlockVarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_CONS *	cons,
		SCIP_Bool	lockdown,
		SCIP_Bool	lockup
	)

unlocks rounding of variable with respect to the lock status of the constraint and its negation; this method should be called whenever the lock status of a variable in a constraint changes, for example if the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were added or removed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
cons	constraint
lockdown	should the rounding be locked in downwards direction?
lockup	should the rounding be locked in upwards direction?

SCIP_RETCODE SCIPchgVarObj	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newobj
	)

changes variable's objective value

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to change the objective value for
newobj	new objective value

SCIP_RETCODE SCIPaddVarObj	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	addobj
	)

adds value to variable's objective value

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to change the objective value for
addobj	additional objective value

SCIP_Real SCIPadjustedVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lb
	)

returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value; does not change the bounds of the variable

Returns: adjusted lower bound for the given variable; the bound of the variable is not changed

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to adjust the bound for
lb	lower bound value to adjust

SCIP_Real SCIPadjustedVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	ub
	)

returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value; does not change the bounds of the variable

Returns: adjusted upper bound for the given variable; the bound of the variable is not changed

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to adjust the bound for
ub	upper bound value to adjust

SCIP_RETCODE SCIPchgVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to change bound at, or NULL for current node
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbNode	(	SCIP *	scip,
		SCIP_NODE *	node,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node to change bound at, or NULL for current node
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarLbLazy	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lazylb
	)

changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet

lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need to be put into the LP explicitly.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP

Parameters

scip	SCIP data structure
var	problem variable
lazylb	the lazy lower bound to be set

SCIP_RETCODE SCIPchgVarUbLazy	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lazyub
	)

changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet

lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need to be put into the LP explicitly.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP

Parameters

scip	SCIP data structure
var	problem variable
lazyub	the lazy lower bound to be set

SCIP_RETCODE SCIPtightenVarLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPtightenVarUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such that in conflict analysis, this change is treated like a branching decision

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferVarLbCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_CONS *	infercons,
		int	inferinfo,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
infercons	constraint that deduced the bound change, or NULL
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferVarUbCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_CONS *	infercons,
		int	inferinfo,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
infercons	constraint that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferBinvarCons	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	fixedval,
		SCIP_CONS *	infercons,
		int	inferinfo,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	binary variable to fix
fixedval	value to fix binary variable to
infercons	constraint that deduced the fixing
inferinfo	user information for inference to help resolving the conflict
infeasible	pointer to store whether the fixing is infeasible
tightened	pointer to store whether the fixing tightened the local bounds, or NULL

SCIP_RETCODE SCIPinferVarLbProp	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_PROP *	inferprop,
		int	inferinfo,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
inferprop	propagator that deduced the bound change, or NULL
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferVarUbProp	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_PROP *	inferprop,
		int	inferinfo,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
inferprop	propagator that deduced the bound change
inferinfo	user information for inference to help resolving the conflict
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the bound change is infeasible
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPinferBinvarProp	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	fixedval,
		SCIP_PROP *	inferprop,
		int	inferinfo,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the deduction of the fixing

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	binary variable to fix
fixedval	value to fix binary variable to
inferprop	propagator that deduced the fixing
inferinfo	user information for inference to help resolving the conflict
infeasible	pointer to store whether the fixing is infeasible
tightened	pointer to store whether the fixing tightened the local bounds, or NULL

SCIP_RETCODE SCIPtightenVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_RETCODE SCIPtightenVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound,
		SCIP_Bool	force,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	tightened
	)

changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; also tightens the local bound, if the global bound is better than the local bound

Warning: If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via SCIPgetVars()) gets resorted.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound
force	force tightening even if below bound strengthening tolerance
infeasible	pointer to store whether the new domain is empty
tightened	pointer to store whether the bound was tightened, or NULL

SCIP_Real SCIPcomputeVarLbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal

Returns: the global lower bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarUbGlobal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables this global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal

Returns: the global upper bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarLbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables this local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal

Returns: the local lower bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_Real SCIPcomputeVarUbLocal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables this local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal

Returns: the local upper bound computed by adding the global bounds from all aggregation variables

Parameters

scip	SCIP data structure
var	variable to compute the bound for

SCIP_RETCODE SCIPgetVarClosestVlb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_SOL *	sol,
		SCIP_Real *	closestvlb,
		int *	closestvlbidx
	)

returns solution value and index of variable lower bound that is closest to the variable's value in the given primal solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is available

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	active problem variable
sol	primal solution, or NULL for LP solution
closestvlb	pointer to store the value of the closest variable lower bound
closestvlbidx	pointer to store the index of the closest variable lower bound

SCIP_RETCODE SCIPgetVarClosestVub	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_SOL *	sol,
		SCIP_Real *	closestvub,
		int *	closestvubidx
	)

returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution; or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
var	active problem variable
sol	primal solution, or NULL for LP solution
closestvub	pointer to store the value of the closest variable lower bound
closestvubidx	pointer to store the index of the closest variable lower bound

SCIP_RETCODE SCIPaddVarVlb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR *	vlbvar,
		SCIP_Real	vlbcoef,
		SCIP_Real	vlbconstant,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
vlbvar	variable z in x >= b*z + d
vlbcoef	coefficient b in x >= b*z + d
vlbconstant	constant d in x >= b*z + d
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPaddVarVub	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VAR *	vubvar,
		SCIP_Real	vubcoef,
		SCIP_Real	vubconstant,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z; if z is binary, the corresponding valid implication for z is also added; if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too; improves the global bounds of the variable and the vlb variable if possible

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
vubvar	variable z in x <= b*z + d
vubcoef	coefficient b in x <= b*z + d
vubconstant	constant d in x <= b*z + d
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPaddVarImplication	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Bool	varfixing,
		SCIP_VAR *	implvar,
		SCIP_BOUNDTYPE	impltype,
		SCIP_Real	implbound,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b; also adds the corresponding implication or variable bound to the implied variable; if the implication is conflicting, the variable is fixed to the opposite value; if the variable is already fixed to the given value, the implication is performed immediately; if the implication is redundant with respect to the variables' global bounds, it is ignored

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
varfixing	FALSE if y should be added in implications for x == 0, TRUE for x == 1
implvar	variable y in implication y <= b or y >= b
impltype	type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER)
implbound	bound b in implication y <= b or y >= b
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPaddClique	(	SCIP *	scip,
		SCIP_VAR **	vars,
		SCIP_Bool *	values,
		int	nvars,
		SCIP_Bool *	infeasible,
		int *	nbdchgs
	)

adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1; if a variable appears twice in the same clique, the corresponding implications are performed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
values	values of the variables in the clique; NULL to use TRUE for all vars
nvars	number of variables in the clique
infeasible	pointer to store whether an infeasibility was detected
nbdchgs	pointer to store the number of performed bound changes, or NULL

SCIP_RETCODE SCIPcalcCliquePartition	(	SCIP *const	scip,
		SCIP_VAR **const	vars,
		int const	nvars,
		int *const	cliquepartition,
		int *const	ncliques
	)

calculates a partition of the given set of binary variables into cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same clique; the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; for each clique at most 1 variables can be set to TRUE in a feasible solution;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
nvars	number of variables in the clique
cliquepartition	array of length nvars to store the clique partition
ncliques	pointer to store the number of cliques actually contained in the partition

SCIP_RETCODE SCIPcalcNegatedCliquePartition	(	SCIP *const	scip,
		SCIP_VAR **const	vars,
		int const	nvars,
		int *const	cliquepartition,
		int *const	ncliques
	)

calculates a partition of the given set of binary variables into negated cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same negated clique; the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
nvars	number of variables in the clique
cliquepartition	array of length nvars to store the clique partition
ncliques	pointer to store the number of cliques actually contained in the partition

int SCIPgetNCliques ( SCIP * scip )

gets the number of cliques in the clique table

Returns: number of cliques in the clique table

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_CLIQUE** SCIPgetCliques ( SCIP * scip )

gets the array of cliques in the clique table

Returns: array of cliques in the clique table

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhaveVarsCommonClique	(	SCIP *	scip,
		SCIP_VAR *	var1,
		SCIP_Bool	value1,
		SCIP_VAR *	var2,
		SCIP_Bool	value2,
		SCIP_Bool	regardimplics
	)

returns whether there is a clique that contains both given variable/value pairs; the variables must be active binary variables; if regardimplics is FALSE, only the cliques in the clique table are looked at; if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded

Returns: TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise

Precondition

This method can be called if scip is in one of the following stages:

Note: a variable with it's negated variable are NOT! in a clique; a variable with itself are in a clique

Parameters

scip	SCIP data structure
var1	first variable
value1	value of first variable
var2	second variable
value2	value of second variable
regardimplics	should the implication graph also be searched for a clique?

SCIP_RETCODE SCIPwriteCliqueGraph	(	SCIP *	scip,
		const char *	fname,
		SCIP_Bool	writeimplications,
		SCIP_Bool	writenodeweights
	)

writes the clique graph to a gml file

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: there can be duplicated arcs in the output file

If writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges between such nodes are written.

Parameters

scip	SCIP data structure
fname	name of file
writeimplications	should we write the binary implications?
writenodeweights	should we write weights of nodes?

SCIP_RETCODE SCIPchgVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	branchfactor
	)

sets the branch factor of the variable; this value can be used in the branching methods to scale the score values of the variables; higher factor leads to a higher probability that this variable is chosen for branching

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
branchfactor	factor to weigh variable's branching score with

SCIP_RETCODE SCIPscaleVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	scale
	)

scales the branch factor of the variable with the given value

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
scale	factor to scale variable's branching factor with

SCIP_RETCODE SCIPaddVarBranchFactor	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	addfactor
	)

adds the given value to the branch factor of the variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
addfactor	value to add to the branch factor of the variable

SCIP_RETCODE SCIPchgVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	branchpriority
	)

sets the branch priority of the variable; variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: the default branching priority is 0

Parameters

scip	SCIP data structure
var	problem variable
branchpriority	branch priority of the variable

SCIP_RETCODE SCIPupdateVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	branchpriority
	)

changes the branch priority of the variable to the given value, if it is larger than the current priority

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
branchpriority	new branch priority of the variable, if it is larger than current priority

SCIP_RETCODE SCIPaddVarBranchPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	addpriority
	)

adds the given value to the branch priority of the variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
addpriority	value to add to the branch priority of the variable

SCIP_RETCODE SCIPchgVarBranchDirection	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	branchdirection
	)

sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards branch)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
branchdirection	preferred branch direction of the variable (downwards, upwards, auto)

SCIP_RETCODE SCIPchgVarType	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_VARTYPE	vartype,
		SCIP_Bool *	infeasible
	)

changes type of variable in the problem;

Warning: This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the corresponding transformed variable is changed; the type of the original variable does not change; If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get adjusted w.r.t. to integrality information

Parameters

scip	SCIP data structure
var	variable to change the bound for
vartype	new type of variable
infeasible	pointer to store whether an infeasibility was detected (, due to integrality condition of the new variable type)

SCIP_RETCODE SCIPfixVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	fixedval,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	fixed
	)

in problem creation and solving stage, both bounds of the variable are set to the given value; in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively; conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders arrays returned from the SCIPvarGetImpl...() methods invalid

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to fix
fixedval	value to fix variable to
infeasible	pointer to store whether the fixing is infeasible
fixed	pointer to store whether the fixing was performed (variable was unfixed)

SCIP_RETCODE SCIPaggregateVars	(	SCIP *	scip,
		SCIP_VAR *	varx,
		SCIP_VAR *	vary,
		SCIP_Real	scalarx,
		SCIP_Real	scalary,
		SCIP_Real	rhs,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	redundant,
		SCIP_Bool *	aggregated
	)

From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid. In the first step, the equality is transformed into an equality with active problem variables a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0, of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible infeasibility) otherwise. In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.

The output flags have the following meaning:

infeasible: the problem is infeasible
redundant: the equality can be deleted from the constraint set
aggregated: the aggregation was successfully performed (the variables were not aggregated before)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
varx	variable x in equality ax + by == c
vary	variable y in equality ax + by == c
scalarx	multiplier a in equality ax + by == c
scalary	multiplier b in equality ax + by == c
rhs	right hand side c in equality ax + by == c
infeasible	pointer to store whether the aggregation is infeasible
redundant	pointer to store whether the equality is (now) redundant
aggregated	pointer to store whether the aggregation was successful

SCIP_RETCODE SCIPmultiaggregateVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	naggvars,
		SCIP_VAR **	aggvars,
		SCIP_Real *	scalars,
		SCIP_Real	constant,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	aggregated
	)

converts variable into multi-aggregated variable; this changes the variable array returned from SCIPgetVars() and SCIPgetVarsData();

Warning: The integrality condition is not checked anymore on the multi-aggregated variable. You must not multi-aggregate an integer variable without being sure, that integrality on the aggregation variables implies integrality on the aggregated variable.

The output flags have the following meaning:

infeasible: the problem is infeasible
aggregated: the aggregation was successfully performed (the variables were not aggregated before)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can only be called if scip is in stage SCIP_STAGE_PRESOLVING

Parameters

scip	SCIP data structure
var	variable x to aggregate
naggvars	number n of variables in aggregation x = a_1y_1 + ... + a_ny_n + c
aggvars	variables y_i in aggregation x = a_1y_1 + ... + a_ny_n + c
scalars	multipliers a_i in aggregation x = a_1y_1 + ... + a_ny_n + c
constant	constant shift c in aggregation x = a_1y_1 + ... + a_ny_n + c
infeasible	pointer to store whether the aggregation is infeasible
aggregated	pointer to store whether the aggregation was successful

SCIP_Bool SCIPdoNotAggr ( SCIP * scip )

returns whether aggregation of variables is not allowed

Parameters

scip	SCIP data structure

SCIP_Bool SCIPdoNotMultaggr ( SCIP * scip )

returns whether multi-aggregation is disabled

Parameters

scip	SCIP data structure

SCIP_Bool SCIPdoNotMultaggrVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns whether variable is not allowed to be multi-aggregated

Parameters

scip	SCIP data structure
var	variable x to aggregate

SCIP_RETCODE SCIPmarkDoNotMultaggrVar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

marks the variable that it must not be multi-aggregated

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not multi-aggregated that this is will be the case.

Parameters

scip	SCIP data structure
var	variable to delete

void SCIPenableVarHistory ( SCIP * scip )

enables the collection of statistics for a variable

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

void SCIPdisableVarHistory ( SCIP * scip )

disables the collection of any statistic for a variable

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPupdateVarPseudocost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta,
		SCIP_Real	objdelta,
		SCIP_Real	weight
	)

updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the variable's solution value and resulting change of "objdelta" in the in the LP's objective value; the update is ignored, if the objective value difference is infinite

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value
objdelta	difference of new LP's objective value - old LP's objective value
weight	weight in (0,1] of this update in pseudo cost sum

SCIP_Real SCIPgetVarPseudocostVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta
	)

gets the variable's pseudo cost value for the given change of the variable's LP value

Returns: the variable's pseudo cost value for the given change of the variable's LP value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetVarPseudocostValCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solvaldelta
	)

gets the variable's pseudo cost value for the given change of the variable's LP value, only using the pseudo cost information of the current run

Returns: the variable's pseudo cost value for the given change of the variable's LP value, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetVarPseudocost	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's pseudo cost value for the given direction

Returns: the variable's pseudo cost value for the given direction

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's pseudo cost value for the given direction, only using the pseudo cost information of the current run

Returns: the variable's pseudo cost value for the given direction, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCount	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's (possible fractional) number of pseudo cost updates for the given direction

Returns: the variable's (possible fractional) number of pseudo cost updates for the given direction

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostCountCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

gets the variable's (possible fractional) number of pseudo cost updates for the given direction, only using the pseudo cost information of the current run

Returns: the variable's (possible fractional) number of pseudo cost updates for the given direction, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarPseudocostScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solval
	)

gets the variable's pseudo cost score value for the given LP solution value

Returns: the variable's pseudo cost score value for the given LP solution value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
solval	variable's LP solution value

SCIP_Real SCIPgetVarPseudocostScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	solval
	)

gets the variable's pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run

Returns: the variable's pseudo cost score value for the given LP solution value, only using the pseudo cost information of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
solval	variable's LP solution value

SCIP_Real SCIPgetVarVSIDS	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's VSIDS value

Returns: the variable's VSIDS value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarVSIDSCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's VSIDS value only using conflicts of the current run

Returns: the variable's VSIDS value only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarConflictScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict score value

Returns: the variable's conflict score value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict score value only using conflicts of the current run

Returns: the variable's conflict score value only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictlengthScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict length score

Returns: the variable's conflict length score

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's conflict length score only using conflicts of the current run

Returns: the variable's conflict length score only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgConflictlength	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's average conflict length

Returns: the variable's average conflict length

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the variable's average conflict length only using conflicts of the current run

Returns: the variable's average conflict length only using conflicts of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferences	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned

Returns: the average number of inferences found after branching on the variable in given direction

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferencesCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of inferences over all variables for branching in the given direction is returned

Returns: the average number of inferences found after branching on the variable in given direction in the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgInferenceScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average inference score value

Returns: the variable's average inference score value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average inference score value only using inferences of the current run

Returns: the variable's average inference score value only using inferences of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_RETCODE SCIPinitVarBranchStats	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	downpscost,
		SCIP_Real	uppscost,
		SCIP_Real	downvsids,
		SCIP_Real	upvsids,
		SCIP_Real	downconflen,
		SCIP_Real	upconflen,
		SCIP_Real	downinfer,
		SCIP_Real	upinfer,
		SCIP_Real	downcutoff,
		SCIP_Real	upcutoff
	)

initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores of a variable to the given values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable which should be initialized
downpscost	value to which pseudocosts for downwards branching should be initialized
uppscost	value to which pseudocosts for upwards branching should be initialized
downvsids	value to which VSIDS score for downwards branching should be initialized
upvsids	value to which VSIDS score for upwards branching should be initialized
downconflen	value to which conflict length score for downwards branching should be initialized
upconflen	value to which conflict length score for upwards branching should be initialized
downinfer	value to which inference counter for downwards branching should be initialized
upinfer	value to which inference counter for upwards branching should be initialized
downcutoff	value to which cutoff counter for downwards branching should be initialized
upcutoff	value to which cutoff counter for upwards branching should be initialized

SCIP_Real SCIPgetVarAvgCutoffs	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching on the variable in given direction; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned

Returns: the average number of cutoffs found after branching on the variable in given direction

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgCutoffsCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching on the variable in given direction in the current run; if branching on the variable in the given direction was yet evaluated, the average number of cutoffs over all variables for branching in the given direction is returned

Returns: the average number of cutoffs found after branching on the variable in given direction in the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetVarAvgCutoffScore	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average cutoff score value

Returns: the variable's average cutoff score value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the variable's average cutoff score value, only using cutoffs of the current run

Returns: the variable's average cutoff score value, only using cutoffs of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetVarAvgInferenceCutoffScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	cutoffweight
	)

returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given factor

Returns: the variable's average inference/cutoff score value

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
cutoffweight	factor to weigh average number of cutoffs in branching score

SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	cutoffweight
	)

returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given factor, only using inferences and cutoffs of the current run

Returns: the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	problem variable
cutoffweight	factor to weigh average number of cutoffs in branching score

SCIP_RETCODE SCIPprintVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		FILE *	file
	)

outputs variable information to file stream via the message system

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: If the message handler is set to a NULL pointer nothing will be printed

Parameters

scip	SCIP data structure
var	problem variable
file	output file (or NULL for standard output)

SCIP_Bool SCIPisConflictAnalysisApplicable ( SCIP * scip )

return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied

Returns: return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPinitConflictAnalysis ( SCIP * scip )

initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddConflictLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx
	)

adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called for each lower bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose lower bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedLb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedlb
	)

adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose lower bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedlb	the relaxed lower bound

SCIP_RETCODE SCIPaddConflictUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx
	)

adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for each upper bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedUb	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedub
	)

adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedub	the relaxed upper bound

SCIP_RETCODE SCIPaddConflictBd	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx
	)

adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called for each bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound

SCIP_RETCODE SCIPaddConflictRelaxedBd	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedbd
	)

adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough to explain a certain bound change; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed) bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
relaxedbd	the relaxed bound

SCIP_RETCODE SCIPaddConflictBinvar	(	SCIP *	scip,
		SCIP_VAR *	var
	)

adds changed bound of fixed binary variable to the conflict analysis' candidate storage; this method should be called in one of the following two cases:

Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called for each binary variable, whose current fixing led to the deduction of the given conflict bound.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	binary variable whose changed bound should be added to conflict queue

SCIP_RETCODE SCIPisConflictVarUsed	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Bool *	used
	)

checks if the given variable is already part of the current conflict set or queued for resolving with the same or even stronger bound

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	variable whose upper bound should be added to conflict candidate queue
boundtype	the type of the conflicting bound (lower or upper bound)
bdchgidx	bound change index representing time on path to current node, when the conflicting bound was valid, NULL for current local bound
used	pointer to store if the variable is already used

SCIP_Real SCIPgetConflictVarLb	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower bound

Returns: returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower bound

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	problem variable

SCIP_Real SCIPgetConflictVarUb	(	SCIP *	scip,
		SCIP_VAR *	var
	)

returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global upper bound

Returns: returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global upper bound

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
var	problem variable

SCIP_RETCODE SCIPanalyzeConflict	(	SCIP *	scip,
		int	validdepth,
		SCIP_Bool *	success
	)

analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons() instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
validdepth	minimal depth level at which the initial conflict set is valid
success	pointer to store whether a conflict constraint was created, or NULL

SCIP_RETCODE SCIPanalyzeConflictCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	success
	)

analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: SCIP stage does not get changed

Parameters

scip	SCIP data structure
cons	constraint that detected the conflict
success	pointer to store whether a conflict constraint was created, or NULL

SCIP_RETCODE SCIPcreateCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONSDATA *	consdata,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode
	)

creates and captures a constraint of the given constraint handler

Warning: If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may be declared feasible even if it violates this particular constraint. This constellation should only be used, if no LP or pseudo solution can violate the constraint – e.g. if a local constraint is redundant due to the variable's local bounds.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to constraint
name	name of constraint
conshdlr	constraint handler for this constraint
consdata	data for this specific constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

SCIP_RETCODE SCIPparseCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	str,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode,
		SCIP_Bool *	success
	)

parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is creates and captures;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Warning: If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may be declared feasible even if it violates this particular constraint. This constellation should only be used, if no LP or pseudo solution can violate the constraint – e.g. if a local constraint is redundant due to the variable's local bounds.

Parameters

scip	SCIP data structure
cons	pointer to store constraint
str	string to parse for constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.
success	pointer to store if the paring process was successful

SCIP_RETCODE SCIPcaptureCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

increases usage counter of constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint to capture

SCIP_RETCODE SCIPreleaseCons	(	SCIP *	scip,
		SCIP_CONS **	cons
	)

decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: the pointer of the constraint will be NULLed

Parameters

scip	SCIP data structure
cons	pointer to constraint

SCIP_RETCODE SCIPchgConsName	(	SCIP *	scip,
		SCIP_CONS *	cons,
		const char *	name
	)

change constraint name

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_PROBLEM

Note: to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h

Parameters

scip	SCIP data structure
cons	constraint
name	new name of constraint

SCIP_RETCODE SCIPsetConsInitial	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	initial
	)

sets the initial flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
initial	new value

SCIP_RETCODE SCIPsetConsSeparated	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	separate
	)

sets the separate flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
separate	new value

SCIP_RETCODE SCIPsetConsEnforced	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	enforce
	)

sets the enforce flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
enforce	new value

SCIP_RETCODE SCIPsetConsChecked	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	check
	)

sets the check flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
check	new value

SCIP_RETCODE SCIPsetConsPropagated	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	propagate
	)

sets the propagate flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
propagate	new value

SCIP_RETCODE SCIPsetConsLocal	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	local
	)

sets the local flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
local	new value

SCIP_RETCODE SCIPsetConsModifiable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	modifiable
	)

sets the modifiable flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
modifiable	new value

SCIP_RETCODE SCIPsetConsDynamic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	dynamic
	)

sets the dynamic flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
dynamic	new value

SCIP_RETCODE SCIPsetConsRemovable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	removable
	)

sets the removable flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
removable	new value

SCIP_RETCODE SCIPsetConsStickingAtNode	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	stickingatnode
	)

sets the stickingatnode flag of the given constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
stickingatnode	new value

SCIP_RETCODE SCIPupdateConsFlags	(	SCIP *	scip,
		SCIP_CONS *	cons0,
		SCIP_CONS *	cons1
	)

updates the flags of the first constraint according to the ones of the second constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons0	constraint that should stay
cons1	constraint that should be deleted

SCIP_RETCODE SCIPtransformCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS **	transcons
	)

gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed, a new transformed constraint for this constraint is created

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint to get/create transformed constraint for
transcons	pointer to store the transformed constraint

SCIP_RETCODE SCIPtransformConss	(	SCIP *	scip,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS **	transconss
	)

gets and captures transformed constraints for an array of constraints; if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created; it is possible to call this method with conss == transconss

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
nconss	number of constraints to get/create transformed constraints for
conss	array with constraints to get/create transformed constraints for
transconss	array to store the transformed constraints

SCIP_RETCODE SCIPgetTransformedCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS **	transcons
	)

gets corresponding transformed constraint of a given constraint; returns NULL as transcons, if transformed constraint is not yet existing

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint to get the transformed constraint for
transcons	pointer to store the transformed constraint

SCIP_RETCODE SCIPgetTransformedConss	(	SCIP *	scip,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS **	transconss
	)

gets corresponding transformed constraints for an array of constraints; stores NULL in a transconss slot, if the transformed constraint is not yet existing; it is possible to call this method with conss == transconss, but remember that constraints that are not yet transformed will be replaced with NULL

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
nconss	number of constraints to get the transformed constraints for
conss	constraints to get the transformed constraints for
transconss	array to store the transformed constraints

SCIP_RETCODE SCIPaddConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	deltaage
	)

adds given value to age of constraint, but age can never become negative; should be called

in constraint separation, if no cut was found for this constraint,
in constraint enforcing, if constraint was feasible, and
in constraint propagation, if no domain reduction was deduced;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
deltaage	value to add to the constraint's age

SCIP_RETCODE SCIPincConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

increases age of constraint by 1.0; should be called

in constraint separation, if no cut was found for this constraint,
in constraint enforcing, if constraint was feasible, and
in constraint propagation, if no domain reduction was deduced;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPresetConsAge	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

resets age of constraint to zero; should be called

in constraint separation, if a cut was found for this constraint,
in constraint enforcing, if the constraint was violated, and
in constraint propagation, if a domain reduction was deduced;

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's separation, propagation, and enforcing capabilities

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated, separated, and enforced anymore until it is enabled again with a call to SCIPenableCons(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again; note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree, and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using an appropriate event handler that watches the corresponding variables' domain changes)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableConsSeparation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's separation capabilities

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableConsSeparation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPenableConsPropagation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

enables constraint's propagation capabilities

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPdisableConsPropagation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPmarkConsPropagate	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

marks constraint to be propagated

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPunmarkConsPropagate	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

unmarks the constraint to be propagated

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint

SCIP_RETCODE SCIPaddConsLocks	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	nlockspos,
		int	nlocksneg
	)

adds given values to lock status of the constraint and updates the rounding locks of the involved variables

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint
nlockspos	increase in number of rounding locks for constraint
nlocksneg	increase in number of rounding locks for constraint's negation

SCIP_RETCODE SCIPcheckCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool	printreason,
		SCIP_RESULT *	result
	)

checks single constraint for feasibility of the given solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cons	constraint to check
sol	primal CIP solution
checkintegrality	has integrality to be checked?
checklprows	have current LP rows (both local and global) to be checked?
printreason	should the reason for the violation be printed?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPenfopsCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	solinfeasible,
		SCIP_Bool	objinfeasible,
		SCIP_RESULT *	result
	)

enforces single constraint for a given pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to enforce
solinfeasible	was the solution already declared infeasible by a constraint handler?
objinfeasible	is the solution infeasible anyway due to violating lower objective bound?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPenfolpCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	solinfeasible,
		SCIP_RESULT *	result
	)

enforces single constraint for a given LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to enforce
solinfeasible	was the solution already declared infeasible by a constraint handler?
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPinitlpCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls LP initialization method for single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to initialize

SCIP_RETCODE SCIPsepalpCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RESULT *	result
	)

calls separation method of single constraint for LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to separate
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPsepasolCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_RESULT *	result
	)

calls separation method of single constraint for given primal solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to separate
sol	primal solution that should be separated
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPpropCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_PROPTIMING	proptiming,
		SCIP_RESULT *	result
	)

calls domain propagation method of single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to propagate
proptiming	current point in the node solving loop
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPrespropCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	infervar,
		int	inferinfo,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedbd,
		SCIP_RESULT *	result
	)

resolves propagation conflict of single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to resolve conflict for
infervar	the conflict variable whose bound change has to be resolved
inferinfo	the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call
boundtype	the type of the changed bound (lower or upper bound)
bdchgidx	the index of the bound change, representing the point of time where the change took place
relaxedbd	the relaxed bound which is sufficient to be explained
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPpresolCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	nrounds,
		int	nnewfixedvars,
		int	nnewaggrvars,
		int	nnewchgvartypes,
		int	nnewchgbds,
		int	nnewholes,
		int	nnewdelconss,
		int	nnewaddconss,
		int	nnewupgdconss,
		int	nnewchgcoefs,
		int	nnewchgsides,
		int *	nfixedvars,
		int *	naggrvars,
		int *	nchgvartypes,
		int *	nchgbds,
		int *	naddholes,
		int *	ndelconss,
		int *	naddconss,
		int *	nupgdconss,
		int *	nchgcoefs,
		int *	nchgsides,
		SCIP_RESULT *	result
	)

presolves of single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_PRESOLVING

Note: This is an advanced method and should be used with caution.

Parameters

scip	SCIP data structure
cons	constraint to presolve
nrounds	number of presolving rounds already done
nnewfixedvars	number of variables fixed since the last call to the presolving method
nnewaggrvars	number of variables aggregated since the last call to the presolving method
nnewchgvartypes	number of variable type changes since the last call to the presolving method
nnewchgbds	number of variable bounds tightened since the last call to the presolving method
nnewholes	number of domain holes added since the last call to the presolving method
nnewdelconss	number of deleted constraints since the last call to the presolving method
nnewaddconss	number of added constraints since the last call to the presolving method
nnewupgdconss	number of upgraded constraints since the last call to the presolving method
nnewchgcoefs	number of changed coefficients since the last call to the presolving method
nnewchgsides	number of changed left or right hand sides since the last call to the presolving method
nfixedvars	pointer to count total number of variables fixed of all presolvers
naggrvars	pointer to count total number of variables aggregated of all presolvers
nchgvartypes	pointer to count total number of variable type changes of all presolvers
nchgbds	pointer to count total number of variable bounds tightened of all presolvers
naddholes	pointer to count total number of domain holes added of all presolvers
ndelconss	pointer to count total number of deleted constraints of all presolvers
naddconss	pointer to count total number of added constraints of all presolvers
nupgdconss	pointer to count total number of upgraded constraints of all presolvers
nchgcoefs	pointer to count total number of changed coefficients of all presolvers
nchgsides	pointer to count total number of changed left/right hand sides of all presolvers
result	pointer to store the result of the callback method

SCIP_RETCODE SCIPactiveCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls constraint activation notification method of single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_TRANSFORMING

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to notify

SCIP_RETCODE SCIPdeactiveCons	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

calls constraint deactivation notification method of single constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: This is an advanced method and should be used with caution. It may only be called for constraints that were not added to SCIP beforehand.

Parameters

scip	SCIP data structure
cons	constraint to notify

SCIP_RETCODE SCIPprintCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		FILE *	file
	)

outputs constraint information to file stream via the message handler system

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: If the message handler is set to a NULL pointer nothing will be printed.; The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a newline character.

Parameters

scip	SCIP data structure
cons	constraint
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPgetConsVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR **	vars,
		int	varssize,
		SCIP_Bool *	success
	)

method to collect the variables of a constraint

If the number of variables is greater than the available slots in the variable array, nothing happens except that the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables a constraint has in its scope.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: The success pointer indicates if all variables were copied into the vars arrray.; It might be that a constraint handler does not support this functionality, in that case the success pointer is set to FALSE.

Parameters

scip	SCIP data structure
cons	constraint for which the variables are wanted
vars	array to store the involved variable of the constraint
varssize	available slots in vars array which is needed to check if the array is large enough
success	pointer to store whether the variables are successfully copied

SCIP_RETCODE SCIPgetConsNVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nvars,
		SCIP_Bool *	success
	)

methed to collect the number of variables of a constraint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: The success pointer indicates if the contraint handler was able to return the number of variables; It might be that a constraint handler does not support this functionality, in that case the success pointer is set to FALSE

Parameters

scip	SCIP data structure
cons	constraint for which the number of variables is wanted
nvars	pointer to store the number of variables
success	pointer to store whether the constraint successfully returned the number of variables

SCIP_Bool SCIPhasCurrentNodeLP ( SCIP * scip )

returns, whether the LP was or is to be solved in the current node

Returns: whether the LP was or is to be solved in the current node.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPConstructed ( SCIP * scip )

returns, whether the LP of the current node is already constructed

Returns: whether the LP of the current node is already constructed.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPconstructLP	(	SCIP *	scip,
		SCIP_Bool *	cutoff
	)

makes sure that the LP of the current node is loaded and may be accessed through the LP information methods

Warning: Contructing the LP might change the amount of variables known in the transformed problem and therefore also the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to call one of the later method after this one

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
cutoff	pointer to store whether the node can be cut off

SCIP_RETCODE SCIPflushLP ( SCIP * scip )

makes sure that the LP of the current node is flushed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_LPSOLSTAT SCIPgetLPSolstat ( SCIP * scip )

gets solution status of current LP

Returns: the solution status of current LP.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPRelax ( SCIP * scip )

returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound

Returns: whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPObjval ( SCIP * scip )

gets objective value of current LP (which is the sum of column and loose objective value)

Returns: the objective value of current LP (which is the sum of column and loose objective value).

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Note: This method returns the objective value of the current LP solution, which might be primal or dual infeasible if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPColumnObjval ( SCIP * scip )

gets part of objective value of current LP that results from COLUMN variables only

Returns: the part of objective value of current LP that results from COLUMN variables only.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPLooseObjval ( SCIP * scip )

gets part of objective value of current LP that results from LOOSE variables only

Returns: part of objective value of current LP that results from LOOSE variables only.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetGlobalPseudoObjval ( SCIP * scip )

gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) global bound

Returns: the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) global bound.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPseudoObjval ( SCIP * scip )

gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the objective function) local bound

Returns: the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the objective function) local bound.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisRootLPRelax ( SCIP * scip )

returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound

Returns: whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootObjval ( SCIP * scip )

gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved

Returns: the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootColumnObjval ( SCIP * scip )

gets part of the objective value of the root node LP that results from COLUMN variables only; returns SCIP_INVALID if the root node LP was not (yet) solved

Returns: the part of the objective value of the root node LP that results from COLUMN variables only; or SCIP_INVALID if the root node LP was not (yet) solved.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLPRootLooseObjval ( SCIP * scip )

gets part of the objective value of the root node LP that results from LOOSE variables only; returns SCIP_INVALID if the root node LP was not (yet) solved

Returns: the part of the objective value of the root node LP that results from LOOSE variables only; or SCIP_INVALID if the root node LP was not (yet) solved.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPColsData	(	SCIP *	scip,
		SCIP_COL ***	cols,
		int *	ncols
	)

gets current LP columns along with the current number of LP columns

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
cols	pointer to store the array of LP columns, or NULL
ncols	pointer to store the number of LP columns, or NULL

SCIP_COL** SCIPgetLPCols ( SCIP * scip )

gets current LP columns

Returns: the current LP columns.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNLPCols ( SCIP * scip )

gets current number of LP columns

Returns: the current number of LP columns.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPRowsData	(	SCIP *	scip,
		SCIP_ROW ***	rows,
		int *	nrows
	)

gets current LP rows along with the current number of LP rows

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
rows	pointer to store the array of LP rows, or NULL
nrows	pointer to store the number of LP rows, or NULL

SCIP_ROW** SCIPgetLPRows ( SCIP * scip )

gets current LP rows

Returns: the current LP rows.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNLPRows ( SCIP * scip )

gets current number of LP rows

Returns: the current number of LP rows.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPallColsInLP ( SCIP * scip )

returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing

Returns: TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisLPSolBasic ( SCIP * scip )

returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis

Returns: whether the current LP solution is basic, i.e. is defined by a valid simplex basis.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLPBasisInd	(	SCIP *	scip,
		int *	basisind
	)

gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
basisind	pointer to store basis indices ready to keep number of rows entries

SCIP_RETCODE SCIPgetLPBInvRow	(	SCIP *	scip,
		int	r,
		SCIP_Real *	coef
	)

gets a row from the inverse basis matrix B^-1

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
r	row number
coef	pointer to store the coefficients of the row

SCIP_RETCODE SCIPgetLPBInvCol	(	SCIP *	scip,
		int	c,
		SCIP_Real *	coef
	)

gets a column from the inverse basis matrix B^-1

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
c	column number of B^-1; this is NOT the number of the column in the LP returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd() to get the array which links the B^-1 column numbers to the row and column numbers of the LP! c must be between 0 and nrows-1, since the basis has the size nrows * nrows
coef	pointer to store the coefficients of the column

SCIP_RETCODE SCIPgetLPBInvARow	(	SCIP *	scip,
		int	r,
		SCIP_Real *	binvrow,
		SCIP_Real *	coef
	)

gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
r	row number
binvrow	row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL
coef	pointer to store the coefficients of the row

SCIP_RETCODE SCIPgetLPBInvACol	(	SCIP *	scip,
		int	c,
		SCIP_Real *	coef
	)

gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A), i.e., it computes B^-1 * A_c with A_c being the c'th column of A

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
c	column number which can be accessed by SCIPcolGetLPPos()
coef	pointer to store the coefficients of the column

SCIP_RETCODE SCIPsumLPRows	(	SCIP *	scip,
		SCIP_Real *	weights,
		SCIP_REALARRAY *	sumcoef,
		SCIP_Real *	sumlhs,
		SCIP_Real *	sumrhs
	)

calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding LP row are swapped in the summation

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
weights	row weights in row summation
sumcoef	array to store sum coefficients indexed by variables' probindex
sumlhs	pointer to store the left hand side of the row summation
sumrhs	pointer to store the right hand side of the row summation

SCIP_RETCODE SCIPcalcMIR	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Real	boundswitch,
		SCIP_Bool	usevbds,
		SCIP_Bool	allowlocal,
		SCIP_Bool	fixintegralrhs,
		int *	boundsfortrans,
		SCIP_BOUNDTYPE *	boundtypesfortrans,
		int	maxmksetcoefs,
		SCIP_Real	maxweightrange,
		SCIP_Real	minfrac,
		SCIP_Real	maxfrac,
		SCIP_Real *	weights,
		int *	sidetypes,
		SCIP_Real	scale,
		SCIP_Real *	mksetcoefs,
		SCIP_Bool *	mksetcoefsvalid,
		SCIP_Real *	mircoef,
		SCIP_Real *	mirrhs,
		SCIP_Real *	cutactivity,
		SCIP_Bool *	success,
		SCIP_Bool *	cutislocal,
		int *	cutrank
	)

calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these rows cannot participate in a MIR cut.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
sol	the solution that should be separated, or NULL for LP solution
boundswitch	fraction of domain up to which lower bound is used in transformation
usevbds	should variable bounds be used in bound transformation?
allowlocal	should local information allowed to be used, resulting in a local cut?
fixintegralrhs	should complementation tried to be adjusted such that rhs gets fractional?
boundsfortrans	bounds that should be used for transformed variables: vlb_idx/vub_idx, -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound; NULL for using closest bound for all variables
boundtypesfortrans	type of bounds that should be used for transformed variables; NULL for using closest bound for all variables
maxmksetcoefs	maximal number of nonzeros allowed in aggregated base inequality
maxweightrange	maximal valid range max(\|weights\|)/min(\|weights\|) of row weights
minfrac	minimal fractionality of rhs to produce MIR cut for
maxfrac	maximal fractionality of rhs to produce MIR cut for
weights	row weights in row summation; some weights might be set to zero
sidetypes	specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices
scale	additional scaling factor multiplied to all rows
mksetcoefs	array to store mixed knapsack set coefficients: size nvars; or NULL
mksetcoefsvalid	pointer to store whether mixed knapsack set coefficients are valid; or NULL
mircoef	array to store MIR coefficients: must be of size SCIPgetNVars()
mirrhs	pointer to store the right hand side of the MIR row
cutactivity	pointer to store the activity of the resulting cut
success	pointer to store whether the returned coefficients are a valid MIR cut
cutislocal	pointer to store whether the returned cut is only valid locally
cutrank	pointer to store the rank of the returned cut; or NULL

SCIP_RETCODE SCIPcalcStrongCG	(	SCIP *	scip,
		SCIP_Real	boundswitch,
		SCIP_Bool	usevbds,
		SCIP_Bool	allowlocal,
		int	maxmksetcoefs,
		SCIP_Real	maxweightrange,
		SCIP_Real	minfrac,
		SCIP_Real	maxfrac,
		SCIP_Real *	weights,
		SCIP_Real	scale,
		SCIP_Real *	mircoef,
		SCIP_Real *	mirrhs,
		SCIP_Real *	cutactivity,
		SCIP_Bool *	success,
		SCIP_Bool *	cutislocal,
		int *	cutrank
	)

calculates a strong CG cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these rows cannot participate in a MIR cut.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
boundswitch	fraction of domain up to which lower bound is used in transformation
usevbds	should variable bounds be used in bound transformation?
allowlocal	should local information allowed to be used, resulting in a local cut?
maxmksetcoefs	maximal number of nonzeros allowed in aggregated base inequality
maxweightrange	maximal valid range max(\|weights\|)/min(\|weights\|) of row weights
minfrac	minimal fractionality of rhs to produce strong CG cut for
maxfrac	maximal fractionality of rhs to produce strong CG cut for
weights	row weights in row summation; some weights might be set to zero
scale	additional scaling factor multiplied to all rows
mircoef	array to store strong CG coefficients: must be of size SCIPgetNVars()
mirrhs	pointer to store the right hand side of the strong CG row
cutactivity	pointer to store the activity of the resulting cut
success	pointer to store whether the returned coefficients are a valid strong CG cut
cutislocal	pointer to store whether the returned cut is only valid locally
cutrank	pointer to store the rank of the returned cut; or NULL

SCIP_RETCODE SCIPwriteLP	(	SCIP *	scip,
		const char *	filename
	)

writes current LP to a file

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
filename	file name

SCIP_RETCODE SCIPwriteMIP	(	SCIP *	scip,
		const char *	filename,
		SCIP_Bool	genericnames,
		SCIP_Bool	origobj,
		SCIP_Bool	lazyconss
	)

writes MIP relaxation of the current branch-and-bound node to a file

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
filename	file name
genericnames	should generic names like x_i and row_j be used in order to avoid troubles with reserved symbols?
origobj	should the original objective function be used?
lazyconss	output removable rows as lazy constraints?

SCIP_RETCODE SCIPgetLPI	(	SCIP *	scip,
		SCIP_LPI **	lpi
	)

gets the LP interface of SCIP; with the LPI you can use all of the methods defined in lpi/lpi.h;

Warning: You have to make sure, that the full internal state of the LPI does not change or is recovered completely after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make sure, the internal solution status is recovered completely at the end of your method. This can be achieved by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.; Make also sure, that all parameter values that you have changed are set back to their original values.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
lpi	pointer to store the LP interface

SCIP_RETCODE SCIPprintLPSolutionQuality	(	SCIP *	scip,
		FILE *	file
	)

Displays quality information about the current LP solution. An LP solution need to be available. Information printed is subject to what the LP solver supports

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Note: The printing process is done via the message handler system.

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPcomputeLPRelIntPoint	(	SCIP *	scip,
		SCIP_Bool	relaxrows,
		SCIP_Bool	inclobjcutoff,
		SCIP_Real	timelimit,
		int	iterlimit,
		SCIP_SOL **	point
	)

compute relative interior point to current LP

See Also: SCIPlpComputeRelIntPoint

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
relaxrows	should the rows be relaxed
inclobjcutoff	should a row for the objective cutoff be included
timelimit	time limit for LP solver
iterlimit	iteration limit for LP solver
point	relative interior point on exit

SCIP_Real SCIPgetColRedcost	(	SCIP *	scip,
		SCIP_COL *	col
	)

returns the reduced costs of a column in the last (feasible) LP

Returns: the reduced costs of a column in the last (feasible) LP

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

SCIP_Real SCIPgetColFarkasCoef	(	SCIP *	scip,
		SCIP_COL *	col
	)

returns the Farkas coefficient of a column in the last (infeasible) LP

Returns: the Farkas coefficient of a column in the last (infeasible) LP

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

void SCIPmarkColNotRemovableLocal	(	SCIP *	scip,
		SCIP_COL *	col
	)

marks a column to be not removable from the LP in the current node

Precondition

this method can be called in the following stage of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
col	LP column

SCIP_RETCODE SCIPcreateRowCons	(	SCIP *	scip,
		SCIP_ROW **	row,
		SCIP_CONSHDLR *	conshdlr,
		const char *	name,
		int	len,
		SCIP_COL **	cols,
		SCIP_Real *	vals,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row from a constraint handler

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
conshdlr	constraint handler that creates the row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateRowSepa	(	SCIP *	scip,
		SCIP_ROW **	row,
		SCIP_SEPA *	sepa,
		const char *	name,
		int	len,
		SCIP_COL **	cols,
		SCIP_Real *	vals,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row from a separator

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
sepa	separator that creates the row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateRowUnspec	(	SCIP *	scip,
		SCIP_ROW **	row,
		const char *	name,
		int	len,
		SCIP_COL **	cols,
		SCIP_Real *	vals,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row from an unspecified source

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateRow	(	SCIP *	scip,
		SCIP_ROW **	row,
		const char *	name,
		int	len,
		SCIP_COL **	cols,
		SCIP_Real *	vals,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Deprecated:: Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
len	number of nonzeros in the row
cols	array with columns of row entries
vals	array with coefficients of row entries
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateEmptyRowCons	(	SCIP *	scip,
		SCIP_ROW **	row,
		SCIP_CONSHDLR *	conshdlr,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row without any coefficients from a constraint handler

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
conshdlr	constraint handler that creates the row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateEmptyRowSepa	(	SCIP *	scip,
		SCIP_ROW **	row,
		SCIP_SEPA *	sepa,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row without any coefficients from a separator

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
sepa	separator that creates the row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateEmptyRowUnspec	(	SCIP *	scip,
		SCIP_ROW **	row,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row without any coefficients from an unspecified source

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcreateEmptyRow	(	SCIP *	scip,
		SCIP_ROW **	row,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	removable
	)

creates and captures an LP row without any coefficients

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Deprecated:: Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().

Parameters

scip	SCIP data structure
row	pointer to row
name	name of row
lhs	left hand side of row
rhs	right hand side of row
local	is row only valid locally?
modifiable	is row modifiable during node processing (subject to column generation)?
removable	should the row be removed from the LP due to aging or cleanup?

SCIP_RETCODE SCIPcaptureRow	(	SCIP *	scip,
		SCIP_ROW *	row
	)

increases usage counter of LP row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	row to capture

SCIP_RETCODE SCIPreleaseRow	(	SCIP *	scip,
		SCIP_ROW **	row
	)

decreases usage counter of LP row, and frees memory if necessary

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	pointer to LP row

SCIP_RETCODE SCIPchgRowLhs	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	lhs
	)

changes left hand side of LP row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
lhs	new left hand side

SCIP_RETCODE SCIPchgRowRhs	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	rhs
	)

changes right hand side of LP row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
rhs	new right hand side

SCIP_RETCODE SCIPcacheRowExtensions	(	SCIP *	scip,
		SCIP_ROW *	row
	)

informs row, that all subsequent additions of variables to the row should be cached and not directly applied; after all additions were applied, SCIPflushRowExtensions() must be called; while the caching of row extensions is activated, information methods of the row give invalid results; caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase the performance

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPflushRowExtensions	(	SCIP *	scip,
		SCIP_ROW *	row
	)

flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with equal columns into a single coefficient

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPaddVarToRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

resolves variable to columns and adds them with the coefficient to the row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Note: In case calling this method in the enforcement process of an lp solution, it might be that some variables, that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP. For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was violated, the linear relaxation might not be violated anymore.)

Parameters

scip	SCIP data structure
row	LP row
var	problem variable
val	value of coefficient

SCIP_RETCODE SCIPaddVarsToRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

resolves variables to columns and adds them with the coefficients to the row; this method caches the row extensions and flushes them afterwards to gain better performance

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
nvars	number of variables to add to the row
vars	problem variables to add
vals	values of coefficients

SCIP_RETCODE SCIPaddVarsToRowSameCoef	(	SCIP *	scip,
		SCIP_ROW *	row,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real	val
	)

resolves variables to columns and adds them with the same single coefficient to the row; this method caches the row extensions and flushes them afterwards to gain better performance

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
nvars	number of variables to add to the row
vars	problem variables to add
val	unique value of all coefficients

SCIP_RETCODE SCIPcalcRowIntegralScalar	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	mindelta,
		SCIP_Real	maxdelta,
		SCIP_Longint	maxdnom,
		SCIP_Real	maxscale,
		SCIP_Bool	usecontvars,
		SCIP_Real *	intscalar,
		SCIP_Bool *	success
	)

tries to find a value, such that all row coefficients, if scaled with this value become integral

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
mindelta	minimal relative allowed difference of scaled coefficient s*c and integral i
maxdelta	maximal relative allowed difference of scaled coefficient s*c and integral i
maxdnom	maximal denominator allowed in rational numbers
maxscale	maximal allowed scalar
usecontvars	should the coefficients of the continuous variables also be made integral?
intscalar	pointer to store scalar that would make the coefficients integral, or NULL
success	stores whether returned value is valid

SCIP_RETCODE SCIPmakeRowIntegral	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	mindelta,
		SCIP_Real	maxdelta,
		SCIP_Longint	maxdnom,
		SCIP_Real	maxscale,
		SCIP_Bool	usecontvars,
		SCIP_Bool *	success
	)

tries to scale row, s.t. all coefficients (of integer variables) become integral

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
mindelta	minimal relative allowed difference of scaled coefficient s*c and integral i
maxdelta	maximal relative allowed difference of scaled coefficient s*c and integral i
maxdnom	maximal denominator allowed in rational numbers
maxscale	maximal value to scale row with
usecontvars	should the coefficients of the continuous variables also be made integral?
success	stores whether row could be made rational

void SCIPmarkRowNotRemovableLocal	(	SCIP *	scip,
		SCIP_ROW *	row
	)

marks a row to be not removable from the LP in the current node

Precondition

this method can be called in the following stage of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMinCoef	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns minimal absolute value of row vector's non-zero coefficients

Returns: minimal absolute value of row vector's non-zero coefficients

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMaxCoef	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns maximal absolute value of row vector's non-zero coefficients

Returns: maximal absolute value of row vector's non-zero coefficients

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMinActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the minimal activity of a row w.r.t. the column's bounds

Returns: the minimal activity of a row w.r.t. the column's bounds

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowMaxActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the maximal activity of a row w.r.t. the column's bounds

Returns: the maximal activity of a row w.r.t. the column's bounds

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowLPActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

recalculates the activity of a row in the last LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowLPActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the activity of a row in the last LP solution

Returns: activity of a row in the last LP solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowLPFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the feasibility of a row in the last LP solution

Returns: the feasibility of a row in the last LP solution: negative value means infeasibility

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowPseudoActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

recalculates the activity of a row for the current pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowPseudoActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the activity of a row for the current pseudo solution

Returns: the activity of a row for the current pseudo solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowPseudoFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the feasibility of a row for the current pseudo solution: negative value means infeasibility

Returns: the feasibility of a row for the current pseudo solution: negative value means infeasibility

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_RETCODE SCIPrecalcRowActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

recalculates the activity of a row in the last LP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowActivity	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the activity of a row in the last LP or pseudo solution

Returns: the activity of a row in the last LP or pseudo solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row
	)

returns the feasibility of a row in the last LP or pseudo solution

Returns: the feasibility of a row in the last LP or pseudo solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row

SCIP_Real SCIPgetRowSolActivity	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_SOL *	sol
	)

returns the activity of a row for the given primal solution

Returns: the activitiy of a row for the given primal solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
sol	primal CIP solution

SCIP_Real SCIPgetRowSolFeasibility	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_SOL *	sol
	)

returns the feasibility of a row for the given primal solution

Returns: the feasibility of a row for the given primal solution

Precondition

this method can be called in one of the following stages of the SCIP solving process:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	LP row
sol	primal CIP solution

SCIP_RETCODE SCIPprintRow	(	SCIP *	scip,
		SCIP_ROW *	row,
		FILE *	file
	)

output row to file stream via the message handler system

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

this method can be called in one of the following stages of the SCIP solving process:

Parameters

scip	SCIP data structure
row	LP row
file	output file (or NULL for standard output)

SCIP_Bool SCIPisNLPEnabled ( SCIP * scip )

returns whether the NLP relaxation has been enabled

If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin. To check whether an NLP is existing, use SCIPisNLPConstructed().

Precondition

This method can be called if SCIP is in one of the following stages:

See Also: SCIPenableNLP

Parameters

scip	SCIP data structure

void SCIPenableNLP ( SCIP * scip )

marks that there are constraints that are representable by nonlinear rows

This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.

The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisNLPConstructed ( SCIP * scip )

returns, whether an NLP has been constructed

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhasNLPContinuousNonlinearity ( SCIP * scip )

returns whether the NLP has a continuous variable in a nonlinear term

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPVarsData	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars
	)

gets current NLP variables along with the current number of NLP variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
vars	pointer to store the array of NLP variables, or NULL
nvars	pointer to store the number of NLP variables, or NULL

SCIP_VAR** SCIPgetNLPVars ( SCIP * scip )

gets array with variables of the NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNNLPVars ( SCIP * scip )

gets current number of variables in NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPVarsNonlinearity	(	SCIP *	scip,
		int *	nlcount
	)

computes for each variables the number of NLP rows in which the variable appears in a nonlinear var

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlcount	an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables

SCIP_Real* SCIPgetNLPVarsLbDualsol ( SCIP * scip )

returns dual solution values associated with lower bounds of NLP variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real* SCIPgetNLPVarsUbDualsol ( SCIP * scip )

returns dual solution values associated with upper bounds of NLP variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPNlRowsData	(	SCIP *	scip,
		SCIP_NLROW ***	nlrows,
		int *	nnlrows
	)

gets current NLP nonlinear rows along with the current number of NLP nonlinear rows

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrows	pointer to store the array of NLP nonlinear rows, or NULL
nnlrows	pointer to store the number of NLP nonlinear rows, or NULL

SCIP_NLROW** SCIPgetNLPNlRows ( SCIP * scip )

gets array with nonlinear rows of the NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNNLPNlRows ( SCIP * scip )

gets current number of nonlinear rows in NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

adds a nonlinear row to the NLP. This row is captured by the NLP.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	nonlinear row to add to NLP

SCIP_RETCODE SCIPflushNLP ( SCIP * scip )

makes sure that the NLP of the current node is flushed

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPsetNLPInitialGuess	(	SCIP *	scip,
		SCIP_Real *	initialguess
	)

sets or clears initial primal guess for NLP solution (start point for NLP solver)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
initialguess	values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point

SCIP_RETCODE SCIPsetNLPInitialGuessSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

sets initial primal guess for NLP solution (start point for NLP solver)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	solution which values should be taken as initial guess, or NULL for LP solution

SCIP_RETCODE SCIPsolveNLP ( SCIP * scip )

solves the current NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_NLPSOLSTAT SCIPgetNLPSolstat ( SCIP * scip )

gets solution status of current NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_NLPTERMSTAT SCIPgetNLPTermstat ( SCIP * scip )

gets termination status of last NLP solve

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPStatistics	(	SCIP *	scip,
		SCIP_NLPSTATISTICS *	statistics
	)

gives statistics (number of iterations, solving time, ...) of last NLP solve

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
statistics	pointer to store statistics

SCIP_Real SCIPgetNLPObjval ( SCIP * scip )

gets objective value of current NLP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Bool SCIPhasNLPSolution ( SCIP * scip )

indicates whether a feasible solution for the current NLP is available thus, returns whether the solution status <= feasible

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetNLPFracVars	(	SCIP *	scip,
		SCIP_VAR ***	fracvars,
		SCIP_Real **	fracvarssol,
		SCIP_Real **	fracvarsfrac,
		int *	nfracvars,
		int *	npriofracvars
	)

gets fractional variables of last NLP solution along with solution values and fractionalities

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
fracvars	pointer to store the array of NLP fractional variables, or NULL
fracvarssol	pointer to store the array of NLP fractional variables solution values, or NULL
fracvarsfrac	pointer to store the array of NLP fractional variables fractionalities, or NULL
nfracvars	pointer to store the number of NLP fractional variables , or NULL
npriofracvars	pointer to store the number of NLP fractional variables with maximal branching priority, or NULL

SCIP_RETCODE SCIPgetNLPIntPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		int *	ival
	)

gets integer parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
ival	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPIntPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		int	ival
	)

sets integer parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
ival	parameter value

SCIP_RETCODE SCIPgetNLPRealPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		SCIP_Real *	dval
	)

gets floating point parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
dval	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPRealPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		SCIP_Real	dval
	)

sets floating point parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
dval	parameter value

SCIP_RETCODE SCIPgetNLPStringPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		const char **	sval
	)

gets string parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
sval	pointer to store the parameter value

SCIP_RETCODE SCIPsetNLPStringPar	(	SCIP *	scip,
		SCIP_NLPPARAM	type,
		const char *	sval
	)

sets string parameter of NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
type	parameter number
sval	parameter value

SCIP_RETCODE SCIPwriteNLP	(	SCIP *	scip,
		const char *	filename
	)

writes current NLP to a file

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
filename	file name

SCIP_RETCODE SCIPgetNLPI	(	SCIP *	scip,
		SCIP_NLPI **	nlpi,
		SCIP_NLPIPROBLEM **	nlpiproblem
	)

gets the NLP interface and problem used by the SCIP NLP; with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;

Warning: You have to make sure, that the full internal state of the NLPI does not change or is recovered completely after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution status is recovered completely at the end of your method. Additionally you have to resolve the NLP with SCIPnlpiSolve() in order to reinstall the internal solution status.; Make also sure, that all parameter values that you have changed are set back to their original values.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlpi	pointer to store the NLP solver interface
nlpiproblem	pointer to store the NLP solver interface problem

SCIP_RETCODE SCIPstartDiveNLP ( SCIP * scip )

initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPendDiveNLP ( SCIP * scip )

ends NLP diving resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP()

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgVarObjDiveNLP	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes linear objective coefficient of a variable in diving NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable which coefficient to change
coef	new value for coefficient

SCIP_RETCODE SCIPchgVarBoundsDiveNLP	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	lb,
		SCIP_Real	ub
	)

changes bounds of a variable in diving NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable which bounds to change
lb	new lower bound
ub	new upper bound

SCIP_RETCODE SCIPchgVarsBoundsDiveNLP	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	lbs,
		SCIP_Real *	ubs
	)

changes bounds of a set of variables in diving NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nvars	number of variables which bounds to changes
vars	variables which bounds to change
lbs	new lower bounds
ubs	new upper bounds

SCIP_RETCODE SCIPsolveDiveNLP ( SCIP * scip )

solves diving NLP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateNlRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow,
		const char *	name,
		SCIP_Real	constant,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadvars,
		SCIP_VAR **	quadvars,
		int	nquadelems,
		SCIP_QUADELEM *	quadelems,
		SCIP_EXPRTREE *	expression,
		SCIP_Real	lhs,
		SCIP_Real	rhs
	)

creates and captures an NLP row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	buffer to store pointer to nonlinear row
name	name of nonlinear row
constant	constant
nlinvars	number of linear variables
linvars	linear variables, or NULL if nlinvars == 0
lincoefs	linear coefficients, or NULL if nlinvars == 0
nquadvars	number of variables in quadratic term
quadvars	variables in quadratic terms, or NULL if nquadvars == 0
nquadelems	number of elements in quadratic term
quadelems	elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0
expression	nonlinear expression, or NULL
lhs	left hand side
rhs	right hand side

SCIP_RETCODE SCIPcreateEmptyNlRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow,
		const char *	name,
		SCIP_Real	lhs,
		SCIP_Real	rhs
	)

creates and captures an NLP nonlinear row without any coefficients

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row
name	name of nonlinear row
lhs	left hand side
rhs	right hand side

SCIP_RETCODE SCIPcreateNlRowFromRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow,
		SCIP_ROW *	row
	)

creates and captures an NLP row from a linear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row
row	the linear row to copy

SCIP_RETCODE SCIPcaptureNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

increases usage counter of NLP nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	nonlinear row to capture

SCIP_RETCODE SCIPreleaseNlRow	(	SCIP *	scip,
		SCIP_NLROW **	nlrow
	)

decreases usage counter of NLP nonlinear row, and frees memory if necessary

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	pointer to nonlinear row

SCIP_RETCODE SCIPchgNlRowLhs	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	lhs
	)

changes left hand side of NLP nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
lhs	new left hand side

SCIP_RETCODE SCIPchgNlRowRhs	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	rhs
	)

changes right hand side of NLP nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
rhs	new right hand side

SCIP_RETCODE SCIPchgNlRowConstant	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real	constant
	)

changes constant of NLP nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
constant	new value for constant

SCIP_RETCODE SCIPaddLinearCoefToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

adds variable with a linear coefficient to the nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
var	problem variable
val	value of coefficient in linear part of row

SCIP_RETCODE SCIPaddLinearCoefsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

adds variables with linear coefficients to the row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
nvars	number of variables to add to the row
vars	problem variables to add
vals	values of coefficients in linear part of row

SCIP_RETCODE SCIPchgNlRowLinearCoef	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes linear coefficient of a variables in a row setting the coefficient to 0.0 means that it is removed from the row the variable does not need to exists before

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
var	variable
coef	new value of coefficient

SCIP_RETCODE SCIPaddQuadVarToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_VAR *	var
	)

adds quadratic variable to the nonlinear row after adding a quadratic variable, it can be used to add quadratic elements

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
var	problem variable

SCIP_RETCODE SCIPaddQuadVarsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nvars,
		SCIP_VAR **	vars
	)

adds quadratic variables to the nonlinear row after adding quadratic variables, they can be used to add quadratic elements

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
nvars	number of problem variables
vars	problem variables

SCIP_RETCODE SCIPaddQuadElementToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_QUADELEM	quadelem
	)

add a quadratic element to the nonlinear row variable indices of the quadratic element need to be relative to quadratic variables array of row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
quadelem	quadratic element

SCIP_RETCODE SCIPaddQuadElementsToNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	nquadelems,
		SCIP_QUADELEM *	quadelems
	)

adds quadratic elements to the nonlinear row variable indices of the quadratic elements need to be relative to quadratic variables array of row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
nquadelems	number of quadratic elements
quadelems	quadratic elements

SCIP_RETCODE SCIPchgNlRowQuadElement	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_QUADELEM	quadelement
	)

changes coefficient in quadratic part of a row setting the coefficient in the quadelement to 0.0 means that it is removed from the row the element does not need to exists before

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
quadelement	new quadratic element, or update for existing one

SCIP_RETCODE SCIPsetNlRowExprtree	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_EXPRTREE *	exprtree
	)

sets or deletes expression tree in the nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
exprtree	expression tree, or NULL

SCIP_RETCODE SCIPsetNlRowExprtreeParam	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		int	paramidx,
		SCIP_Real	paramval
	)

sets a parameter of expression tree in the nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
paramidx	index of parameter in expression tree
paramval	new value of parameter in expression tree

SCIP_RETCODE SCIPsetNlRowExprtreeParams	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	paramvals
	)

sets parameters of expression tree in the nonlinear row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
paramvals	new values of parameter in expression tree

SCIP_RETCODE SCIPrecalcNlRowNLPActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

recalculates the activity of a nonlinear row in the last NLP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowNLPActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	activity
	)

returns the activity of a nonlinear row in the last NLP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowNLPFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	feasibility
	)

gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPrecalcNlRowPseudoActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

recalculates the activity of a nonlinear row for the current pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowPseudoActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	pseudoactivity
	)

gives the activity of a nonlinear row for the current pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
pseudoactivity	pointer to store pseudo activity value

SCIP_RETCODE SCIPgetNlRowPseudoFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	pseudofeasibility
	)

gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
pseudofeasibility	pointer to store pseudo feasibility value

SCIP_RETCODE SCIPrecalcNlRowActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow
	)

recalculates the activity of a nonlinear row in the last NLP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row

SCIP_RETCODE SCIPgetNlRowActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	activity
	)

gives the activity of a nonlinear row in the last NLP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	feasibility
	)

gives the feasibility of a nonlinear row in the last NLP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPgetNlRowSolActivity	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_SOL *	sol,
		SCIP_Real *	activity
	)

gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
sol	primal CIP solution, or NULL for NLP solution of pseudo solution
activity	pointer to store activity value

SCIP_RETCODE SCIPgetNlRowSolFeasibility	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_SOL *	sol,
		SCIP_Real *	feasibility
	)

gives the feasibility of a nonlinear row for the given primal solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP nonlinear row
sol	primal CIP solution
feasibility	pointer to store feasibility value

SCIP_RETCODE SCIPgetNlRowActivityBounds	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		SCIP_Real *	minactivity,
		SCIP_Real *	maxactivity
	)

gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
minactivity	buffer to store minimal activity, or NULL
maxactivity	buffer to store maximal activity, or NULL

SCIP_RETCODE SCIPprintNlRow	(	SCIP *	scip,
		SCIP_NLROW *	nlrow,
		FILE *	file
	)

output nonlinear row to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
nlrow	NLP row
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPgetExprtreeTransformedVars	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree
	)

replaces array of variables in expression tree by corresponding transformed variables

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree

SCIP_RETCODE SCIPevalExprtreeSol	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_SOL *	sol,
		SCIP_Real *	val
	)

evaluates an expression tree for a primal solution or LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
sol	a solution, or NULL for current LP solution
val	buffer to store value

SCIP_RETCODE SCIPevalExprtreeGlobalBounds	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_Real	infinity,
		SCIP_INTERVAL *	val
	)

evaluates an expression tree w.r.t. current global bounds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
infinity	value to use for infinity
val	buffer to store result

SCIP_RETCODE SCIPevalExprtreeLocalBounds	(	SCIP *	scip,
		SCIP_EXPRTREE *	tree,
		SCIP_Real	infinity,
		SCIP_INTERVAL *	val
	)

evaluates an expression tree w.r.t. current local bounds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
tree	expression tree
infinity	value to use for infinity
val	buffer to store result

SCIP_Real SCIPgetCutEfficacy	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut
	)

returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm

Returns: the efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution, or NULL for current LP solution
cut	separated cut

SCIP_Bool SCIPisCutEfficacious	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut
	)

returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy

Returns: TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy, otherwise FALSE

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution, or NULL for current LP solution
cut	separated cut

SCIP_Bool SCIPisEfficacious	(	SCIP *	scip,
		SCIP_Real	efficacy
	)

checks, if the given cut's efficacy is larger than the minimal cut efficacy

Returns: TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE

Parameters

scip	SCIP data structure
efficacy	efficacy of the cut

SCIP_Real SCIPgetVectorEfficacyNorm	(	SCIP *	scip,
		SCIP_Real *	vals,
		int	nvals
	)

calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter

Returns: the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter

Parameters

scip	SCIP data structure
vals	array of values
nvals	number of values

SCIP_Bool SCIPisCutApplicable	(	SCIP *	scip,
		SCIP_ROW *	cut
	)

indicates whether a cut is applicable

If the cut has only one variable and this method returns FALSE, it may still be possible that the cut can be added to the LP (as a row instead of a boundchange), but it will be a very weak cut. The user is asked to avoid such cuts.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Returns: whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon

Parameters

scip	SCIP data structure
cut	separated cut

SCIP_RETCODE SCIPaddCut	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_ROW *	cut,
		SCIP_Bool	forcecut,
		SCIP_Bool *	infeasible
	)

adds cut to separation storage

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution that was separated, or NULL for LP solution
cut	separated cut
forcecut	should the cut be forced to enter the LP?
infeasible	pointer to store whether cut has been detected to be infeasible for local bounds

SCIP_RETCODE SCIPaddPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

if not already existing, adds row to global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_RETCODE SCIPdelPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

removes the row from the global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_CUT** SCIPgetPoolCuts ( SCIP * scip )

gets current cuts in the global cut pool

Returns: the current cuts in the global cut pool

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNPoolCuts ( SCIP * scip )

gets current number of rows in the global cut pool

Returns: the current number of rows in the global cut pool

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_CUTPOOL* SCIPgetGlobalCutpool ( SCIP * scip )

gets the global cut pool used by SCIP

Returns: the global cut pool used by SCIP

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL **	cutpool,
		int	agelimit
	)

creates a cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutpool	pointer to store cut pool
agelimit	maximum age a cut can reach before it is deleted from the pool

SCIP_RETCODE SCIPfreeCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL **	cutpool
	)

frees a cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutpool	pointer to store cut pool

SCIP_RETCODE SCIPaddRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

if not already existing, adds row to a cut pool and captures it

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutpool	cut pool
row	cutting plane to add

SCIP_RETCODE SCIPaddNewRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

adds row to a cut pool and captures it; doesn't check for multiple cuts

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutpool	cut pool
row	cutting plane to add

SCIP_RETCODE SCIPdelRowCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_ROW *	row
	)

removes the LP row from a cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutpool	cut pool
row	row to remove

SCIP_RETCODE SCIPseparateCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_RESULT *	result
	)

separates cuts from a cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPseparateSolCutpool	(	SCIP *	scip,
		SCIP_CUTPOOL *	cutpool,
		SCIP_SOL *	sol,
		SCIP_RESULT *	result
	)

separates cuts w.r.t. given solution from a cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
cutpool	cut pool
sol	solution to be separated
result	pointer to store the result of the separation call

SCIP_RETCODE SCIPaddDelayedPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

if not already existing, adds row to the delayed global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_RETCODE SCIPdelDelayedPoolCut	(	SCIP *	scip,
		SCIP_ROW *	row
	)

removes the row from the delayed global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
row	cutting plane to add

SCIP_CUT** SCIPgetDelayedPoolCuts ( SCIP * scip )

gets current cuts in the delayed global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNDelayedPoolCuts ( SCIP * scip )

gets current number of rows in the delayed global cut pool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_CUTPOOL* SCIPgetDelayedGlobalCutpool ( SCIP * scip )

gets the delayed global cut pool used by SCIP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition: This method can be called if scip is the stages SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPseparateSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	pretendroot,
		SCIP_Bool	onlydelayed,
		SCIP_Bool *	delayed,
		SCIP_Bool *	cutoff
	)

separates the given primal solution or the current LP solution by calling the separators and constraint handlers' separation methods; the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and SCIPgetNCuts(); after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the separation storage; it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts afterwards

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution that should be separated, or NULL for LP solution
pretendroot	should the cut separators be called as if we are at the root node?
onlydelayed	should only separators be called that were delayed in the previous round?
delayed	pointer to store whether a separator was delayed
cutoff	pointer to store whether the node can be cut off

SCIP_ROW** SCIPgetCuts ( SCIP * scip )

gets the array of cuts currently stored in the separation storage

Returns: the array of cuts currently stored in the separation storage

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNCuts ( SCIP * scip )

get current number of cuts in the separation storage

Returns: the current number of cuts in the separation storage

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPclearCuts ( SCIP * scip )

clears the separation storage

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPremoveInefficaciousCuts ( SCIP * scip )

removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetRelaxFeastolFactor ( SCIP * scip )

returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver

Gives value of separating/feastolfac parameter.

Returns: factor on cut infeasibility to limit feasibility tolerance for relaxation solver

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartDive ( SCIP * scip )

initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note: diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from numerical troubles during the last LP solve; because of this, most users will want to call this method only if SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPendDive ( SCIP * scip )

quits LP diving and resets bounds and objective values of columns to the current node's values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgCutoffboundDive	(	SCIP *	scip,
		SCIP_Real	newcutoffbound
	)

changes cutoffbound in current dive

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
newcutoffbound	new cutoffbound

SCIP_RETCODE SCIPchgVarObjDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newobj
	)

changes variable's objective value in current dive

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the objective value for
newobj	new objective value

SCIP_RETCODE SCIPchgVarLbDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes variable's lower bound in current dive

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbDive	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

changes variable's upper bound in current dive

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPaddRowDive	(	SCIP *	scip,
		SCIP_ROW *	row
	)

adds a row to the LP in current dive

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to be added

SCIP_RETCODE SCIPchgRowLhsDive	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	newlhs
	)

changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to change the lhs for
newlhs	new value for lhs

SCIP_RETCODE SCIPchgRowRhsDive	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_Real	newrhs
	)

changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
row	row to change the lhs for
newrhs	new value for rhs

SCIP_Real SCIPgetVarObjDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's objective value in current dive

Returns: the variable's objective value in current dive.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_Real SCIPgetVarLbDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's lower bound in current dive

Returns: the variable's lower bound in current dive.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_Real SCIPgetVarUbDive	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets variable's upper bound in current dive

Returns: the variable's upper bound in current dive.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to get the bound for

SCIP_RETCODE SCIPsolveDiveLP	(	SCIP *	scip,
		int	itlim,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP of the current dive; no separation or pricing is applied

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note: be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL, compare the explanation of SCIPstartDive()

Parameters

scip	SCIP data structure
itlim	maximal number of LP iterations to perform, or -1 for no limit
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the diving LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_Longint SCIPgetLastDivenode ( SCIP * scip )

returns the number of the node in the current branch and bound run, where the last LP was solved in diving or probing mode

Returns: the number of the node in the current branch and bound run, where the last LP was solved in diving or probing mode.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinDive ( SCIP * scip )

returns whether we are in diving mode

Returns: whether we are in diving mode.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinProbing ( SCIP * scip )

returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped via SCIPendProbing()

Returns: TRUE, if SCIP is currently in probing mode, otherwise FALSE

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstartProbing ( SCIP * scip )

initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Note: The collection of variable statistics is turned off during probing. If these statistics should be collected during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPnewProbingNode ( SCIP * scip )

creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path with a call to SCIPbacktrackProbing(); using a sub node for each set of probing bound changes can improve conflict analysis

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetProbingDepth ( SCIP * scip )

returns the current probing depth

Returns: the probing depth, i.e. the number of probing sub nodes existing in the probing path

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPbacktrackProbing	(	SCIP *	scip,
		int	probingdepth
	)

undoes all changes to the problem applied in probing up to the given probing depth; the changes of the probing node of the given probing depth are the last ones that remain active; changes that were applied before calling SCIPnewProbingNode() cannot be undone

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
probingdepth	probing depth of the node in the probing path that should be reactivated

SCIP_RETCODE SCIPendProbing ( SCIP * scip )

quits probing and resets bounds and constraints to the focus node's environment

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgVarLbProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPchgVarUbProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	newbound
	)

injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to change the bound for
newbound	new value for bound

SCIP_RETCODE SCIPfixVarProbing	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	fixedval
	)

injects a change of variable's bounds into current probing node to fix the variable to the specified value; the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated like deductions instead of branching decisions

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to change the bound for
fixedval	value to fix variable to

SCIP_RETCODE SCIPpropagateProbing	(	SCIP *	scip,
		int	maxproprounds,
		SCIP_Bool *	cutoff,
		SCIP_Longint *	ndomredsfound
	)

applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
maxproprounds	maximal number of propagation rounds (-1: no limit, 0: parameter settings)
cutoff	pointer to store whether the probing node can be cut off
ndomredsfound	pointer to store the number of domain reductions found, or NULL

SCIP_RETCODE SCIPpropagateProbingImplications	(	SCIP *	scip,
		SCIP_Bool *	cutoff
	)

applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; only propagations of the binary variables fixed at the current probing node that are triggered by the implication graph and the clique table are applied; the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
cutoff	pointer to store whether the probing node can be cut off

SCIP_RETCODE SCIPsolveProbingLP	(	SCIP *	scip,
		int	itlim,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP at the current probing node (cannot be applied at preprocessing stage); no separation or pricing is applied

The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
itlim	maximal number of LP iterations to perform, or -1 for no limit
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the probing LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_RETCODE SCIPsolveProbingLPWithPricing	(	SCIP *	scip,
		SCIP_Bool	pretendroot,
		SCIP_Bool	displayinfo,
		int	maxpricerounds,
		SCIP_Bool *	lperror,
		SCIP_Bool *	cutoff
	)

solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing until the LP is solved to optimality; no separation is applied

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
pretendroot	should the pricers be called as if we are at the root node?
displayinfo	should info lines be displayed after each pricing round?
maxpricerounds	maximal number of pricing rounds (-1: no limit); a finite limit means that the LP might not be solved to optimality!
lperror	pointer to store whether an unresolved LP error occurred
cutoff	pointer to store whether the probing LP was infeasible or the objective limit was reached (or NULL, if not needed)

SCIP_RETCODE SCIPgetLPBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	lpcands,
		SCIP_Real **	lpcandssol,
		SCIP_Real **	lpcandsfrac,
		int *	nlpcands,
		int *	npriolpcands,
		int *	nfracimplvars
	)

gets branching candidates for LP solution branching (fractional variables) along with solution values, fractionalities, and number of branching candidates; The number of branching candidates does NOT account for fractional implicit integer variables which should not be used for branching decisions.

Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1

branching rules should always select the branching candidate among the first npriolpcands of the candidate list

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
lpcands	pointer to store the array of LP branching candidates, or NULL
lpcandssol	pointer to store the array of LP candidate solution values, or NULL
lpcandsfrac	pointer to store the array of LP candidate fractionalities, or NULL
nlpcands	pointer to store the number of LP branching candidates, or NULL
npriolpcands	pointer to store the number of candidates with maximal priority, or NULL
nfracimplvars	pointer to store the number of fractional implicit integer variables, or NULL

int SCIPgetNLPBranchCands ( SCIP * scip )

gets number of branching candidates for LP solution branching (number of fractional variables)

Returns: the number of branching candidates for LP solution branching (number of fractional variables).

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioLPBranchCands ( SCIP * scip )

gets number of branching candidates with maximal priority for LP solution branching

Returns: the number of branching candidates with maximal priority for LP solution branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetExternBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	externcands,
		SCIP_Real **	externcandssol,
		SCIP_Real **	externcandsscore,
		int *	nexterncands,
		int *	nprioexterncands,
		int *	nprioexternbins,
		int *	nprioexternints,
		int *	nprioexternimpls
	)

gets external branching candidates along with solution values, scores, and number of branching candidates; these branching candidates can be used by relaxations or nonlinear constraint handlers branching rules should always select the branching candidate among the first nprioexterncands of the candidate list

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Note: Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and continuous last.

Parameters

scip	SCIP data structure
externcands	pointer to store the array of extern branching candidates, or NULL
externcandssol	pointer to store the array of extern candidate solution values, or NULL
externcandsscore	pointer to store the array of extern candidate scores, or NULL
nexterncands	pointer to store the number of extern branching candidates, or NULL
nprioexterncands	pointer to store the number of candidates with maximal priority, or NULL
nprioexternbins	pointer to store the number of binary candidates with maximal priority, or NULL
nprioexternints	pointer to store the number of integer candidates with maximal priority, or NULL
nprioexternimpls	pointer to store the number of implicit integer candidates with maximal priority, or NULL

int SCIPgetNExternBranchCands ( SCIP * scip )

gets number of external branching candidates

Returns: the number of external branching candidates.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchCands ( SCIP * scip )

gets number of external branching candidates with maximal branch priority

Returns: the number of external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchBins ( SCIP * scip )

gets number of binary external branching candidates with maximal branch priority

Returns: the number of binary external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchInts ( SCIP * scip )

gets number of integer external branching candidates with maximal branch priority

Returns: the number of integer external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchImpls ( SCIP * scip )

gets number of implicit integer external branching candidates with maximal branch priority

Returns: the number of implicit integer external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioExternBranchConts ( SCIP * scip )

gets number of continuous external branching candidates with maximal branch priority

Returns: the number of continuous external branching candidates with maximal branch priority.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPaddExternBranchCand	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	score,
		SCIP_Real	solval
	)

insert variable, its score and its solution value into the external branching candidate storage the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to insert
score	score of external candidate, e.g. infeasibility
solval	value of the variable in the current solution

void SCIPclearExternBranchCands ( SCIP * scip )

removes all external candidates from the storage for external branching

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Bool SCIPcontainsExternBranchCand	(	SCIP *	scip,
		SCIP_VAR *	var
	)

checks whether the given variable is contained in the candidate storage for external branching

Returns: whether the given variable is contained in the candidate storage for external branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to look for

SCIP_RETCODE SCIPgetPseudoBranchCands	(	SCIP *	scip,
		SCIP_VAR ***	pseudocands,
		int *	npseudocands,
		int *	npriopseudocands
	)

gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
pseudocands	pointer to store the array of pseudo branching candidates, or NULL
npseudocands	pointer to store the number of pseudo branching candidates, or NULL
npriopseudocands	pointer to store the number of candidates with maximal priority, or NULL

int SCIPgetNPseudoBranchCands ( SCIP * scip )

gets number of branching candidates for pseudo solution branching (non-fixed variables)

Returns: the number branching candidates for pseudo solution branching (non-fixed variables).

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchCands ( SCIP * scip )

gets number of branching candidates with maximal branch priority for pseudo solution branching

Returns: the number of branching candidates with maximal branch priority for pseudo solution branching.

Precondition

This method can be called if scip is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchBins ( SCIP * scip )

gets number of binary branching candidates with maximal branch priority for pseudo solution branching

Returns: the number of binary branching candidates with maximal branch priority for pseudo solution branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchInts ( SCIP * scip )

gets number of integer branching candidates with maximal branch priority for pseudo solution branching

Returns: the number of integer branching candidates with maximal branch priority for pseudo solution branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

int SCIPgetNPrioPseudoBranchImpls ( SCIP * scip )

gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching

Returns: the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetBranchScore	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	downgain,
		SCIP_Real	upgain
	)

calculates the branching score out of the gain predictions for a binary branching

Returns: the branching score out of the gain predictions for a binary branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching factor should be applied, or NULL
downgain	prediction of objective gain for rounding downwards
upgain	prediction of objective gain for rounding upwards

SCIP_Real SCIPgetBranchScoreMultiple	(	SCIP *	scip,
		SCIP_VAR *	var,
		int	nchildren,
		SCIP_Real *	gains
	)

calculates the branching score out of the gain predictions for a branching with arbitrary many children

Returns: the branching score out of the gain predictions for a branching with arbitrary many children.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching factor should be applied, or NULL
nchildren	number of children that the branching will create
gains	prediction of objective gain for each child

SCIP_Real SCIPgetBranchingPoint	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	suggestion
	)

computes a branching point for a continuous or discrete variable

See Also: SCIPbranchGetBranchingPoint

Returns: the branching point for a continuous or discrete variable.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable, of which the branching point should be computed
suggestion	suggestion for branching point, or SCIP_INVALID if no suggestion

SCIP_Real SCIPcalcNodeselPriority	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_BRANCHDIR	branchdir,
		SCIP_Real	targetvalue
	)

calculates the node selection priority for moving the given variable's LP value to the given target value; this node selection priority can be given to the SCIPcreateChild() call

Returns: the node selection priority for moving the given variable's LP value to the given target value.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable on which the branching is applied
branchdir	type of branching that was performed: upwards, downwards, or fixed; fixed should only be used, when both bounds changed
targetvalue	new value of the variable in the child node

SCIP_Real SCIPcalcChildEstimate	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	targetvalue
	)

calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given branching; this estimate can be given to the SCIPcreateChild() call

Returns: the estimate for the objective of the best feasible solution contained in the subtree after applying the given branching.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable on which the branching is applied
targetvalue	new value of the variable in the child node

SCIP_RETCODE SCIPcreateChild	(	SCIP *	scip,
		SCIP_NODE **	node,
		SCIP_Real	nodeselprio,
		SCIP_Real	estimate
	)

creates a child node of the focus node

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
node	pointer to node data structure
nodeselprio	node selection priority of new node
estimate	estimate for (transformed) objective value of best feasible solution in subtree

SCIP_RETCODE SCIPbranchVar	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_NODE **	downchild,
		SCIP_NODE **	eqchild,
		SCIP_NODE **	upchild
	)

branches on a non-continuous variable v using the current LP or pseudo solution; if solution value x' is fractional, two child nodes will be created (x <= floor(x'), x >= ceil(x')), if solution value is integral, the x' is equal to lower or upper bound of the branching variable and the bounds of v are finite, then two child nodes will be created (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)), otherwise (up to) three child nodes will be created (x <= x'-1, x == x', x >= x'+1)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
downchild	pointer to return the left child with variable rounded down, or NULL
eqchild	pointer to return the middle child with variable fixed, or NULL
upchild	pointer to return the right child with variable rounded up, or NULL

SCIP_RETCODE SCIPbranchVarHole	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	left,
		SCIP_Real	right,
		SCIP_NODE **	downchild,
		SCIP_NODE **	upchild
	)

branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
left	left side of the domain hole
right	right side of the domain hole
downchild	pointer to return the left child (x <= left), or NULL
upchild	pointer to return the right child (x >= right), or NULL

SCIP_RETCODE SCIPbranchVarVal	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val,
		SCIP_NODE **	downchild,
		SCIP_NODE **	eqchild,
		SCIP_NODE **	upchild
	)

branches on a variable x using a given value x'; for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds; two child nodes (x <= x', x >= x') are created; for integer variables, if solution value x' is fractional, two child nodes are created (x <= floor(x'), x >= ceil(x')), if x' is integral, three child nodes are created (x <= x'-1, x == x', x >= x'+1)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
val	value to branch on
downchild	pointer to return the left child with variable rounded down, or NULL
eqchild	pointer to return the middle child with variable fixed, or NULL
upchild	pointer to return the right child with variable rounded up, or NULL

SCIP_RETCODE SCIPbranchVarValNary	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_Real	val,
		int	n,
		SCIP_Real	minwidth,
		SCIP_Real	widthfactor,
		int *	nchildren
	)

n-ary branching on a variable x using a given value Branches on variable x such that up to n/2 children are created on each side of the usual branching value. The branching value is selected as in SCIPbranchVarVal(). The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes. If n is odd, one child with domain width 'width' and having the branching value in the middle is created. Otherwise, two children with domain width 'width' and being left and right of the branching value are created. Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance from the first nodes. The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value. If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.

Giving a large value for widthfactor results in creating children with small domain when close to the branching value and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3 results in a ternary branching where the branching variable is mostly fixed in the middle child. Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width (except for one child if the branching value is not in the middle).

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
var	variable to branch on
val	value to branch on
n	attempted number of children to be created, must be >= 2
minwidth	minimal domain width in children
widthfactor	multiplier for children domain width with increasing distance from val, must be >= 1.0
nchildren	pointer to store number of created children, or NULL

SCIP_RETCODE SCIPbranchLP	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN; if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPbranchExtern	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPbranchPseudo	(	SCIP *	scip,
		SCIP_RESULT *	result
	)

calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure
result	pointer to store the result of the branching (s. branch.h)

SCIP_RETCODE SCIPcreateSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to zero

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateLPSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateNLPSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current NLP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateRelaxSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current relaxation solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreatePseudoSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateCurrentSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved at the current node

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateUnknownSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution, initialized to unknown values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateOrigSol	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_HEUR *	heur
	)

creates a primal solution living in the original problem space, initialized to zero; a solution in original space allows to set original variables to values that would be invalid in the transformed problem due to preprocessing fixings or aggregations

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to store the solution
heur	heuristic that found the solution (or NULL if it's from the tree)

SCIP_RETCODE SCIPcreateSolCopy	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_SOL *	sourcesol
	)

creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked if it should stay unaffected from changes in the LP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to store the solution
sourcesol	primal CIP solution to copy

SCIP_RETCODE SCIPcreateFiniteSolCopy	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_SOL *	sourcesol,
		SCIP_Bool *	success
	)

creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values; the copy is always defined in the original variable space; success indicates whether the objective value of the solution was changed by removing infinite values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to store the solution
sourcesol	primal CIP solution to copy
success	does the finite solution have the same objective value?

SCIP_RETCODE SCIPfreeSol	(	SCIP *	scip,
		SCIP_SOL **	sol
	)

frees primal CIP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	pointer to the solution

SCIP_RETCODE SCIPlinkLPSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current LP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkNLPSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current NLP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkRelaxSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current relaxation solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkPseudoSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPlinkCurrentSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

links a primal solution to the current LP or pseudo solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPclearSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

clears a primal solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPunlinkSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

stores solution values of variables in solution's own array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_RETCODE SCIPsetSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var,
		SCIP_Real	val
	)

sets value of variable in primal CIP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution
var	variable to add to solution
val	solution value of variable

SCIP_RETCODE SCIPsetSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

sets values of multiple variables in primal CIP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution
nvars	number of variables to set solution value for
vars	array with variables to add to solution
vals	array with solution values of variables

SCIP_RETCODE SCIPincSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var,
		SCIP_Real	incval
	)

increases value of variable in primal CIP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution
var	variable to increase solution value for
incval	increment for solution value of variable

SCIP_Real SCIPgetSolVal	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR *	var
	)

returns value of variable in primal CIP solution, or in current LP/pseudo solution

Returns: value of variable in primal CIP solution, or in current LP/pseudo solution

Precondition

In case the solution pointer sol is NULL, that means it is asked for the LP or pseudo solution, this method can only be called if scip is in the solving stage SCIP_STAGE_SOLVING. In any other case, this method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
var	variable to get value for

SCIP_RETCODE SCIPgetSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals
	)

gets values of multiple variables in primal CIP solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
nvars	number of variables to get solution value for
vars	array with variables to get value for
vals	array to store solution values of variables

SCIP_Real SCIPgetSolOrigObj	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value

Returns: objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo objective value

SCIP_Real SCIPgetSolTransObj	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value

Returns: transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo objective value

SCIP_Real SCIPtransformObj	(	SCIP *	scip,
		SCIP_Real	obj
	)

maps original space objective value into transformed objective value

Returns: transformed objective value

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
obj	original space objective value to transform

SCIP_Real SCIPretransformObj	(	SCIP *	scip,
		SCIP_Real	obj
	)

maps transformed objective value into original space

Returns: objective value into original space

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
obj	transformed objective value to retransform in original space

SCIP_Real SCIPgetSolTime	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

gets clock time, when this solution was found

Returns: clock time, when this solution was found

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

int SCIPgetSolRunnum	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

gets branch and bound run number, where this solution was found

Returns: branch and bound run number, where this solution was found

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_Longint SCIPgetSolNodenum	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

gets node number of the specific branch and bound run, where this solution was found

Returns: node number of the specific branch and bound run, where this solution was found

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_HEUR* SCIPgetSolHeur	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

gets heuristic, that found this solution (or NULL if it's from the tree)

Returns: heuristic, that found this solution (or NULL if it's from the tree)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution

SCIP_Bool SCIPareSolsEqual	(	SCIP *	scip,
		SCIP_SOL *	sol1,
		SCIP_SOL *	sol2
	)

returns whether two given solutions are exactly equal

Returns: returns whether two given solutions are exactly equal

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol1	first primal CIP solution
sol2	second primal CIP solution

SCIP_RETCODE SCIPadjustImplicitSolVals	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	uselprows
	)

adjusts solution values of implicit integer variables in handed solution. Solution objective value is not deteriorated by this method.

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal CIP solution
uselprows	should LP row information be considered for none-objective variables

SCIP_RETCODE SCIPprintSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution in original problem space to the given file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

In case the solution pointer sol is NULL (askinking for the current LP/pseudo solution), this method can be called if scip is in one of the following stages:

In case the solution pointer sol is not NULL, this method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintTransSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution in transformed problem space to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintDualSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs dual solution from LP solver to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVED

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintRay	(	SCIP *	scip,
		SCIP_SOL *	sol,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs non-zero variables of solution representing a ray in original problem space to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal solution representing ray
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

int SCIPgetNSols ( SCIP * scip )

gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate storage is returned

Returns: number of feasible primal solutions stored in the solution storage in case the problem is transformed; or number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_SOL** SCIPgetSols ( SCIP * scip )

gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored

Returns: array of feasible primal solutions

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_SOL* SCIPgetBestSol ( SCIP * scip )

gets best feasible primal solution found so far if the problem is transformed; in case the problem is in SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate store is empty;

Returns: best feasible primal solution so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintBestSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs best feasible primal solution found so far to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIPprintBestTransSol	(	SCIP *	scip,
		FILE *	file,
		SCIP_Bool	printzeros
	)

outputs best feasible primal solution found so far in transformed variables to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
printzeros	should variables set to zero be printed?

SCIP_RETCODE SCIProundSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	success
	)

try to round given solution

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
sol	primal solution
success	pointer to store whether rounding was successful

SCIP_RETCODE SCIPretransformSol	(	SCIP *	scip,
		SCIP_SOL *	sol
	)

retransforms solution to original problem space

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal CIP solution

SCIP_RETCODE SCIPreadSol	(	SCIP *	scip,
		const char *	filename
	)

reads a given solution file, problem has to be transformed in advance

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
filename	name of the input file

SCIP_RETCODE SCIPaddSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	stored
	)

adds feasible primal solution to solution storage by copying it

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	primal CIP solution
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPaddSolFree	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_Bool *	stored
	)

adds primal solution to solution storage, frees the solution afterwards

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	pointer to primal CIP solution; is cleared in function call
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPaddCurrentSol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_Bool *	stored
	)

adds current LP/pseudo solution to solution storage

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
heur	heuristic that found the solution
stored	stores whether given solution was good enough to keep

SCIP_RETCODE SCIPtrySol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks solution for feasibility; if possible, adds it to storage by copying

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	primal CIP solution
printreason	should all reasons of violations be printed?
checkbounds	should the bounds of the variables be checked?
checkintegrality	has integrality to be checked?
checklprows	have current LP rows (both local and global) to be checked?
stored	stores whether given solution was feasible and good enough to keep

SCIP_RETCODE SCIPtrySolFree	(	SCIP *	scip,
		SCIP_SOL **	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks primal solution; if feasible, adds it to storage; solution is freed afterwards

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: Do not call during propagation, use heur_trysol instead.

Parameters

scip	SCIP data structure
sol	pointer to primal CIP solution; is cleared in function call
printreason	should all reasons of violations be printed?
checkbounds	should the bounds of the variables be checked?
checkintegrality	has integrality to be checked?
checklprows	have current LP rows (both local and global) to be checked?
stored	stores whether solution was feasible and good enough to keep

SCIP_RETCODE SCIPtryCurrentSol	(	SCIP *	scip,
		SCIP_HEUR *	heur,
		SCIP_Bool	printreason,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	stored
	)

checks current LP/pseudo solution for feasibility; if possible, adds it to storage

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
heur	heuristic that found the solution
printreason	should all reasons of violations be printed?
checkintegrality	has integrality to be checked?
checklprows	have current LP rows (both local and global) to be checked?
stored	stores whether given solution was feasible and good enough to keep

SCIP_RETCODE SCIPcheckSol	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool	printreason,
		SCIP_Bool	checkbounds,
		SCIP_Bool	checkintegrality,
		SCIP_Bool	checklprows,
		SCIP_Bool *	feasible
	)

checks solution for feasibility without adding it to the solution store

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal CIP solution
printreason	should all reasons of violations be printed?
checkbounds	should the bounds of the variables be checked?
checkintegrality	has integrality to be checked?
checklprows	have current LP rows (both local and global) to be checked?
feasible	stores whether given solution is feasible

SCIP_RETCODE SCIPcheckSolOrig	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_Bool *	feasible,
		SCIP_Bool	printreason,
		SCIP_Bool	completely
	)

checks solution for feasibility in original problem without adding it to the solution store; this method is used to double check a solution in order to validate the presolving process

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
sol	primal CIP solution
feasible	stores whether given solution is feasible
printreason	should the reason for the violation be printed?
completely	should all violations be checked?

SCIP_Bool SCIPhasPrimalRay ( SCIP * scip )

return whether a primal ray is stored that proves unboundedness of the LP relaxation

Returns: return whether a primal ray is stored that proves unboundedness of the LP relaxation

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPrimalRayVal	(	SCIP *	scip,
		SCIP_VAR *	var
	)

gets value of given variable in primal ray causing unboundedness of the LP relaxation; should only be called if such a ray is stored (check with SCIPhasPrimalRay())

Returns: value of given variable in primal ray causing unboundedness of the LP relaxation

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
var	variable to get value for

SCIP_RETCODE SCIPcatchEvent	(	SCIP *	scip,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

catches a global (not variable or row dependent) event

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropEvent	(	SCIP *	scip,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

drops a global event (stops to track event)

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchEvent(), or -1

SCIP_RETCODE SCIPcatchVarEvent	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

catches an objective value or domain change event on the given transformed variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	transformed variable to catch event for
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropVarEvent	(	SCIP *	scip,
		SCIP_VAR *	var,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

drops an objective value or domain change event (stops to track event) on the given transformed variable

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
var	transformed variable to drop event for
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchVarEvent(), or -1

SCIP_RETCODE SCIPcatchRowEvent	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int *	filterpos
	)

catches a row coefficient, constant, or side change event on the given row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
row	linear row to catch event for
eventtype	event type mask to select events to catch
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	pointer to store position of event filter entry, or NULL

SCIP_RETCODE SCIPdropRowEvent	(	SCIP *	scip,
		SCIP_ROW *	row,
		SCIP_EVENTTYPE	eventtype,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_EVENTDATA *	eventdata,
		int	filterpos
	)

drops a row coefficient, constant, or side change event (stops to track event) on the given row

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure
row	linear row to drop event for
eventtype	event type mask of dropped event
eventhdlr	event handler to process events with
eventdata	event data to pass to the event handler when processing this event
filterpos	position of event filter entry returned by SCIPcatchVarEvent(), or -1

SCIP_NODE* SCIPgetCurrentNode ( SCIP * scip )

gets current node in the tree

Returns: the current node of the search tree

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetRootNode ( SCIP * scip )

gets the root node of the tree

Returns: the root node of the search tree

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Bool SCIPinRepropagation ( SCIP * scip )

returns whether the current node is already solved and only propagated again

Returns: TRUE is returned if SCIP performance repropagation, otherwise FALSE.

Precondition

This method can be called if scip is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetChildren	(	SCIP *	scip,
		SCIP_NODE ***	children,
		int *	nchildren
	)

gets children of focus node along with the number of children

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
children	pointer to store children array, or NULL if not needed
nchildren	pointer to store number of children, or NULL if not needed

int SCIPgetNChildren ( SCIP * scip )

gets number of children of focus node

Returns: number of children of the focus node

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetSiblings	(	SCIP *	scip,
		SCIP_NODE ***	siblings,
		int *	nsiblings
	)

gets siblings of focus node along with the number of siblings

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
siblings	pointer to store siblings array, or NULL if not needed
nsiblings	pointer to store number of siblings, or NULL if not needed

int SCIPgetNSiblings ( SCIP * scip )

gets number of siblings of focus node

Returns: the number of siblings of focus node

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetLeaves	(	SCIP *	scip,
		SCIP_NODE ***	leaves,
		int *	nleaves
	)

gets leaves of the tree along with the number of leaves

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
leaves	pointer to store leaves array, or NULL if not needed
nleaves	pointer to store number of leaves, or NULL if not needed

int SCIPgetNLeaves ( SCIP * scip )

gets number of leaves in the tree

Returns: the number of leaves in the tree

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetPrioChild ( SCIP * scip )

gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule

Returns: the best child of the focus node w.r.t. the node selection priority assigned by the branching rule

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetPrioSibling ( SCIP * scip )

gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule

Returns: the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestChild ( SCIP * scip )

gets the best child of the focus node w.r.t. the node selection strategy

Returns: the best child of the focus node w.r.t. the node selection strategy

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestSibling ( SCIP * scip )

gets the best sibling of the focus node w.r.t. the node selection strategy

Returns: the best sibling of the focus node w.r.t. the node selection strategy

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestLeaf ( SCIP * scip )

gets the best leaf from the node queue w.r.t. the node selection strategy

Returns: the best leaf from the node queue w.r.t. the node selection strategy

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestNode ( SCIP * scip )

gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy

Returns: the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_NODE* SCIPgetBestboundNode ( SCIP * scip )

gets the node with smallest lower bound from the tree (child, sibling, or leaf)

Returns: the node with smallest lower bound from the tree (child, sibling, or leaf)

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPgetOpenNodesData	(	SCIP *	scip,
		SCIP_NODE ***	leaves,
		SCIP_NODE ***	children,
		SCIP_NODE ***	siblings,
		int *	nleaves,
		int *	nchildren,
		int *	nsiblings
	)

access to all data of open nodes (leaves, children, and siblings)

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
leaves	pointer to store the leaves, or NULL if not needed
children	pointer to store the children, or NULL if not needed
siblings	pointer to store the siblings, or NULL if not needed
nleaves	pointer to store the number of leaves, or NULL
nchildren	pointer to store the number of children, or NULL
nsiblings	pointer to store the number of siblings, or NULL

SCIP_RETCODE SCIPcutoffNode	(	SCIP *	scip,
		SCIP_NODE *	node
	)

cuts off node and whole sub tree from branch and bound tree

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node that should be cut off

SCIP_RETCODE SCIPrepropagateNode	(	SCIP *	scip,
		SCIP_NODE *	node
	)

marks the given node to be propagated again the next time a node of its subtree is processed

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node that should be propagated again

int SCIPgetCutoffdepth ( SCIP * scip )

returns depth of first node in active path that is marked being cutoff

Returns: depth of first node in active path that is marked being cutoff

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetRepropdepth ( SCIP * scip )

returns depth of first node in active path that has to be propagated again

Returns: depth of first node in active path that has to be propagated again

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintNodeRootPath	(	SCIP *	scip,
		SCIP_NODE *	node,
		FILE *	file
	)

prints all branching decisions on variables from the root to the given node

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if scip is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
node	node data
file	output file (or NULL for standard output)

int SCIPgetNRuns ( SCIP * scip )

gets number of branch and bound runs performed, including the current run

Returns: the number of branch and bound runs performed, including the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodes ( SCIP * scip )

gets number of processed nodes in current run, including the focus node

Returns: the number of processed nodes in current run, including the focus node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNTotalNodes ( SCIP * scip )

gets total number of processed nodes in all runs, including the focus node

Returns: the total number of processed nodes in all runs, including the focus node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNNodesLeft ( SCIP * scip )

gets number of nodes left in the tree (children + siblings + leaves)

Returns: the number of nodes left in the tree (children + siblings + leaves)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLPs ( SCIP * scip )

gets total number of LPs solved so far

Returns: the total number of LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLPIterations ( SCIP * scip )

gets total number of iterations used so far in primal and dual simplex and barrier algorithm

Returns: the total number of iterations used so far in primal and dual simplex and barrier algorithm

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootLPIterations ( SCIP * scip )

gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node

Returns: the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootFirstLPIterations ( SCIP * scip )

gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root node

Returns: the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalLPs ( SCIP * scip )

gets total number of primal LPs solved so far

Returns: the total number of primal LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalLPIterations ( SCIP * scip )

gets total number of iterations used so far in primal simplex

Returns: total number of iterations used so far in primal simplex

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualLPs ( SCIP * scip )

gets total number of dual LPs solved so far

Returns: the total number of dual LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualLPIterations ( SCIP * scip )

gets total number of iterations used so far in dual simplex

Returns: the total number of iterations used so far in dual simplex

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBarrierLPs ( SCIP * scip )

gets total number of barrier LPs solved so far

Returns: the total number of barrier LPs solved so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBarrierLPIterations ( SCIP * scip )

gets total number of iterations used so far in barrier algorithm

Returns: the total number of iterations used so far in barrier algorithm

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNResolveLPs ( SCIP * scip )

gets total number of LPs solved so far that were resolved from an advanced start basis

Returns: the total number of LPs solved so far that were resolved from an advanced start basis

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNResolveLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis was available

Returns: the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis was available

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalResolveLPs ( SCIP * scip )

gets total number of primal LPs solved so far that were resolved from an advanced start basis

Returns: the total number of primal LPs solved so far that were resolved from an advanced start basis

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNPrimalResolveLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis was available

Returns: the total number of simplex iterations used so far in primal simplex calls where an advanced start basis was available

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualResolveLPs ( SCIP * scip )

gets total number of dual LPs solved so far that were resolved from an advanced start basis

Returns: the total number of dual LPs solved so far that were resolved from an advanced start basis

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDualResolveLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis was available

Returns: the total number of simplex iterations used so far in dual simplex calls where an advanced start basis was available

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeLPs ( SCIP * scip )

gets total number of LPs solved so far for node relaxations

Returns: the total number of LPs solved so far for node relaxations

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far for node relaxations

Returns: the total number of simplex iterations used so far for node relaxations

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeInitLPs ( SCIP * scip )

gets total number of LPs solved so far for initial LP in node relaxations

Returns: the total number of LPs solved so far for initial LP in node relaxations

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNNodeInitLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far for initial LP in node relaxations

Returns: the total number of simplex iterations used so far for initial LP in node relaxations

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDivingLPs ( SCIP * scip )

gets total number of LPs solved so far during diving and probing

Returns: total number of LPs solved so far during diving and probing

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNDivingLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far during diving and probing

Returns: the total number of simplex iterations used so far during diving and probing

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNStrongbranchs ( SCIP * scip )

gets total number of times, strong branching was called (each call represents solving two LPs)

Returns: the total number of times, strong branching was called (each call represents solving two LPs)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNStrongbranchLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far in strong branching

Returns: the total number of simplex iterations used so far in strong branching

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootStrongbranchs ( SCIP * scip )

gets total number of times, strong branching was called at the root node (each call represents solving two LPs)

Returns: the total number of times, strong branching was called at the root node (each call represents solving two LPs)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNRootStrongbranchLPIterations ( SCIP * scip )

gets total number of simplex iterations used so far in strong branching at the root node

Returns: the total number of simplex iterations used so far in strong branching at the root node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNPriceRounds ( SCIP * scip )

gets number of pricing rounds performed so far at the current node

Returns: the number of pricing rounds performed so far at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNPricevars ( SCIP * scip )

get current number of variables in the pricing store

Returns: the current number of variables in the pricing store

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNPricevarsFound ( SCIP * scip )

get total number of pricing variables found so far

Returns: the total number of pricing variables found so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNPricevarsApplied ( SCIP * scip )

get total number of pricing variables applied to the LPs

Returns: the total number of pricing variables applied to the LPs

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNSepaRounds ( SCIP * scip )

gets number of separation rounds performed so far at the current node

Returns: the number of separation rounds performed so far at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure

int SCIPgetNCutsFound ( SCIP * scip )

get total number of cuts found so far

Returns: the total number of cuts found so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNCutsFoundRound ( SCIP * scip )

get number of cuts found so far in current separation round

Returns: the number of cuts found so far in current separation round

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNCutsApplied ( SCIP * scip )

get total number of cuts applied to the LPs

Returns: the total number of cuts applied to the LPs

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNConflictConssFound ( SCIP * scip )

get total number of constraints found in conflict analysis (conflict and reconvergence constraints)

Returns: the total number of constraints found in conflict analysis (conflict and reconvergence constraints)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNConflictConssFoundNode ( SCIP * scip )

get number of conflict constraints found so far at the current node

Returns: the number of conflict constraints found so far at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNConflictConssApplied ( SCIP * scip )

get total number of conflict constraints added to the problem

Returns: the total number of conflict constraints added to the problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetDepth ( SCIP * scip )

gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node, such that the depth includes the probing path

Returns: the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node, such that the depth includes the probing path

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetFocusDepth ( SCIP * scip )

gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the branching tree, excluding the nodes of the probing path

Returns: the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the branching tree, excluding the nodes of the probing path

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetMaxDepth ( SCIP * scip )

gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)

Returns: the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetMaxTotalDepth ( SCIP * scip )

gets maximal depth of all processed nodes over all branch and bound runs

Returns: the maximal depth of all processed nodes over all branch and bound runs

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBacktracks ( SCIP * scip )

gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue

Returns: the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetPlungeDepth ( SCIP * scip )

gets current plunging depth (successive times, a child was selected as next node)

Returns: the current plunging depth (successive times, a child was selected as next node)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNActiveConss ( SCIP * scip )

gets total number of active constraints at the current node

Returns: the total number of active constraints at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

int SCIPgetNEnabledConss ( SCIP * scip )

gets total number of enabled constraints at the current node

Returns: the total number of enabled constraints at the current node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgDualbound ( SCIP * scip )

gets average dual bound of all unprocessed nodes for original problem

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgLowerbound ( SCIP * scip )

gets average lower (dual) bound of all unprocessed nodes in transformed problem

Returns: the average lower (dual) bound of all unprocessed nodes in transformed problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetDualbound ( SCIP * scip )

gets global dual bound

Returns: the global dual bound

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLowerbound ( SCIP * scip )

gets global lower (dual) bound in transformed problem

Returns: the global lower (dual) bound in transformed problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetDualboundRoot ( SCIP * scip )

gets dual bound of the root node for the original problem

Returns: the dual bound of the root node for the original problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetLowerboundRoot ( SCIP * scip )

gets lower (dual) bound in transformed problem of the root node

Returns: the lower (dual) bound in transformed problem of the root node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPDualboundRoot ( SCIP * scip )

gets dual bound for the original problem obtained by the first LP solve at the root node

Returns: the dual bound for the original problem of the first LP solve at the root node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPLowerboundRoot ( SCIP * scip )

gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node

Returns: the lower (dual) bound in transformed problem obtained by first LP solve at the root node

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPrimalbound ( SCIP * scip )

gets global primal bound (objective value of best solution or user objective limit) for the original problem

Returns: the global primal bound (objective value of best solution or user objective limit) for the original problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetUpperbound ( SCIP * scip )

gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)

Returns: the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetCutoffbound ( SCIP * scip )

gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the objective value is always integral, the cutoff bound is (nearly) one less than the upper bound; additionally, due to objective function domain propagation, the cutoff bound can be further reduced

Returns: global cutoff bound in transformed problem

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPupdateCutoffbound	(	SCIP *	scip,
		SCIP_Real	cutoffbound
	)

updates the cutoff bound

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Note: the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())

Parameters

scip	SCIP data structure
cutoffbound	new cutoff bound

SCIP_Bool SCIPisPrimalboundSol ( SCIP * scip )

returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound was set from the user as objective limit

Returns: TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetGap ( SCIP * scip )

Returns: the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign, or infinity, if they have opposite sign

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetTransGap ( SCIP * scip )

Returns: current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds have same sign, or infinity, if they have opposite sign

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNSolsFound ( SCIP * scip )

gets number of feasible primal solutions found so far

Returns: the number of feasible primal solutions found so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNLimSolsFound ( SCIP * scip )

gets number of feasible primal solutions respecting the objective limit found so far

Returns: the number of feasible primal solutions respecting the objective limit found so far

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetNBestSolsFound ( SCIP * scip )

gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found

Returns: the number of feasible primal solutions found so far, that improved the primal bound at the time they were found

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgPseudocost	(	SCIP *	scip,
		SCIP_Real	solvaldelta
	)

gets the average pseudo cost value for the given direction over all variables

Returns: the average pseudo cost value for the given direction over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetAvgPseudocostCurrentRun	(	SCIP *	scip,
		SCIP_Real	solvaldelta
	)

gets the average pseudo cost value for the given direction over all variables, only using the pseudo cost information of the current run

Returns: the average pseudo cost value for the given direction over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
solvaldelta	difference of variable's new LP value - old LP value

SCIP_Real SCIPgetAvgPseudocostCount	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

gets the average number of pseudo cost updates for the given direction over all variables

Returns: the average number of pseudo cost updates for the given direction over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgPseudocostCountCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

gets the average number of pseudo cost updates for the given direction over all variables, only using the pseudo cost information of the current run

Returns: the average number of pseudo cost updates for the given direction over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgPseudocostScore ( SCIP * scip )

gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5

Returns: the average pseudo cost score value over all variables, assuming a fractionality of 0.5

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun ( SCIP * scip )

gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5, only using the pseudo cost information of the current run

Returns: the average pseudo cost score value over all variables, assuming a fractionality of 0.5, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictScore ( SCIP * scip )

gets the average conflict score value over all variables

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictScoreCurrentRun ( SCIP * scip )

gets the average conflict score value over all variables, only using the pseudo cost information of the current run

Returns: the average conflict score value over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictlengthScore ( SCIP * scip )

gets the average inference score value over all variables

Returns: the average inference score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun ( SCIP * scip )

gets the average conflictlength score value over all variables, only using the pseudo cost information of the current run

Returns: the average conflictlength score value over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgInferences	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching in given direction over all variables

Returns: the average number of inferences found after branching in given direction over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgInferencesCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

returns the average number of inferences found after branching in given direction over all variables, only using the pseudo cost information of the current run

Returns: the average number of inferences found after branching in given direction over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgInferenceScore ( SCIP * scip )

gets the average inference score value over all variables

Returns: the average inference score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgInferenceScoreCurrentRun ( SCIP * scip )

gets the average inference score value over all variables, only using the inference information information of the current run

Returns: the average inference score value over all variables, only using the inference information information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgCutoffs	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching in given direction over all variables

Returns: the average number of cutoffs found after branching in given direction over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgCutoffsCurrentRun	(	SCIP *	scip,
		SCIP_BRANCHDIR	dir
	)

returns the average number of cutoffs found after branching in given direction over all variables, only using the pseudo cost information of the current run

Returns: the average number of cutoffs found after branching in given direction over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
dir	branching direction (downwards, or upwards)

SCIP_Real SCIPgetAvgCutoffScore ( SCIP * scip )

gets the average cutoff score value over all variables

Returns: the average cutoff score value over all variables

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetAvgCutoffScoreCurrentRun ( SCIP * scip )

gets the average cutoff score value over all variables, only using the pseudo cost information of the current run

Returns: the average cutoff score value over all variables, only using the pseudo cost information of the current run

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPprintOrigProblem	(	SCIP *	scip,
		FILE *	file,
		const char *	extension,
		SCIP_Bool	genericnames
	)

outputs original problem to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
extension	file format (or NULL for default CIP format)
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPprintTransProblem	(	SCIP *	scip,
		FILE *	file,
		const char *	extension,
		SCIP_Bool	genericnames
	)

outputs transformed problem of the current node to file stream

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
extension	file format (or NULL for default CIP format)
genericnames	using generic variable and constraint names?

SCIP_RETCODE SCIPprintStatistics	(	SCIP *	scip,
		FILE *	file
	)

outputs solving statistics

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Note: If limits have been changed between the solution and the call to this function, the status is recomputed and thus may to correspond to the original status.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPprintBranchingStatistics	(	SCIP *	scip,
		FILE *	file
	)

outputs history statistics about branchings on variables

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)

SCIP_RETCODE SCIPprintDisplayLine	(	SCIP *	scip,
		FILE *	file,
		SCIP_VERBLEVEL	verblevel,
		SCIP_Bool	endline
	)

outputs node information display line

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

SCIP_STAGE_SOLVING

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
verblevel	minimal verbosity level to actually display the information line
endline	should the line be terminated with a newline symbol?

int SCIPgetNImplications ( SCIP * scip )

gets total number of implications between variables that are stored in the implication graph

Returns: the total number of implications between variables that are stored in the implication graph

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPwriteImplicationConflictGraph	(	SCIP *	scip,
		const char *	filename
	)

stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

Parameters

scip	SCIP data structure
filename	file name, or NULL for stdout

SCIP_Real SCIPgetTimeOfDay ( SCIP * scip )

gets current time of day in seconds (standard time zone)

Returns: the current time of day in seconds (standard time zone).

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock using the default clock type

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPcreateCPUClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock counting the CPU user seconds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPcreateWallClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

creates a clock counting the wall clock seconds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPfreeClock	(	SCIP *	scip,
		SCIP_CLOCK **	clck
	)

frees a clock

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	pointer to clock timer

SCIP_RETCODE SCIPresetClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

resets the time measurement of a clock to zero and completely stops the clock

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPstartClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

starts the time measurement of a clock

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPstopClock	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

stops the time measurement of a clock

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPstartSolvingTime ( SCIP * scip )

starts the current solving time

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPstopSolvingTime ( SCIP * scip )

stops the current solving time in seconds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetClockTime	(	SCIP *	scip,
		SCIP_CLOCK *	clck
	)

gets the measured time of a clock in seconds

Returns: the measured time of a clock in seconds.

Parameters

scip	SCIP data structure
clck	clock timer

SCIP_RETCODE SCIPsetClockTime	(	SCIP *	scip,
		SCIP_CLOCK *	clck,
		SCIP_Real	sec
	)

sets the measured time of a clock to the given value in seconds

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
clck	clock timer
sec	time in seconds to set the clock's timer to

SCIP_Real SCIPgetTotalTime ( SCIP * scip )

gets the current total SCIP time in seconds

Returns: the current total SCIP time in seconds.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetSolvingTime ( SCIP * scip )

gets the current solving time in seconds

Returns: the current solving time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetReadingTime ( SCIP * scip )

gets the current reading time in seconds

Returns: the current reading time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetPresolvingTime ( SCIP * scip )

gets the current presolving time in seconds

Returns: the current presolving time in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetFirstLPTime ( SCIP * scip )

gets the time need to solve the first LP in the root node

Returns: the solving time for the first LP in the root node in seconds.

Precondition

This method can be called if SCIP is in one of the following stages:

See SCIP_STAGE for a complete list of all possible solving stages.

Parameters

scip	SCIP data structure

SCIP_Real SCIPepsilon ( SCIP * scip )

returns value treated as zero

Returns: value treated as zero

Parameters

scip	SCIP data structure

SCIP_Real SCIPsumepsilon ( SCIP * scip )

returns value treated as zero for sums of floating point values

Returns: value treated as zero for sums of floating point values

Parameters

scip	SCIP data structure

SCIP_Real SCIPfeastol ( SCIP * scip )

returns feasibility tolerance for constraints

Returns: feasibility tolerance for constraints

Parameters

scip	SCIP data structure

SCIP_Real SCIPlpfeastol ( SCIP * scip )

returns primal feasibility tolerance of LP solver

Returns: primal feasibility tolerance of LP solver

Parameters

scip	SCIP data structure

SCIP_Real SCIPdualfeastol ( SCIP * scip )

returns feasibility tolerance for reduced costs

Returns: feasibility tolerance for reduced costs

Parameters

scip	SCIP data structure

SCIP_Real SCIPbarrierconvtol ( SCIP * scip )

returns convergence tolerance used in barrier algorithm

Returns: convergence tolerance used in barrier algorithm

Parameters

scip	SCIP data structure

SCIP_Real SCIPcutoffbounddelta ( SCIP * scip )

return the cutoff bound delta

Returns: cutoff bound data

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPchgFeastol	(	SCIP *	scip,
		SCIP_Real	feastol
	)

sets the feasibility tolerance for constraints

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
feastol	new feasibility tolerance for constraints

SCIP_RETCODE SCIPchgLpfeastol	(	SCIP *	scip,
		SCIP_Real	lpfeastol,
		SCIP_Bool	printnewvalue
	)

sets the primal feasibility tolerance of LP solver

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
lpfeastol	new primal feasibility tolerance of LP solver
printnewvalue	should "numerics/lpfeastol = ..." be printed?

SCIP_RETCODE SCIPchgDualfeastol	(	SCIP *	scip,
		SCIP_Real	dualfeastol
	)

sets the feasibility tolerance for reduced costs

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
dualfeastol	new feasibility tolerance for reduced costs

SCIP_RETCODE SCIPchgBarrierconvtol	(	SCIP *	scip,
		SCIP_Real	barrierconvtol
	)

sets the convergence tolerance used in barrier algorithm

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
barrierconvtol	new convergence tolerance used in barrier algorithm

void SCIPmarkLimitChanged ( SCIP * scip )

marks that some limit parameter was changed

Parameters

scip	SCIP data structure

SCIP_Real SCIPinfinity ( SCIP * scip )

returns value treated as infinity

Parameters

scip	SCIP data structure

SCIP_Real SCIPgetHugeValue ( SCIP * scip )

returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity computation)

Parameters

scip	SCIP data structure

SCIP_Bool SCIPisEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if values are in range of epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than epsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than epsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than epsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than epsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisInfinity	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is (positive) infinite

Parameters

scip	SCIP data structure
val	value to be compared against infinity

SCIP_Bool SCIPisHugeValue	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is huge and should be handled separately (e.g., in activity computation)

Parameters

scip	SCIP data structure
val	value to be checked whether it is huge

SCIP_Bool SCIPisZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range epsilon of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is integral within epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisScalingIntegral	(	SCIP *	scip,
		SCIP_Real	val,
		SCIP_Real	scalar
	)

checks whether the product val * scalar is integral in epsilon scaled by scalar

Parameters

scip	SCIP data structure
val	unscaled value to check for scaled integrality
scalar	value to scale val with for checking for integrality

SCIP_Bool SCIPisFracIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if given fractional part is smaller than epsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfloor	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value + epsilon down to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPceil	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - epsilon up to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPround	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value to the nearest integer with epsilon tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfrac	(	SCIP *	scip,
		SCIP_Real	val
	)

returns fractional part of value, i.e. x - floor(x) in epsilon tolerance

Parameters

scip	SCIP data structure
val	value to return fractional part for

SCIP_Bool SCIPisSumEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if values are in range of sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than sumepsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than sumepsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is (more than sumepsilon) greater than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if val1 is not (more than sumepsilon) lower than val2

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range sumepsilon of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisSumPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than sumepsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisSumNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -sumepsilon

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference val1 and val2 is lower than feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than feasibility tolerance

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than feastol

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -feastol

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisFeasZero	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is in range feasibility tolerance of 0.0

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasPositive	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is greater than feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasNegative	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is lower than -feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if value is integral within the LP feasibility bounds

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisFeasFracIntegral	(	SCIP *	scip,
		SCIP_Real	val
	)

checks, if given fractional part is smaller than feastol

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasFloor	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value + feasibility tolerance down to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasCeil	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - feasibility tolerance up to the next integer

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasRound	(	SCIP *	scip,
		SCIP_Real	val
	)

rounds value - feasibility tolerance up to the next integer in feasibility tolerance

Parameters

scip	SCIP data structure
val	value to process

SCIP_Real SCIPfeasFrac	(	SCIP *	scip,
		SCIP_Real	val
	)

returns fractional part of value, i.e. x - floor(x)

Parameters

scip	SCIP data structure
val	value to process

SCIP_Bool SCIPisLbBetter	(	SCIP *	scip,
		SCIP_Real	newlb,
		SCIP_Real	oldlb,
		SCIP_Real	oldub
	)

checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one

Parameters

scip	SCIP data structure
newlb	new lower bound
oldlb	old lower bound
oldub	old upper bound

SCIP_Bool SCIPisUbBetter	(	SCIP *	scip,
		SCIP_Real	newub,
		SCIP_Real	oldlb,
		SCIP_Real	oldub
	)

checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one

Parameters

scip	SCIP data structure
newub	new upper bound
oldlb	old lower bound
oldub	old upper bound

SCIP_Bool SCIPisRelEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is lower than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisRelGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -epsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelEQ	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of values is in range of sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelLT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is lower than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelLE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not greater than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelGT	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is greater than sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisSumRelGE	(	SCIP *	scip,
		SCIP_Real	val1,
		SCIP_Real	val2
	)

checks, if relative difference of val1 and val2 is not lower than -sumepsilon

Parameters

scip	SCIP data structure
val1	first value to be compared
val2	second value to be compared

SCIP_Bool SCIPisUpdateUnreliable	(	SCIP *	scip,
		SCIP_Real	newvalue,
		SCIP_Real	oldvalue
	)

Checks, if an iteratively updated value is reliable or should be recomputed from scratch. This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high absolute value during the optimization process which is later reduced significantly. In this case, the last digits were canceled out when increasing the value and are random after decreasing it. We do not consider the cancellations which can occur during increasing the absolute value because they just cannot be expressed using fixed precision floating point arithmetic, anymore. In order to get more reliable values, the idea is to always store the last reliable value, where increasing the absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared against the last reliable one with this method, checking whether it was decreased by a factor of at least "lp/recompfac" and should be recomputed.

Parameters

scip	SCIP data structure
newvalue	new value after update
oldvalue	old value, i.e., last reliable value

void SCIPprintReal	(	SCIP *	scip,
		FILE *	file,
		SCIP_Real	val,
		int	width,
		int	precision
	)

outputs a real number, or "+infinity", or "-infinity" to a file

Parameters

scip	SCIP data structure
file	output file (or NULL for standard output)
val	value to print
width	width of the field
precision	number of significant digits printed

BMS_BLKMEM* SCIPblkmem ( SCIP * scip )

returns block memory to use at the current time

Returns: the block memory to use at the current time.

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetMemUsed ( SCIP * scip )

returns the total number of bytes used in block memory

Returns: the total number of bytes used in block memory.

Parameters

scip	SCIP data structure

SCIP_Longint SCIPgetMemExternEstim ( SCIP * scip )

returns the estimated number of bytes used by external software, e.g., the LP solver

Returns: the estimated number of bytes used by external software, e.g., the LP solver.

Parameters

scip	SCIP data structure

int SCIPcalcMemGrowSize	(	SCIP *	scip,
		int	num
	)

calculate memory size for dynamically allocated arrays

Returns: the memory size for dynamically allocated arrays.

Parameters

scip	SCIP data structure
num	minimum number of entries to store

SCIP_RETCODE SCIPensureBlockMemoryArray_call	(	SCIP *	scip,
		void **	arrayptr,
		size_t	elemsize,
		int *	arraysize,
		int	minsize
	)

extends a dynamically allocated block memory array to be able to store at least the given number of elements; use SCIPensureBlockMemoryArray() define to call this method!

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
arrayptr	pointer to dynamically sized array
elemsize	size in bytes of each element in array
arraysize	pointer to current array size
minsize	required minimal array size

SCIP_RETCODE SCIPallocBufferSize	(	SCIP *	scip,
		void **	ptr,
		int	size
	)

gets a memory buffer with at least the given size

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptr	pointer to store the buffer
size	required size in bytes of buffer

SCIP_RETCODE SCIPduplicateBufferSize	(	SCIP *	scip,
		void **	ptr,
		const void *	source,
		int	size
	)

allocates a memory buffer with at least the given size and copies the given memory into the buffer

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptr	pointer to store the buffer
source	memory block to copy into the buffer
size	required size in bytes of buffer

SCIP_RETCODE SCIPreallocBufferSize	(	SCIP *	scip,
		void **	ptr,
		int	size
	)

reallocates a memory buffer to at least the given size

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptr	pointer to the buffer
size	required size in bytes of buffer

void SCIPfreeBufferSize	(	SCIP *	scip,
		void **	ptr,
		int	dummysize
	)

frees a memory buffer

Parameters

scip	SCIP data structure
ptr	pointer to the buffer
dummysize	used to get a safer define for SCIPfreeBuffer() and SCIPfreeBufferArray()

void SCIPprintMemoryDiagnostic ( SCIP * scip )

prints output about used memory

Parameters

scip	SCIP data structure

SCIP_RETCODE SCIPcreateRealarray	(	SCIP *	scip,
		SCIP_REALARRAY **	realarray
	)

creates a dynamic array of real values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	pointer to store the real array

SCIP_RETCODE SCIPfreeRealarray	(	SCIP *	scip,
		SCIP_REALARRAY **	realarray
	)

frees a dynamic array of real values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	pointer to the real array

SCIP_RETCODE SCIPextendRealarray	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	minidx,
		int	maxidx
	)

extends dynamic array to be able to store indices from minidx to maxidx

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearRealarray	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

clears a dynamic real array

Returns: clears a dynamic real array

Parameters

scip	SCIP data structure
realarray	dynamic real array

SCIP_Real SCIPgetRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx
	)

gets value of entry in dynamic array

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to get value for

SCIP_RETCODE SCIPsetRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx,
		SCIP_Real	val
	)

sets value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to set value for
val	value to set array index to

SCIP_RETCODE SCIPincRealarrayVal	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray,
		int	idx,
		SCIP_Real	incval
	)

increases value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
realarray	dynamic real array
idx	array index to increase value for
incval	value to increase array index

int SCIPgetRealarrayMinIdx	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

returns the minimal index of all stored non-zero elements

Returns: the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
realarray	dynamic real array

int SCIPgetRealarrayMaxIdx	(	SCIP *	scip,
		SCIP_REALARRAY *	realarray
	)

returns the maximal index of all stored non-zero elements

Returns: the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
realarray	dynamic real array

SCIP_RETCODE SCIPcreateIntarray	(	SCIP *	scip,
		SCIP_INTARRAY **	intarray
	)

creates a dynamic array of int values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	pointer to store the int array

SCIP_RETCODE SCIPfreeIntarray	(	SCIP *	scip,
		SCIP_INTARRAY **	intarray
	)

frees a dynamic array of int values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	pointer to the int array

SCIP_RETCODE SCIPextendIntarray	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	minidx,
		int	maxidx
	)

extends dynamic array to be able to store indices from minidx to maxidx

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearIntarray	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

clears a dynamic int array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array

int SCIPgetIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx
	)

gets value of entry in dynamic array

Returns: value of entry in dynamic array

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to get value for

SCIP_RETCODE SCIPsetIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx,
		int	val
	)

sets value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to set value for
val	value to set array index to

SCIP_RETCODE SCIPincIntarrayVal	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray,
		int	idx,
		int	incval
	)

increases value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
intarray	dynamic int array
idx	array index to increase value for
incval	value to increase array index

int SCIPgetIntarrayMinIdx	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

returns the minimal index of all stored non-zero elements

Returns: the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
intarray	dynamic int array

int SCIPgetIntarrayMaxIdx	(	SCIP *	scip,
		SCIP_INTARRAY *	intarray
	)

returns the maximal index of all stored non-zero elements

Returns: the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
intarray	dynamic int array

SCIP_RETCODE SCIPcreateBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY **	boolarray
	)

creates a dynamic array of bool values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	pointer to store the bool array

SCIP_RETCODE SCIPfreeBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY **	boolarray
	)

frees a dynamic array of bool values

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	pointer to the bool array

SCIP_RETCODE SCIPextendBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	minidx,
		int	maxidx
	)

extends dynamic array to be able to store indices from minidx to maxidx

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearBoolarray	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

clears a dynamic bool array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

SCIP_Bool SCIPgetBoolarrayVal	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	idx
	)

gets value of entry in dynamic array

Returns: value of entry in dynamic array at position idx

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
idx	array index to get value for

SCIP_RETCODE SCIPsetBoolarrayVal	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray,
		int	idx,
		SCIP_Bool	val
	)

sets value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
boolarray	dynamic bool array
idx	array index to set value for
val	value to set array index to

int SCIPgetBoolarrayMinIdx	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

returns the minimal index of all stored non-zero elements

Returns: the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

int SCIPgetBoolarrayMaxIdx	(	SCIP *	scip,
		SCIP_BOOLARRAY *	boolarray
	)

returns the maximal index of all stored non-zero elements

Returns: the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
boolarray	dynamic bool array

SCIP_RETCODE SCIPcreatePtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY **	ptrarray
	)

creates a dynamic array of pointers

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	pointer to store the int array

SCIP_RETCODE SCIPfreePtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY **	ptrarray
	)

frees a dynamic array of pointers

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	pointer to the int array

SCIP_RETCODE SCIPextendPtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	minidx,
		int	maxidx
	)

extends dynamic array to be able to store indices from minidx to maxidx

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
minidx	smallest index to allocate storage for
maxidx	largest index to allocate storage for

SCIP_RETCODE SCIPclearPtrarray	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

clears a dynamic pointer array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array

void* SCIPgetPtrarrayVal	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	idx
	)

gets value of entry in dynamic array

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
idx	array index to get value for

SCIP_RETCODE SCIPsetPtrarrayVal	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray,
		int	idx,
		void *	val
	)

sets value of entry in dynamic array

Returns: SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See SCIP_RETCODE for a complete list of error codes.

Parameters

scip	SCIP data structure
ptrarray	dynamic int array
idx	array index to set value for
val	value to set array index to

int SCIPgetPtrarrayMinIdx	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

returns the minimal index of all stored non-zero elements

Returns: the minimal index of all stored non-zero elements

Parameters

scip	SCIP data structure
ptrarray	dynamic ptr array

int SCIPgetPtrarrayMaxIdx	(	SCIP *	scip,
		SCIP_PTRARRAY *	ptrarray
	)

returns the maximal index of all stored non-zero elements

Returns: the maximal index of all stored non-zero elements

Parameters

scip	SCIP data structure
ptrarray	dynamic ptr array

SCIP

Detailed Description

Functions

Memory Management

Macro Definition Documentation

Function Documentation