neighborhoodsize;
158 SCIP_CALL(
SCIPcopyConsCompression(
scip, *probingscip, *varmapfw,
NULL,
"feaspump",
NULL,
NULL, 0,
FALSE,
FALSE,
297assert(mostfracvars !=
NULL);
298assert(mostfracvals !=
NULL);
299assert(nflipcands !=
NULL);
306 if( *nflipcands >= maxnflipcands )
308 if( frac <= mostfracvals[*nflipcands-1] )
315 for( i = *nflipcands; i > 0 && mostfracvals[i-1] < frac; i-- )
317mostfracvars[i] = mostfracvars[i-1];
318mostfracvals[i] = mostfracvals[i-1];
320assert(0 <= i && i <= *nflipcands && *nflipcands < maxnflipcands);
323mostfracvars[i] = var;
324mostfracvals[i] = frac;
346assert(heurdata !=
NULL);
347assert(var !=
NULL);
360newobjcoeff = (1.0 - alpha)/scalingfactor + alpha * orgobjcoeff;
362newobjcoeff = - (1.0 - alpha)/scalingfactor + alpha * orgobjcoeff;
364newobjcoeff = alpha * orgobjcoeff;
386 for( i = 0; i < nflipcands; i++ )
392var = mostfracvars[i];
400 if( roundedsolval > solval )
407 SCIPdebugMsg(
scip,
"1-cycle flip: variable <%s> [%g,%g] LP sol %.15g sol %.15g -> %.15g\n",
432 for( i = 0; i < nbinandintvars; i++ )
451 if(
MIN(frac, 1.0 - frac) +
MAX(flipprob, 0.0) > 0.5 )
457 if( roundedsolval > solval )
503rhs = neighborhoodsize;
506 for( i = 0; i < nbinvars; i++ )
516consvals[nconsvars] = -1.0;
521consvals[nconsvars] = 1.0;
523 if( consvars[nconsvars] ==
NULL)
532lhs, rhs,
FALSE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE) );
559assert(subscip !=
NULL);
566 for( i = 0; i < nvars; i++ )
581assert(heur !=
NULL);
596assert(heur !=
NULL);
602assert(heurdata !=
NULL);
616assert(heur !=
NULL);
621assert(heurdata !=
NULL);
628heurdata->nlpiterations = 0;
629heurdata->nsuccess = 0;
644assert(heur !=
NULL);
649assert(heurdata !=
NULL);
669assert(heurdata !=
NULL);
697 if( nstallloops <= 1 )
699 if( nsolsfound == 0 )
700 return4*maxnlpiterations;
702 return2*maxnlpiterations;
705 returnmaxnlpiterations;
767assert(heur !=
NULL);
770assert(result !=
NULL);
776 if( nodeinfeasible )
810assert(heurdata !=
NULL);
819assert(0 <= nfracs && nfracs <= nbinvars + nintvars);
827maxnlpiterations = (
SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
828maxnlpiterations += heurdata->maxlpiterofs;
831 if( heurdata->nlpiterations >= maxnlpiterations )
836maxnlpiterations += nlpiterations;
839maxnlpiterations =
MAX(maxnlpiterations, heurdata->nlpiterations +
MINLPITER);
842maxflips = 3*heurdata->minflips;
843maxloops = (heurdata->maxloops == -1 ? INT_MAX : heurdata->maxloops);
844maxstallloops = (heurdata->maxstallloops == -1 ? INT_MAX : heurdata->maxstallloops);
847nlpiterations, maxnlpiterations, maxflips);
854 if( heurdata->usefp20 )
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");
913assert(varmapfw ==
NULL);
927 for( j = 0; j < heurdata->cyclelength; j++ )
933 if( heurdata->stage3 )
947 if( heurdata->objfactor == 1.0 )
948objfactor =
MIN(1.0 - 0.1 / (
SCIP_Real)(1 + nsolsfound), 0.999);
950objfactor = heurdata->objfactor;
954objnorm =
MAX(objnorm, 1.0);
955scalingfactor = sqrt((
SCIP_Real)(nbinvars + nintvars)) / objnorm;
958alpha = heurdata->alpha;
962bestnfracs = INT_MAX;
968&& nloops < maxloops && nstallloops < maxstallloops
980 SCIPdebugMsg(
scip,
"feasibility pump loop %d: %d fractional variables (alpha: %.4f, stall: %d/%d)\n",
981nloops, nfracs, alpha, nstallloops, maxstallloops);
988maxnflipcands =
SCIPrandomGetInt(heurdata->randnumgen,
MIN(nfracs/2+1, heurdata->minflips),
MIN(nfracs, maxflips));
996 if( heurdata->usefp20 )
1000 for( i = 0; i < npseudocands; i++ )
1003pseudocandsfrac[i] =
MIN(frac, 1.0-frac);
1005pseudocandsfrac[i] -= 10.0;
1007 SCIPsortRealPtr(pseudocandsfrac, (
void**)pseudocands, npseudocands);
1013 for( i = 0; i < npseudocands; i++ )
1019var = pseudocands[i];
1037 if( heurdata->usefp20 )
1044 if( probingvar !=
NULL)
1049solval =
MAX(solval, lbprobing);
1050solval =
MIN(solval, ubprobing);
1055assert(
SCIPisFeasLE(probingscip, lbprobing, ubprobing));
1079 insertFlipCand(mostfracvars, mostfracvals, &nflipcands, maxnflipcands, var, frac);
1082 if( heurdata->usefp20 )
1088 for( i = nbinvars+nintvars; i < nvars; i++ )
1096minimum =
MIN(heurdata->cyclelength, nloops-1);
1097 for( j = 0; j < heurdata->cyclelength; j++ )
1098cycles[j] = (nloops > j+1) && (
REALABS(lastalphas[j] - alpha) < heurdata->alphadiff);
1101 for( i = 0; i < nbinvars+nintvars; i++ )
1106 for( j = 0; j < minimum; j++ )
1116assert(heurdata->perturbfreq > 0);
1117 if( nloops % heurdata->perturbfreq == 0 || (heurdata->pertsolfound &&
SCIPgetNBestSolsFound(
scip) > nbestsolsfound) )
1125minimum =
MIN(heurdata->cyclelength, nloops-1);
1127 for( j = 0; j < minimum; j++ )
1135 SCIPdebugMsg(
scip,
" -> avoiding 1-cycle: flipping %d candidates\n", nflipcands);
1150nlpiterationsleft =
adjustedMaxNLPIterations(maxnlpiterations, nsolsfound, nstallloops) - heurdata->nlpiterations;
1151iterlimit =
MAX((
int)nlpiterationsleft,
MINLPITER);
1152 SCIPdebugMsg(
scip,
" -> solve LP with iteration limit %d\n", iterlimit);
1154 if( heurdata->stage3 )
1173 SCIPwarningMessage(
scip,
"Error while solving LP in Feaspump heuristic; LP solve terminated with code <%d>\n", retcode);
1180heurdata->nlpiterations,
adjustedMaxNLPIterations(maxnlpiterations, nsolsfound, nstallloops), lperror, lpsolstat);
1186 if( heurdata->stage3 )
1190assert(closestsol !=
NULL);
1194 for( i = 0; i < nbinvars+nintvars; i++ )
1201distance +=
REALABS(roundedval - lpval);
1207 for( i = 0; i < nbinvars+nintvars; i++ )
1212mindistance = distance;
1218tmpsol = lastroundedsols[heurdata->cyclelength-1];
1219 for( j = heurdata->cyclelength-1; j > 0; j-- )
1221lastroundedsols[j] = lastroundedsols[j-1];
1222lastalphas[j] = lastalphas[j-1];
1224lastroundedsols[0] = heurdata->roundedsol;
1225lastalphas[0] = alpha;
1226heurdata->roundedsol = tmpsol;
1230 if( nfracs < bestnfracs )
1232bestnfracs = nfracs;
1239nfracs, nstallloops, maxstallloops, heurdata->nlpiterations,
adjustedMaxNLPIterations(maxnlpiterations, nsolsfound, nstallloops));
1248 SCIPdebugMsg(
scip,
"feasibility pump found solution (%d fractional variables)\n", nfracs);
1258 if( heurdata->usefp20 )
1268assert(closestsol !=
NULL);
1272 if( heurdata->usefp20 )
1274assert(probingscip !=
NULL);
1279assert(probingscip ==
NULL);
1312heurdata->nsuccess++;
1315 if( varmapfw !=
NULL)
1318 if( probingscip !=
NULL)
1323 if( heurdata->stage3 )
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);
1386assert(heur !=
NULL);
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",
1435 "heuristics/" HEUR_NAME "/cyclelength",
1436 "maximum length of cycles to be checked explicitly in each round",
1439 "heuristics/" HEUR_NAME "/perturbfreq",
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 SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
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 SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)
void SCIPheurSetTimingmask(SCIP_HEUR *heur, SCIP_HEURTIMING timingmask)
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
int SCIPheurGetFreqofs(SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
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_RETCODE SCIPendDive(SCIP *scip)
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)
SCIP_RETCODE SCIPendProbing(SCIP *scip)
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
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_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
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)
void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
#define DEFAULT_CYCLELENGTH
static SCIP_RETCODE setupProbingSCIP(SCIP *scip, SCIP **probingscip, SCIP_HASHMAP **varmapfw, SCIP_Bool copycuts, SCIP_Bool *success)
static SCIP_DECL_HEURINITSOL(heurInitsolFeaspump)
#define DEFAULT_ALPHADIFF
#define DEFAULT_MAXLPITERQUOT
static SCIP_DECL_HEURFREE(heurFreeFeaspump)
#define DEFAULT_NEIGHBORHOODSIZE
static SCIP_DECL_HEUREXIT(heurExitFeaspump)
static SCIP_DECL_HEUREXEC(heurExecFeaspump)
static SCIP_RETCODE handle1Cycle(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR **mostfracvars, int nflipcands, SCIP_Real alpha, SCIP_Real scalingfactor)
static SCIP_DECL_HEUREXITSOL(heurExitsolFeaspump)
#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_DECL_HEURINIT(heurInitFeaspump)
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)
static SCIP_DECL_HEURCOPY(heurCopyFeaspump)
#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.
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
struct SCIP_HeurData SCIP_HEURDATA
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
enum SCIP_Retcode SCIP_RETCODE
enum SCIP_Status SCIP_STATUS
#define SCIP_HEURTIMING_DURINGLPLOOP
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4