74#define HEUR_NAME "alns"
75#define HEUR_DESC "Large neighborhood search heuristic that orchestrates the popular neighborhoods Local Branching, RINS, RENS, DINS etc."
76#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_LNS
77#define HEUR_PRIORITY -1100500
80#define HEUR_MAXDEPTH -1
81#define HEUR_TIMING SCIP_HEURTIMING_AFTERNODE | SCIP_HEURTIMING_DURINGLPLOOP
82#define HEUR_USESSUBSCIP TRUE
84#define NNEIGHBORHOODS 9
86#define DEFAULT_SHOWNBSTATS FALSE
91#define DEFAULT_NODESQUOT 0.1
92#define DEFAULT_NODESQUOTMIN 0.0
93#define DEFAULT_NODESOFFSET 500LL
94#define DEFAULT_NSOLSLIM 3
95#define DEFAULT_MINNODES 50LL
96#define DEFAULT_MAXNODES 5000LL
97#define DEFAULT_WAITINGNODES 25LL
98#define DEFAULT_TARGETNODEFACTOR 1.05
101#define DEFAULT_INITDURINGROOT FALSE
102#define DEFAULT_MAXCALLSSAMESOL -1
107#define DEFAULT_MINIMPROVELOW 0.01
108#define DEFAULT_MINIMPROVEHIGH 0.01
109#define MINIMPROVEFAC 1.5
110#define DEFAULT_STARTMINIMPROVE 0.01
111#define DEFAULT_ADJUSTMINIMPROVE FALSE
112#define DEFAULT_ADJUSTTARGETNODES TRUE
117#define DEFAULT_BESTSOLWEIGHT 1
118#define DEFAULT_BANDITALGO 'i'
119#define DEFAULT_REWARDCONTROL 0.8
120#define DEFAULT_SCALEBYEFFORT TRUE
121#define DEFAULT_RESETWEIGHTS TRUE
122#define DEFAULT_SUBSCIPRANDSEEDS FALSE
123#define DEFAULT_REWARDBASELINE 0.5
124#define DEFAULT_FIXTOL 0.1
125#define DEFAULT_UNFIXTOL 0.1
126#define DEFAULT_USELOCALREDCOST FALSE
127#define DEFAULT_BETA 0.0
133#define DEFAULT_EPS 0.4685844
134#define DEFAULT_ALPHA 0.0016
135#define DEFAULT_GAMMA 0.07041455
139#define DEFAULT_USEREDCOST TRUE
140#define DEFAULT_USEPSCOST TRUE
141#define DEFAULT_USEDISTANCES TRUE
142#define DEFAULT_DOMOREFIXINGS TRUE
144#define DEFAULT_ADJUSTFIXINGRATE TRUE
145#define FIXINGRATE_DECAY 0.75
146#define FIXINGRATE_STARTINC 0.2
147#define DEFAULT_USESUBSCIPHEURS FALSE
148#define DEFAULT_COPYCUTS FALSE
149#define DEFAULT_REWARDFILENAME "-"
152#define DEFAULT_SEED 113
153#define MUTATIONSEED 121
154#define CROSSOVERSEED 321
157#define DEFAULT_MINFIXINGRATE_RENS 0.3
158#define DEFAULT_MAXFIXINGRATE_RENS 0.9
159#define DEFAULT_ACTIVE_RENS TRUE
160#define DEFAULT_PRIORITY_RENS 1.0
162#define DEFAULT_MINFIXINGRATE_RINS 0.3
163#define DEFAULT_MAXFIXINGRATE_RINS 0.9
164#define DEFAULT_ACTIVE_RINS TRUE
165#define DEFAULT_PRIORITY_RINS 1.0
167#define DEFAULT_MINFIXINGRATE_MUTATION 0.3
168#define DEFAULT_MAXFIXINGRATE_MUTATION 0.9
169#define DEFAULT_ACTIVE_MUTATION TRUE
170#define DEFAULT_PRIORITY_MUTATION 1.0
172#define DEFAULT_MINFIXINGRATE_LOCALBRANCHING 0.3
173#define DEFAULT_MAXFIXINGRATE_LOCALBRANCHING 0.9
174#define DEFAULT_ACTIVE_LOCALBRANCHING TRUE
175#define DEFAULT_PRIORITY_LOCALBRANCHING 1.0
177#define DEFAULT_MINFIXINGRATE_PROXIMITY 0.3
178#define DEFAULT_MAXFIXINGRATE_PROXIMITY 0.9
179#define DEFAULT_ACTIVE_PROXIMITY TRUE
180#define DEFAULT_PRIORITY_PROXIMITY 1.0
182#define DEFAULT_MINFIXINGRATE_CROSSOVER 0.3
183#define DEFAULT_MAXFIXINGRATE_CROSSOVER 0.9
184#define DEFAULT_ACTIVE_CROSSOVER TRUE
185#define DEFAULT_PRIORITY_CROSSOVER 1.0
187#define DEFAULT_MINFIXINGRATE_ZEROOBJECTIVE 0.3
188#define DEFAULT_MAXFIXINGRATE_ZEROOBJECTIVE 0.9
189#define DEFAULT_ACTIVE_ZEROOBJECTIVE TRUE
190#define DEFAULT_PRIORITY_ZEROOBJECTIVE 1.0
192#define DEFAULT_MINFIXINGRATE_DINS 0.3
193#define DEFAULT_MAXFIXINGRATE_DINS 0.9
194#define DEFAULT_ACTIVE_DINS TRUE
195#define DEFAULT_PRIORITY_DINS 1.0
197#define DEFAULT_MINFIXINGRATE_TRUSTREGION 0.3
198#define DEFAULT_MAXFIXINGRATE_TRUSTREGION 0.9
199#define DEFAULT_ACTIVE_TRUSTREGION FALSE
200#define DEFAULT_PRIORITY_TRUSTREGION 1.0
203#define DEFAULT_NSOLS_CROSSOVER 2
204#define DEFAULT_NPOOLSOLS_DINS 5
205#define DEFAULT_VIOLPENALTY_TRUSTREGION 100.0
208#define EVENTHDLR_NAME "Alns"
209#define EVENTHDLR_DESC "LP event handler for " HEUR_NAME " heuristic"
210#define SCIP_EVENTTYPE_ALNS (SCIP_EVENTTYPE_LPSOLVED | SCIP_EVENTTYPE_SOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND)
213#define TABLE_NAME_NEIGHBORHOOD "neighborhood"
214#define TABLE_DESC_NEIGHBORHOOD "ALNS neighborhood statistics"
215#define TABLE_POSITION_NEIGHBORHOOD 12500
216#define TABLE_EARLIEST_STAGE_NEIGHBORHOOD SCIP_STAGE_TRANSFORMED
257 #define DECL_VARFIXINGS(x) SCIP_RETCODE x ( \
263 SCIP_RESULT* result \
274#define DECL_CHANGESUBSCIP(x) SCIP_RETCODE x ( \
278 SCIP_VAR** subvars, \
286#define DECL_NHINIT(x) SCIP_RETCODE x ( \
292#define DECL_NHEXIT(x) SCIP_RETCODE x ( \
298#define DECL_NHFREE(x) SCIP_RETCODE x ( \
311#define DECL_NHREFSOL(x) SCIP_RETCODE x ( \
315 SCIP_RESULT* result \
319#define DECL_NHDEACTIVATE(x) SCIP_RETCODE x (\
321 SCIP_Bool* deactivate \
336#define NHISTENTRIES 7
420 char* rewardfilename;
446 int nactiveneighborhoods;
447 int ninitneighborhoods;
450 int currneighborhood;
591 switch (subscipstatus)
656 switch (subscipstatus)
735 switch (subscipstatus)
831 (*neighborhood)->changesubscip = changesubscip;
832 (*neighborhood)->varfixings = varfixings;
833 (*neighborhood)->nhinit = nhinit;
834 (*neighborhood)->nhexit = nhexit;
835 (*neighborhood)->nhfree = nhfree;
836 (*neighborhood)->nhrefsol = nhrefsol;
837 (*neighborhood)->nhdeactivate = nhdeactivate;
842 &(*neighborhood)->fixingrate.minfixingrate,
TRUE, minfixingrate, 0.0, 1.0,
NULL,
NULL) );
845 &(*neighborhood)->fixingrate.maxfixingrate,
TRUE, maxfixingrate, 0.0, 1.0,
NULL,
NULL) );
851 &(*neighborhood)->priority,
TRUE, priority, 1e-2, 1.0,
NULL,
NULL) );
870 nhptr = *neighborhood;
876 if( nhptr->nhfree !=
NULL )
885 *neighborhood =
NULL;
901 if( neighborhood->nhinit !=
NULL )
919 if( neighborhood->nhexit !=
NULL )
948 sourcescip = eventdata->sourcescip;
949 subvars = eventdata->subvars;
950 heur = eventdata->heur;
951 runstats = eventdata->runstats;
953 assert(sourcescip != subscip);
965 if( eventdata->allrewardsmode )
1072 switch (subscipstatus)
1107 SCIPinfoMessage(
scip, file,
"Neighborhoods : %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %4s %4s %4s %4s %4s %4s %4s %4s\n",
1108 "Calls",
"SetupTime",
"SolveTime",
"SolveNodes",
"Sols",
"Best",
"Exp3",
"Exp3-IX",
"EpsGreedy",
"UCB",
"TgtFixRate",
1109 "Opt",
"Inf",
"Node",
"Stal",
"Sol",
"Usr",
"Othr",
"Actv");
1120 neighborhood =
heurdata->neighborhoods[
i];
1132 epsgreedyweight = -1.0;
1179 stats = &neighborhood->
stats;
1242 else if( dist1 > dist2 )
1298 if( ! uselocalredcost )
1323 score = redcost * (refsolval - bestbound);
1326 if( ! uselocalredcost )
1327 score =
MAX(score, 0.0);
1391 varbuf[*nfixings] =
var;
1392 valbuf[*nfixings] = val;
1410 if( neighborhood->nhrefsol !=
NULL )
1480 if( ntargetfixings >= nbinintvars )
1484 nvarstoadd = ntargetfixings - *nfixings;
1485 if( nvarstoadd == 0 )
1518 for(
b = 0;
b < *nfixings; ++
b )
1526 if( probindex < nbinintvars )
1527 isfixed[probindex] =
TRUE;
1534 for(
b = 0;
b < nbinintvars; ++
b )
1549 unfixedvars[nunfixedvars] =
var;
1550 perm[nunfixedvars] = nunfixedvars;
1554 solvals[nunfixedvars] = solvals[
b];
1555 distances[nunfixedvars] = distances[
b];
1557 SCIPdebugMsg(
scip,
"Var <%s> scores: dist %3d, red cost %15.9g, pscost %15.9g rand %6.4f\n",
1559 pscostscores[nunfixedvars], randscores[nunfixedvars]);
1570 nvarstoadd =
MIN(nunfixedvars, nvarstoadd);
1573 if( nvarstoadd < nunfixedvars )
1574 SCIPselectInd(perm, sortIndCompAlns, &varprio, nvarstoadd, nunfixedvars);
1577 for(
b = 0;
b < nvarstoadd; ++
b )
1579 int permindex = perm[
b];
1581 assert(permindex < nunfixedvars);
1607 unsigned int initseed
1624 heurdata->nactiveneighborhoods, initseed) );
1685 int* fixeddistances;
1695 if( nbinintvars == 0 )
1718 for(
i = 0;
i < *nfixings; ++
i )
1724 isfixedvar[probindex] =
TRUE;
1730 for(
i = 0;
i < nbinintvars; ++
i )
1732 if( ! isfixedvar[
i] )
1733 unfixedvars[nunfixed++] =
vars[
i];
1743 for(
i = 0;
i < *nfixings; ++
i )
1746 if( probindex >= 0 )
1747 fixeddistances[
i] = distances[probindex];
1757 for(
i = 0;
i < *nfixings; ++
i )
1768 SCIPdebugMsg(
scip,
"Var <%s> scores: dist %3d, red cost %15.9g, pscost %15.9g rand %6.4f\n",
1769 SCIPvarGetName(fixedvar), fixeddistances[
i], redcostscores[
i], pscostscores[
i], randscores[
i]);
1784 for(
i = 0;
i < ntargetfixings; ++
i )
1786 valbuf[
i] = valbufcpy[perm[
i]];
1787 varbuf[
i] = varbufcpy[perm[
i]];
1790 *nfixings = ntargetfixings;
1838 if( neighborhood->varfixings !=
NULL )
1840 SCIP_CALL( neighborhood->varfixings(
scip, neighborhood, varbuf, valbuf, nfixings,
result) );
1845 else if( ntargetfixings == 0 )
1857 nminfixings =
MAX(nminfixings, 0);
1859 nmaxfixings =
MIN(nmaxfixings, nbinintvars);
1861 SCIPdebugMsg(
scip,
"Neighborhood Fixings/Target: %d / %d <= %d <= %d\n",*nfixings, nminfixings, ntargetfixings, nmaxfixings);
1873 if( refsol !=
NULL )
1887 SCIPdebugMsg(
scip,
"After additional fixings: %d / %d\n",*nfixings, ntargetfixings);
1889 else if( (
SCIP_Real)(*nfixings) > nmaxfixings )
1897 SCIPdebugMsg(
scip,
"Unfixed variables, fixed variables remaining: %d\n", ntargetfixings);
1935 if( neighborhood->changesubscip !=
NULL )
1937 SCIP_CALL( neighborhood->changesubscip(sourcescip, targetscip, neighborhood, targetvars, ndomchgs, nchgobjs, naddedconss, success) );
2013 nodesquot =
MAX(nodesquot,
heurdata->nodesquotmin);
2024 initfactor = (
heurdata->nactiveneighborhoods -
heurdata->ninitneighborhoods + 1.0) / (
heurdata->nactiveneighborhoods + 1.0);
2050 int* neighborhoodidx
2058 *neighborhoodidx = -1;
2063 assert(*neighborhoodidx >= 0);
2081 memset(rewardptr, 0,
sizeof(*rewardptr)*(
int)
NREWARDTYPES);
2091 if( ndiscretevars > 0 )
2125 reward /= (effort + 1.0);
2128 reward =
heurdata->rewardbaseline + (1.0 -
heurdata->rewardbaseline) * reward;
2136 if( ndiscretevars > 0 )
2161 assert(neighborhoodidx >= 0);
2162 assert(neighborhoodidx < heurdata->nactiveneighborhoods);
2166 SCIPdebugMsg(
scip,
"Rewarding bandit algorithm action %d with reward %.2f\n", neighborhoodidx, reward);
2198#ifdef ALNS_SUBSCIPOUTPUT
2317 SCIPdebugMsg(
scip,
"Solve Limits: %lld (%lld) nodes (stall nodes), %.1f sec., %d sols\n",
2338 int neighborhoodidx;
2356 if(
heurdata->nactiveneighborhoods == 0 )
2371 if(
heurdata->maxcallssamesol != -1 )
2411 if( allrewardsmode )
2425 SCIPdebugMsg(
scip,
"Delay ALNS heuristic until a feasible node with optimally solved LP relaxation\n");
2432 if(
heurdata->currneighborhood >= 0 )
2434 assert(! allrewardsmode);
2435 banditidx =
heurdata->currneighborhood;
2441 SCIPdebugMsg(
scip,
"Selected neighborhood %d with bandit algorithm\n", banditidx);
2445 if( ! allrewardsmode )
2446 neighborhoodidx = banditidx;
2448 neighborhoodidx = 0;
2476 neighborhood =
heurdata->neighborhoods[neighborhoodidx];
2501 if( allrewardsmode )
2503 if( ntries ==
heurdata->nactiveneighborhoods )
2506 neighborhoodidx = (neighborhoodidx + 1) %
heurdata->nactiveneighborhoods;
2525 else if(
heurdata->currneighborhood == -1 )
2527 heurdata->currneighborhood = neighborhoodidx;
2538 if( ntries < heurdata->nactiveneighborhoods )
2545 SCIPdebugMsg(
scip,
"Neighborhood cannot run -> try next neighborhood %d\n", neighborhoodidx);
2560 runstats[neighborhoodidx].
nfixings = nfixings;
2567 SCIP_CALL(
SCIPcopyLargeNeighborhoodSearch(
scip, subscip, varmapf, probnamesuffix, varbuf, valbuf, nfixings,
FALSE,
heurdata->copycuts, &success,
NULL) );
2570 for( v = 0; v <
nvars; ++v )
2584 if( ! allrewardsmode || ntries ==
heurdata->nactiveneighborhoods )
2587 neighborhoodidx = (neighborhoodidx + 1) %
heurdata->nactiveneighborhoods;
2600 eventdata.nodelimit = solvelimits.
nodelimit;
2601 eventdata.lplimfac =
heurdata->lplimfac;
2602 eventdata.heur = heur;
2603 eventdata.sourcescip =
scip;
2604 eventdata.subvars = subvars;
2605 eventdata.runstats = &runstats[neighborhoodidx];
2606 eventdata.allrewardsmode = allrewardsmode;
2623 SCIPwarningMessage(
scip,
"Error while presolving subproblem in ALNS heuristic; sub-SCIP terminated with code <%d>\n", retcode);
2634 allfixingrate =
MAX(allfixingrate, 0.0);
2643 SCIPdebugMsg(
scip,
"Fixed only %.3f of all variables after presolving -> do not solve sub-SCIP\n", allfixingrate);
2646#ifdef ALNS_SUBSCIPOUTPUT
2655 SCIPdebugMsg(
scip,
"Status of sub-SCIP run: %d\n", subscipstatus[neighborhoodidx]);
2660 if( allrewardsmode && ntries < heurdata->nactiveneighborhoods )
2662 neighborhoodidx = (neighborhoodidx + 1) %
heurdata->nactiveneighborhoods;
2671 if( subscip !=
NULL )
2681 if( ! allrewardsmode )
2682 banditidx = neighborhoodidx;
2698 if(
heurdata->adjustfixingrate && ! allrewardsmode )
2725 if( allrewardsmode )
2729 for(
i = 0;
i <
heurdata->nactiveneighborhoods; ++
i )
2730 fprintf(
heurdata->rewardfile,
"%.4f,", rewards[
i][j]);
2732 fprintf(
heurdata->rewardfile,
"%d\n", banditidx);
2746 int *fracidx =
NULL;
2790 fracidx[nfracs++] =
i;
2835 if( subvars[
i] ==
NULL )
2892 nvars = nbinintvars;
2898 for( v = 0; v <
nvars; ++v )
2909 for( s = 1; s < nsols; ++s )
2951 if( incumbent ==
NULL )
2965 sols[1] = incumbent;
3036 nsols = data->
nsols;
3060 if( lastdraw == nsols )
3065 for( s = 0; s < nsols; ++s )
3066 sols[s] = scipsols[s];
3074 assert(nsols < lastdraw);
3080 sols[nsols - 1] = scipsols[nextdraw];
3082 lastdraw = nextdraw;
3184 if( nbinintvars == 0 )
3188 if( incumbentsol ==
NULL )
3192 ntargetfixings = (int)(targetfixingrate * nbinintvars) + 1;
3195 if( nbinintvars <= ntargetfixings )
3204 for(
i = 0; *nfixings < ntargetfixings &&
i < nbinintvars; ++
i )
3207 assert(randint < nbinintvars);
3217 assert(
i == nbinintvars || *nfixings == ntargetfixings);
3224 if( *nfixings == ntargetfixings )
3262 if( referencesol ==
NULL )
3266 rhs =
MAX(rhs, 2.0);
3274 if( subvars[
i] ==
NULL )
3326 if( referencesol ==
NULL )
3335 if( subvars[
i] ==
NULL )
3349 if( subvars[
i] ==
NULL )
3389 if( subvars[
i] ==
NULL )
3430 if(
REALABS(lpsol - mipsol) >= 0.5 )
3438 range = 2 * lpsol - mipsol;
3440 if( mipsol >= lpsol )
3443 *lbptr =
MAX(*lbptr, range);
3454 *ubptr =
MIN(*ubptr, range);
3464 *lbptr =
MAX(*lbptr, lbglobal);
3465 *ubptr =
MIN(*ubptr, ubglobal);
3470 *lbptr =
MAX(mipsol, lbglobal);
3471 *ubptr =
MIN(mipsol, ubglobal);
3518 nsols = nmipsols + 2;
3522 sols[1] = rootlpsol;
3574 if( subvars[v] ==
NULL )
3624 SCIPdebugMsg(sourcescip,
"changeSubscipTrustregion unsuccessful, because it was called without incumbent being present\n");
3725 varFixingsRens, changeSubscipRens,
NULL,
NULL,
NULL,
NULL, nhDeactivateDiscreteVars) );
3730 varFixingsRins,
NULL,
NULL,
NULL,
NULL, nhRefsolIncumbent, nhDeactivateDiscreteVars) );
3735 varFixingsMutation,
NULL, nhInitMutation, nhExitMutation,
NULL, nhRefsolIncumbent, nhDeactivateDiscreteVars) );
3740 NULL, changeSubscipLocalbranching,
NULL,
NULL,
NULL, nhRefsolIncumbent, nhDeactivateBinVars) );
3745 varFixingsCrossover,
NULL,
3746 nhInitCrossover, nhExitCrossover, nhFreeCrossover, nhRefsolCrossover, nhDeactivateDiscreteVars) );
3759 NULL, changeSubscipProximity,
NULL,
NULL,
NULL, nhRefsolIncumbent, nhDeactivateBinVars) );
3764 NULL, changeSubscipZeroobjective,
NULL,
NULL,
NULL, nhRefsolIncumbent, nhDeactivateObjVars) );
3769 varFixingsDins, changeSubscipDins,
NULL,
NULL, nhFreeDins, nhRefsolIncumbent, nhDeactivateBinVars) );
3776 "number of pool solutions where binary solution values must agree",
3782 NULL, changeSubscipTrustregion,
NULL,
NULL, nhFreeTrustregion, nhRefsolIncumbent, nhDeactivateBinVars) );
3788 "the penalty for each change in the binary variables from the candidate solution",
3849 unsigned int initseed;
3861 for(
i =
heurdata->nneighborhoods - 1;
i >= 0; --
i )
3869 if( deactivate || ! neighborhood->
active )
3871 if(
heurdata->nactiveneighborhoods - 1 >
i )
3881 for(
i = 0;
i <
heurdata->nactiveneighborhoods; ++
i )
3882 priorities[
i] =
heurdata->neighborhoods[
i]->priority;
3894 if(
heurdata->nactiveneighborhoods > 0 )
4045 "show statistics on neighborhoods?",
4050 "maximum number of nodes to regard in the subproblem",
4054 "offset added to the nodes budget",
4058 "minimum number of nodes required to start a sub-SCIP",
4062 "number of nodes since last incumbent solution that the heuristic should wait",
4066 "fraction of nodes compared to the main SCIP for budget computation",
4069 "lower bound fraction of nodes compared to the main SCIP for budget computation",
4073 "initial factor by which ALNS should at least improve the incumbent",
4077 "lower threshold for the minimal improvement over the incumbent",
4081 "upper bound for the minimal improvement over the incumbent",
4085 "limit on the number of improving solutions in a sub-SCIP call",
4089 "the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x",
4093 "weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3",
4097 "reward offset between 0 and 1 at every observation for Exp.3",
4101 "parameter to increase the confidence width in UCB",
4105 "distances from fixed variables be used for variable prioritization",
4109 "should reduced cost scores be used for variable prioritization?",
4113 "should the ALNS heuristic do more fixings by itself based on variable prioritization "
4114 "until the target fixing rate is reached?",
4118 "should the heuristic adjust the target fixing rate based on the success?",
4122 "should the heuristic activate other sub-SCIP heuristics during its search?",
4126 "reward control to increase the weight of the simple solution indicator and decrease the weight of the closed gap reward",
4130 "factor by which target node number is eventually increased",
4134 "initial random seed for bandit algorithms and random decisions by neighborhoods",
4137 "number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active neighborhoods)",
4141 "should the factor by which the minimum improvement is bound be dynamically updated?",
4145 "should the target nodes be dynamically adjusted?",
4149 "increase exploration in epsilon-greedy bandit algorithm",
4153 "the reward baseline to separate successful and failed calls",
4157 "should the bandit algorithms be reset when a new problem is read?",
4164 "should random seeds of sub-SCIPs be altered to increase diversification?",
4168 "should the reward be scaled by the effort?",
4172 "should cutting planes be copied to the sub-SCIP?",
4176 "tolerance by which the fixing rate may be missed without generic fixing",
4180 "tolerance by which the fixing rate may be exceeded without generic unfixing",
4184 "should local reduced costs be used for generic (un)fixing?",
4188 "should pseudo cost scores be used for variable priorization?",
4192 "should the heuristic be executed multiple times during the root node?",
static GRAPHNODE ** active
Constraint handler for linear constraints in their most general form, .
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
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 SCIPtranslateSubSol(SCIP *scip, SCIP *subscip, SCIP_SOL *subsol, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_SOL **newsol)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
int SCIPgetNObjVars(SCIP *scip)
int SCIPgetNIntVars(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)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
SCIP_Bool SCIPisObjIntegral(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 SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
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 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 SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
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 SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
void SCIPswapPointers(void **pointer1, void **pointer2)
SCIP_RETCODE SCIPincludeHeurAlns(SCIP *scip)
SCIP_RETCODE SCIPresetBandit(SCIP *scip, SCIP_BANDIT *bandit, SCIP_Real *priorities, unsigned int seed)
SCIP_RETCODE SCIPbanditUpdate(SCIP_BANDIT *bandit, int action, SCIP_Real score)
int SCIPbanditGetNActions(SCIP_BANDIT *bandit)
SCIP_Real SCIPgetProbabilityExp3IX(SCIP_BANDIT *exp3ix, int action)
SCIP_Real * SCIPgetWeightsEpsgreedy(SCIP_BANDIT *epsgreedy)
SCIP_RANDNUMGEN * SCIPbanditGetRandnumgen(SCIP_BANDIT *bandit)
SCIP_RETCODE SCIPcreateBanditExp3(SCIP *scip, SCIP_BANDIT **exp3, SCIP_Real *priorities, SCIP_Real gammaparam, SCIP_Real beta, int nactions, unsigned int initseed)
SCIP_RETCODE SCIPcreateBanditEpsgreedy(SCIP *scip, SCIP_BANDIT **epsgreedy, SCIP_Real *priorities, SCIP_Real eps, SCIP_Bool usemodification, SCIP_Bool preferrecent, SCIP_Real decayfactor, int avglim, int nactions, unsigned int initseed)
SCIP_Real SCIPgetConfidenceBoundUcb(SCIP_BANDIT *ucb, int action)
SCIP_RETCODE SCIPcreateBanditExp3IX(SCIP *scip, SCIP_BANDIT **exp3ix, SCIP_Real *priorities, int nactions, unsigned int initseed)
SCIP_RETCODE SCIPbanditSelect(SCIP_BANDIT *bandit, int *action)
SCIP_RETCODE SCIPcreateBanditUcb(SCIP *scip, SCIP_BANDIT **ucb, SCIP_Real *priorities, SCIP_Real alpha, int nactions, unsigned int initseed)
SCIP_RETCODE SCIPfreeBandit(SCIP *scip, SCIP_BANDIT **bandit)
SCIP_Real SCIPgetProbabilityExp3(SCIP_BANDIT *exp3, int action)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
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,)
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
int SCIPheurGetFreq(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)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
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 SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_SOLORIGIN SCIPsolGetOrigin(SCIP_SOL *sol)
SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)
int SCIPgetNSols(SCIP *scip)
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_SOL ** SCIPgetSols(SCIP *scip)
SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
SCIP_RETCODE SCIPtrySolFree(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 SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
SCIP_RETCODE SCIPpresolve(SCIP *scip)
SCIP_RETCODE SCIPinterruptSolve(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_Longint SCIPgetNLPs(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_RETCODE SCIPaddTrustregionNeighborhoodConstraint(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **subvars, SCIP_Real violpenalty)
SCIP_RETCODE SCIPcopyLargeNeighborhoodSearch(SCIP *sourcescip, SCIP *subscip, SCIP_HASHMAP *varmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool uselprows, SCIP_Bool copycuts, SCIP_Bool *success, SCIP_Bool *valid)
SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)
SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstopClock(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_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisDualfeasNegative(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 SCIPisDualfeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
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_Real SCIPround(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisDualfeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsumepsilon(SCIP *scip)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPvariablegraphBreadthFirst(SCIP *scip, SCIP_VGRAPH *vargraph, SCIP_VAR **startvars, int nstartvars, int *distances, int maxdistance, int maxvars, int maxbinintvars)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootSol(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_Real SCIPvarGetRootSol(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootRedcost(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 SCIPselectInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
void SCIPselectDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, 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_BESTSOLWEIGHT
static void tryAdd2variableBuffer(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_VAR **varbuf, SCIP_Real *valbuf, int *nfixings, SCIP_Bool integer)
static void updateRunStats(NH_STATS *stats, SCIP *subscip)
#define DEFAULT_ACTIVE_MUTATION
#define DEFAULT_MINFIXINGRATE_ZEROOBJECTIVE
static SCIP_RETCODE alnsFixMoreVariables(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_SOL *refsol, SCIP_VAR **varbuf, SCIP_Real *valbuf, int *nfixings, int ntargetfixings, SCIP_Bool *success)
static SCIP_RETCODE alnsFreeNeighborhood(SCIP *scip, NH **neighborhood)
#define TABLE_POSITION_NEIGHBORHOOD
#define DEFAULT_NODESQUOT
static void increaseFixingRate(NH_FIXINGRATE *fx)
#define DEFAULT_MINIMPROVEHIGH
#define DEFAULT_MAXCALLSSAMESOL
#define DECL_NHDEACTIVATE(x)
static SCIP_RETCODE neighborhoodStatsReset(SCIP *scip, NH_STATS *stats)
#define DEFAULT_MINIMPROVELOW
#define DEFAULT_REWARDBASELINE
#define DEFAULT_PRIORITY_RENS
#define DEFAULT_ACTIVE_PROXIMITY
#define DEFAULT_NODESQUOTMIN
#define DEFAULT_MINFIXINGRATE_DINS
#define DEFAULT_ACTIVE_RINS
static void updateNeighborhoodStats(NH_STATS *runstats, NH *neighborhood, SCIP_STATUS subscipstatus)
#define TABLE_NAME_NEIGHBORHOOD
static SCIP_RETCODE neighborhoodGetRefsol(SCIP *scip, NH *neighborhood, SCIP_SOL **solptr)
#define DEFAULT_USEREDCOST
#define DEFAULT_ADJUSTFIXINGRATE
#define DEFAULT_ADJUSTMINIMPROVE
static void decreaseFixingRate(NH_FIXINGRATE *fx)
static void increaseMinimumImprovement(SCIP_HEURDATA *heurdata)
static SCIP_RETCODE updateBanditAlgorithm(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_Real reward, int neighborhoodidx)
#define FIXINGRATE_STARTINC
static void resetMinimumImprovement(SCIP_HEURDATA *heurdata)
#define DEFAULT_MAXFIXINGRATE_RENS
#define DEFAULT_PRIORITY_PROXIMITY
static void resetTargetNodeLimit(SCIP_HEURDATA *heurdata)
static SCIP_RETCODE neighborhoodInit(SCIP *scip, NH *neighborhood)
#define DEFAULT_STARTMINIMPROVE
static SCIP_RETCODE alnsIncludeNeighborhood(SCIP *scip, SCIP_HEURDATA *heurdata, NH **neighborhood, const char *name, SCIP_Real minfixingrate, SCIP_Real maxfixingrate, SCIP_Bool active, SCIP_Real priority, DECL_VARFIXINGS((*varfixings)), DECL_CHANGESUBSCIP((*changesubscip)), DECL_NHINIT((*nhinit)), DECL_NHEXIT((*nhexit)), DECL_NHFREE((*nhfree)), DECL_NHREFSOL((*nhrefsol)),)
#define DEFAULT_ACTIVE_TRUSTREGION
#define DEFAULT_MINFIXINGRATE_RENS
#define DEFAULT_MAXFIXINGRATE_DINS
#define DEFAULT_MINFIXINGRATE_RINS
struct NH_FixingRate NH_FIXINGRATE
#define DEFAULT_PRIORITY_ZEROOBJECTIVE
static void updateMinimumImprovement(SCIP_HEURDATA *heurdata, SCIP_STATUS subscipstatus, NH_STATS *runstats)
#define DEFAULT_WAITINGNODES
struct data_mutation DATA_MUTATION
#define DEFAULT_NODESOFFSET
#define TABLE_DESC_NEIGHBORHOOD
#define DECL_CHANGESUBSCIP(x)
struct data_trustregion DATA_TRUSTREGION
@ REWARDTYPE_NOSOLPENALTY
#define DEFAULT_RESETWEIGHTS
static void increaseTargetNodeLimit(SCIP_HEURDATA *heurdata)
#define DEFAULT_MAXFIXINGRATE_MUTATION
#define TABLE_EARLIEST_STAGE_NEIGHBORHOOD
#define DEFAULT_ADJUSTTARGETNODES
static void updateTargetNodeLimit(SCIP_HEURDATA *heurdata, NH_STATS *runstats, SCIP_STATUS subscipstatus)
#define DEFAULT_USELOCALREDCOST
#define DEFAULT_MAXFIXINGRATE_TRUSTREGION
#define DEFAULT_MAXFIXINGRATE_ZEROOBJECTIVE
static void updateFixingRate(NH *neighborhood, SCIP_STATUS subscipstatus, NH_STATS *runstats)
static void initRunStats(SCIP *scip, NH_STATS *stats)
static SCIP_BANDIT * getBandit(SCIP_HEURDATA *heurdata)
static SCIP_RETCODE selectNeighborhood(SCIP *scip, SCIP_HEURDATA *heurdata, int *neighborhoodidx)
#define DEFAULT_ACTIVE_RENS
static void updateFixingRateIncrement(NH_FIXINGRATE *fx)
#define DEFAULT_MINFIXINGRATE_CROSSOVER
static SCIP_RETCODE addLocalBranchingConstraint(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **subvars, int distance, SCIP_Bool *success, int *naddedconss)
#define DEFAULT_REWARDCONTROL
#define DEFAULT_ACTIVE_ZEROOBJECTIVE
#define DEFAULT_MINFIXINGRATE_LOCALBRANCHING
#define SCIP_EVENTTYPE_ALNS
static SCIP_RETCODE determineLimits(SCIP *scip, SCIP_HEUR *heur, SOLVELIMITS *solvelimits, SCIP_Bool *runagain)
#define DEFAULT_PRIORITY_CROSSOVER
#define DEFAULT_DOMOREFIXINGS
static SCIP_RETCODE setLimits(SCIP *subscip, SOLVELIMITS *solvelimits)
#define DEFAULT_INITDURINGROOT
#define DEFAULT_VIOLPENALTY_TRUSTREGION
struct SolveLimits SOLVELIMITS
static SCIP_RETCODE resetFixingRate(SCIP *scip, NH_FIXINGRATE *fixingrate)
#define DEFAULT_ACTIVE_LOCALBRANCHING
static void decreaseMinimumImprovement(SCIP_HEURDATA *heurdata)
static SCIP_RETCODE fixMatchingSolutionValues(SCIP *scip, SCIP_SOL **sols, int nsols, SCIP_VAR **vars, int nvars, SCIP_VAR **varbuf, SCIP_Real *valbuf, int *nfixings)
#define DEFAULT_PRIORITY_MUTATION
#define DEFAULT_PRIORITY_RINS
#define DEFAULT_REWARDFILENAME
static SCIP_Real getVariablePscostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real refsolval, SCIP_Bool uselocallpsol)
static int getHistIndex(SCIP_STATUS subscipstatus)
#define DEFAULT_ACTIVE_DINS
#define DEFAULT_PRIORITY_TRUSTREGION
#define DEFAULT_MAXFIXINGRATE_LOCALBRANCHING
#define DEFAULT_SUBSCIPRANDSEEDS
#define DEFAULT_NPOOLSOLS_DINS
static void computeIntegerVariableBoundsDins(SCIP *scip, SCIP_VAR *var, SCIP_Real *lbptr, SCIP_Real *ubptr)
#define DEFAULT_MAXFIXINGRATE_RINS
static SCIP_RETCODE includeNeighborhoods(SCIP *scip, SCIP_HEURDATA *heurdata)
#define DEFAULT_MINFIXINGRATE_MUTATION
#define DEFAULT_TARGETNODEFACTOR
#define DEFAULT_MAXFIXINGRATE_CROSSOVER
#define DEFAULT_NSOLS_CROSSOVER
#define DEFAULT_USEDISTANCES
struct data_dins DATA_DINS
#define DEFAULT_SCALEBYEFFORT
static void resetCurrentNeighborhood(SCIP_HEURDATA *heurdata)
static SCIP_RETCODE getReward(SCIP *scip, SCIP_HEURDATA *heurdata, NH_STATS *runstats, SCIP_Real *rewardptr)
struct data_crossover DATA_CROSSOVER
static SCIP_Real getVariableRedcostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real refsolval, SCIP_Bool uselocalredcost)
#define DEFAULT_SHOWNBSTATS
static SCIP_RETCODE alnsUnfixVariables(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_VAR **varbuf, SCIP_Real *valbuf, int *nfixings, int ntargetfixings, SCIP_Bool *success)
static SCIP_RETCODE neighborhoodExit(SCIP *scip, NH *neighborhood)
#define DEFAULT_ACTIVE_CROSSOVER
#define DEFAULT_USESUBSCIPHEURS
#define DEFAULT_PRIORITY_DINS
static void printNeighborhoodStatistics(SCIP *scip, SCIP_HEURDATA *heurdata, FILE *file)
static SCIP_RETCODE setupSubScip(SCIP *scip, SCIP *subscip, SCIP_VAR **subvars, SOLVELIMITS *solvelimits, SCIP_HEUR *heur, SCIP_Bool objchgd)
#define DEFAULT_MAXFIXINGRATE_PROXIMITY
static SCIP_RETCODE neighborhoodChangeSubscip(SCIP *sourcescip, SCIP *targetscip, NH *neighborhood, SCIP_VAR **targetvars, int *ndomchgs, int *nchgobjs, int *naddedconss, SCIP_Bool *success)
#define DECL_VARFIXINGS(x)
#define DEFAULT_PRIORITY_LOCALBRANCHING
#define DEFAULT_MINFIXINGRATE_TRUSTREGION
#define DEFAULT_BANDITALGO
#define DEFAULT_MINFIXINGRATE_PROXIMITY
static SCIP_RETCODE createBandit(SCIP *scip, SCIP_HEURDATA *heurdata, SCIP_Real *priorities, unsigned int initseed)
static SCIP_RETCODE neighborhoodFixVariables(SCIP *scip, SCIP_HEURDATA *heurdata, NH *neighborhood, SCIP_VAR **varbuf, SCIP_Real *valbuf, int *nfixings, SCIP_RESULT *result)
#define DEFAULT_USEPSCOST
static SCIP_RETCODE transferSolution(SCIP *subscip, SCIP_EVENTDATA *eventdata)
Adaptive large neighborhood search heuristic that orchestrates popular LNS heuristics.
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
methods commonly used by primal heuristics
static const char * paramname[]
memory allocation routines
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSclearMemory(ptr)
#define BMSfreeMemoryArray(ptr)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for bandit algorithms
public methods for the epsilon greedy bandit selector
public methods for Exp.3-IX
public methods for UCB bandit selection
public methods for managing constraints
public methods for managing events
public methods for primal heuristics
public methods for message output
public data structures and miscellaneous methods
methods for selecting (weighted) k-medians
public methods for primal CIP solutions
public methods for problem variables
public methods for bandit algorithms
public methods for branching rule plugins and branching
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for event handler plugins and event handlers
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 global and local (sub)problems
public methods for random numbers
public methods for solutions
public methods for querying solving statistics
public methods for statistics table plugins
public methods for timing
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_Real targetfixingrate
int statushist[NHISTENTRIES]
SCIP_Longint nbestsolsfound
DECL_CHANGESUBSCIP((*changesubscip))
union Nh::@134264243327243237357224041227301111216002025114 data
DATA_CROSSOVER * crossover
DECL_NHDEACTIVATE((*nhdeactivate))
DATA_TRUSTREGION * trustregion
DECL_VARFIXINGS((*varfixings))
DECL_NHREFSOL((*nhrefsol))
unsigned int usedistances
SCIP_Real * redcostscores
struct SCIP_Bandit SCIP_BANDIT
struct SCIP_Clock SCIP_CLOCK
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Eventhdlr SCIP_EVENTHDLR
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_BESTSOLFOUND
#define SCIP_EVENTTYPE_SOLFOUND
#define SCIP_EVENTTYPE_LPSOLVED
#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_HEUREXEC(x)
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTINDCOMP(x)
struct SCIP_RandNumGen SCIP_RANDNUMGEN
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_SOLORIGIN_ORIGINAL
@ SCIP_STATUS_TOTALNODELIMIT
@ SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_PRIMALLIMIT
@ SCIP_STATUS_USERINTERRUPT
@ SCIP_STATUS_STALLNODELIMIT
@ SCIP_STATUS_RESTARTLIMIT
enum SCIP_Status SCIP_STATUS
#define SCIP_DECL_TABLEOUTPUT(x)
#define SCIP_HEURTIMING_DURINGLPLOOP