Scippy

SCIP

Solving Constraint Integer Programs

scip.h File Reference

Detailed Description

SCIP callable library.

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

Definition in file scip.h.

#include <stdio.h>
#include "scip/def.h"
#include "blockmemshell/memory.h"
#include "scip/type_retcode.h"
#include "scip/type_result.h"
#include "scip/type_clock.h"
#include "scip/type_misc.h"
#include "scip/type_timing.h"
#include "scip/type_paramset.h"
#include "scip/type_event.h"
#include "scip/type_lp.h"
#include "scip/type_nlp.h"
#include "scip/type_var.h"
#include "scip/type_prob.h"
#include "scip/type_tree.h"
#include "scip/type_scip.h"
#include "scip/type_branch.h"
#include "scip/type_conflict.h"
#include "scip/type_cons.h"
#include "scip/type_dialog.h"
#include "scip/type_disp.h"
#include "scip/type_heur.h"
#include "scip/type_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 SCIPhasPerformedPresolve (SCIP *scip)
 
SCIP_Bool SCIPpressedCtrlC (SCIP *scip)
 
SCIP_Bool SCIPisStopped (SCIP *scip)
 
Message Output Methods
SCIP_RETCODE SCIPsetMessagehdlr (SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)
 
SCIP_MESSAGEHDLRSCIPgetMessagehdlr (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_PARAMSCIPgetParam (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_READERSCIPfindReader (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_PRICERSCIPfindPricer (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_CONSHDLRSCIPfindConshdlr (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_CONFLICTHDLRSCIPfindConflicthdlr (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_PRESOLSCIPfindPresol (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_RELAXSCIPfindRelax (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_SEPASCIPfindSepa (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_PROPSCIPfindProp (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_HEURSCIPfindHeur (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_EVENTHDLRSCIPfindEventhdlr (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_NODESELSCIPfindNodesel (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_NODESELSCIPgetNodesel (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_BRANCHRULESCIPfindBranchrule (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_DISPSCIPfindDisp (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_NLPISCIPfindNlpi (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_DIALOGSCIPgetRootDialog (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_PROBDATASCIPgetProbData (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_VARSCIPfindVar (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_CONSSCIPfindOrigCons (SCIP *scip, const char *name)
 
SCIP_CONSSCIPfindCons (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_RealSCIPgetNLPVarsLbDualsol (SCIP *scip)
 
SCIP_RealSCIPgetNLPVarsUbDualsol (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_CUTPOOLSCIPgetGlobalCutpool (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_CUTPOOLSCIPgetDelayedGlobalCutpool (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_HEURSCIPgetSolHeur (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_SOLSCIPgetBestSol (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_NODESCIPgetCurrentNode (SCIP *scip)
 
SCIP_NODESCIPgetRootNode (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_NODESCIPgetPrioChild (SCIP *scip)
 
SCIP_NODESCIPgetPrioSibling (SCIP *scip)
 
SCIP_NODESCIPgetBestChild (SCIP *scip)
 
SCIP_NODESCIPgetBestSibling (SCIP *scip)
 
SCIP_NODESCIPgetBestLeaf (SCIP *scip)
 
SCIP_NODESCIPgetBestNode (SCIP *scip)
 
SCIP_NODESCIPgetBestboundNode (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 SCIPenableOrDisableStatisticTiming (SCIP *scip)
 
SCIP_RETCODE SCIPstartSolvingTime (SCIP *scip)
 
SCIP_RETCODE SCIPstopSolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetClockTime (SCIP *scip, SCIP_CLOCK *clck)
 
SCIP_RETCODE SCIPsetClockTime (SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
 
SCIP_Real SCIPgetTotalTime (SCIP *scip)
 
SCIP_Real SCIPgetSolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetReadingTime (SCIP *scip)
 
SCIP_Real SCIPgetPresolvingTime (SCIP *scip)
 
SCIP_Real SCIPgetFirstLPTime (SCIP *scip)
 
Numerical Methods
SCIP_Real SCIPepsilon (SCIP *scip)
 
SCIP_Real SCIPsumepsilon (SCIP *scip)
 
SCIP_Real SCIPfeastol (SCIP *scip)
 
SCIP_Real SCIPlpfeastol (SCIP *scip)
 
SCIP_Real SCIPdualfeastol (SCIP *scip)
 
SCIP_Real SCIPbarrierconvtol (SCIP *scip)
 
SCIP_Real SCIPcutoffbounddelta (SCIP *scip)
 
SCIP_RETCODE SCIPchgFeastol (SCIP *scip, SCIP_Real feastol)
 
SCIP_RETCODE SCIPchgLpfeastol (SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
 
SCIP_RETCODE SCIPchgDualfeastol (SCIP *scip, SCIP_Real dualfeastol)
 
SCIP_RETCODE SCIPchgBarrierconvtol (SCIP *scip, SCIP_Real barrierconvtol)
 
void SCIPmarkLimitChanged (SCIP *scip)
 
SCIP_Real SCIPinfinity (SCIP *scip)
 
SCIP_Real SCIPgetHugeValue (SCIP *scip)
 
SCIP_Bool SCIPisEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisInfinity (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisHugeValue (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisScalingIntegral (SCIP *scip, SCIP_Real val, SCIP_Real scalar)
 
SCIP_Bool SCIPisFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPceil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPround (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisSumNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisFeasZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisFeasFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasFloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasCeil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasRound (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPfeasFrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisDualfeasZero (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasPositive (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasNegative (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisDualfeasFracIntegral (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasFloor (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasCeil (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasRound (SCIP *scip, SCIP_Real val)
 
SCIP_Real SCIPdualfeasFrac (SCIP *scip, SCIP_Real val)
 
SCIP_Bool SCIPisLbBetter (SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
 
SCIP_Bool SCIPisUbBetter (SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
 
SCIP_Bool SCIPisRelEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisRelGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelEQ (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelLT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelLE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelGT (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
SCIP_Bool SCIPisSumRelGE (SCIP *scip, SCIP_Real val1, SCIP_Real val2)
 
int SCIPconvertRealToInt (SCIP *scip, SCIP_Real real)
 
SCIP_Longint SCIPconvertRealToLongint (SCIP *scip, SCIP_Real real)
 
SCIP_Bool SCIPisUpdateUnreliable (SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
 
void SCIPprintReal (SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
 
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) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19159 of file scip.h.

#define SCIPallocMemoryArray (   scip,
  ptr,
  num 
)
Value:
( (BMSallocMemoryArray((ptr), (num)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19161 of file scip.h.

#define SCIPallocClearMemoryArray (   scip,
  ptr,
  num 
)
Value:
( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19163 of file scip.h.

#define SCIPallocMemorySize (   scip,
  ptr,
  size 
)
Value:
( (BMSallocMemorySize((ptr), (size)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19165 of file scip.h.

#define SCIPreallocMemoryArray (   scip,
  ptr,
  newnum 
)
Value:
( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19167 of file scip.h.

#define SCIPreallocMemorySize (   scip,
  ptr,
  newsize 
)
Value:
( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19169 of file scip.h.

#define SCIPduplicateMemory (   scip,
  ptr,
  source 
)
Value:
( (BMSduplicateMemory((ptr), (source)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129

Definition at line 19171 of file scip.h.

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

Definition at line 19176 of file scip.h.

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

Definition at line 19177 of file scip.h.

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

Definition at line 19179 of file scip.h.

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

Definition at line 19180 of file scip.h.

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

Definition at line 19181 of file scip.h.

#define SCIPallocBlockMemory (   scip,
  ptr 
)
Value:
( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19183 of file scip.h.

#define SCIPallocBlockMemoryArray (   scip,
  ptr,
  num 
)
Value:
( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19185 of file scip.h.

#define SCIPallocBlockMemorySize (   scip,
  ptr,
  size 
)
Value:
( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19187 of file scip.h.

#define SCIPreallocBlockMemoryArray (   scip,
  ptr,
  oldnum,
  newnum 
)
Value:
( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19189 of file scip.h.

#define SCIPreallocBlockMemorySize (   scip,
  ptr,
  oldsize,
  newsize 
)
Value:
( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19192 of file scip.h.

#define SCIPduplicateBlockMemory (   scip,
  ptr,
  source 
)
Value:
( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19195 of file scip.h.

#define SCIPduplicateBlockMemoryArray (   scip,
  ptr,
  source,
  num 
)
Value:
( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) \
#define NULL
Definition: lpi_spx.cpp:129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)

Definition at line 19198 of file scip.h.

#define SCIPensureBlockMemoryArray (   scip,
  ptr,
  arraysizeptr,
  minsize 
)
Value:
( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), \
(arraysizeptr), (minsize))) )
SCIP_RETCODE SCIPensureBlockMemoryArray_call(SCIP *scip, void **arrayptr, size_t elemsize, int *arraysize, int minsize)

Definition at line 19201 of file scip.h.

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

Definition at line 19204 of file scip.h.

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

Definition at line 19205 of file scip.h.

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

Definition at line 19206 of file scip.h.

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

Definition at line 19207 of file scip.h.

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

Definition at line 19209 of file scip.h.

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

Definition at line 19210 of file scip.h.

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

Definition at line 19213 of file scip.h.

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

Definition at line 19214 of file scip.h.

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

Definition at line 19215 of file scip.h.

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

Definition at line 19216 of file scip.h.

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

Definition at line 19217 of file scip.h.

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

Definition at line 19219 of file scip.h.

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

Definition at line 19220 of file scip.h.

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

Definition at line 19221 of file scip.h.

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

Definition at line 19222 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
scipSCIP data structure
fileoutput 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
retcodeSCIP return code causing the error
void SCIPstoreSolutionGap ( SCIP scip)

update statistical information when a new solution was found

Parameters
scipSCIP 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
scippointer 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
scippointer 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
scipSCIP 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
scipSCIP data structure
fileoutput 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
scipSCIP 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
scipSCIP data structure
fileoutput 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
scipSCIP 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
scipSCIP 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
scipSCIP data structure
SCIP_Bool SCIPhasPerformedPresolve ( SCIP scip)

returns whether SCIP has performed presolving during the last solve

Returns
Returns TRUE if presolving was performed during the last solve
Parameters
scipSCIP 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
scipSCIP 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
scipSCIP 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
scipSCIP data structure
messagehdlrmessage 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
scipSCIP data structure
void SCIPsetMessagehdlrLogfile ( SCIP scip,
const char *  filename 
)

sets the log file name for the currently installed message handler

Parameters
scipSCIP data structure
filenamename 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
scipSCIP data structure
quietshould screen messages be suppressed?
void SCIPwarningMessage ( SCIP scip,
const char *  formatstr,
  ... 
)

prints a warning message via the message handler

Parameters
scipSCIP data structure
formatstrformat 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
scipSCIP data structure
filefile stream to print into, or NULL for stdout
formatstrformat 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
scipSCIP data structure
filefile stream to print into, or NULL for stdout
formatstrformat 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
scipSCIP data structure
msgverblevelverbosity level of this message
filefile stream to print into, or NULL for stdout
formatstrformat 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
scipSCIP 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:
Note
sourcescip stage does not get changed

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

Parameters
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
copyreadersshould the file readers be copied
copypricersshould the variable pricers be copied
copyconshdlrsshould the constraint handlers be copied
copyconflicthdlrsshould the conflict handlers be copied
copypresolversshould the presolvers be copied
copyrelaxatorsshould the relaxation handler be copied
copyseparatorsshould the separators be copied
copypropagatorsshould the propagators be copied
copyheuristicsshould the heuristics be copied
copyeventhdlrsshould the event handlers be copied
copynodeselectorsshould the node selectors be copied
copybranchrulesshould the branchrules be copied
copydisplaysshould the display columns be copied
copydialogsshould the dialogs be copied
copynlpisshould the NLPIs be copied
passmessagehdlrshould the message handler be passed
validpointer 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:
Note
sourcescip stage does not get changed

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

Parameters
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalcreate a global or a local copy?
nameproblem 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:
Note
sourcescip stage does not get changed

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

Parameters
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
nameproblem 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
sourcevarsource variable
targetvarpointer to store the target variable
varmapa hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalshould global or local bounds be used?
successpointer 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:
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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalshould 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:
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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables to the corresponding target variables, or NULL
consmapa 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
sourceconssource constraint of the source SCIP
targetconspointer to store the created target constraint
sourceconshdlrsource constraint handler for this constraint
varmapa SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
namename of constraint, or NULL if the name of the source constraint should be used
initialshould the LP relaxation of constraint be in the initial LP?
separateshould the constraint be separated during LP processing?
enforceshould the constraint be enforced during node processing?
checkshould the constraint be checked for feasibility?
propagateshould the constraint be propagated during node processing?
localis constraint only valid locally?
modifiableis constraint modifiable (subject to column generation)?
dynamicis constraint subject to aging?
removableshould the relaxation be removed from the LP due to aging or cleanup?
stickingatnodeshould the constraint always be kept at the node where it was added, even if it may be moved to a more global node?
globalcreate a global or a local copy?
successpointer 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:
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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, must not be NULL!
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalcreate a global or a local copy?
enablepricingshould pricing be enabled in copied SCIP instance? If TRUE, the modifiable flag of constraints will be copied.
validpointer 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:
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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa SCIP_HASHMAP mapping variables of the source SCIP to the corresponding variables of the target SCIP, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
enablepricingshould pricing be enabled in copied SCIP instance? If TRUE, the modifiable flag of constraints will be copied.
validpointer 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
scipSCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalcreate a global or a local copy?
ncutsaddedpointer 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalcreate a global or a local copy?
ncutsaddedpointer 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
globalcreate a global or a local copy?
infeasiblepointer to store whether an infeasibility was detected
nbdchgspointer to store the number of performed bound changes, or NULL
ncopiedpointer 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
sourcescipsource SCIP data structure
targetsciptarget 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
scipSCIP 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
suffixsuffix which will be added to the names of the source SCIP
globalcreate a global or a local copy?
enablepricingshould 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
passmessagehdlrshould the message handler be passed
validpointer 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
sourcescipsource SCIP data structure
targetsciptarget SCIP data structure
varmapa hashmap to store the mapping of source variables corresponding target variables, or NULL
consmapa hashmap to store the mapping of source constraints to the corresponding target constraints, or NULL
suffixsuffix which will be added to the names of the target SCIP, might be empty
enablepricingshould 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
passmessagehdlrshould the message handler be passed
validpointer 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
scipSCIP data structure
namename of the parameter
descdescription of the parameter
valueptrpointer to store the current parameter value, or NULL
isadvancedis this parameter an advanced parameter?
defaultvaluedefault value of the parameter
paramdatalocally 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
scipSCIP data structure
namename of the parameter
descdescription of the parameter
valueptrpointer to store the current parameter value, or NULL
isadvancedis this parameter an advanced parameter?
defaultvaluedefault value of the parameter
minvalueminimum value for parameter
maxvaluemaximum value for parameter
paramdatalocally 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
scipSCIP data structure
namename of the parameter
descdescription of the parameter
valueptrpointer to store the current parameter value, or NULL
isadvancedis this parameter an advanced parameter?
defaultvaluedefault value of the parameter
minvalueminimum value for parameter
maxvaluemaximum value for parameter
paramdatalocally 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 comple