/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecGuideddiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_DIVESET* diveset;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* don't dive, if no feasible solutions exist */
if( SCIPgetNSols(scip) == 0 )
return SCIP_OKAY;
/* get best solution that should guide the search; if this solution lives in the original variable space,
* we cannot use it since it might violate the global bounds of the current problem
*/
if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
return SCIP_OKAY;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* if there are no integer variables (note that, e.g., SOS1 variables may be present) */
if ( SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip) == 0 )
return SCIP_OKAY;
assert(SCIPheurGetNDivesets(heur) > 0);
assert(SCIPheurGetDivesets(heur) != NULL);
diveset = SCIPheurGetDivesets(heur)[0];
assert(diveset != NULL);
/* call generic diving algorithm */
SCIP_CALL( SCIPperformGenericDivingAlgorithm(scip, diveset, heurdata->sol, heur, result, nodeinfeasible) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecMutation)
{ /*lint --e{715}*/
SCIP_Longint maxnnodes;
SCIP_Longint nsubnodes; /* node limit for the subproblem */
SCIP_HEURDATA* heurdata; /* heuristic's data */
SCIP* subscip; /* the subproblem created by mutation */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real maxnnodesr;
SCIP_Real memorylimit;
SCIP_Real timelimit; /* timelimit for the subproblem */
SCIP_Real upperbound;
int nvars; /* number of original problem's variables */
int i;
SCIP_Bool success;
SCIP_RETCODE retcode;
assert( heur != NULL );
assert( scip != NULL );
assert( result != NULL );
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
*result = SCIP_DELAYED;
/* only call heuristic, if feasible solution is available */
if( SCIPgetNSols(scip) <= 0 )
return SCIP_OKAY;
/* only call heuristic, if the best solution comes from transformed problem */
assert( SCIPgetBestSol(scip) != NULL );
if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
return SCIP_OKAY;
/* only call heuristic, if enough nodes were processed since last incumbent */
if( SCIPgetNNodes(scip) - SCIPgetSolNodenum(scip,SCIPgetBestSol(scip)) < heurdata->nwaitingnodes)
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if discrete variables are present */
if( SCIPgetNBinVars(scip) == 0 && SCIPgetNIntVars(scip) == 0 )
return SCIP_OKAY;
/* calculate the maximal number of branching nodes until heuristic is aborted */
maxnnodesr = heurdata->nodesquot * SCIPgetNNodes(scip);
/* reward mutation if it succeeded often, count the setup costs for the sub-MIP as 100 nodes */
maxnnodesr *= 1.0 + 2.0 * (SCIPheurGetNBestSolsFound(heur)+1.0)/(SCIPheurGetNCalls(heur) + 1.0);
maxnnodes = (SCIP_Longint) maxnnodesr - 100 * SCIPheurGetNCalls(heur);
maxnnodes += heurdata->nodesofs;
/* determine the node limit for the current process */
nsubnodes = maxnnodes - heurdata->usednodes;
nsubnodes = MIN(nsubnodes, heurdata->maxnodes);
/* check whether we have enough nodes left to call subproblem solving */
if( nsubnodes < heurdata->minnodes )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initializing the subproblem */
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
if( heurdata->uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_mutationsub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_mutationsub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_Bool valid;
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "rens", TRUE, FALSE, TRUE, &valid) );
if( heurdata->copycuts )
{
/* copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
SCIPdebugMessage("Copying the SCIP instance was %s complete.\n", valid ? "" : "not ");
}
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* create a new problem, which fixes variables with same value in bestsol and LP relaxation */
SCIP_CALL( createSubproblem(scip, subscip, subvars, heurdata->minfixingrate, &heurdata->randseed, heurdata->uselprows) );
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
goto TERMINATE;
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nsubnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
if( !SCIPisParamFixed(subscip, "conflict/useprop") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useinflp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useboundlp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usesb") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usepseudo") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handlers; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no decutions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 10) );
}
/* add an objective cutoff */
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip, SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip, -1.0 * SCIPgetLowerbound(scip)) )
{
cutoff = (1-heurdata->minimprove) * SCIPgetUpperbound(scip) + heurdata->minimprove * SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - heurdata->minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + heurdata->minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff );
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
/* solve the subproblem */
SCIPdebugMessage("Solve Mutation subMIP\n");
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in Mutation heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
heurdata->usednodes += SCIPgetNNodes(subscip);
/* check, whether a solution was found */
if( SCIPgetNSols(subscip) > 0 )
{
SCIP_SOL** subsols;
int nsubsols;
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
}
if( success )
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** main procedure of the zeroobj heuristic, creates and solves a sub-SCIP */
SCIP_RETCODE SCIPapplyZeroobj(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< heuristic data structure */
SCIP_RESULT* result, /**< result data structure */
SCIP_Real minimprove, /**< factor by which zeroobj should at least improve the incumbent */
SCIP_Longint nnodes /**< node limit for the subproblem */
)
{
SCIP* subscip; /* the subproblem created by zeroobj */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_HEURDATA* heurdata; /* heuristic's private data structure */
SCIP_EVENTHDLR* eventhdlr; /* event handler for LP events */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real timelimit; /* time limit for zeroobj subproblem */
SCIP_Real memorylimit; /* memory limit for zeroobj subproblem */
SCIP_Real large;
int nvars; /* number of original problem's variables */
int i;
SCIP_Bool success;
SCIP_Bool valid;
SCIP_RETCODE retcode;
SCIP_SOL** subsols;
int nsubsols;
assert(scip != NULL);
assert(heur != NULL);
assert(result != NULL);
assert(nnodes >= 0);
assert(0.0 <= minimprove && minimprove <= 1.0);
*result = SCIP_DIDNOTRUN;
/* only call heuristic once at the root */
if( SCIPgetDepth(scip) <= 0 && SCIPheurGetNCalls(heur) > 0 )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only call the heuristic if we do not have an incumbent */
if( SCIPgetNSolsFound(scip) > 0 && heurdata->onlywithoutsol )
return SCIP_OKAY;
/* check whether there is enough time and memory left */
timelimit = 0.0;
memorylimit = 0.0;
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get variable data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initialize the subproblem */
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
/* different methods to create sub-problem: either copy LP relaxation or the CIP with all constraints */
valid = FALSE;
/* copy complete SCIP instance */
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "zeroobj", TRUE, FALSE, TRUE, &valid) );
SCIPdebugMessage("Copying the SCIP instance was %s complete.\n", valid ? "" : "not ");
/* create event handler for LP events */
eventhdlr = NULL;
SCIP_CALL( SCIPincludeEventhdlrBasic(subscip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecZeroobj, NULL) );
if( eventhdlr == NULL )
{
SCIPerrorMessage("event handler for "HEUR_NAME" heuristic not found.\n");
return SCIP_PLUGINNOTFOUND;
}
/* determine large value to set variables to */
large = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, 0.1 / SCIPfeastol(scip)) )
large = 0.1 / SCIPfeastol(scip);
/* get variable image and change to 0.0 in sub-SCIP */
for( i = 0; i < nvars; i++ )
{
SCIP_Real adjustedbound;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real inf;
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
SCIP_CALL( SCIPchgVarObj(subscip, subvars[i], 0.0) );
lb = SCIPvarGetLbGlobal(subvars[i]);
ub = SCIPvarGetUbGlobal(subvars[i]);
inf = SCIPinfinity(subscip);
/* adjust infinite bounds in order to avoid that variables with non-zero objective
* get fixed to infinite value in zeroobj subproblem
*/
if( SCIPisInfinity(subscip, ub ) )
{
adjustedbound = MAX(large, lb+large);
adjustedbound = MIN(adjustedbound, inf);
SCIP_CALL( SCIPchgVarUbGlobal(subscip, subvars[i], adjustedbound) );
}
if( SCIPisInfinity(subscip, -lb ) )
{
adjustedbound = MIN(-large, ub-large);
adjustedbound = MAX(adjustedbound, -inf);
SCIP_CALL( SCIPchgVarLbGlobal(subscip, subvars[i], adjustedbound) );
}
}
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPsetIntParam(subscip, "limits/solutions", 1) );
/* forbid recursive call of heuristics and separators solving sub-SCIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable expensive techniques that merely work on the dual bound */
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
if( !SCIPisParamFixed(subscip, "presolving/maxrounds") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "presolving/maxrounds", 50) );
}
/* use best dfs node selection */
if( SCIPfindNodesel(subscip, "dfs") != NULL && !SCIPisParamFixed(subscip, "nodeselection/dfs/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/dfs/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/leastinf/priority", INT_MAX/4) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handler; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no deductions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 10) );
}
/* disable feaspump and fracdiving */
if( !SCIPisParamFixed(subscip, "heuristics/feaspump/freq") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/feaspump/freq", -1) );
}
if( !SCIPisParamFixed(subscip, "heuristics/fracdiving/freq") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/fracdiving/freq", -1) );
}
/* restrict LP iterations */
SCIP_CALL( SCIPsetLongintParam(subscip, "lp/iterlim", 2*heurdata->maxlpiters / MAX(1,nnodes)) );
SCIP_CALL( SCIPsetLongintParam(subscip, "lp/rootiterlim", heurdata->maxlpiters) );
#ifdef SCIP_DEBUG
/* for debugging zeroobj, enable MIP output */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 5) );
SCIP_CALL( SCIPsetIntParam(subscip, "display/freq", 100000000) );
#endif
/* if there is already a solution, add an objective cutoff */
if( SCIPgetNSols(scip) > 0 )
{
SCIP_Real upperbound;
SCIP_CONS* origobjcons;
#ifndef NDEBUG
int nobjvars;
nobjvars = 0;
#endif
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip,SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-minimprove)*SCIPgetUpperbound(scip) + minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound(scip) >= 0 )
cutoff = ( 1 - minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff);
SCIP_CALL( SCIPcreateConsLinear(subscip, &origobjcons, "objbound_of_origscip", 0, NULL, NULL, -SCIPinfinity(subscip), cutoff,
TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE) );
for( i = 0; i < nvars; ++i)
{
if( !SCIPisFeasZero(subscip, SCIPvarGetObj(vars[i])) )
{
SCIP_CALL( SCIPaddCoefLinear(subscip, origobjcons, subvars[i], SCIPvarGetObj(vars[i])) );
#ifndef NDEBUG
nobjvars++;
#endif
}
}
SCIP_CALL( SCIPaddCons(subscip, origobjcons) );
SCIP_CALL( SCIPreleaseCons(subscip, &origobjcons) );
assert(nobjvars == SCIPgetNObjVars(scip));
}
/* catch LP events of sub-SCIP */
SCIP_CALL( SCIPtransformProb(subscip) );
SCIP_CALL( SCIPcatchEvent(subscip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, NULL) );
SCIPdebugMessage("solving subproblem: nnodes=%"SCIP_LONGINT_FORMAT"\n", nnodes);
retcode = SCIPsolve(subscip);
/* drop LP events of sub-SCIP */
SCIP_CALL( SCIPdropEvent(subscip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, -1) );
/* errors in solving the subproblem should not kill the overall solving process;
* hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in zeroobj heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && (!success || heurdata->addallsols); ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
#ifdef SCIP_DEBUG
SCIP_CALL( SCIPprintStatistics(subscip, NULL) );
#endif
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecGuideddiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_SOL* bestsol;
SCIP_VAR* var;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Real* lpcandsfrac;
SCIP_Real searchubbound;
SCIP_Real searchavgbound;
SCIP_Real searchbound;
SCIP_Real objval;
SCIP_Real oldobjval;
SCIP_Real obj;
SCIP_Real objgain;
SCIP_Real bestobjgain;
SCIP_Real frac;
SCIP_Real bestfrac;
SCIP_Real solval;
SCIP_Real bestsolval;
SCIP_Bool bestcandmayrounddown;
SCIP_Bool bestcandmayroundup;
SCIP_Bool bestcandroundup;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Bool roundup;
SCIP_Bool lperror;
SCIP_Bool cutoff;
SCIP_Bool backtracked;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int nlpcands;
int startnlpcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int bestcand;
int c;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* don't dive, if no feasible solutions exist */
if( SCIPgetNSols(scip) == 0 )
return SCIP_OKAY;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get fractional variables that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the objective search bound */
if( heurdata->maxdiveubquot > 0.0 )
searchubbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveubquot * (SCIPgetCutoffbound(scip) - SCIPgetLowerbound(scip));
else
searchubbound = SCIPinfinity(scip);
if( heurdata->maxdiveavgquot > 0.0 )
searchavgbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveavgquot * (SCIPgetAvgLowerbound(scip) - SCIPgetLowerbound(scip));
else
searchavgbound = SCIPinfinity(scip);
searchbound = MIN(searchubbound, searchavgbound);
if( SCIPisObjIntegral(scip) )
searchbound = SCIPceil(scip, searchbound);
/* calculate the maximal diving depth: 10 * min{number of integer variables, max depth} */
maxdivedepth = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
maxdivedepth = MIN(maxdivedepth, maxdepth);
maxdivedepth *= 10;
/* get best solution that should guide the search; if this solution lives in the original variable space,
* we cannot use it since it might violate the global bounds of the current problem
*/
if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
return SCIP_OKAY;
/* store a copy of the best solution */
SCIP_CALL( SCIPcreateSolCopy(scip, &bestsol, SCIPgetBestSol(scip)) );
*result = SCIP_DIDNOTFIND;
/* start diving */
SCIP_CALL( SCIPstartProbing(scip) );
/* enables collection of variable statistics during probing */
SCIPenableVarHistory(scip);
/* get LP objective value */
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
objval = SCIPgetLPObjval(scip);
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing guideddiving heuristic: depth=%d, %d fractionals, dualbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), SCIPretransformObj(scip, searchbound));
/* dive as long we are in the given objective, depth and iteration limits and fractional variables exist, but
* - if possible, we dive at least with the depth 10
* - if the number of fractional variables decreased at least with 1 variable per 2 dive depths, we continue diving
*/
lperror = FALSE;
cutoff = FALSE;
divedepth = 0;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
startnlpcands = nlpcands;
while( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations && objval < searchbound))
&& !SCIPisStopped(scip) )
{
SCIP_CALL( SCIPnewProbingNode(scip) );
divedepth++;
/* choose variable fixing:
* - prefer variables that may not be rounded without destroying LP feasibility:
* - of these variables, round a variable to its value in direction of incumbent solution, and choose the
* variable that is closest to its rounded value
* - if all remaining fractional variables may be rounded without destroying LP feasibility:
* - round variable in direction that destroys LP feasibility (other direction is checked by SCIProundSol())
* - round variable with least increasing objective value
*/
bestcand = -1;
bestobjgain = SCIPinfinity(scip);
bestfrac = SCIP_INVALID;
bestcandmayrounddown = TRUE;
bestcandmayroundup = TRUE;
bestcandroundup = FALSE;
for( c = 0; c < nlpcands; ++c )
{
var = lpcands[c];
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
solval = lpcandssol[c];
frac = lpcandsfrac[c];
obj = SCIPvarGetObj(var);
bestsolval = SCIPgetSolVal(scip, bestsol, var);
/* select default rounding direction */
roundup = (solval < bestsolval);
if( mayrounddown || mayroundup )
{
/* the candidate may be rounded: choose this candidate only, if the best candidate may also be rounded */
if( bestcandmayrounddown || bestcandmayroundup )
{
/* choose rounding direction:
* - if variable may be rounded in both directions, round corresponding to its value in incumbent solution
* - otherwise, round in the infeasible direction, because feasible direction is tried by rounding
* the current fractional solution with SCIProundSol()
*/
if( !mayrounddown || !mayroundup )
roundup = mayrounddown;
if( roundup )
{
frac = 1.0 - frac;
objgain = frac*obj;
}
else
objgain = -frac*obj;
/* penalize too small fractions */
if( frac < 0.01 )
objgain *= 1000.0;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
objgain *= 1000.0;
/* check, if candidate is new best candidate */
if( SCIPisLT(scip, objgain, bestobjgain) || (SCIPisEQ(scip, objgain, bestobjgain) && frac < bestfrac) )
{
bestcand = c;
bestobjgain = objgain;
bestfrac = frac;
bestcandmayrounddown = mayrounddown;
bestcandmayroundup = mayroundup;
bestcandroundup = roundup;
}
}
}
else
{
/* the candidate may not be rounded */
if( roundup )
frac = 1.0 - frac;
/* penalize too small fractions */
if( frac < 0.01 )
frac += 10.0;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
frac *= 1000.0;
/* check, if candidate is new best candidate: prefer unroundable candidates in any case */
if( bestcandmayrounddown || bestcandmayroundup || frac < bestfrac )
{
bestcand = c;
bestfrac = frac;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
bestcandroundup = roundup;
}
}
}
assert(bestcand != -1);
/* if all candidates are roundable, try to round the solution */
if( bestcandmayrounddown || bestcandmayroundup )
{
SCIP_Bool success;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("guideddiving found roundable primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
}
var = lpcands[bestcand];
backtracked = FALSE;
do
{
/* if the variable is already fixed or if the solution value is outside the domain, numerical troubles may have
* occured or variable was fixed by propagation while backtracking => Abort diving!
*/
if( SCIPvarGetLbLocal(var) >= SCIPvarGetUbLocal(var) - 0.5 )
{
SCIPdebugMessage("Selected variable <%s> already fixed to [%g,%g] (solval: %.9f), diving aborted \n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), lpcandssol[bestcand]);
cutoff = TRUE;
break;
}
if( SCIPisFeasLT(scip, lpcandssol[bestcand], SCIPvarGetLbLocal(var)) || SCIPisFeasGT(scip, lpcandssol[bestcand], SCIPvarGetUbLocal(var)) )
{
SCIPdebugMessage("selected variable's <%s> solution value is outside the domain [%g,%g] (solval: %.9f), diving aborted\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), lpcandssol[bestcand]);
assert(backtracked);
break;
}
/* apply rounding of best candidate */
if( bestcandroundup == !backtracked )
{
/* round variable up */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, bestsol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetSolVal(scip, bestsol, var),
SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPfeasCeil(scip, lpcandssol[bestcand]), SCIPvarGetUbLocal(var));
SCIP_CALL( SCIPchgVarLbProbing(scip, var, SCIPfeasCeil(scip, lpcandssol[bestcand])) );
}
else
{
/* round variable down */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, bestsol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetSolVal(scip, bestsol, var),
SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPvarGetLbLocal(var), SCIPfeasFloor(scip, lpcandssol[bestcand]));
SCIP_CALL( SCIPchgVarUbProbing(scip, var, SCIPfeasFloor(scip, lpcandssol[bestcand])) );
}
/* apply domain propagation */
SCIP_CALL( SCIPpropagateProbing(scip, 0, &cutoff, NULL) );
if( !cutoff )
{
/* resolve the diving LP */
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
#ifdef NDEBUG
SCIP_RETCODE retstat;
nlpiterations = SCIPgetNLPIterations(scip);
retstat = SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff);
if( retstat != SCIP_OKAY )
{
SCIPwarningMessage(scip, "Error while solving LP in Guideddiving heuristic; LP solve terminated with code <%d>\n",retstat);
}
#else
nlpiterations = SCIPgetNLPIterations(scip);
SCIP_CALL( SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff) );
#endif
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* get LP solution status, objective value, and fractional variables, that should be integral */
lpsolstat = SCIPgetLPSolstat(scip);
assert(cutoff || (lpsolstat != SCIP_LPSOLSTAT_OBJLIMIT && lpsolstat != SCIP_LPSOLSTAT_INFEASIBLE &&
(lpsolstat != SCIP_LPSOLSTAT_OPTIMAL || SCIPisLT(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)))));
}
/* perform backtracking if a cutoff was detected */
if( cutoff && !backtracked && heurdata->backtrack )
{
SCIPdebugMessage(" *** cutoff detected at level %d - backtracking\n", SCIPgetProbingDepth(scip));
SCIP_CALL( SCIPbacktrackProbing(scip, SCIPgetProbingDepth(scip)-1) );
SCIP_CALL( SCIPnewProbingNode(scip) );
backtracked = TRUE;
}
else
backtracked = FALSE;
}
while( backtracked );
if( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
/* get new objective value */
oldobjval = objval;
objval = SCIPgetLPObjval(scip);
/* update pseudo cost values */
if( SCIPisGT(scip, objval, oldobjval) )
{
if( bestcandroundup )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 1.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
else
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 0.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
}
/* get new fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
}
SCIPdebugMessage(" -> lpsolstat=%d, objval=%g, nfrac=%d\n", lpsolstat, objval, nlpcands);
}
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("guideddiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendProbing(scip) );
/* free copied best solution */
SCIP_CALL( SCIPfreeSol(scip, &bestsol) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("guideddiving heuristic finished\n");
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecOneopt)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* bestsol; /* incumbent solution */
SCIP_SOL* worksol; /* heuristic's working solution */
SCIP_VAR** vars; /* SCIP variables */
SCIP_VAR** shiftcands; /* shiftable variables */
SCIP_ROW** lprows; /* SCIP LP rows */
SCIP_Real* activities; /* row activities for working solution */
SCIP_Real* shiftvals;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Bool localrows;
SCIP_Bool valid;
int nchgbound;
int nbinvars;
int nintvars;
int nvars;
int nlprows;
int i;
int nshiftcands;
int shiftcandssize;
SCIP_RETCODE retcode;
assert(heur != NULL);
assert(scip != NULL);
assert(result != NULL);
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
*result = SCIP_DELAYED;
/* we only want to process each solution once */
bestsol = SCIPgetBestSol(scip);
if( bestsol == NULL || heurdata->lastsolindex == SCIPsolGetIndex(bestsol) )
return SCIP_OKAY;
/* reset the timing mask to its default value (at the root node it could be different) */
if( SCIPgetNNodes(scip) > 1 )
SCIPheurSetTimingmask(heur, HEUR_TIMING);
/* get problem variables */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
nintvars += nbinvars;
/* do not run if there are no discrete variables */
if( nintvars == 0 )
{
*result = SCIP_DIDNOTRUN;
return SCIP_OKAY;
}
if( heurtiming == SCIP_HEURTIMING_BEFOREPRESOL )
{
SCIP* subscip; /* the subproblem created by zeroobj */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_Real* subsolvals; /* solution values of the subproblem */
SCIP_Real timelimit; /* time limit for zeroobj subproblem */
SCIP_Real memorylimit; /* memory limit for zeroobj subproblem */
SCIP_SOL* startsol;
SCIP_SOL** subsols;
int nsubsols;
if( !heurdata->beforepresol )
return SCIP_OKAY;
/* check whether there is enough time and memory left */
timelimit = 0.0;
memorylimit = 0.0;
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
return SCIP_OKAY;
/* initialize the subproblem */
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
/* copy complete SCIP instance */
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "oneopt", TRUE, FALSE, TRUE, &valid) );
SCIP_CALL( SCIPtransformProb(subscip) );
/* get variable image */
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* copy the solution */
SCIP_CALL( SCIPallocBufferArray(scip, &subsolvals, nvars) );
SCIP_CALL( SCIPgetSolVals(scip, bestsol, nvars, vars, subsolvals) );
/* create start solution for the subproblem */
SCIP_CALL( SCIPcreateOrigSol(subscip, &startsol, NULL) );
SCIP_CALL( SCIPsetSolVals(subscip, startsol, nvars, subvars, subsolvals) );
/* try to add new solution to sub-SCIP and free it immediately */
valid = FALSE;
SCIP_CALL( SCIPtrySolFree(subscip, &startsol, FALSE, FALSE, FALSE, FALSE, &valid) );
SCIPfreeBufferArray(scip, &subsolvals);
SCIPhashmapFree(&varmapfw);
/* disable statistic timing inside sub SCIP */
SCIP_CALL( SCIPsetBoolParam(subscip, "timing/statistictiming", FALSE) );
/* deactivate basically everything except oneopt in the sub-SCIP */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetHeuristics(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* if necessary, some of the parameters have to be unfixed first */
if( SCIPisParamFixed(subscip, "lp/solvefreq") )
{
SCIPwarningMessage(scip, "unfixing parameter lp/solvefreq in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "lp/solvefreq") );
}
SCIP_CALL( SCIPsetIntParam(subscip, "lp/solvefreq", -1) );
if( SCIPisParamFixed(subscip, "heuristics/oneopt/freq") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/freq in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/freq") );
}
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/oneopt/freq", 1) );
if( SCIPisParamFixed(subscip, "heuristics/oneopt/forcelpconstruction") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/forcelpconstruction in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/forcelpconstruction") );
}
SCIP_CALL( SCIPsetBoolParam(subscip, "heuristics/oneopt/forcelpconstruction", TRUE) );
/* avoid recursive call, which would lead to an endless loop */
if( SCIPisParamFixed(subscip, "heuristics/oneopt/beforepresol") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/beforepresol in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/beforepresol") );
}
SCIP_CALL( SCIPsetBoolParam(subscip, "heuristics/oneopt/beforepresol", FALSE) );
if( valid )
{
retcode = SCIPsolve(subscip);
/* errors in solving the subproblem should not kill the overall solving process;
* hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in zeroobj heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
#ifdef SCIP_DEBUG
SCIP_CALL( SCIPprintStatistics(subscip, NULL) );
#endif
}
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
valid = FALSE;
for( i = 0; i < nsubsols && !valid; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &valid) );
if( valid )
*result = SCIP_FOUNDSOL;
}
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/* we can only work on solutions valid in the transformed space */
if( SCIPsolIsOriginal(bestsol) )
return SCIP_OKAY;
if( heurtiming == SCIP_HEURTIMING_BEFORENODE && (SCIPhasCurrentNodeLP(scip) || heurdata->forcelpconstruction) )
{
SCIP_Bool cutoff;
cutoff = FALSE;
SCIP_CALL( SCIPconstructLP(scip, &cutoff) );
SCIP_CALL( SCIPflushLP(scip) );
/* get problem variables again, SCIPconstructLP() might have added new variables */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
nintvars += nbinvars;
}
/* we need an LP */
if( SCIPgetNLPRows(scip) == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
nchgbound = 0;
/* initialize data */
nshiftcands = 0;
shiftcandssize = 8;
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
SCIP_CALL( SCIPcreateSolCopy(scip, &worksol, bestsol) );
SCIPsolSetHeur(worksol,heur);
SCIPdebugMessage("Starting bound adjustment in 1-opt heuristic\n");
/* maybe change solution values due to global bound changes first */
for( i = nvars - 1; i >= 0; --i )
{
SCIP_VAR* var;
SCIP_Real solval;
var = vars[i];
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
solval = SCIPgetSolVal(scip, bestsol,var);
/* old solution value is smaller than the actual lower bound */
if( SCIPisFeasLT(scip, solval, lb) )
{
/* set the solution value to the global lower bound */
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, lb) );
++nchgbound;
SCIPdebugMessage("var <%s> type %d, old solval %g now fixed to lb %g\n", SCIPvarGetName(var), SCIPvarGetType(var), solval, lb);
}
/* old solution value is greater than the actual upper bound */
else if( SCIPisFeasGT(scip, solval, SCIPvarGetUbGlobal(var)) )
{
/* set the solution value to the global upper bound */
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, ub) );
++nchgbound;
SCIPdebugMessage("var <%s> type %d, old solval %g now fixed to ub %g\n", SCIPvarGetName(var), SCIPvarGetType(var), solval, ub);
}
}
SCIPdebugMessage("number of bound changes (due to global bounds) = %d\n", nchgbound);
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
localrows = FALSE;
valid = TRUE;
/* initialize activities */
for( i = 0; i < nlprows; ++i )
{
SCIP_ROW* row;
row = lprows[i];
assert(SCIProwGetLPPos(row) == i);
if( !SCIProwIsLocal(row) )
{
activities[i] = SCIPgetRowSolActivity(scip, row, worksol);
SCIPdebugMessage("Row <%s> has activity %g\n", SCIProwGetName(row), activities[i]);
if( SCIPisFeasLT(scip, activities[i], SCIProwGetLhs(row)) || SCIPisFeasGT(scip, activities[i], SCIProwGetRhs(row)) )
{
valid = FALSE;
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
SCIPdebugMessage("row <%s> activity %g violates bounds, lhs = %g, rhs = %g\n", SCIProwGetName(row), activities[i], SCIProwGetLhs(row), SCIProwGetRhs(row));
break;
}
}
else
localrows = TRUE;
}
if( !valid )
{
/** @todo try to correct lp rows */
SCIPdebugMessage("Some global bound changes were not valid in lp rows.\n");
goto TERMINATE;
}
SCIP_CALL( SCIPallocBufferArray(scip, &shiftcands, shiftcandssize) );
SCIP_CALL( SCIPallocBufferArray(scip, &shiftvals, shiftcandssize) );
SCIPdebugMessage("Starting 1-opt heuristic\n");
/* enumerate all integer variables and find out which of them are shiftable */
for( i = 0; i < nintvars; i++ )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
SCIP_Real shiftval;
SCIP_Real solval;
/* find out whether the variable can be shifted */
solval = SCIPgetSolVal(scip, worksol, vars[i]);
shiftval = calcShiftVal(scip, vars[i], solval, activities);
/* insert the variable into the list of shifting candidates */
if( !SCIPisFeasZero(scip, shiftval) )
{
SCIPdebugMessage(" -> Variable <%s> can be shifted by <%1.1f> \n", SCIPvarGetName(vars[i]), shiftval);
if( nshiftcands == shiftcandssize)
{
shiftcandssize *= 8;
SCIP_CALL( SCIPreallocBufferArray(scip, &shiftcands, shiftcandssize) );
SCIP_CALL( SCIPreallocBufferArray(scip, &shiftvals, shiftcandssize) );
}
shiftcands[nshiftcands] = vars[i];
shiftvals[nshiftcands] = shiftval;
nshiftcands++;
}
}
}
/* if at least one variable can be shifted, shift variables sorted by their objective */
if( nshiftcands > 0 )
{
SCIP_Real shiftval;
SCIP_Real solval;
SCIP_VAR* var;
/* the case that exactly one variable can be shifted is slightly easier */
if( nshiftcands == 1 )
{
var = shiftcands[0];
assert(var != NULL);
solval = SCIPgetSolVal(scip, worksol, var);
shiftval = shiftvals[0];
assert(!SCIPisFeasZero(scip,shiftval));
SCIPdebugMessage(" Only one shiftcand found, var <%s>, which is now shifted by<%1.1f> \n",
SCIPvarGetName(var), shiftval);
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, solval+shiftval) );
}
else
{
SCIP_Real* objcoeffs;
SCIP_CALL( SCIPallocBufferArray(scip, &objcoeffs, nshiftcands) );
SCIPdebugMessage(" %d shiftcands found \n", nshiftcands);
/* sort the variables by their objective, optionally weighted with the shiftval */
if( heurdata->weightedobj )
{
for( i = 0; i < nshiftcands; ++i )
objcoeffs[i] = SCIPvarGetObj(shiftcands[i])*shiftvals[i];
}
else
{
for( i = 0; i < nshiftcands; ++i )
objcoeffs[i] = SCIPvarGetObj(shiftcands[i]);
}
/* sort arrays with respect to the first one */
SCIPsortRealPtr(objcoeffs, (void**)shiftcands, nshiftcands);
/* try to shift each variable -> Activities have to be updated */
for( i = 0; i < nshiftcands; ++i )
{
var = shiftcands[i];
assert(var != NULL);
solval = SCIPgetSolVal(scip, worksol, var);
shiftval = calcShiftVal(scip, var, solval, activities);
SCIPdebugMessage(" -> Variable <%s> is now shifted by <%1.1f> \n", SCIPvarGetName(vars[i]), shiftval);
assert(i > 0 || !SCIPisFeasZero(scip, shiftval));
assert(SCIPisFeasGE(scip, solval+shiftval, SCIPvarGetLbGlobal(var)) && SCIPisFeasLE(scip, solval+shiftval, SCIPvarGetUbGlobal(var)));
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, solval+shiftval) );
SCIP_CALL( updateRowActivities(scip, activities, var, shiftval) );
}
SCIPfreeBufferArray(scip, &objcoeffs);
}
/* if the problem is a pure IP, try to install the solution, if it is a MIP, solve LP again to set the continuous
* variables to the best possible value
*/
if( nvars == nintvars || !SCIPhasCurrentNodeLP(scip) || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* since we ignore local rows, we cannot guarantee their feasibility and have to set the checklprows flag to
* TRUE if local rows are present
*/
SCIP_CALL( SCIPtrySol(scip, worksol, FALSE, FALSE, FALSE, localrows, &success) );
if( success )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, worksol, NULL, FALSE) ) );
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
*result = SCIP_FOUNDSOL;
}
}
else
{
SCIP_Bool lperror;
#ifdef NDEBUG
SCIP_RETCODE retstat;
#endif
SCIPdebugMessage("shifted solution should be feasible -> solve LP to fix continuous variables to best values\n");
/* start diving to calculate the LP relaxation */
SCIP_CALL( SCIPstartDive(scip) );
/* set the bounds of the variables: fixed for integers, global bounds for continuous */
for( i = 0; i < nvars; ++i )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
SCIP_CALL( SCIPchgVarLbDive(scip, vars[i], SCIPvarGetLbGlobal(vars[i])) );
SCIP_CALL( SCIPchgVarUbDive(scip, vars[i], SCIPvarGetUbGlobal(vars[i])) );
}
}
/* apply this after global bounds to not cause an error with intermediate empty domains */
for( i = 0; i < nintvars; ++i )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
solval = SCIPgetSolVal(scip, worksol, vars[i]);
SCIP_CALL( SCIPchgVarLbDive(scip, vars[i], solval) );
SCIP_CALL( SCIPchgVarUbDive(scip, vars[i], solval) );
}
}
/* solve LP */
SCIPdebugMessage(" -> old LP iterations: %" SCIP_LONGINT_FORMAT "\n", SCIPgetNLPIterations(scip));
/**@todo in case of an MINLP, if SCIPisNLPConstructed() is TRUE, say, rather solve the NLP instead of the LP */
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
#ifdef NDEBUG
retstat = SCIPsolveDiveLP(scip, -1, &lperror, NULL);
if( retstat != SCIP_OKAY )
{
SCIPwarningMessage(scip, "Error while solving LP in Oneopt heuristic; LP solve terminated with code <%d>\n",retstat);
}
#else
SCIP_CALL( SCIPsolveDiveLP(scip, -1, &lperror, NULL) );
#endif
SCIPdebugMessage(" -> new LP iterations: %" SCIP_LONGINT_FORMAT "\n", SCIPgetNLPIterations(scip));
SCIPdebugMessage(" -> error=%u, status=%d\n", lperror, SCIPgetLPSolstat(scip));
/* check if this is a feasible solution */
if( !lperror && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, worksol) );
SCIP_CALL( SCIPtrySol(scip, worksol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check solution for feasibility */
if( success )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, worksol, NULL, FALSE) ) );
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
*result = SCIP_FOUNDSOL;
}
}
/* terminate the diving */
SCIP_CALL( SCIPendDive(scip) );
}
}
SCIPdebugMessage("Finished 1-opt heuristic\n");
SCIPfreeBufferArray(scip, &shiftvals);
SCIPfreeBufferArray(scip, &shiftcands);
TERMINATE:
SCIPfreeBufferArray(scip, &activities);
SCIP_CALL( SCIPfreeSol(scip, &worksol) );
return SCIP_OKAY;
}
/** reduced cost pricing method of variable pricer for feasible LPs */
static
SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
{ /*lint --e{715}*/
SCIP* subscip;
SCIP_PRICERDATA* pricerdata;
SCIP_CONS** conss;
SCIP_VAR** vars;
int* ids;
SCIP_Bool addvar;
SCIP_SOL** sols;
int nsols;
int s;
int nitems;
SCIP_Longint capacity;
SCIP_Real timelimit;
SCIP_Real memorylimit;
assert(scip != NULL);
assert(pricer != NULL);
(*result) = SCIP_DIDNOTRUN;
/* get the pricer data */
pricerdata = SCIPpricerGetData(pricer);
assert(pricerdata != NULL);
capacity = pricerdata->capacity;
conss = pricerdata->conss;
ids = pricerdata->ids;
nitems = pricerdata->nitems;
/* get the remaining time and memory limit */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
if( !SCIPisInfinity(scip, memorylimit) )
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
/* initialize SCIP */
SCIP_CALL( SCIPcreate(&subscip) );
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* create problem in sub SCIP */
SCIP_CALL( SCIPcreateProbBasic(subscip, "pricing") );
SCIP_CALL( SCIPsetObjsense(subscip, SCIP_OBJSENSE_MAXIMIZE) );
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* set time and memory limit */
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPallocMemoryArray(subscip, &vars, nitems) );
/* initialization local pricing problem */
SCIP_CALL( initPricing(scip, pricerdata, subscip, vars) );
SCIPdebugMessage("solve pricer problem\n");
/* solve sub SCIP */
SCIP_CALL( SCIPsolve(subscip) );
sols = SCIPgetSols(subscip);
nsols = SCIPgetNSols(subscip);
addvar = FALSE;
/* loop over all solutions and create the corresponding column to master if the reduced cost are negative for master,
* that is the objective value i greater than 1.0
*/
for( s = 0; s < nsols; ++s )
{
SCIP_Bool feasible;
SCIP_SOL* sol;
/* the soultion should be sorted w.r.t. the objective function value */
assert(s == 0 || SCIPisFeasGE(subscip, SCIPgetSolOrigObj(subscip, sols[s-1]), SCIPgetSolOrigObj(subscip, sols[s])));
sol = sols[s];
assert(sol != NULL);
/* check if solution is feasible in original sub SCIP */
SCIP_CALL( SCIPcheckSolOrig(subscip, sol, &feasible, FALSE, FALSE ) );
if( !feasible )
{
SCIPwarningMessage(scip, "solution in pricing problem (capacity <%d>) is infeasible\n", capacity);
continue;
}
/* check if the solution has a value greater than 1.0 */
if( SCIPisFeasGT(subscip, SCIPgetSolOrigObj(subscip, sol), 1.0) )
{
SCIP_VAR* var;
SCIP_VARDATA* vardata;
int* consids;
char strtmp[SCIP_MAXSTRLEN];
char name[SCIP_MAXSTRLEN];
int nconss;
int o;
int v;
SCIPdebug( SCIP_CALL( SCIPprintSol(subscip, sol, NULL, FALSE) ) );
nconss = 0;
(void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "items");
SCIP_CALL( SCIPallocBufferArray(scip, &consids, nitems) );
/* check which variables are fixed -> which item belongs to this packing */
for( o = 0, v = 0; o < nitems; ++o )
{
if( !SCIPconsIsEnabled(conss[o]) )
continue;
assert(SCIPgetNFixedonesSetppc(scip, conss[o]) == 0);
if( SCIPgetSolVal(subscip, sol, vars[v]) > 0.5 )
{
(void) SCIPsnprintf(strtmp, SCIP_MAXSTRLEN, "_%d", ids[o]);
strcat(name, strtmp);
consids[nconss] = o;
nconss++;
}
else
assert( SCIPisFeasEQ(subscip, SCIPgetSolVal(subscip, sol, vars[v]), 0.0) );
v++;
}
SCIP_CALL( SCIPvardataCreateBinpacking(scip, &vardata, consids, nconss) );
/* create variable for a new column with objective function coefficient 0.0 */
SCIP_CALL( SCIPcreateVarBinpacking(scip, &var, name, 1.0, FALSE, TRUE, vardata) );
/* add the new variable to the pricer store */
SCIP_CALL( SCIPaddPricedVar(scip, var, 1.0) );
addvar = TRUE;
/* change the upper bound of the binary variable to lazy since the upper bound is already enforced due to
* the objective function the set covering constraint; The reason for doing is that, is to avoid the bound
* of x <= 1 in the LP relaxation since this bound constraint would produce a dual variable which might have
* a positive reduced cost
*/
SCIP_CALL( SCIPchgVarUbLazy(scip, var, 1.0) );
/* check which variable are fixed -> which orders belong to this packing */
for( v = 0; v < nconss; ++v )
{
assert(SCIPconsIsEnabled(conss[consids[v]]));
SCIP_CALL( SCIPaddCoefSetppc(scip, conss[consids[v]], var) );
}
SCIPdebug(SCIPprintVar(scip, var, NULL) );
SCIP_CALL( SCIPreleaseVar(scip, &var) );
SCIPfreeBufferArray(scip, &consids);
}
else
break;
}
/* free pricer MIP */
SCIPfreeMemoryArray(subscip, &vars);
if( addvar || SCIPgetStatus(subscip) == SCIP_STATUS_OPTIMAL )
(*result) = SCIP_SUCCESS;
/* free sub SCIP */
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** main procedure of the RENS heuristic, creates and solves a subMIP */
SCIP_RETCODE SCIPapplyGcgrens(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< heuristic data structure */
SCIP_RESULT* result, /**< result data structure */
SCIP_Real minfixingrate, /**< minimum percentage of integer variables that have to be fixed */
SCIP_Real minimprove, /**< factor by which RENS should at least improve the incumbent */
SCIP_Longint maxnodes, /**< maximum number of nodes for the subproblem */
SCIP_Longint nstallnodes, /**< number of stalling nodes for the subproblem */
SCIP_Bool binarybounds, /**< should general integers get binary bounds [floor(.),ceil(.)]? */
SCIP_Bool uselprows /**< should subproblem be created out of the rows in the LP rows? */
)
{
SCIP* subscip; /* the subproblem created by RENS */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real timelimit;
SCIP_Real memorylimit;
int nvars;
int i;
SCIP_Bool success;
SCIP_RETCODE retcode;
assert(scip != NULL);
assert(heur != NULL);
assert(result != NULL);
assert(maxnodes >= 0);
assert(nstallnodes >= 0);
assert(0.0 <= minfixingrate && minfixingrate <= 1.0);
assert(0.0 <= minimprove && minimprove <= 1.0);
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initialize the subproblem */
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
if( uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_gcgrenssub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_gcgrenssub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_Bool valid;
SCIP_HEURDATA* heurdata;
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "gcgrens", TRUE, FALSE, TRUE, &valid) ); /** @todo check for thread safeness */
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
if( heurdata->copycuts )
{
/** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
SCIPdebugMessage("Copying the SCIP instance was %s complete.\n", valid ? "" : "not ");
}
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* create a new problem, which fixes variables with same value in bestsol and LP relaxation */
SCIP_CALL( createSubproblem(scip, subscip, subvars, minfixingrate, binarybounds, uselprows, &success) );
SCIPdebugMessage("RENS subproblem: %d vars, %d cons, success=%u\n", SCIPgetNVars(subscip), SCIPgetNConss(subscip), success);
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* check whether there is enough time and memory left */
timelimit = 0.0;
memorylimit = 0.0;
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
if( !SCIPisInfinity(scip, memorylimit) )
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
if( timelimit <= 0.0 || memorylimit <= 0.0 )
goto TERMINATE;
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/stallnodes", nstallnodes) );
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", maxnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving sub-SCIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(scip, "estimate") != NULL )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(scip, "inference") != NULL )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
#ifdef SCIP_DEBUG
/* for debugging RENS, enable MIP output */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 5) );
SCIP_CALL( SCIPsetIntParam(subscip, "display/freq", 100000000) );
#endif
/* if the subproblem could not be created, free memory and return */
if( !success )
{
*result = SCIP_DIDNOTRUN;
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/* if there is already a solution, add an objective cutoff */
if( SCIPgetNSols(scip) > 0 )
{
SCIP_Real upperbound;
assert( !SCIPisInfinity(scip,SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-minimprove)*SCIPgetUpperbound(scip) + minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff);
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
}
/* presolve the subproblem */
retcode = SCIPpresolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while presolving subproblem in GCG RENS heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
SCIPdebugMessage("GCG RENS presolved subproblem: %d vars, %d cons, success=%u\n", SCIPgetNVars(subscip), SCIPgetNConss(subscip), success);
/* after presolving, we should have at least reached a certain fixing rate over ALL variables (including continuous)
* to ensure that not only the MIP but also the LP relaxation is easy enough
*/
if( ( nvars - SCIPgetNVars(subscip) ) / (SCIP_Real)nvars >= minfixingrate / 2.0 )
{
SCIP_SOL** subsols;
int nsubsols;
/* solve the subproblem */
SCIPdebugMessage("solving subproblem: nstallnodes=%"SCIP_LONGINT_FORMAT", maxnodes=%"SCIP_LONGINT_FORMAT"\n", nstallnodes, maxnodes);
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in GCG RENS heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
}
if( success )
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecLocalbranching)
{ /*lint --e{715}*/
SCIP_Longint maxnnodes; /* maximum number of subnodes */
SCIP_Longint nsubnodes; /* nodelimit for subscip */
SCIP_HEURDATA* heurdata;
SCIP* subscip; /* the subproblem created by localbranching */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_SOL* bestsol; /* best solution so far */
SCIP_EVENTHDLR* eventhdlr; /* event handler for LP events */
SCIP_Real timelimit; /* timelimit for subscip (equals remaining time of scip) */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real upperbound;
SCIP_Real memorylimit;
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars;
int nvars;
int i;
SCIP_Bool success;
SCIP_RETCODE retcode;
assert(heur != NULL);
assert(scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
/* there should be enough binary variables that a local branching constraint makes sense */
if( SCIPgetNBinVars(scip) < 2*heurdata->neighborhoodsize )
return SCIP_OKAY;
*result = SCIP_DELAYED;
/* only call heuristic, if an IP solution is at hand */
if( SCIPgetNSols(scip) <= 0 )
return SCIP_OKAY;
bestsol = SCIPgetBestSol(scip);
assert(bestsol != NULL);
/* only call heuristic, if the best solution comes from transformed problem */
if( SCIPsolIsOriginal(bestsol) )
return SCIP_OKAY;
/* only call heuristic, if enough nodes were processed since last incumbent */
if( SCIPgetNNodes(scip) - SCIPgetSolNodenum(scip, bestsol) < heurdata->nwaitingnodes)
return SCIP_OKAY;
/* only call heuristic, if the best solution does not come from trivial heuristic */
if( SCIPsolGetHeur(bestsol) != NULL && strcmp(SCIPheurGetName(SCIPsolGetHeur(bestsol)), "trivial") == 0 )
return SCIP_OKAY;
/* reset neighborhood and minnodes, if new solution was found */
if( heurdata->lastsol != bestsol )
{
heurdata->curneighborhoodsize = heurdata->neighborhoodsize;
heurdata->curminnodes = heurdata->minnodes;
heurdata->emptyneighborhoodsize = 0;
heurdata->callstatus = EXECUTE;
heurdata->lastsol = bestsol;
}
/* if no new solution was found and local branching also seems to fail, just keep on waiting */
if( heurdata->callstatus == WAITFORNEWSOL )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* calculate the maximal number of branching nodes until heuristic is aborted */
maxnnodes = (SCIP_Longint)(heurdata->nodesquot * SCIPgetNNodes(scip));
/* reward local branching if it succeeded often */
maxnnodes = (SCIP_Longint)(maxnnodes * (1.0 + 2.0*(SCIPheurGetNBestSolsFound(heur)+1.0)/(SCIPheurGetNCalls(heur)+1.0)));
maxnnodes -= 100 * SCIPheurGetNCalls(heur); /* count the setup costs for the sub-MIP as 100 nodes */
maxnnodes += heurdata->nodesofs;
/* determine the node limit for the current process */
nsubnodes = maxnnodes - heurdata->usednodes;
nsubnodes = MIN(nsubnodes, heurdata->maxnodes);
/* check whether we have enough nodes left to call sub problem solving */
if( nsubnodes < heurdata->curminnodes )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIPdebugMessage("running localbranching heuristic ...\n");
/* get the data of the variables and the best solution */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initializing the subproblem */
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
success = FALSE;
eventhdlr = NULL;
if( heurdata->uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_localbranchsub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_localbranchsub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "localbranchsub", TRUE, FALSE, TRUE, &success) );
if( heurdata->copycuts )
{
/* copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
/* create event handler for LP events */
SCIP_CALL( SCIPincludeEventhdlrBasic(subscip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecLocalbranching, NULL) );
if( eventhdlr == NULL )
{
SCIPerrorMessage("event handler for "HEUR_NAME" heuristic not found.\n");
return SCIP_PLUGINNOTFOUND;
}
}
SCIPdebugMessage("Copying the plugins was %ssuccessful.\n", success ? "" : "not ");
for (i = 0; i < nvars; ++i)
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* if the subproblem could not be created, free memory and return */
if( !success )
{
*result = SCIP_DIDNOTRUN;
goto TERMINATE;
}
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
#ifndef SCIP_DEBUG
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
#endif
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
goto TERMINATE;
/* set limits for the subproblem */
heurdata->nodelimit = nsubnodes;
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nsubnodes) );
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/stallnodes", MAX(10, nsubnodes/10)) );
SCIP_CALL( SCIPsetIntParam(subscip, "limits/bestsol", 3) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
if( !SCIPisParamFixed(subscip, "conflict/useprop") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useinflp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useboundlp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usesb") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usepseudo") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handler; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no deductions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 500) );
}
/* copy the original problem and add the local branching constraint */
if( heurdata->uselprows )
{
SCIP_CALL( createSubproblem(scip, subscip, subvars) );
}
SCIP_CALL( addLocalBranchingConstraint(scip, subscip, subvars, heurdata) );
/* add an objective cutoff */
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip,SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-heurdata->minimprove)*SCIPgetUpperbound(scip) + heurdata->minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - heurdata->minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + heurdata->minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff );
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
/* catch LP events of sub-SCIP */
if( !heurdata->uselprows )
{
assert(eventhdlr != NULL);
SCIP_CALL( SCIPtransformProb(subscip) );
SCIP_CALL( SCIPcatchEvent(subscip, SCIP_EVENTTYPE_LPSOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, NULL) );
}
/* solve the subproblem */
SCIPdebugMessage("solving local branching subproblem with neighborhoodsize %d and maxnodes %"SCIP_LONGINT_FORMAT"\n",
heurdata->curneighborhoodsize, nsubnodes);
retcode = SCIPsolve(subscip);
/* drop LP events of sub-SCIP */
if( !heurdata->uselprows )
{
assert(eventhdlr != NULL);
SCIP_CALL( SCIPdropEvent(subscip, SCIP_EVENTTYPE_LPSOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, -1) );
}
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in local branching heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
/* print solving statistics of subproblem if we are in SCIP's debug mode */
SCIPdebug( SCIP_CALL( SCIPprintStatistics(subscip, NULL) ) );
heurdata->usednodes += SCIPgetNNodes(subscip);
SCIPdebugMessage("local branching used %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT" nodes\n",
SCIPgetNNodes(subscip), nsubnodes);
/* check, whether a solution was found */
if( SCIPgetNSols(subscip) > 0 )
{
SCIP_SOL** subsols;
int nsubsols;
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
}
if( success )
{
SCIPdebugMessage("-> accepted solution of value %g\n", SCIPgetSolOrigObj(subscip, subsols[i]));
*result = SCIP_FOUNDSOL;
}
}
/* check the status of the sub-MIP */
switch( SCIPgetStatus(subscip) )
{
case SCIP_STATUS_OPTIMAL:
case SCIP_STATUS_BESTSOLLIMIT:
heurdata->callstatus = WAITFORNEWSOL; /* new solution will immediately be installed at next call */
SCIPdebugMessage(" -> found new solution\n");
break;
case SCIP_STATUS_NODELIMIT:
case SCIP_STATUS_STALLNODELIMIT:
case SCIP_STATUS_TOTALNODELIMIT:
heurdata->callstatus = EXECUTE;
heurdata->curneighborhoodsize = (heurdata->emptyneighborhoodsize + heurdata->curneighborhoodsize)/2;
heurdata->curminnodes *= 2;
SCIPdebugMessage(" -> node limit reached: reduced neighborhood to %d, increased minnodes to %d\n",
heurdata->curneighborhoodsize, heurdata->curminnodes);
if( heurdata->curneighborhoodsize <= heurdata->emptyneighborhoodsize )
{
heurdata->callstatus = WAITFORNEWSOL;
SCIPdebugMessage(" -> new neighborhood was already proven to be empty: wait for new solution\n");
}
break;
case SCIP_STATUS_INFEASIBLE:
case SCIP_STATUS_INFORUNBD:
heurdata->emptyneighborhoodsize = heurdata->curneighborhoodsize;
heurdata->curneighborhoodsize += heurdata->curneighborhoodsize/2;
heurdata->curneighborhoodsize = MAX(heurdata->curneighborhoodsize, heurdata->emptyneighborhoodsize + 2);
heurdata->callstatus = EXECUTE;
SCIPdebugMessage(" -> neighborhood is empty: increased neighborhood to %d\n", heurdata->curneighborhoodsize);
break;
case SCIP_STATUS_UNKNOWN:
case SCIP_STATUS_USERINTERRUPT:
case SCIP_STATUS_TIMELIMIT:
case SCIP_STATUS_MEMLIMIT:
case SCIP_STATUS_GAPLIMIT:
case SCIP_STATUS_SOLLIMIT:
case SCIP_STATUS_UNBOUNDED:
default:
heurdata->callstatus = WAITFORNEWSOL;
SCIPdebugMessage(" -> unexpected sub-MIP status <%d>: waiting for new solution\n", SCIPgetStatus(subscip));
break;
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecForward)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
int n;
int p;
int ndep;
/* "_" means the matrix for blas */
SCIP_Real* y; /* [n] */
SCIP_Real* orig_X_; /* [n*p] */
SCIP_Real* orig_Q_; /* [p*p] <- (X^t) X */
SCIP_Real* orig_q; /* [p] <- (X^t) y */
SCIP_Real r;
int* Mdep; /* [ndep] */
int* groupX; /* [ndep*p] */
/* for forward selection */
int dim;
int* list; /* [p] */
SCIP_Real* a; /* [dim] */
SCIP_Real* a_old; /* [dim-1] */
SCIP_Real* a_new; /* [dim] */
SCIP_Real RSS; /* residual sum of square */
SCIP_Real RSS_new;
SCIP_Real AIC;
SCIP_Real AIC_new;
int ublb;
int *Branchz; /* [3*p] */
/*
* X: sub matrix of orig_X_
* Y: (X^t X)^-1
* X_new = (X, x_i);
* Z: (X_new ^t X_new)^-1
* = ( V v
v^t u )
*/
SCIP_Real* Xy; /* sub vector of orig_q */
SCIP_Real* X_;
SCIP_Real* Y_; /* [(dim-1)*(dim-1)] */
SCIP_Real* Z_; /* [dim*dim] */
SCIP_Real* W_; /* [dim*dim] */
SCIP_Real* V_; /* [(dim-1)*(dim-1)] */
SCIP_Real* v; /* [dim-1] */
SCIP_Real u;
SCIP_Real* b; /* [dim-1] */
SCIP_Real* c; /* [dim-1] */
SCIP_Real* d; /* [n] */
/* variables */
SCIP_VAR** var_a; /* [p] continuous variables */
SCIP_VAR** var_z; /* [p] 01 variables */
SCIP_VAR** var_ep; /* [n] continuous variables */
SCIP_VAR* var_rss; /* continuous variable, residual sum of squares */
SCIP_VAR* var_log; /* continuous variable, log(rss) */
/* set solution */
SCIP_Real *ep;
int nsols;
int store;
SCIP_SOL** sols;
SCIP_Real objval;
SCIP_SOL* sol;
SCIP_Real* solvals;
SCIP_Bool success;
int nvars = SCIPgetNVars(scip);
SCIP_VAR** vars;
int i,j,t,ct;
int memo;
assert(heur != NULL);
assert(scip != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
#if MYPARA_LOG
printf("forward selection!\n");
#endif
/* get heuristic data */
/*
SCIP_HEURDATA* heurdata;
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
assert(lastsolindices != NULL);
*/
/* get values from probdata */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
n = SCIPprobdataGetNdatas(probdata);
p = SCIPprobdataGetNexvars(probdata);
ndep = SCIPprobdataGetNdep(probdata);
y = SCIPprobdataGety(probdata);
orig_X_ = SCIPprobdataGetX(probdata);
orig_Q_ = SCIPprobdataGetQ(probdata);
orig_q = SCIPprobdataGetq(probdata);
r = SCIPprobdataGetr(probdata);
if( ndep ){
Mdep = SCIPprobdataGetMdep(probdata);
groupX = SCIPprobdataGetgroupX(probdata);
}else{
Mdep = NULL;
groupX = NULL;
}
/* variables */
var_a = SCIPprobdataGetVars_a(probdata);
var_z = SCIPprobdataGetVars_z(probdata);
var_ep = SCIPprobdataGetVars_ep(probdata);
var_rss = SCIPprobdataGetVar_rss(probdata);
var_log = SCIPprobdataGetVar_log(probdata);
/* get branching info */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &Branchz, 3*p));
GenerateZeroVecInt( 3*p, Branchz);
for(i=0; i<p; ++i){
ublb = SCIPround(scip, SCIPcomputeVarUbLocal(scip, var_z[i])
+ SCIPcomputeVarLbLocal(scip, var_z[i]));
*(Branchz+(ublb*p)+i) = 1;
}
#if MYPARA_LOG
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
#endif
if( ndep ){
for(i=0; i<ndep; i++){
memo = -1;
for(j=0; j<p; j++){
if( *(groupX+(i*p)+j)==1 ){
if( *(Branchz+j)==1 ) break;
if( *(Branchz+p+j)==1 ) memo=j;
if( j==Mdep[i] ){
if( memo==-1 ){
printf("error in heur_backward.c\n");
stop();
}
*(Branchz+p+memo) = 0;
*(Branchz+memo) = 1;
break;
}
}
}
}
}
#if MYPARA_LOG
printf("linear dependent\n");
if( ndep ){
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
}
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &X_, n*p));
SCIP_CALL( SCIPallocBufferArray(scip, &Xy, p));
SCIP_CALL( SCIPallocBufferArray(scip, &d, n));
SCIP_CALL( SCIPallocBufferArray(scip, &list, p));
/* initialize from Branchz */
#if MYPARA_LOG
printf("initialization\n");
#endif
GenerateZeroVecInt( p, list);
dim = 0;
memo = -1;
AIC = 1e+06;
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim+1));
for(i=0; i<p; i++){
if( Branchz[i]==1 ){ /* if z_i is fixed to 0 */
list[i] = -1;
}else if( Branchz[p+i]==1 ){ /* if z_i is unfixed */
list[i] = 0;
}else if( Branchz[2*p+i]==1 ){ /* if z_i is fixed 1 */
dim++;
list[i] = dim;
if( dim == 1 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS = RSSvalue( 1, a_old, &orig_q[i], r);
AIC = AICvalue( n, dim, RSS);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, i, i);
}else{
/* alloc */
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray( scip, &a_old, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_old <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_old);
//printv( dim, a_old);
RSS = RSSvalue( dim, a_old, Xy, r);
AIC = AICvalue( n, dim, RSS);
/* copy */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( Z_, Y_, dim*dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* free */
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
}
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", i, AIC);
#endif
}else{
printf("error:heur_forward.c\n");
stop();
}
}
if( dim == 0 ){
#if MYPARA_LOG
printf("[dim:0]\n");
#endif
dim++;
RSS = 1e+06;
for(i=0; i<p; i++){
if( list[i] == 0 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS_new = RSSvalue( 1, a_old, &orig_q[i], r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
printf("error in heur_forward.c\n");
stop();
}
AIC = AICvalue( n, dim, RSS);
list[memo] = dim;
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, memo, memo);
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
} /* if ( dim==0 ) */
while(1){
dim++;
memo = -1;
RSS = 1e+06;
#if MYPARA_LOG
printf("(dim=%d) ", dim);
Longline();
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray( scip, &a_new, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &a, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
SCIP_CALL( SCIPallocBufferArray( scip, &W_, (dim)*(dim)));
for(i=0; i<p; i++){
/*
* 1. b <- X^t x_i
* 2. c <- Y b
* 3. d <- - X c + x_i
* 4. u <- 1 / <x_i, d>
* 5. v <- - u c
* 6. V <- Y + u c c^t
* 7. Z <- ( V v
v^t u )
* 8. a_new <- Z (Xy)
*/
if( list[i]==0 ){
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_new <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_new);
//printv( dim, a_new);
/* test */
RSS_new = RSSvalue( dim, a_new, Xy, r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
mydcopy_( Z_, W_, dim*dim);
mydcopy_( a_new, a, dim);
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
if( memo == -1 ){
for(i=0; i<p; i++){
if( list[i] == 0 ){
memo = i;
break;
}
}
if( memo != -1 ){
printf("error in heur_forward.c\n");
stop();
}
}else{
printf("error in heur_forward.c\n");
stop();
}
}
AIC_new = AICvalue( n, dim, RSS);
if( AIC_new < AIC ){
AIC = AIC_new;
list[memo] = dim;
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
/* copy and free */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( W_, Y_, dim*dim);
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim));
mydcopy_( a, a_old, dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
}else{
memo = -1;
SCIPfreeBufferArray(scip, Y_);
#if MYPARA_LOG
printf("--> no selection, (AIC:%f)\n", AIC_new);
#endif
}
/* free */
SCIPfreeBufferArray(scip, &a_new);
SCIPfreeBufferArray(scip, &a);
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
SCIPfreeBufferArray(scip, &W_);
if( memo == -1 ){
dim--;
break;
}
}
nsols = SCIPgetNSols(scip);
if( nsols < MP_NUM_SOL ){
store = 1;
}else{
sols = SCIPgetSols(scip);
objval = AIC;
nsols = MP_NUM_SOL;
if( objval < SCIPgetSolOrigObj(scip,sols[nsols-1]) ){
store = 1;
}else{
store = 0;
}
}
if( store ){
/* generate solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &ep, n));
dgemv_1( X_, n, dim, a_old, y, -1.0, 1.0, ep);
/* set solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &solvals, nvars));
SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvars));
ct=0;
/* a */
for(i=0; i<p; ++i){
vars[ct] = var_a[i];
if( list[i] > 0 ){
solvals[ct] = a_old[list[i]-1];
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* z */
for(i=0; i<p; i++){
vars[ct] = var_z[i];
if( list[i] > 0 ){
solvals[ct] = 1.0;
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* ep */
for(i=0; i<n; ++i){
vars[ct] = var_ep[i];
solvals[ct] = ep[i];
ct++;
}
vars[ct] = var_rss;
solvals[ct] = myddot_( ep, ep, n);
ct++;
vars[ct] = var_log;
solvals[ct] = log(myddot_( ep, ep, n));
ct++;
if( ct!=nvars ){
SCIPerrorMessage("It is unexpected error in set sol,");
printf("( ct, nvars) = ( %d, %d)", ct, nvars);
stop();
}
SCIP_CALL( SCIPcreateSol(scip, &sol, heur));
SCIP_CALL( SCIPsetSolVals(scip, sol, nvars, vars, solvals));
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, FALSE, TRUE, TRUE, &success));
/* free */
SCIPfreeBufferArray(scip, &ep);
SCIPfreeBufferArray(scip, &solvals);
SCIPfreeBufferArray(scip, &vars);
}
/* free */
SCIPfreeBufferArray(scip, &d);
SCIPfreeBufferArray(scip, &X_);
SCIPfreeBufferArray(scip, &Xy);
SCIPfreeBufferArray(scip, &a_old);
SCIPfreeBufferArray(scip, &list);
SCIPfreeBufferArray(scip, &Branchz);
*result = SCIP_FOUNDSOL;
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecCrossover)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata; /* primal heuristic data */
SCIP* subscip; /* the subproblem created by crossover */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_SOL** sols;
SCIP_Real memorylimit; /* memory limit for the subproblem */
SCIP_Real timelimit; /* time limit for the subproblem */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real upperbound;
SCIP_Bool success;
SCIP_Longint nstallnodes; /* node limit for the subproblem */
int* selection; /* pool of solutions crossover uses */
int nvars; /* number of original problem's variables */
int nbinvars;
int nintvars;
int nusedsols;
int i;
SCIP_RETCODE retcode;
assert(heur != NULL);
assert(scip != NULL);
assert(result != NULL);
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
nusedsols = heurdata->nusedsols;
*result = SCIP_DELAYED;
/* only call heuristic, if enough solutions are at hand */
if( SCIPgetNSols(scip) < nusedsols )
return SCIP_OKAY;
sols = SCIPgetSols(scip);
assert(sols != NULL);
/* if one good solution was found, heuristic should not be delayed any longer */
if( sols[nusedsols-1] != heurdata->prevlastsol )
{
heurdata->nextnodenumber = SCIPgetNNodes(scip);
if( sols[0] != heurdata->prevbestsol )
heurdata->nfailures = 0;
}
/* in nonrandomized mode: only recall heuristic, if at least one new good solution was found in the meantime */
else if( !heurdata->randomization )
return SCIP_OKAY;
/* if heuristic should be delayed, wait until certain number of nodes is reached */
if( SCIPgetNNodes(scip) < heurdata->nextnodenumber )
return SCIP_OKAY;
/* only call heuristic, if enough nodes were processed since last incumbent */
if( SCIPgetNNodes(scip) - SCIPgetSolNodenum(scip,SCIPgetBestSol(scip)) < heurdata->nwaitingnodes
&& (SCIPgetDepth(scip) > 0 || !heurdata->dontwaitatroot) )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* calculate the maximal number of branching nodes until heuristic is aborted */
nstallnodes = (SCIP_Longint)(heurdata->nodesquot * SCIPgetNNodes(scip));
/* reward Crossover if it succeeded often */
nstallnodes = (SCIP_Longint)
(nstallnodes * (1.0 + 2.0*(SCIPheurGetNBestSolsFound(heur)+1.0)/(SCIPheurGetNCalls(heur)+1.0)));
/* count the setup costs for the sub-MIP as 100 nodes */
nstallnodes -= 100 * SCIPheurGetNCalls(heur);
nstallnodes += heurdata->nodesofs;
/* determine the node limit for the current process */
nstallnodes -= heurdata->usednodes;
nstallnodes = MIN(nstallnodes, heurdata->maxnodes);
/* check whether we have enough nodes left to call subproblem solving */
if( nstallnodes < heurdata->minnodes )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
assert(nvars > 0);
/* check whether discrete variables are available */
if( nbinvars == 0 && nintvars == 0 )
return SCIP_OKAY;
/* initializing the subproblem */
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
success = FALSE;
if( heurdata->uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_crossoversub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_crossoversub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "crossover", TRUE, FALSE, TRUE, &success) );
if( heurdata->copycuts )
{
/** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
}
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &selection, nusedsols) );
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) (size_t) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
success = FALSE;
/* create a new problem, which fixes variables with same value in a certain set of solutions */
SCIP_CALL( setupSubproblem(scip, subscip, subvars, selection, heurdata, &success) );
heurdata->prevbestsol = SCIPgetBestSol(scip);
heurdata->prevlastsol = sols[heurdata->nusedsols-1];
/* if creation of sub-SCIP was aborted (e.g. due to number of fixings), free sub-SCIP and abort */
if( !success )
{
*result = SCIP_DIDNOTRUN;
/* this run will be counted as a failure since no new solution tuple could be generated or the neighborhood of the
* solution was not fruitful in the sense that it was too big
*/
updateFailureStatistic(scip, heurdata);
goto TERMINATE;
}
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
goto TERMINATE;
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nstallnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
if( !SCIPisParamFixed(subscip, "conflict/useprop") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useinflp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useboundlp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usesb") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usepseudo") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
}
/* add an objective cutoff */
cutoff = SCIPinfinity(scip);
assert(!SCIPisInfinity(scip, SCIPgetUpperbound(scip)));
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-heurdata->minimprove)*SCIPgetUpperbound(scip) + heurdata->minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - heurdata->minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + heurdata->minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff );
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
/* permute the subproblem to increase diversification */
if( heurdata->permute )
{
SCIP_CALL( SCIPpermuteProb(subscip, (unsigned int) SCIPheurGetNCalls(heur), TRUE, TRUE, TRUE, TRUE, TRUE) );
}
/* solve the subproblem */
SCIPdebugMessage("Solve Crossover subMIP\n");
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process.
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop. */
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in Crossover heuristic; sub-SCIP terminated with code <%d>\n", retcode);
}
heurdata->usednodes += SCIPgetNNodes(subscip);
/* check, whether a solution was found */
if( SCIPgetNSols(subscip) > 0 )
{
SCIP_SOL** subsols;
int nsubsols;
int solindex; /* index of the solution created by crossover */
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted */
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
solindex = -1;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &solindex, &success) );
}
if( success )
{
int tmp;
assert(solindex != -1);
*result = SCIP_FOUNDSOL;
/* insert all crossings of the new solution and (nusedsols-1) of its parents into the hashtable
* in order to avoid incest ;)
*/
for( i = 0; i < nusedsols; i++ )
{
SOLTUPLE* elem;
tmp = selection[i];
selection[i] = solindex;
SCIP_CALL( createSolTuple(scip, &elem, selection, nusedsols, heurdata) );
SCIP_CALL( SCIPhashtableInsert(heurdata->hashtable, elem) );
selection[i] = tmp;
}
/* if solution was among the best ones, crossover should not be called until another good solution was found */
if( !heurdata->randomization )
{
heurdata->prevbestsol = SCIPgetBestSol(scip);
heurdata->prevlastsol = SCIPgetSols(scip)[heurdata->nusedsols-1];
}
}
/* if solution is not better then incumbent or could not be added to problem => run is counted as a failure */
if( !success || solindex != SCIPsolGetIndex(SCIPgetBestSol(scip)) )
updateFailureStatistic(scip, heurdata);
}
else
{
/* if no new solution was found, run was a failure */
updateFailureStatistic(scip, heurdata);
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &selection);
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** creates a subproblem for subscip by fixing a number of variables */
static
SCIP_RETCODE setupSubproblem(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP data structure for the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
int* selection, /**< pool of solutions crossover will use */
SCIP_HEURDATA* heurdata, /**< primal heuristic data */
SCIP_Bool* success /**< pointer to store whether the problem was created successfully */
)
{
SCIP_SOL** sols; /* array of all solutions found so far */
int nsols; /* number of all solutions found so far */
int nusedsols; /* number of solutions to use in crossover */
int i;
char consname[SCIP_MAXSTRLEN];
/* get solutions' data */
nsols = SCIPgetNSols(scip);
sols = SCIPgetSols(scip);
nusedsols = heurdata->nusedsols;
assert(nusedsols > 1);
assert(nsols >= nusedsols);
/* use nusedsols best solutions if randomization is deactivated or there are only nusedsols solutions at hand
* or a good new solution was found since last call */
if( !heurdata->randomization || nsols == nusedsols || heurdata->prevlastsol != sols[nusedsols-1] )
{
SOLTUPLE* elem;
SCIP_HEUR* solheur;
SCIP_Longint solnodenum;
SCIP_Bool allsame;
for( i = 0; i < nusedsols; i++ )
selection[i] = i;
SCIP_CALL( createSolTuple(scip, &elem, selection, nusedsols, heurdata) );
solheur = SCIPsolGetHeur(sols[0]);
solnodenum = SCIPsolGetNodenum(sols[0]);
allsame = TRUE;
/* check, whether all solutions have been found by the same heuristic at the same node; in this case we do not run
* crossover, since it would probably just optimize over the same space as the other heuristic
*/
for( i = 1; i < nusedsols; i++ )
{
if( SCIPsolGetHeur(sols[i]) != solheur || SCIPsolGetNodenum(sols[i]) != solnodenum )
allsame = FALSE;
}
*success = !allsame && !SCIPhashtableExists(heurdata->hashtable, elem);
/* check, whether solution tuple has already been tried */
if( !SCIPhashtableExists(heurdata->hashtable, elem) )
{
SCIP_CALL( SCIPhashtableInsert(heurdata->hashtable, elem) );
}
/* if solution tuple has already been tried, randomization is allowed and enough solutions are at hand, try
* to randomize another tuple. E.g., this can happen if the last crossover solution was among the best ones */
if( !(*success) && heurdata->randomization && nsols > nusedsols )
{
SCIP_CALL( selectSolsRandomized(scip, selection, heurdata, success) );
}
}
/* otherwise randomize the set of solutions */
else
{
SCIP_CALL( selectSolsRandomized(scip, selection, heurdata, success) );
}
/* no acceptable solution tuple could be created */
if( !(*success) )
return SCIP_OKAY;
/* get name of the original problem and add the string "_crossoversub" */
(void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "%s_crossoversub", SCIPgetProbName(scip));
/* set up the variables of the subproblem */
SCIP_CALL( fixVariables(scip, subscip, subvars, selection, heurdata, success) );
/* we copy the rows of the LP, if the enough variables could be fixed and we work on the MIP
relaxation of the problem */
if( *success && heurdata->uselprows )
{
SCIP_CALL( createRows(scip, subscip, subvars) );
}
return SCIP_OKAY;
}
/** randomly selects the solutions crossover will use from the pool of all solutions found so far */
static
SCIP_RETCODE selectSolsRandomized(
SCIP* scip, /**< original SCIP data structure */
int* selection, /**< pool of solutions crossover uses */
SCIP_HEURDATA* heurdata, /**< primal heuristic data */
SCIP_Bool* success /**< pointer to store whether the process was successful */
)
{
int i;
int j;
int lastsol; /* the worst solution possible to choose */
int nusedsols; /* number of solutions which will be chosen */
SOLTUPLE* elem;
SCIP_SOL** sols;
/* initialization */
nusedsols = heurdata->nusedsols;
lastsol = SCIPgetNSols(scip);
sols = SCIPgetSols(scip);
assert(nusedsols < lastsol);
i = 0;
*success = FALSE;
/* perform at maximum 10 restarts and stop as soon as a new set of solutions is found */
while( !*success && i < 10 )
{
SCIP_Bool validtuple;
validtuple = TRUE;
for( j = 0; j < nusedsols && validtuple; j++ )
{
int k;
k = SCIPgetRandomInt(nusedsols-j-1, lastsol-1, &heurdata->randseed);
/* ensure that the solution does not have a similar source as the others */
while( k >= nusedsols-j-1 && !solHasNewSource(sols, selection, j, k) )
k--;
validtuple = (k >= nusedsols-j-1);
selection[j] = k;
lastsol = k;
}
if( validtuple )
{
/* creates an object ready to be inserted into the hashtable */
SCIP_CALL( createSolTuple(scip, &elem, selection, nusedsols, heurdata) );
/* check whether the randomized set is already in the hashtable, if not, insert it */
if( !SCIPhashtableExists(heurdata->hashtable, elem) )
{
SCIP_CALL( SCIPhashtableInsert(heurdata->hashtable, elem) );
*success = TRUE;
}
}
i++;
}
return SCIP_OKAY;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpRapidlearning)
{/*lint --e{715}*/
SCIP* subscip; /* the subproblem created by rapid learning */
SCIP_SEPADATA* sepadata; /* separator's private data */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_HASHMAP* varmapbw; /* mapping of sub-SCIP variables to SCIP variables */
SCIP_CONSHDLR** conshdlrs; /* array of constraint handler's that might that might obtain conflicts */
int* oldnconss; /* number of constraints without rapid learning conflicts */
SCIP_Longint nodelimit; /* node limit for the subproblem */
SCIP_Real timelimit; /* time limit for the subproblem */
SCIP_Real memorylimit; /* memory limit for the subproblem */
int nconshdlrs; /* size of conshdlr and oldnconss array */
int nfixedvars; /* number of variables that could be fixed by rapid learning */
int nvars; /* number of variables */
int restartnum; /* maximal number of conflicts that should be created */
int i; /* counter */
SCIP_Bool success; /* was problem creation / copying constraint successful? */
SCIP_RETCODE retcode; /* used for catching sub-SCIP errors in debug mode */
int nconflicts; /* statistic: number of conflicts applied */
int nbdchgs; /* statistic: number of bound changes applied */
int n1startinfers; /* statistic: number of one side infer values */
int n2startinfers; /* statistic: number of both side infer values */
SCIP_Bool soladded; /* statistic: was a new incumbent found? */
SCIP_Bool dualboundchg; /* statistic: was a new dual bound found? */
SCIP_Bool disabledualreductions; /* TRUE, if dual reductions in sub-SCIP are not valid for original SCIP,
* e.g., because a constraint could not be copied or a primal solution
* could not be copied back
*/
int ndiscvars;
soladded = FALSE;
assert(sepa != NULL);
assert(scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
ndiscvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip)+SCIPgetNImplVars(scip);
/* only run when still not fixed binary variables exists */
if( ndiscvars == 0 )
return SCIP_OKAY;
/* get separator's data */
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
/* only run for integer programs */
if( !sepadata->contvars && ndiscvars != SCIPgetNVars(scip) )
return SCIP_OKAY;
/* only run if there are few enough continuous variables */
if( sepadata->contvars && SCIPgetNContVars(scip) > sepadata->contvarsquot * SCIPgetNVars(scip) )
return SCIP_OKAY;
/* do not run if pricers are present */
if( SCIPgetNActivePricers(scip) > 0 )
return SCIP_OKAY;
/* if the separator should be exclusive to the root node, this prevents multiple calls due to restarts */
if( SCIPsepaGetFreq(sepa) == 0 && SCIPsepaGetNCalls(sepa) > 0)
return SCIP_OKAY;
/* call separator at most once per node */
if( SCIPsepaGetNCallsAtNode(sepa) > 0 )
return SCIP_OKAY;
/* do not call rapid learning, if the problem is too big */
if( SCIPgetNVars(scip) > sepadata->maxnvars || SCIPgetNConss(scip) > sepadata->maxnconss )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initializing the subproblem */
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPcreate(&subscip) );
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
success = FALSE;
/* copy the subproblem */
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "rapid", FALSE, FALSE, &success) );
if( sepadata->copycuts )
{
/** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, FALSE) );
}
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) (size_t) SCIPhashmapGetImage(varmapfw, vars[i]);
SCIPhashmapFree(&varmapfw);
/* this avoids dual presolving */
if( !success )
{
for( i = 0; i < nvars; i++ )
{
SCIP_CALL( SCIPaddVarLocks(subscip, subvars[i], 1, 1 ) );
}
}
SCIPdebugMessage("Copying SCIP was%s successful.\n", success ? "" : " not");
/* mimic an FD solver: DFS, no LP solving, 1-FUIP instead of all-FUIP */
SCIP_CALL( SCIPsetIntParam(subscip, "lp/solvefreq", -1) );
SCIP_CALL( SCIPsetIntParam(subscip, "conflict/fuiplevels", 1) );
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/dfs/stdpriority", INT_MAX/4) );
SCIP_CALL( SCIPsetBoolParam(subscip, "constraints/disableenfops", TRUE) );
SCIP_CALL( SCIPsetIntParam(subscip, "propagating/pseudoobj/freq", -1) );
/* use inference branching */
SCIP_CALL( SCIPsetBoolParam(subscip, "branching/inference/useweightedsum", FALSE) );
/* only create short conflicts */
SCIP_CALL( SCIPsetRealParam(subscip, "conflict/maxvarsfac", 0.05) );
/* set limits for the subproblem */
nodelimit = SCIPgetNLPIterations(scip);
nodelimit = MAX(sepadata->minnodes, nodelimit);
nodelimit = MIN(sepadata->maxnodes, nodelimit);
restartnum = 1000;
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
if( !SCIPisInfinity(scip, memorylimit) )
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
if( timelimit <= 0.0 || memorylimit <= 0.0 )
goto TERMINATE;
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nodelimit/5) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPsetIntParam(subscip, "limits/restarts", 0) );
SCIP_CALL( SCIPsetIntParam(subscip, "conflict/restartnum", restartnum) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
#ifndef SCIP_DEBUG
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
#endif
/* add an objective cutoff */
SCIP_CALL( SCIPsetObjlimit(subscip, SCIPgetUpperbound(scip)) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapbw, SCIPblkmem(scip), SCIPcalcHashtableSize(5 * nvars)) );
/* store reversing mapping of variables */
SCIP_CALL( SCIPtransformProb(subscip) );
for( i = 0; i < nvars; ++i)
{
SCIP_CALL( SCIPhashmapInsert(varmapbw, SCIPvarGetTransVar(subvars[i]), vars[i]) );
}
/** allocate memory for constraints storage. Each constraint that will be created from now on will be a conflict.
* Therefore, we need to remember oldnconss to get the conflicts from the FD search.
*/
nconshdlrs = 4;
SCIP_CALL( SCIPallocBufferArray(scip, &conshdlrs, nconshdlrs) );
SCIP_CALL( SCIPallocBufferArray(scip, &oldnconss, nconshdlrs) );
/* store number of constraints before rapid learning search */
conshdlrs[0] = SCIPfindConshdlr(subscip, "bounddisjunction");
conshdlrs[1] = SCIPfindConshdlr(subscip, "setppc");
conshdlrs[2] = SCIPfindConshdlr(subscip, "linear");
conshdlrs[3] = SCIPfindConshdlr(subscip, "logicor");
/* redundant constraints might be eliminated in presolving */
SCIP_CALL( SCIPpresolve(subscip));
for( i = 0; i < nconshdlrs; ++i)
{
if( conshdlrs[i] != NULL )
oldnconss[i] = SCIPconshdlrGetNConss(conshdlrs[i]);
}
nfixedvars = SCIPgetNFixedVars(scip);
/* solve the subproblem */
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage("Error while solving subproblem in rapid learning separator; sub-SCIP terminated with code <%d>\n",retcode);
}
/* abort solving, if limit of applied conflicts is reached */
if( SCIPgetNConflictConssApplied(subscip) >= restartnum )
{
SCIPdebugMessage("finish after %lld successful conflict calls.\n", SCIPgetNConflictConssApplied(subscip));
}
/* if the first 20% of the solution process were successful, proceed */
else if( (sepadata->applyprimalsol && SCIPgetNSols(subscip) > 0 && SCIPisFeasLT(scip, SCIPgetUpperbound(subscip), SCIPgetUpperbound(scip) ) )
|| (sepadata->applybdchgs && SCIPgetNFixedVars(subscip) > nfixedvars)
|| (sepadata->applyconflicts && SCIPgetNConflictConssApplied(subscip) > 0) )
{
SCIPdebugMessage("proceed solving after the first 20%% of the solution process, since:\n");
if( SCIPgetNSols(subscip) > 0 && SCIPisFeasLE(scip, SCIPgetUpperbound(subscip), SCIPgetUpperbound(scip) ) )
{
SCIPdebugMessage(" - there was a better solution (%f < %f)\n",SCIPgetUpperbound(subscip), SCIPgetUpperbound(scip));
}
if( SCIPgetNFixedVars(subscip) > nfixedvars )
{
SCIPdebugMessage(" - there were %d variables fixed\n", SCIPgetNFixedVars(scip)-nfixedvars );
}
if( SCIPgetNConflictConssFound(subscip) > 0 )
{
SCIPdebugMessage(" - there were %lld conflict constraints created\n", SCIPgetNConflictConssApplied(subscip));
}
/* set node limit to 100% */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nodelimit) );
/* solve the subproblem */
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage("Error while solving subproblem in rapid learning separator; sub-SCIP terminated with code <%d>\n",retcode);
}
}
else
{
SCIPdebugMessage("do not proceed solving after the first 20%% of the solution process.\n");
}
#ifdef SCIP_DEBUG
SCIP_CALL( SCIPprintStatistics(subscip, NULL) );
#endif
disabledualreductions = FALSE;
/* check, whether a solution was found */
if( sepadata->applyprimalsol && SCIPgetNSols(subscip) > 0 && SCIPfindHeur(scip, "trysol") != NULL )
{
SCIP_HEUR* heurtrysol;
SCIP_SOL** subsols;
int nsubsols;
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until was declared to be feasible
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
soladded = FALSE;
heurtrysol = SCIPfindHeur(scip, "trysol");
/* sequentially add solutions to trysol heuristic */
for( i = 0; i < nsubsols && !soladded; ++i )
{
SCIPdebugMessage("Try to create new solution by copying subscip solution.\n");
SCIP_CALL( createNewSol(scip, subscip, subvars, heurtrysol, subsols[i], &soladded) );
}
if( !soladded || !SCIPisEQ(scip, SCIPgetSolOrigObj(subscip, subsols[i-1]), SCIPgetSolOrigObj(subscip, subsols[0])) )
disabledualreductions = TRUE;
}
/* if the sub problem was solved completely, we update the dual bound */
dualboundchg = FALSE;
if( sepadata->applysolved && !disabledualreductions
&& (SCIPgetStatus(subscip) == SCIP_STATUS_OPTIMAL || SCIPgetStatus(subscip) == SCIP_STATUS_INFEASIBLE) )
{
/* we need to multiply the dualbound with the scaling factor and add the offset,
* because this information has been disregarded in the sub-SCIP */
SCIPdebugMessage("Update old dualbound %g to new dualbound %g.\n", SCIPgetDualbound(scip), SCIPgetTransObjscale(scip) * SCIPgetDualbound(subscip) + SCIPgetTransObjoffset(scip));
SCIP_CALL( SCIPupdateLocalDualbound(scip, SCIPgetDualbound(subscip) * SCIPgetTransObjscale(scip) + SCIPgetTransObjoffset(scip)) );
dualboundchg = TRUE;
}
/* check, whether conflicts were created */
nconflicts = 0;
if( sepadata->applyconflicts && !disabledualreductions && SCIPgetNConflictConssApplied(subscip) > 0 )
{
SCIP_HASHMAP* consmap;
int hashtablesize;
assert(SCIPgetNConflictConssApplied(subscip) < (SCIP_Longint) INT_MAX);
hashtablesize = (int) SCIPgetNConflictConssApplied(subscip);
assert(hashtablesize < INT_MAX/5);
hashtablesize *= 5;
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&consmap, SCIPblkmem(scip), SCIPcalcHashtableSize(hashtablesize)) );
/* loop over all constraint handlers that might contain conflict constraints */
for( i = 0; i < nconshdlrs; ++i)
{
/* copy constraints that have been created in FD run */
if( conshdlrs[i] != NULL && SCIPconshdlrGetNConss(conshdlrs[i]) > oldnconss[i] )
{
SCIP_CONS** conss;
int c;
int nconss;
nconss = SCIPconshdlrGetNConss(conshdlrs[i]);
conss = SCIPconshdlrGetConss(conshdlrs[i]);
/* loop over all constraints that have been added in sub-SCIP run, these are the conflicts */
for( c = oldnconss[i]; c < nconss; ++c)
{
SCIP_CONS* cons;
SCIP_CONS* conscopy;
cons = conss[c];
assert(cons != NULL);
success = FALSE;
SCIP_CALL( SCIPgetConsCopy(subscip, scip, cons, &conscopy, conshdlrs[i], varmapbw, consmap, NULL,
SCIPconsIsInitial(cons), SCIPconsIsSeparated(cons), SCIPconsIsEnforced(cons), SCIPconsIsChecked(cons),
SCIPconsIsPropagated(cons), TRUE, FALSE, SCIPconsIsDynamic(cons),
SCIPconsIsRemovable(cons), FALSE, TRUE, &success) );
if( success )
{
nconflicts++;
SCIP_CALL( SCIPaddCons(scip, conscopy) );
SCIP_CALL( SCIPreleaseCons(scip, &conscopy) );
}
else
{
SCIPdebugMessage("failed to copy conflict constraint %s back to original SCIP\n", SCIPconsGetName(cons));
}
}
}
}
SCIPhashmapFree(&consmap);
}
/* check, whether tighter global bounds were detected */
nbdchgs = 0;
if( sepadata->applybdchgs && !disabledualreductions )
for( i = 0; i < nvars; ++i )
{
SCIP_Bool infeasible;
SCIP_Bool tightened;
assert(SCIPisLE(scip, SCIPvarGetLbGlobal(vars[i]), SCIPvarGetLbGlobal(subvars[i])));
assert(SCIPisLE(scip, SCIPvarGetLbGlobal(subvars[i]), SCIPvarGetUbGlobal(subvars[i])));
assert(SCIPisLE(scip, SCIPvarGetUbGlobal(subvars[i]), SCIPvarGetUbGlobal(vars[i])));
/* update the bounds of the original SCIP, if a better bound was proven in the sub-SCIP */
SCIP_CALL( SCIPtightenVarUb(scip, vars[i], SCIPvarGetUbGlobal(subvars[i]), FALSE, &infeasible, &tightened) );
if( tightened )
nbdchgs++;
SCIP_CALL( SCIPtightenVarLb(scip, vars[i], SCIPvarGetLbGlobal(subvars[i]), FALSE, &infeasible, &tightened) );
if( tightened )
nbdchgs++;
}
n1startinfers = 0;
n2startinfers = 0;
/* install start values for inference branching */
if( sepadata->applyinfervals && (!sepadata->reducedinfer || soladded || nbdchgs+nconflicts > 0) )
{
for( i = 0; i < nvars; ++i )
{
SCIP_Real downinfer;
SCIP_Real upinfer;
SCIP_Real downvsids;
SCIP_Real upvsids;
SCIP_Real downconflen;
SCIP_Real upconflen;
/* copy downwards branching statistics */
downvsids = SCIPgetVarVSIDS(subscip, subvars[i], SCIP_BRANCHDIR_DOWNWARDS);
downconflen = SCIPgetVarAvgConflictlength(subscip, subvars[i], SCIP_BRANCHDIR_DOWNWARDS);
downinfer = SCIPgetVarAvgInferences(subscip, subvars[i], SCIP_BRANCHDIR_DOWNWARDS);
/* copy upwards branching statistics */
upvsids = SCIPgetVarVSIDS(subscip, subvars[i], SCIP_BRANCHDIR_UPWARDS);
upconflen = SCIPgetVarAvgConflictlength(subscip, subvars[i], SCIP_BRANCHDIR_UPWARDS);
upinfer = SCIPgetVarAvgInferences(subscip, subvars[i], SCIP_BRANCHDIR_UPWARDS);
/* memorize statistics */
if( downinfer+downconflen+downvsids > 0.0 || upinfer+upconflen+upvsids != 0 )
n1startinfers++;
if( downinfer+downconflen+downvsids > 0.0 && upinfer+upconflen+upvsids != 0 )
n2startinfers++;
SCIP_CALL( SCIPinitVarBranchStats(scip, vars[i], 0.0, 0.0, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, 0.0, 0.0) );
}
}
SCIPdebugPrintf("XXX Rapidlearning added %d conflicts, changed %d bounds, %s primal solution, %s dual bound improvement.\n", nconflicts, nbdchgs, soladded ? "found" : "no",
dualboundchg ? "found" : "no");
SCIPdebugPrintf("YYY Infervalues initialized on one side: %5.2f %% of variables, %5.2f %% on both sides\n",
100.0 * n1startinfers/(SCIP_Real)nvars, 100.0 * n2startinfers/(SCIP_Real)nvars);
/* change result pointer */
if( nconflicts > 0 || dualboundchg )
*result = SCIP_CONSADDED;
else if( nbdchgs > 0 )
*result = SCIP_REDUCEDDOM;
/* free local data */
SCIPfreeBufferArray(scip, &oldnconss);
SCIPfreeBufferArray(scip, &conshdlrs);
SCIPhashmapFree(&varmapbw);
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
