/** call writing method */
static
SCIP_RETCODE writeBoundsFocusNode(
SCIP* scip, /**< SCIP data structure */
SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
)
{
FILE* file;
SCIP_Bool writesubmipdualbound;
SCIP_NODE* node;
assert(scip != NULL);
assert(eventhdlrdata != NULL);
file = eventhdlrdata->file;
writesubmipdualbound = eventhdlrdata->writesubmipdualbound;
node = SCIPgetCurrentNode(scip);
/* do not process probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return SCIP_OKAY;
/* do not process cutoff nodes */
if( SCIPisInfinity(scip, SCIPgetNodeDualbound(scip, node)) )
return SCIP_OKAY;
if( !SCIPisEQ(scip, eventhdlrdata->lastpb, SCIPgetPrimalbound(scip)) )
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Status after %"SCIP_LONGINT_FORMAT" processed nodes (%d open)\n", SCIPgetNNodes(scip), SCIPgetNNodesLeft(scip));
SCIPinfoMessage(scip, file, "Primalbound: %g\n", SCIPgetPrimalbound(scip));
SCIPinfoMessage(scip, file, "Dualbound: %g\n", SCIPgetDualbound(scip));
#else
SCIPinfoMessage(scip, file, "PB %g\n", SCIPgetPrimalbound(scip));
#endif
eventhdlrdata->lastpb = SCIPgetPrimalbound(scip);
}
if( writesubmipdualbound )
{
SCIP* subscip;
SCIP_Bool valid;
SCIP_Real submipdb;
SCIP_Bool cutoff;
SCIP_CALL( SCIPcreate(&subscip) );
submipdb = SCIP_INVALID;
valid = FALSE;
cutoff = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, NULL, NULL, "__boundwriting", FALSE, FALSE, TRUE, &valid) );
if( valid )
{
/* 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) );
/* solve only root node */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
#if 0
/* disable heuristics in subscip */
SCIP_CALL( SCIPsetHeuristics(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
#endif
/* set cutoffbound as objective limit for subscip */
SCIP_CALL( SCIPsetObjlimit(subscip, SCIPgetCutoffbound(scip)) );
SCIP_CALL( SCIPsolve(subscip) );
cutoff = (SCIPgetStatus(subscip) == SCIP_STATUS_INFEASIBLE);
submipdb = SCIPgetDualbound(subscip) * SCIPgetTransObjscale(scip) + SCIPgetTransObjoffset(scip);
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g, nodesubmiprootdualbound: %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#endif
SCIP_CALL( SCIPfree(&subscip) );
}
else
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#endif
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "\n");
#endif
return SCIP_OKAY;
}
/** call writing method */
static
SCIP_RETCODE writeBounds(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< file to write to or NULL */
SCIP_Bool writesubmipdualbound/**< write dualbounds of submip roots for all open nodes */
)
{
SCIP_NODE** opennodes;
int nopennodes;
int n;
int v;
assert(scip != NULL);
nopennodes = -1;
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Status after %"SCIP_LONGINT_FORMAT" processed nodes (%d open)\n", SCIPgetNNodes(scip), SCIPgetNNodesLeft(scip));
SCIPinfoMessage(scip, file, "Primalbound: %g\n", SCIPgetPrimalbound(scip));
SCIPinfoMessage(scip, file, "Dualbound: %g\n", SCIPgetDualbound(scip));
#else
SCIPinfoMessage(scip, file, "PB %g\n", SCIPgetPrimalbound(scip));
#endif
/* get all open nodes and therefor print all dualbounds */
for( v = 2; v >= 0; --v )
{
SCIP_NODE* node;
switch( v )
{
case 2:
SCIP_CALL( SCIPgetChildren(scip, &opennodes, &nopennodes) );
break;
case 1:
SCIP_CALL( SCIPgetSiblings(scip, &opennodes, &nopennodes) );
break;
case 0:
SCIP_CALL( SCIPgetLeaves(scip, &opennodes, &nopennodes) );
break;
default:
assert(0);
break;
}
assert(nopennodes >= 0);
/* print all node information */
for( n = nopennodes - 1; n >= 0 && !SCIPisStopped(scip); --n )
{
node = opennodes[n];
if( writesubmipdualbound )
{
SCIP* subscip;
SCIP_Bool valid;
SCIP_HASHMAP* varmap; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
int nvars;
SCIP_Real submipdb;
SCIP_Bool cutoff;
SCIP_CALL( SCIPcreate(&subscip) );
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
submipdb = SCIP_INVALID;
valid = FALSE;
cutoff = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmap, NULL, "__boundwriting", TRUE, FALSE, TRUE, &valid) );
if( valid )
{
SCIP_VAR** branchvars;
SCIP_Real* branchbounds;
SCIP_BOUNDTYPE* boundtypes;
int nbranchvars;
int size;
size = SCIPnodeGetDepth(node);
/* allocate memory for all branching decisions */
SCIP_CALL( SCIPallocBufferArray(scip, &branchvars, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &branchbounds, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, size) );
/* we assume that we only have one branching decision at each node */
SCIPnodeGetAncestorBranchings( node, branchvars, branchbounds, boundtypes, &nbranchvars, size );
/* check if did not have enough memory */
if( nbranchvars > size )
{
size = nbranchvars;
SCIP_CALL( SCIPallocBufferArray(scip, &branchvars, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &branchbounds, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, size) );
/* now getting all information */
SCIPnodeGetAncestorBranchings( node, branchvars, branchbounds, boundtypes, &nbranchvars, size );
}
/* apply all changes to the submip */
SCIP_CALL( applyDomainChanges(subscip, branchvars, branchbounds, boundtypes, nbranchvars, varmap) );
/* free memory for all branching decisions */
SCIPfreeBufferArray(scip, &boundtypes);
SCIPfreeBufferArray(scip, &branchbounds);
SCIPfreeBufferArray(scip, &branchvars);
/* 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) );
/* solve only root node */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
/* set cutoffbound as objective limit for subscip */
SCIP_CALL( SCIPsetObjlimit(subscip, SCIPgetCutoffbound(scip)) );
SCIP_CALL( SCIPsolve(subscip) );
cutoff = (SCIPgetStatus(subscip) == SCIP_STATUS_INFEASIBLE);
submipdb = SCIPgetDualbound(subscip) * SCIPgetTransObjscale(scip) + SCIPgetTransObjoffset(scip);
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g, nodesubmiprootdualbound: %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#endif
/* free hash map */
SCIPhashmapFree(&varmap);
SCIP_CALL( SCIPfree(&subscip) );
}
else
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#endif
}
}
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "\n");
#endif
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;
}
