64#define HEUR_NAME "feaspump"
65#define HEUR_DESC "objective feasibility pump 2.0"
66#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_OBJDIVING
67#define HEUR_PRIORITY -1000000
70#define HEUR_MAXDEPTH -1
71#define HEUR_TIMING SCIP_HEURTIMING_AFTERLPPLUNGE
72#define HEUR_USESSUBSCIP FALSE
74#define DEFAULT_MAXLPITERQUOT 0.01
75#define DEFAULT_MAXLPITEROFS 1000
76#define DEFAULT_MAXSOLS 10
78#define DEFAULT_MAXLOOPS 10000
79#define DEFAULT_MAXSTALLLOOPS 10
80#define DEFAULT_MINFLIPS 10
81#define DEFAULT_CYCLELENGTH 3
82#define DEFAULT_PERTURBFREQ 100
83#define DEFAULT_OBJFACTOR 0.1
85#define DEFAULT_ALPHA 1.0
86#define DEFAULT_ALPHADIFF 1.0
87#define DEFAULT_BEFORECUTS TRUE
88#define DEFAULT_USEFP20 FALSE
89#define DEFAULT_PERTSOLFOUND TRUE
90#define DEFAULT_STAGE3 FALSE
91#define DEFAULT_NEIGHBORHOODSIZE 18
92#define DEFAULT_COPYCUTS TRUE
98#define DEFAULT_RANDSEED 13
106 SCIP_Real maxlpiterquot;
121 int neighborhoodsize;
124 SCIP_Bool beforecuts;
126 SCIP_Bool pertsolfound;
158 SCIP_CALL(
SCIPcopyConsCompression(
scip, *probingscip, *varmapfw,
NULL,
"feaspump",
NULL,
NULL, 0,
FALSE,
FALSE,
288 SCIP_Real* mostfracvals,
306 if( *nflipcands >= maxnflipcands )
308 if(
frac <= mostfracvals[*nflipcands-1] )
315 for(
i = *nflipcands;
i > 0 && mostfracvals[
i-1] <
frac;
i-- )
317 mostfracvars[
i] = mostfracvars[
i-1];
318 mostfracvals[
i] = mostfracvals[
i-1];
320 assert(0 <=
i &&
i <= *nflipcands && *nflipcands < maxnflipcands);
323 mostfracvars[
i] =
var;
324 mostfracvals[
i] =
frac;
338 SCIP_Real scalingfactor
343 SCIP_Real newobjcoeff;
344 SCIP_Real orgobjcoeff;
360 newobjcoeff = (1.0 -
alpha)/scalingfactor +
alpha * orgobjcoeff;
362 newobjcoeff = - (1.0 -
alpha)/scalingfactor +
alpha * orgobjcoeff;
364 newobjcoeff =
alpha * orgobjcoeff;
380 SCIP_Real scalingfactor
386 for(
i = 0;
i < nflipcands;
i++ )
390 SCIP_Real roundedsolval;
392 var = mostfracvars[
i];
400 if( roundedsolval > solval )
407 SCIPdebugMsg(
scip,
"1-cycle flip: variable <%s> [%g,%g] LP sol %.15g sol %.15g -> %.15g\n",
426 SCIP_Real scalingfactor
432 for(
i = 0;
i < nbinandintvars;
i++ )
438 SCIP_Real roundedsolval;
457 if( roundedsolval > solval )
477 SCIP_Real neighborhoodsize
503 rhs = neighborhoodsize;
516 consvals[nconsvars] = -1.0;
521 consvals[nconsvars] = 1.0;
523 if( consvars[nconsvars] ==
NULL )
532 lhs, rhs,
FALSE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE) );
697 if( nstallloops <= 1 )
716 SCIP_Real* lastalphas;
727 SCIP_Real* mostfracvals;
734 SCIP_Real scalingfactor;
735 SCIP_Real mindistance;
741 SCIP_Longint nbestsolsfound;
844 maxstallloops = (
heurdata->maxstallloops == -1 ? INT_MAX :
heurdata->maxstallloops);
861 if( probingscip !=
NULL )
874 SCIPwarningMessage(
scip,
"Error while solving subproblem in feaspump heuristic; sub-SCIP terminated with code <%d>\n", retcode);
909 SCIPdebugMsg(
scip,
"successfully copied SCIP instance -> feasibility pump 2.0 can be used.\n");
927 for( j = 0; j <
heurdata->cyclelength; j++ )
948 objfactor =
MIN(1.0 - 0.1 / (SCIP_Real)(1 +
nsolsfound), 0.999);
954 objnorm =
MAX(objnorm, 1.0);
962 bestnfracs = INT_MAX;
968 && nloops < maxloops && nstallloops < maxstallloops
972 SCIP_Real* pseudocandsfrac;
973 SCIP_Longint nlpiterationsleft;
980 SCIPdebugMsg(
scip,
"feasibility pump loop %d: %d fractional variables (alpha: %.4f, stall: %d/%d)\n",
981 nloops, nfracs,
alpha, nstallloops, maxstallloops);
1000 for(
i = 0;
i < npseudocands;
i++ )
1005 pseudocandsfrac[
i] -= 10.0;
1013 for(
i = 0;
i < npseudocands;
i++ )
1016 SCIP_Bool infeasible;
1017 SCIP_Longint ndomreds;
1039 SCIP_Real lbprobing;
1040 SCIP_Real ubprobing;
1044 if( probingvar !=
NULL )
1049 solval =
MAX(solval, lbprobing);
1050 solval =
MIN(solval, ubprobing);
1097 for( j = 0; j <
heurdata->cyclelength; j++ )
1106 for( j = 0; j < minimum; j++ )
1127 for( j = 0; j < minimum; j++ )
1135 SCIPdebugMsg(
scip,
" -> avoiding 1-cycle: flipping %d candidates\n", nflipcands);
1173 SCIPwarningMessage(
scip,
"Error while solving LP in Feaspump heuristic; LP solve terminated with code <%d>\n", retcode);
1196 SCIP_Real roundedval;
1201 distance +=
REALABS(roundedval - lpval);
1212 mindistance = distance;
1218 tmpsol = lastroundedsols[
heurdata->cyclelength-1];
1219 for( j =
heurdata->cyclelength-1; j > 0; j-- )
1221 lastroundedsols[j] = lastroundedsols[j-1];
1222 lastalphas[j] = lastalphas[j-1];
1224 lastroundedsols[0] =
heurdata->roundedsol;
1225 lastalphas[0] =
alpha;
1230 if( nfracs < bestnfracs )
1232 bestnfracs = nfracs;
1248 SCIPdebugMsg(
scip,
"feasibility pump found solution (%d fractional variables)\n", nfracs);
1315 if( varmapfw !=
NULL )
1318 if( probingscip !=
NULL )
1329 for( j = 0; j <
heurdata->cyclelength; j++ )
1340 SCIPdebugMsg(
scip,
"feasibility pump finished [%d iterations done].\n", nloops);
1342#ifdef SCIP_STATISTIC
1350 SCIPstatisticMessage(
"feasibility pump found: 1, objval: %f, iterations: %d, primal bound: %f\n",
objval, nloops, primalBound);
1357 SCIPstatisticMessage(
"feasibility pump found: 0, objval: +inf, iterations: %d, primal bound: %f\n", nloops, primalBound);
1398 "heuristics/" HEUR_NAME "/maxlpiterquot",
1399 "maximal fraction of diving LP iterations compared to node LP iterations",
1403 "factor by which the regard of the objective is decreased in each round, 1.0 for dynamic",
1407 "initial weight of the objective function in the convex combination",
1411 "threshold difference for the convex parameter to perform perturbation",
1415 "heuristics/" HEUR_NAME "/maxlpiterofs",
1416 "additional number of allowed LP iterations",
1420 "total number of feasible solutions found up to which heuristic is called (-1: no limit)",
1424 "maximal number of pumping loops (-1: no limit)",
1427 "heuristics/" HEUR_NAME "/maxstallloops",
1428 "maximal number of pumping rounds without fractionality improvement (-1: no limit)",
1432 "minimum number of random variables to flip, if a 1-cycle is encountered",
1436 "maximum length of cycles to be checked explicitly in each round",
1440 "number of iterations until a random perturbation is forced",
1443 "radius (using Manhattan metric) of the neighborhood to be searched in stage 3",
1448 "should the feasibility pump be called at root node before cut separation?",
1452 "should an iterative round-and-propagate scheme be used to find the integral points?",
1455 "heuristics/" HEUR_NAME "/pertsolfound",
1456 "should a random perturbation be performed if a feasible solution was found?",
1460 "should we solve a local branching sub-MIP if no solution could be found?",
1463 "should all active cuts from cutpool be copied to constraints in subproblem?",
Constraint handler for linear constraints in their most general form, .
#define SCIP_MAXTREEDEPTH
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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 SCIPtranslateSubSols(SCIP *scip, SCIP *subscip, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_Bool *success, int *solindex)
SCIP_RETCODE SCIPcopyConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
SCIP_RETCODE SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetObjNorm(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
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 SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
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 SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
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 SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPincludeHeurFeaspump(SCIP *scip)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur,)
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur,)
SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur,)
void SCIPheurSetTimingmask(SCIP_HEUR *heur, SCIP_HEURTIMING timingmask)
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
int SCIPheurGetFreqofs(SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur,)
const char * SCIPheurGetName(SCIP_HEUR *heur)
void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
SCIP_RETCODE SCIPstartDive(SCIP *scip)
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
int SCIPgetNPricers(SCIP *scip)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
int SCIPgetNSols(SCIP *scip)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
SCIPfreeRandom(scip, &heurdata->randnumgen)
#define DEFAULT_CYCLELENGTH
static SCIP_RETCODE setupProbingSCIP(SCIP *scip, SCIP **probingscip, SCIP_HASHMAP **varmapfw, SCIP_Bool copycuts, SCIP_Bool *success)
#define DEFAULT_ALPHADIFF
#define DEFAULT_MAXLPITERQUOT
#define DEFAULT_NEIGHBORHOODSIZE
static SCIP_RETCODE handle1Cycle(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR **mostfracvars, int nflipcands, SCIP_Real alpha, SCIP_Real scalingfactor)
#define DEFAULT_MAXLPITEROFS
#define DEFAULT_MAXSTALLLOOPS
#define DEFAULT_PERTURBFREQ
#define DEFAULT_PERTSOLFOUND
static void insertFlipCand(SCIP_VAR **mostfracvars, SCIP_Real *mostfracvals, int *nflipcands, int maxnflipcands, SCIP_VAR *var, SCIP_Real frac)
static SCIP_RETCODE setupSCIPparamsFP2(SCIP *scip, SCIP *probingscip)
static SCIP_Longint adjustedMaxNLPIterations(SCIP_Longint maxnlpiterations, SCIP_Longint nsolsfound, int nstallloops)
static SCIP_RETCODE setupSCIPparamsStage3(SCIP *scip, SCIP *probingscip)
static SCIP_RETCODE updateVariableRounding(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR *var, SCIP_Real solval, SCIP_Real alpha, SCIP_Real scalingfactor)
static SCIP_RETCODE addLocalBranchingConstraint(SCIP *scip, SCIP *probingscip, SCIP_HASHMAP *varmapfw, SCIP_SOL *bestsol, SCIP_Real neighborhoodsize)
#define DEFAULT_BEFORECUTS
static SCIP_RETCODE handleCycle(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR **vars, int nbinandintvars, SCIP_Real alpha, SCIP_Real scalingfactor)
#define DEFAULT_OBJFACTOR
static SCIP_RETCODE createNewSols(SCIP *scip, SCIP *subscip, SCIP_HASHMAP *varmapfw, SCIP_HEUR *heur, SCIP_Bool *success)
Objective Feasibility Pump 2.0.
static SCIP_LPSOLSTAT lpsolstat
SCIP_Longint maxnlpiterations
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
SCIPlinkLPSol(scip, sol))
memory allocation routines
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for primal heuristics
public methods for message output
#define SCIPstatisticMessage
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
public methods for branching rule plugins and branching
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for primal heuristic plugins and divesets
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for node selector plugins
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for variable pricer plugins
public methods for global and local (sub)problems
public methods for the probing mode
public methods for random numbers
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
#define SCIP_DECL_HEURINITSOL(x)
#define SCIP_DECL_HEURCOPY(x)
struct SCIP_HeurData SCIP_HEURDATA
#define SCIP_DECL_HEURINIT(x)
#define SCIP_DECL_HEUREXIT(x)
#define SCIP_DECL_HEURFREE(x)
#define SCIP_DECL_HEUREXITSOL(x)
#define SCIP_DECL_HEUREXEC(x)
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
enum SCIP_Retcode SCIP_RETCODE
enum SCIP_Status SCIP_STATUS
#define SCIP_HEURTIMING_DURINGLPLOOP