87#define HEUR_NAME "undercover"
88#define HEUR_DESC "solves a sub-CIP determined by a set covering approach"
89#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_LNS
90#define HEUR_PRIORITY -1110000
93#define HEUR_MAXDEPTH -1
94#define HEUR_TIMING SCIP_HEURTIMING_AFTERNODE
95#define HEUR_USESSUBSCIP TRUE
98#define DEFAULT_FIXINGALTS "li"
100#define DEFAULT_MAXNODES (SCIP_Longint)500
101#define DEFAULT_MINNODES (SCIP_Longint)500
102#define DEFAULT_NODESOFS (SCIP_Longint)500
104#define DEFAULT_CONFLICTWEIGHT 1000.0
105#define DEFAULT_CUTOFFWEIGHT 1.0
106#define DEFAULT_INFERENCEWEIGHT 1.0
107#define DEFAULT_MAXCOVERSIZEVARS 1.0
108#define DEFAULT_MAXCOVERSIZECONSS SCIP_REAL_MAX
109#define DEFAULT_MINCOVEREDREL 0.15
110#define DEFAULT_MINCOVEREDABS 5
111#define DEFAULT_MINIMPROVE 0.0
112#define DEFAULT_NODESQUOT 0.1
113#define DEFAULT_RECOVERDIV 0.9
115#define DEFAULT_MAXBACKTRACKS 6
116#define DEFAULT_MAXRECOVERS 0
117#define DEFAULT_MAXREORDERS 1
119#define DEFAULT_COVERINGOBJ 'u'
120#define DEFAULT_FIXINGORDER 'v'
122#define DEFAULT_BEFORECUTS TRUE
123#define DEFAULT_FIXINTFIRST FALSE
124#define DEFAULT_LOCKSROUNDING TRUE
125#define DEFAULT_ONLYCONVEXIFY FALSE
126#define DEFAULT_POSTNLP TRUE
127#define DEFAULT_COVERAND TRUE
128#define DEFAULT_COVERBD FALSE
129#define DEFAULT_COVERIND FALSE
130#define DEFAULT_COVERNL TRUE
131#define DEFAULT_REUSECOVER FALSE
132#define DEFAULT_COPYCUTS TRUE
135#define DEFAULT_RANDSEED 43
138#define COVERINGOBJS "cdlmtu"
139#define FIXINGORDERS "CcVv"
141#define MAXPOSTNLPFAILS 1
142#define MINTIMELEFT 1.0
143#define SUBMIPSETUPCOSTS 200
266 if( !consmarker[idx] )
269 consmarker[idx] =
TRUE;
352 for( t = 0; t < nquadexprs; ++t )
382 incCounters(termcounter, conscounter, consmarker, probidx);
388 for( t = 0; t < nbilinexprs; ++t )
407 if( probidx1 == -1 || probidx2 == -1 )
417 coveringconsvars[0] = coveringvars[probidx1];
418 coveringconsvars[1] = coveringvars[probidx2];
422 if( coveringcons ==
NULL )
424 SCIPdebugMsg(
scip,
"failed to create set covering constraint <%s>\n", name);
433 incCounters(termcounter, conscounter, consmarker, probidx1);
434 incCounters(termcounter, conscounter, consmarker, probidx2);
454 SCIPdebugMsg(
scip,
"strange: inactive variable <%s> detected in nonlinear row <%s>\n",
470 incCounters(termcounter, conscounter, consmarker, probidx);
544 coveringvars[
i] =
NULL;
573 if( conshdlr !=
NULL && coverand )
623 if( probindex == -1 )
663 coveringconsvars[ntofix] = coveringvars[probindex];
664 coveringconsvals[ntofix] = 1.0;
684 if( probindex == -1 )
738 coveringconsvars[ntofix] = coveringvars[probindex];
739 coveringconsvals[ntofix] = (
SCIP_Real)(ntofix - 1);
748 if( coveringcons ==
NULL )
761 for( v = ntofix-1; v >= 0; v-- )
776 if( conshdlr !=
NULL && coverbd )
808 for( v = nbdvars-1; v >= 0; v-- )
824 if( probindex == -1 )
864 coveringconsvars[ntofix] = coveringvars[probindex];
865 coveringconsvals[ntofix] = 1.0;
872 assert(ntofix <= nbdvars);
880 if( coveringcons ==
NULL )
893 for( v = ntofix-1; v >= 0; v-- )
908 if( conshdlr !=
NULL && coverind )
934 if( probindex == -1 )
965 coveringvar = coveringvars[probindex];
972 incCounters(termcounter, conscounter, consmarker, probindex);
982 if( conshdlr !=
NULL && covernl )
1002 termcounter, conscounter, consmarker, globalbounds, onlyconvexify, success) );
1004 if( *success ==
FALSE )
1012 switch( coveringobj )
1017 if( coveringvars[
i] ==
NULL )
1025 if( coveringvars[
i] ==
NULL )
1034 if( coveringvars[
i] ==
NULL )
1044 if( coveringvars[
i] ==
NULL )
1054 if( coveringvars[
i] ==
NULL )
1062 if( coveringvars[
i] ==
NULL )
1068 SCIPerrorMessage(
"invalid choice <%c> for covering objective\n", coveringobj);
1081 nnonzs += termcounter[
i];
1085 if( conscounter[
i] > 0 )
1108 int diversification,
1126 assert(diversification >= 1);
1144 if( diversification == 1 )
1147 for(
i = coversize-1;
i >= 0;
i-- )
1157 if( nconsvars == 0 )
1178 for(
i = coversize-1;
i >= 0;
i-- )
1182 consvars[nconsvars] =
vars[cover[
i]];
1183 consvals[nconsvars] = 1.0;
1187 rhs = (
SCIP_Real) (nconsvars-diversification);
1212 if( !(*infeas) && cons !=
NULL )
1260 for(
i = bdlen-1;
i >= 0 && isbinary;
i-- )
1272 for(
i = bdlen-1;
i >= 0;
i-- )
1279 consvars[
i] = bdvars[
i];
1347 assert(memorylimit > 0.0);
1368 SCIPdebugMsg(coveringscip,
"timelimit = %g, memlimit = %g\n", timelimit, memorylimit);
1397 SCIPwarningMessage(coveringscip,
"Error while solving covering problem in Undercover heuristic; sub-SCIP terminated with code <%d>\n",retcode);
1408 for(
i = 0;
i < ncoveringvars;
i++ )
1410 if( coveringvars[
i] ==
NULL )
1415 cover[*coversize] =
i;
1423 SCIPdebugMsg(coveringscip,
"found a feasible cover: %d/%d variables fixed, normalized penalty=%g\n\n",
1465 if( lastfailed == 0 )
1472 sortdown = (
heurdata->fixingorder ==
'c' ||
heurdata->fixingorder ==
'v' );
1476 for(
i = coversize-1;
i >= 0;
i-- )
1493 scores[
i] = cover[
i];
1501 bestscore =
MAX(bestscore, scores[
i]);
1503 bestscore =
MIN(bestscore, scores[
i]);
1509 for(
i = coversize-1;
i >= 0;
i-- )
1514 scores[
i] += bestscore+1.0;
1516 scores[
i] = bestscore - 1.0/(scores[
i]+1.0);
1522 if( lastfailed < coversize )
1525 scores[lastfailed] += bestscore+2.0;
1527 scores[lastfailed] = bestscore - 2.0/(scores[lastfailed]+1.0);
1528 i = cover[lastfailed];
1537 assert(lastfailed >= coversize || cover[0] ==
i);
1602 for(
i = bdlen-1;
i >= 0;
i-- )
1608 relaxvar = bdvars[
i];
1611 if(
i > 0 && bdvars[
i-1] == relaxvar )
1613 assert(bdtypes[
i] != bdtypes[
i-1]);
1647 SCIPdebugMsg(
scip,
"solving NLP relaxation to obtain fixing values %s (stat=%d)\n", *success ?
"successful" :
"failed", stat);
1713 alternatives[0] = 1.0 - fixval;
1718 alternatives[0] = 0.0;
1719 alternatives[1] = 1.0;
1745 alternatives[*nalternatives] = lb;
1752 alternatives[*nalternatives] = ub;
1759 alternatives[*nalternatives] = (lb+fixval)/2.0;
1766 alternatives[*nalternatives] = (ub+fixval)/2.0;
1770 assert(*nalternatives <= 4);
1794 else if( locksrounding )
1856 assert(memorylimit > 0.0);
1858 assert(nstallnodes >= 1);
1864 *validsolved =
FALSE;
1875 nfixedvars = coversize;
1878 for(
i = coversize-1;
i >= 0;
i-- )
1883 fixedvars[
i] =
vars[cover[
i]];
1903 SCIPdebugMsg(
scip,
"problem copied, copy %svalid\n", *validsolved ?
"" :
"in");
1994 SCIPwarningMessage(
scip,
"Error while solving subproblem in Undercover heuristic; sub-SCIP terminated with code <%d>\n",retcode);
2024 for(
i = 0;
i < nsubsols;
i++ )
2034 SCIPdebugMsg(
scip,
"heuristic found %d solutions in subproblem; solution %d feasible in original problem\n", nsubsols,
i);
2046 if( !success ||
i > 0 )
2047 *validsolved =
FALSE;
2116 SCIPdebugMsg(
scip,
"tentatively decreasing upper bound of variable <%s> to %g for probing\n",
2120 bdvars[*bdlen] =
var;
2123 oldbounds[*bdlen] = oldub;
2138 oldbounds[*bdlen] = oldlb;
2143 val =
MIN(val, oldub);
2144 val =
MAX(val, oldlb);
2161 SCIPdebugMsg(
scip,
"tentatively increasing lower bound of variable <%s> to %g for probing\n",
2165 bdvars[*bdlen] =
var;
2224 for(
i = 0;
i < coversize && !(*infeas);
i++ )
2256 for( nbacktracks = 0; nbacktracks <=
heurdata->maxbacktracks+nfailedvals && *infeas; nbacktracks++ )
2266 if( nbacktracks < heurdata->nfixingalts )
2274 if( (
heurdata->fixingalts[nbacktracks] !=
'l' || lpsolved)
2283 SCIPdebugMsg(
scip,
"retrieving fixing value '%c' for variable <%s> failed, trying next in the list\n",
2291 if( boundalts ==
NULL )
2301 else if( boundalts !=
NULL && nbacktracks < heurdata->nfixingalts+nboundalts )
2304 val = boundalts[nbacktracks-
heurdata->nfixingalts];
2319 val =
MIN(val, oldub);
2320 val =
MAX(val, oldlb);
2326 for( j = nusedvals-1; j >= 0 && !usedbefore; j-- )
2336 assert(nusedvals < heurdata->maxbacktracks);
2337 usedvals[nusedvals] = val;
2352 if( boundalts !=
NULL)
2359 SCIPdebugMsg(
scip,
"no feasible fixing value found for variable <%s> in fixing order\n",
2367 fixingvals[
i] = val;
2376 assert(*infeas ||
i == coversize);
2377 assert(!(*infeas) ||
i < coversize);
2467 SCIPdebugMsg(
scip,
"too few nonlinear constraints present, not running\n");
2476 if(
heurdata->maxcoversizevars < 1.0 )
2481 maxcoversize += 1.0;
2482 maxcoversize *=
heurdata->maxcoversizevars;
2493 maxcoversize =
MIN(maxcoversize, maxcoversizeconss);
2553 while( (ncovers <= heurdata->maxrecovers || reusecover) && !success )
2566 conflictcreated =
FALSE;
2575 if( ncovers == 0 && success )
2589 SCIPdebugMsg(
scip,
"no feasible cover found in covering problem %d, terminating\n", ncovers);
2594 if( coversize == 0 || coversize > maxcoversize )
2613 lastfailed = reusecover ?
MAX(1, coversize-1) : coversize;
2616 while( ndives <= heurdata->maxreorders && !success )
2623 reordered = reordered || ndives == 0;
2624 SCIPdebugMsg(
scip,
"%sordering variables in cover %s\n", ndives == 0 ?
"" :
"re", reordered ?
"" :
"failed");
2631 SCIP_CALL(
fixAndPropagate(
scip,
heurdata, cover, coversize, fixingvals, &bdlen, bdvars, bdtypes, bdbounds, oldbounds,
2632 &nfixedints, &nfixedconts, &lastfailed, &infeas) );
2650 SCIPdebugMsg(
scip,
"no feasible fixing values found for cover %d\n", ncovers);
2658 SCIPdebugMsg(
scip,
"heuristic successfully fixed %d variables (%d integral, %d continuous) during probing\n",
2659 nfixedints+nfixedconts, nfixedints, nfixedconts);
2663 validsolved =
FALSE;
2668 timelimit, memorylimit,
heurdata->maxnodes, nstallnodes, &validsolved, &
sol, &nsubnodes) );
2685 useconf = bdlen > 0 && (bdlen <= minmaxvars || bdlen < maxvarsfac*
nvars);
2691 conflictcreated = success;
2694 SCIPdebugMsg(
scip,
"subproblem solved (%s), forbidding assignment in original problem %s, %sconflict length=%d\n",
2695 sol ==
NULL ?
"infeasible" :
"optimal",
2696 success ?
"successful" :
"failed", useconf ?
"" :
"skipped due to ", bdlen);
2709 if( nfixedconts == 0 && validsolved )
2711 SCIPdebugMsg(
scip,
"subproblem solved to optimality while all covering variables are integral, hence skipping NLP local search\n");
2715 SCIPdebugMsg(
scip,
"NLP heuristic not found, skipping NLP local search\n");
2737 if( !success && ncovers <= heurdata->maxrecovers )
2740 int diversification;
2744 diversification =
MAX(diversification, 1);
2751 SCIPdebugMsg(
scip,
"recovering problem infeasible (diversification=%d), terminating\n", diversification);
2756 SCIPdebugMsg(
scip,
"failed to forbid current cover in the covering problem, terminating\n");
2761 SCIPdebugMsg(
scip,
"added constraint to the covering problem in order to forbid current cover\n");
2767 if(
heurdata->reusecover && !reusecover && conflictcreated )
2801 if( coveringvars[
i] ==
NULL )
2994 if( nodeinfeasible )
3008 SCIPdebugMsg(
scip,
"skipping undercover heuristic: want to use NLP fixing values exclusively, but no NLP solver available\n");
3021 nstallnodes -=
heurdata->nusednodes;
3022 nstallnodes =
MIN(nstallnodes,
heurdata->maxnodes);
3023 nstallnodes =
MAX(nstallnodes, 1);
3026 if( nstallnodes < heurdata->minnodes )
3038 SCIPdebugMsg(
scip,
"skipping undercover heuristic: time left=%g\n", timelimit);
3059 for(
h =
heurdata->nnlconshdlrs-1;
h >= 0 && !run;
h-- )
3076 for(
i = nnlrows-1;
i >= 0 && !run;
i-- )
3085 SCIPdebugMsg(
scip,
"skipping undercover heuristic: no nonlinear constraints found\n");
3143 "prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution)",
3148 "maximum number of nodes to regard in the subproblem",
3152 "minimum number of nodes required to start the subproblem",
3156 "number of nodes added to the contingent of the total nodes",
3161 "weight for conflict score in fixing order",
3165 "weight for cutoff score in fixing order",
3169 "weight for inference score in fixing order",
3173 "maximum coversize (as fraction of total number of variables)",
3177 "maximum coversize (as ratio to the percentage of non-affected constraints)",
3181 "minimum percentage of nonlinear constraints in the original problem",
3185 "factor by which the heuristic should at least improve the incumbent",
3189 "contingent of sub problem nodes in relation to the number of nodes of the original problem",
3193 "fraction of covering variables in the last cover which need to change their value when recovering",
3198 "minimum number of nonlinear constraints in the original problem",
3202 "maximum number of backtracks in fix-and-propagate",
3206 "maximum number of recoverings",
3210 "maximum number of reorderings of the fixing order",
3215 "objective function of the covering problem (influenced nonlinear 'c'onstraints/'t'erms, 'd'omain size, 'l'ocks, 'm'in of up/down locks, 'u'nit penalties)",
3219 "order in which variables should be fixed (increasing 'C'onflict score, decreasing 'c'onflict score, increasing 'V'ariable index, decreasing 'v'ariable index",
3224 "should the heuristic be called at root node before cut separation?",
3228 "should integer variables in the cover be fixed first?",
3232 "shall LP values for integer vars be rounded according to locks?",
3236 "should we only fix variables in order to obtain a convex problem?",
3240 "should the NLP heuristic be called to polish a feasible solution?",
3244 "should and constraints be covered (or just copied)?",
3248 "should bounddisjunction constraints be covered (or just copied)?",
3252 "should indicator constraints be covered (or just copied)?",
3256 "should nonlinear constraints be covered (or just copied)?",
3260 "should all active cuts from cutpool be copied to constraints in subproblem?",
3264 "shall the cover be reused if a conflict was added after an infeasible subproblem?",
3310 coverand, coverbd, coverind, covernl, coveringobj, success) );
3326 for(
i = *coversize-1;
i >= 0;
i-- )
3330 cover[
i] =
vars[coverinds[
i]];
3342 if( coveringvars[
i] ==
NULL )
3386 timelimit, memorylimit, objlimit,
3387 globalbounds, onlyconvexify, coverand, coverbd, coverind, covernl,
3388 coveringobj, success);
#define DEFAULT_INFERENCEWEIGHT
#define DEFAULT_CONFLICTWEIGHT
#define DEFAULT_CUTOFFWEIGHT
Constraint handler for AND constraints, .
constraint handler for bound disjunction constraints
constraint handler for indicator constraints
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
constraint handler for nonlinear constraints specified by algebraic expressions
Constraint handler for the set partitioning / packing / covering constraints .
#define SCIP_MAXTREEDEPTH
#define SCIP_LONGINT_FORMAT
SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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 SCIPgetNlRowNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)
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_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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 SCIPcreateConsSetcover(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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_VAR ** SCIPgetVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
void SCIPsetSubscipDepth(SCIP *scip, int newdepth)
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)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
SCIP_RETCODE SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
SCIP_RETCODE SCIPtranslateSubSol(SCIP *scip, SCIP *subscip, SCIP_SOL *subsol, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_SOL **newsol)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
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)
int SCIPgetNConss(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
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)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPapplyHeurSubNlp(SCIP *scip, SCIP_HEUR *heur, SCIP_RESULT *result, SCIP_SOL *refpoint, SCIP_SOL *resultsol)
SCIP_RETCODE SCIPcomputeCoverUndercover(SCIP *scip, int *coversize, SCIP_VAR **cover, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Real objlimit, SCIP_Bool globalbounds, SCIP_Bool onlyconvexify, SCIP_Bool coverand, SCIP_Bool coverbd, SCIP_Bool coverind, SCIP_Bool covernl, char coveringobj, SCIP_Bool *success)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
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_Bool SCIPisParamFixed(SCIP *scip, const char *name)
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 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 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_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 SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, 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 SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPincludeHeurUndercover(SCIP *scip)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)
SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)
SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)
void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)
SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)
SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)
void SCIPfreeExpriter(SCIP_EXPRITER **iterator)
SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)
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_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
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_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPendDiveNLP(SCIP *scip)
SCIP_RETCODE SCIPstartDiveNLP(SCIP *scip)
SCIP_RETCODE SCIPchgVarBoundsDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
int SCIPgetNNlpis(SCIP *scip)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
#define SCIPsolveNLP(...)
SCIP_RETCODE SCIPsetNLPInitialGuessSol(SCIP *scip, SCIP_SOL *sol)
int SCIPgetNNLPNlRows(SCIP *scip)
SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)
const char * SCIPnlrowGetName(SCIP_NLROW *nlrow)
SCIP_Real SCIPnlrowGetRhs(SCIP_NLROW *nlrow)
SCIP_Real SCIPnlrowGetLhs(SCIP_NLROW *nlrow)
SCIP_EXPRCURV SCIPnlrowGetCurvature(SCIP_NLROW *nlrow)
SCIP_EXPR * SCIPnlrowGetExpr(SCIP_NLROW *nlrow)
int SCIPgetProbingDepth(SCIP *scip)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
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_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
int SCIPgetNSols(SCIP *scip)
SCIP_SOL ** SCIPgetSols(SCIP *scip)
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_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Real SCIPsumepsilon(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
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_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, int len)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPfreeRandom(scip, &heurdata->randnumgen)
#define DEFAULT_NODESQUOT
#define DEFAULT_MINIMPROVE
#define DEFAULT_MAXBACKTRACKS
#define DEFAULT_BEFORECUTS
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
NLP local search primal heuristic using sub-SCIPs.
static SCIP_RETCODE performFixing(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_Bool *infeas, int *bdlen, SCIP_VAR **bdvars, SCIP_BOUNDTYPE *bdtypes, SCIP_Real *bdbounds, SCIP_Real *oldbounds)
static SCIP_RETCODE getFixingValue(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR *var, SCIP_Real *val, char fixalt, SCIP_Bool *success, int bdlen, SCIP_VAR **bdvars, SCIP_BOUNDTYPE *bdtypes, SCIP_Real *oldbounds)
#define DEFAULT_MAXRECOVERS
static void incCounters(int *termcounter, int *conscounter, SCIP_Bool *consmarker, int idx)
static SCIP_RETCODE solveSubproblem(SCIP *scip, SCIP_HEUR *heur, int coversize, int *cover, SCIP_Real *fixedvals, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Longint nodelimit, SCIP_Longint nstallnodes, SCIP_Bool *validsolved, SCIP_SOL **sol, SCIP_Longint *nusednodes)
#define DEFAULT_FIXINGALTS
#define DEFAULT_MINCOVEREDABS
static SCIP_RETCODE computeCoverUndercover(SCIP *scip, SCIP *coveringscip, int *coversize, SCIP_VAR **cover, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Real objlimit, SCIP_Bool globalbounds, SCIP_Bool onlyconvexify, SCIP_Bool coverand, SCIP_Bool coverbd, SCIP_Bool coverind, SCIP_Bool covernl, char coveringobj, SCIP_Bool *success)
#define DEFAULT_ONLYCONVEXIFY
static SCIP_Bool termIsConstant(SCIP *scip, SCIP_VAR *var, SCIP_Real coeff, SCIP_Bool global)
static SCIP_RETCODE fixAndPropagate(SCIP *scip, SCIP_HEURDATA *heurdata, int *cover, int coversize, SCIP_Real *fixingvals, int *bdlen, SCIP_VAR **bdvars, SCIP_BOUNDTYPE *bdtypes, SCIP_Real *bdbounds, SCIP_Real *oldbounds, int *nfixedints, int *nfixedconts, int *lastfailed, SCIP_Bool *infeas)
#define DEFAULT_RECOVERDIV
#define DEFAULT_MINCOVEREDREL
#define DEFAULT_MAXCOVERSIZECONSS
static SCIP_RETCODE createCoveringProblem(SCIP *scip, SCIP *coveringscip, SCIP_VAR **coveringvars, SCIP_Bool globalbounds, SCIP_Bool onlyconvexify, SCIP_Bool coverand, SCIP_Bool coverbd, SCIP_Bool coverind, SCIP_Bool covernl, char coveringobj, SCIP_Bool *success)
#define DEFAULT_REUSECOVER
#define DEFAULT_FIXINGORDER
static SCIP_RETCODE forbidCover(SCIP *scip, int nvars, SCIP_VAR **vars, int coversize, int *cover, int diversification, SCIP_Bool *success, SCIP_Bool *infeas)
static SCIP_RETCODE roundFixingValue(SCIP *scip, SCIP_Real *val, SCIP_VAR *var, SCIP_Bool locksrounding)
static SCIP_RETCODE updateTimelimit(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real *timelimit)
static SCIP_Bool termIsConvex(SCIP *scip, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool sign)
static SCIP_RETCODE solveCoveringProblem(SCIP *coveringscip, int ncoveringvars, SCIP_VAR **coveringvars, int *coversize, int *cover, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Real objlimit, SCIP_Bool *success)
static SCIP_RETCODE SCIPapplyUndercover(SCIP *scip, SCIP_HEUR *heur, SCIP_RESULT *result, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Longint nstallnodes)
#define DEFAULT_MAXCOVERSIZEVARS
#define DEFAULT_COVERINGOBJ
#define DEFAULT_LOCKSROUNDING
static void calculateAlternatives(SCIP *scip, SCIP_VAR *var, SCIP_Real fixval, int *nalternatives, SCIP_Real *alternatives)
static SCIP_RETCODE processNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP *coveringscip, int nvars, SCIP_VAR **coveringvars, int *termcounter, int *conscounter, SCIP_Bool *consmarker, SCIP_Bool globalbounds, SCIP_Bool onlyconvexify, SCIP_Bool *success)
static SCIP_Bool varIsFixed(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_Bool global)
#define DEFAULT_FIXINTFIRST
static SCIP_RETCODE createConflict(SCIP *scip, int bdlen, SCIP_VAR **bdvars, SCIP_BOUNDTYPE *bdtypes, SCIP_Real *bdbounds, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool *success)
#define DEFAULT_MAXREORDERS
static SCIP_RETCODE computeFixingOrder(SCIP *scip, SCIP_HEURDATA *heurdata, int nvars, SCIP_VAR **vars, int coversize, int *cover, int lastfailed, SCIP_Bool *success)
Undercover primal heuristic for MINLPs.
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public functions to work with algebraic expressions
public methods for primal heuristics
public methods for message output
#define SCIPstatisticPrintf
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for NLP management
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 nonlinear relaxation
public methods for numerical tolerances
public methods for SCIP parameter handling
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 timing
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)
struct SCIP_Clock SCIP_CLOCK
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Expr SCIP_EXPR
struct SCIP_ExprIter SCIP_EXPRITER
#define SCIP_DECL_HEURINITSOL(x)
#define SCIP_DECL_HEURCOPY(x)
struct SCIP_HeurData SCIP_HEURDATA
struct SCIP_Heur SCIP_HEUR
#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_BoundType SCIP_BOUNDTYPE
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_RandNumGen SCIP_RANDNUMGEN
struct SCIP_NlRow SCIP_NLROW
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
@ SCIP_NLPSOLSTAT_FEASIBLE
@ SCIP_NLPSOLSTAT_GLOBOPT
@ SCIP_PARAMSETTING_AGGRESSIVE
@ SCIP_PARAMEMPHASIS_FEASIBILITY
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
#define SCIP_HEURTIMING_DURINGLPLOOP
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR