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

SCIP

Detailed Description

Functions

Memory Management

Macro Definition Documentation

Function Documentation