/** deinitialization method of primal heuristic (called before transformed problem is freed) */
static
SCIP_DECL_HEUREXIT(heurExitRandrounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
/* free heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
SCIP_CALL( SCIPfreeSol(scip, &heurdata->sol) );
return SCIP_OKAY;
}
/** deinitialization method of primal heuristic (called before transformed problem is freed) */
static
SCIP_DECL_HEUREXIT(heurExitLinesearchdiving)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(heur != NULL);
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* free working solution */
SCIP_CALL( SCIPfreeSol(scip, &heurdata->sol) );
return SCIP_OKAY;
}
/** deinitialization method of primal heuristic (called before transformed problem is freed) */
static
SCIP_DECL_HEUREXIT(heurExitActconsdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* free working solution */
SCIP_CALL( SCIPfreeSol(scip, &heurdata->sol) );
return SCIP_OKAY;
}
/** solving process deinitialization method of separator (called before branch and bound process data is freed) */
static
SCIP_DECL_SEPAEXITSOL(sepaExitsolClosecuts)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
assert( sepa != NULL );
assert( strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0 );
sepadata = SCIPsepaGetData(sepa);
assert( sepadata != NULL );
if ( sepadata->separelint && sepadata->sepasol != NULL )
{
SCIP_CALL( SCIPfreeSol(scip, &sepadata->sepasol) );
}
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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecTrivial)
{ /*lint --e{715}*/
SCIP_VAR** vars;
SCIP_SOL* lbsol; /* solution where all variables are set to their lower bounds */
SCIP_SOL* ubsol; /* solution where all variables are set to their upper bounds */
SCIP_SOL* zerosol; /* solution where all variables are set to zero */
SCIP_SOL* locksol; /* solution where all variables are set to the bound with the fewer locks */
SCIP_Real large;
int nvars;
int nbinvars;
int i;
SCIP_Bool success;
SCIP_Bool zerovalid;
*result = SCIP_DIDNOTRUN;
if( SCIPgetNRuns(scip) > 1 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
success = FALSE;
/* initialize data structure */
SCIP_CALL( SCIPcreateSol(scip, &lbsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &ubsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &zerosol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &locksol, heur) );
/* determine large value to set variables to */
large = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, 0.1 / SCIPfeastol(scip)) )
large = 0.1 / SCIPfeastol(scip);
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* if the problem is binary, we do not have to check the zero solution, since it is equal to the lower bound
* solution */
zerovalid = (nvars != nbinvars);
assert(vars != NULL || nvars == 0);
for( i = 0; i < nvars; i++ )
{
SCIP_Real lb;
SCIP_Real ub;
assert(vars != NULL); /* this assert is needed for flexelint */
lb = SCIPvarGetLbLocal(vars[i]);
ub = SCIPvarGetUbLocal(vars[i]);
/* if problem is obviously infeasible due to empty domain, stop */
if( SCIPisGT(scip, lb, ub) )
goto TERMINATE;
/* set bounds to sufficient large value */
if( SCIPisInfinity(scip, -lb) )
lb = MIN(-large, ub);
if( SCIPisInfinity(scip, ub) )
{
SCIP_Real tmp;
tmp = SCIPvarGetLbLocal(vars[i]);
ub = MAX(tmp, large);
}
SCIP_CALL( SCIPsetSolVal(scip, lbsol, vars[i], lb) );
SCIP_CALL( SCIPsetSolVal(scip, ubsol, vars[i], ub) );
/* try the zero vector, if it is in the bounds region */
if( zerovalid )
{
if( SCIPisLE(scip, lb, 0.0) && SCIPisLE(scip, 0.0, ub) )
{
SCIP_CALL( SCIPsetSolVal(scip, zerosol, vars[i], 0.0) );
}
else
zerovalid = FALSE;
}
/* set variables to the bound with fewer locks, if tie choose an average value */
if( SCIPvarGetNLocksDown(vars[i]) > SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], ub) );
}
else if( SCIPvarGetNLocksDown(vars[i]) < SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], lb) );
}
else
{
SCIP_Real solval;
solval = (lb+ub)/2.0;
/* if a tie occurs, roughly every third integer variable will be rounded up */
if( SCIPvarGetType(vars[i]) != SCIP_VARTYPE_CONTINUOUS )
solval = i % 3 == 0 ? SCIPceil(scip,solval) : SCIPfloor(scip,solval);
assert(SCIPisFeasLE(scip,SCIPvarGetLbLocal(vars[i]),solval) && SCIPisFeasLE(scip,solval,SCIPvarGetUbLocal(vars[i])));
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], solval) );
}
}
/* try lower bound solution */
SCIPdebugMessage("try lower bound solution\n");
SCIP_CALL( SCIPtrySol(scip, lbsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lower bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, lbsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try upper bound solution */
SCIPdebugMessage("try upper bound solution\n");
SCIP_CALL( SCIPtrySol(scip, ubsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible upper bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, ubsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try zero solution */
if( zerovalid )
{
SCIPdebugMessage("try zero solution\n");
SCIP_CALL( SCIPtrySol(scip, zerosol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible zero solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, zerosol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* try lock solution */
SCIPdebugMessage("try lock solution\n");
SCIP_CALL( SCIPtrySol(scip, locksol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lock solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, locksol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free solutions */
SCIP_CALL( SCIPfreeSol(scip, &lbsol) );
SCIP_CALL( SCIPfreeSol(scip, &ubsol) );
SCIP_CALL( SCIPfreeSol(scip, &zerosol) );
SCIP_CALL( SCIPfreeSol(scip, &locksol) );
return SCIP_OKAY;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpClosecuts)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
SCIP_Longint currentnodenumber;
SCIP_Bool isroot;
assert( sepa != NULL );
assert( strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0 );
assert( result != NULL );
*result = SCIP_DIDNOTRUN;
/* only call separator, if there are fractional variables */
if ( SCIPgetNLPBranchCands(scip) == 0 )
return SCIP_OKAY;
sepadata = SCIPsepaGetData(sepa);
assert( sepadata != NULL );
currentnodenumber = SCIPnodeGetNumber(SCIPgetCurrentNode(scip));
if ( sepadata->discardnode == currentnodenumber )
return SCIP_OKAY;
isroot = FALSE;
if (SCIPgetNNodes(scip) == 0)
isroot = TRUE;
/* only separate close cuts in the root if required */
if ( sepadata->separootonly || isroot )
{
SCIP_SOL* point = NULL;
SCIPdebugMessage("Separation method of closecuts separator.\n");
*result = SCIP_DIDNOTFIND;
/* check whether we have to compute a relative interior point */
if ( sepadata->separelint )
{
/* check if previous relative interior point should be forgotten,
* otherwise it is computed only once and the same point is used for all nodes */
if ( sepadata->recomputerelint && sepadata->sepasol != NULL )
{
SCIP_CALL( SCIPfreeSol(scip, &sepadata->sepasol) );
}
if ( sepadata->sepasol == NULL )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, 0, "Computing relative interior point (norm type: %c) ...\n", sepadata->relintnormtype);
assert(sepadata->relintnormtype == 'o' || sepadata->relintnormtype == 's');
SCIP_CALL( SCIPcomputeLPRelIntPoint(scip, TRUE, sepadata->inclobjcutoff, sepadata->relintnormtype, &sepadata->sepasol) );
}
}
else
{
/* get best solution (NULL if not present) */
sepadata->sepasol = SCIPgetBestSol(scip);
}
/* separate close cuts */
if ( sepadata->sepasol != NULL )
{
SCIPdebugMessage("Generating close cuts ... (combination value: %f)\n", sepadata->sepacombvalue);
/* generate point to be separated */
SCIP_CALL( generateCloseCutPoint(scip, sepadata, &point) );
/* apply a separation round to generated point */
if ( point != NULL )
{
int noldcuts;
SCIP_Bool delayed;
SCIP_Bool cutoff;
noldcuts = SCIPgetNCuts(scip);
SCIP_CALL( SCIPseparateSol(scip, point, isroot, FALSE, &delayed, &cutoff) );
SCIP_CALL( SCIPfreeSol(scip, &point) );
assert( point == NULL );
/* the cuts can be not violated by the current LP if the computed point is strange */
SCIP_CALL( SCIPremoveInefficaciousCuts(scip) );
if ( cutoff )
*result = SCIP_CUTOFF;
else
{
if ( SCIPgetNCuts(scip) - noldcuts > sepadata->sepathreshold )
{
sepadata->nunsuccessful = 0;
*result = SCIP_NEWROUND;
}
else
{
if ( SCIPgetNCuts(scip) > noldcuts )
{
sepadata->nunsuccessful = 0;
*result = SCIP_SEPARATED;
}
else
++sepadata->nunsuccessful;
}
}
SCIPdebugMessage("Separated close cuts: %d (enoughcuts: %d, unsuccessful: %d).\n", SCIPgetNCuts(scip) - noldcuts,
SCIPgetNCuts(scip) - noldcuts > sepadata->sepathreshold, sepadata->nunsuccessful);
if ( sepadata->maxunsuccessful >= 0 && sepadata->nunsuccessful > sepadata->maxunsuccessful )
{
SCIPdebugMessage("Turn off close cut separation, because of %d unsuccessful calls.\n", sepadata->nunsuccessful);
sepadata->discardnode = currentnodenumber;
}
}
}
}
return SCIP_OKAY;
}
/** reads a given SCIP solution file, problem has to be transformed in advance */
static
SCIP_RETCODE readSol(
SCIP* scip, /**< SCIP data structure */
const char* fname /**< name of the input file */
)
{
SCIP_SOL* sol;
SCIP_FILE* file;
SCIP_Bool error;
SCIP_Bool unknownvariablemessage;
SCIP_Bool stored;
SCIP_Bool usevartable;
int lineno;
assert(scip != NULL);
assert(fname != NULL);
SCIP_CALL( SCIPgetBoolParam(scip, "misc/usevartable", &usevartable) );
if( !usevartable )
{
SCIPerrorMessage("Cannot read solution file if vartable is disabled. Make sure parameter 'misc/usevartable' is set to TRUE.\n");
return SCIP_READERROR;
}
/* open input file */
file = SCIPfopen(fname, "r");
if( file == NULL )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", fname);
SCIPprintSysError(fname);
return SCIP_NOFILE;
}
/* create zero solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, NULL) );
/* read the file */
error = FALSE;
unknownvariablemessage = FALSE;
lineno = 0;
while( !SCIPfeof(file) && !error )
{
char buffer[SCIP_MAXSTRLEN];
char varname[SCIP_MAXSTRLEN];
char valuestring[SCIP_MAXSTRLEN];
char objstring[SCIP_MAXSTRLEN];
SCIP_VAR* var;
SCIP_Real value;
int nread;
/* get next line */
if( SCIPfgets(buffer, (int) sizeof(buffer), file) == NULL )
break;
lineno++;
/* there are some lines which may preceed the solution information */
if( strncasecmp(buffer, "solution status:", 16) == 0 || strncasecmp(buffer, "objective value:", 16) == 0 ||
strncasecmp(buffer, "Log started", 11) == 0 || strncasecmp(buffer, "Variable Name", 13) == 0 ||
strncasecmp(buffer, "All other variables", 19) == 0 || strncasecmp(buffer, "\n", 1) == 0 ||
strncasecmp(buffer, "NAME", 4) == 0 || strncasecmp(buffer, "ENDATA", 6) == 0 ) /* allow parsing of SOL-format on the MIPLIB 2003 pages */
continue;
/* parse the line */
nread = sscanf(buffer, "%s %s %s\n", varname, valuestring, objstring);
if( nread < 2 )
{
SCIPerrorMessage("Invalid input line %d in solution file <%s>: <%s>.\n", lineno, fname, buffer);
error = TRUE;
break;
}
/* find the variable */
var = SCIPfindVar(scip, varname);
if( var == NULL )
{
if( !unknownvariablemessage )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "unknown variable <%s> in line %d of solution file <%s>\n",
varname, lineno, fname);
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, " (further unknown variables are ignored)\n");
unknownvariablemessage = TRUE;
}
continue;
}
/* cast the value */
if( strncasecmp(valuestring, "inv", 3) == 0 )
continue;
else if( strncasecmp(valuestring, "+inf", 4) == 0 || strncasecmp(valuestring, "inf", 3) == 0 )
value = SCIPinfinity(scip);
else if( strncasecmp(valuestring, "-inf", 4) == 0 )
value = -SCIPinfinity(scip);
else
{
nread = sscanf(valuestring, "%lf", &value);
if( nread != 1 )
{
SCIPerrorMessage("Invalid solution value <%s> for variable <%s> in line %d of solution file <%s>.\n",
valuestring, varname, lineno, fname);
error = TRUE;
break;
}
}
/* set the solution value of the variable, if not multiaggregated */
if( SCIPisTransformed(scip) && SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_MULTAGGR )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n", SCIPvarGetName(var));
}
else
{
SCIP_RETCODE retcode;
retcode = SCIPsetSolVal(scip, sol, var, value);
if( retcode == SCIP_INVALIDDATA )
{
if( SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_FIXED )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored conflicting solution value for fixed variable <%s>\n",
SCIPvarGetName(var));
}
else
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n",
SCIPvarGetName(var));
}
}
else
{
SCIP_CALL( retcode );
}
}
}
/* close input file */
SCIPfclose(file);
if( !error )
{
/* add and free the solution */
if( SCIPisTransformed(scip) )
{
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, TRUE, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
fname, stored ? "accepted" : "rejected - solution is infeasible or objective too poor");
}
else
{
/* add primal solution to solution candidate storage, frees the solution afterwards */
SCIP_CALL( SCIPaddSolFree(scip, &sol, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
fname, stored ? "accepted as candidate, will be checked when solving starts" : "rejected - solution objective too poor");
}
return SCIP_OKAY;
}
else
{
/* free solution */
SCIP_CALL( SCIPfreeSol(scip, &sol) );
return SCIP_READERROR;
}
}
/** reads a given xml solution file */
static
SCIP_RETCODE readXMLSol(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< name of the input file */
)
{
SCIP_Bool unknownvariablemessage;
SCIP_SOL* sol;
SCIP_Bool error;
XML_NODE* start;
const XML_NODE* varsnode;
const XML_NODE* varnode;
const char* tag;
assert( scip != NULL );
assert( filename != NULL );
/* read xml file */
start = xmlProcess(filename);
if( start == NULL )
{
SCIPerrorMessage("Some error occured during parsing the XML solution file.\n");
return SCIP_READERROR;
}
/* create zero solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, NULL) );
error = FALSE;
/* find variable sections */
tag = "variables";
varsnode = xmlFindNodeMaxdepth(start, tag, 0, 3);
if( varsnode == NULL )
{
/* free xml data */
xmlFreeNode(start);
SCIPerrorMessage("Variable section not found.\n");
return SCIP_READERROR;
}
/* loop through all variables */
unknownvariablemessage = FALSE;
for( varnode = xmlFirstChild(varsnode); varnode != NULL; varnode = xmlNextSibl(varnode) )
{
SCIP_VAR* var;
const char* varname;
const char* varvalue;
SCIP_Real value;
int nread;
/* find variable name */
varname = xmlGetAttrval(varnode, "name");
if( varname == NULL )
{
SCIPerrorMessage("Attribute \"name\" of variable not found.\n");
error = TRUE;
break;
}
/* find the variable */
var = SCIPfindVar(scip, varname);
if( var == NULL )
{
if( !unknownvariablemessage )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "unknown variable <%s> of solution file <%s>\n",
varname, filename);
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, " (further unknown variables are ignored)\n");
unknownvariablemessage = TRUE;
}
continue;
}
/* find value of variable */
varvalue = xmlGetAttrval(varnode, "value");
if( varvalue == NULL )
{
SCIPerrorMessage("Attribute \"value\" of variable not found.\n");
error = TRUE;
break;
}
/* cast the value */
if( strncasecmp(varvalue, "inv", 3) == 0 )
continue;
else if( strncasecmp(varvalue, "+inf", 4) == 0 || strncasecmp(varvalue, "inf", 3) == 0 )
value = SCIPinfinity(scip);
else if( strncasecmp(varvalue, "-inf", 4) == 0 )
value = -SCIPinfinity(scip);
else
{
nread = sscanf(varvalue, "%lf", &value);
if( nread != 1 )
{
SCIPwarningMessage(scip, "invalid solution value <%s> for variable <%s> in XML solution file <%s>\n", varvalue, varname, filename);
error = TRUE;
break;
}
}
/* set the solution value of the variable, if not multiaggregated */
if( SCIPisTransformed(scip) && SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_MULTAGGR )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n", SCIPvarGetName(var));
}
else
{
SCIP_RETCODE retcode;
retcode = SCIPsetSolVal(scip, sol, var, value);
if( retcode == SCIP_INVALIDDATA )
{
if( SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_FIXED )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored conflicting solution value for fixed variable <%s>\n",
SCIPvarGetName(var));
}
else
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n",
SCIPvarGetName(var));
}
}
else
{
SCIP_CALL( retcode );
}
}
}
if( !error )
{
SCIP_Bool stored;
/* add and free the solution */
if( SCIPisTransformed(scip) )
{
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, TRUE, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
filename, stored ? "accepted" : "rejected - solution is infeasible or objective too poor");
}
else
{
SCIP_CALL( SCIPaddSolFree(scip, &sol, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
filename, stored ? "accepted as candidate, will be checked when solving starts" : "rejected - solution objective too poor");
}
}
else
{
/* free solution */
SCIP_CALL( SCIPfreeSol(scip, &sol) );
/* free xml data */
xmlFreeNode(start);
return SCIP_READERROR;
}
/* free xml data */
xmlFreeNode(start);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecOctane)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_SOL** first_sols; /* stores the first ffirst sols in order to check for common violation of a row */
SCIP_VAR** vars; /* the variables of the problem */
SCIP_VAR** fracvars; /* variables, that are fractional in current LP solution */
SCIP_VAR** subspacevars; /* the variables on which the search is performed. Either coinciding with vars or with the
* space of all fractional variables of the current LP solution */
SCIP_Real p; /* n/2 - <delta,x> ( for some facet delta ) */
SCIP_Real q; /* <delta,a> */
SCIP_Real* rayorigin; /* origin of the ray, vector x in paper */
SCIP_Real* raydirection; /* direction of the ray, vector a in paper */
SCIP_Real* negquotient; /* negated quotient of rayorigin and raydirection, vector v in paper */
SCIP_Real* lambda; /* stores the distance of the facets (s.b.) to the origin of the ray */
SCIP_Bool usefracspace; /* determines whether the search concentrates on fractional variables and fixes integer ones */
SCIP_Bool cons_viol; /* used for checking whether a linear constraint is violated by one of the possible solutions */
SCIP_Bool success;
SCIP_Bool* sign; /* signature of the direction of the ray */
SCIP_Bool** facets; /* list of extended facets */
int nvars; /* number of variables */
int nbinvars; /* number of 0-1-variables */
int nfracvars; /* number of fractional variables in current LP solution */
int nsubspacevars; /* dimension of the subspace on which the search is performed */
int nfacets; /* number of facets hidden by the ray that where already found */
int i; /* counter */
int j; /* counter */
int f_max; /* {0,1}-points to be checked */
int f_first; /* {0,1}-points to be generated at first in order to check whether a restart is necessary */
int r; /* counter */
int firstrule;
int* perm; /* stores the way in which the coordinates were permuted */
int* fracspace; /* maps the variables of the subspace to the original variables */
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* OCTANE is for use in 0-1 programs only */
if( nvars != nbinvars )
return SCIP_OKAY;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
/* don't call heuristic, if it was not successful enough in the past */
/*lint --e{647}*/
if( SCIPgetNNodes(scip) % (SCIPheurGetNCalls(heur) / (100 * SCIPheurGetNBestSolsFound(heur) + 10*heurdata->nsuccess + 1) + 1) != 0 )
return SCIP_OKAY;
SCIP_CALL( SCIPgetLPBranchCands(scip, &fracvars, NULL, NULL, &nfracvars, NULL) );
/* don't use integral starting points */
if( nfracvars == 0 )
return SCIP_OKAY;
/* get working pointers from heurdata */
sol = heurdata->sol;
assert( sol != NULL );
f_max = heurdata->f_max;
f_first = heurdata->f_first;
usefracspace = heurdata->usefracspace;
SCIP_CALL( SCIPallocBufferArray(scip, &fracspace, nvars) );
/* determine the space one which OCTANE should work either as the whole space or as the space of fractional variables */
if( usefracspace )
{
nsubspacevars = nfracvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
BMScopyMemoryArray(subspacevars, fracvars, nsubspacevars);
for( i = nvars - 1; i >= 0; --i )
fracspace[i] = -1;
for( i = nsubspacevars - 1; i >= 0; --i )
fracspace[SCIPvarGetProbindex(subspacevars[i])] = i;
}
else
{
int currentindex;
nsubspacevars = nvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
/* only copy the variables which are in the current LP */
currentindex = 0;
for( i = 0; i < nvars; ++i )
{
if( SCIPcolGetLPPos(SCIPvarGetCol(vars[i])) >= 0 )
{
subspacevars[currentindex] = vars[i];
fracspace[i] = currentindex;
++currentindex;
}
else
{
fracspace[i] = -1;
--nsubspacevars;
}
}
}
/* nothing to do for empty search space */
if( nsubspacevars == 0 )
return SCIP_OKAY;
assert(0 < nsubspacevars && nsubspacevars <= nvars);
for( i = 0; i < nsubspacevars; i++)
assert(fracspace[SCIPvarGetProbindex(subspacevars[i])] == i);
/* at most 2^(n-1) facets can be hit */
if( nsubspacevars < 30 )
{
/*lint --e{701}*/
assert(f_max > 0);
f_max = MIN(f_max, 1 << (nsubspacevars - 1) );
}
f_first = MIN(f_first, f_max);
/* memory allocation */
SCIP_CALL( SCIPallocBufferArray(scip, &rayorigin, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &raydirection, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &negquotient, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &sign, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &perm, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &lambda, f_max + 1) );
SCIP_CALL( SCIPallocBufferArray(scip, &facets, f_max + 1) );
for( i = f_max; i >= 0; --i )
{
/*lint --e{866}*/
SCIP_CALL( SCIPallocBufferArray(scip, &facets[i], nsubspacevars) );
}
SCIP_CALL( SCIPallocBufferArray(scip, &first_sols, f_first) );
*result = SCIP_DIDNOTFIND;
/* starting OCTANE */
SCIPdebugMessage("run Octane heuristic on %s variables, which are %d vars, generate at most %d facets, using rule number %d\n",
usefracspace ? "fractional" : "all", nsubspacevars, f_max, (heurdata->lastrule+1)%5);
/* generate starting point in original coordinates */
SCIP_CALL( generateStartingPoint(scip, rayorigin, subspacevars, nsubspacevars) );
for( i = nsubspacevars - 1; i >= 0; --i )
rayorigin[i] -= 0.5;
firstrule = heurdata->lastrule;
++firstrule;
for( r = firstrule; r <= firstrule + 10 && !SCIPisStopped(scip); r++ )
{
SCIP_ROW** rows;
int nrows;
/* generate shooting ray in original coordinates by certain rules */
switch(r % 5)
{
case 1:
if( heurdata->useavgnbray )
{
SCIP_CALL( generateAverageNBRay(scip, raydirection, fracspace, subspacevars, nsubspacevars) );
}
break;
case 2:
if( heurdata->useobjray )
{
SCIP_CALL( generateObjectiveRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 3:
if( heurdata->usediffray )
{
SCIP_CALL( generateDifferenceRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 4:
if( heurdata->useavgwgtray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, TRUE) );
}
break;
case 0:
if( heurdata->useavgray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, FALSE) );
}
break;
default:
SCIPerrorMessage("invalid ray rule identifier\n");
SCIPABORT();
}
/* there must be a feasible direction for the shooting ray */
if( isZero(scip, raydirection, nsubspacevars) )
continue;
/* transform coordinates such that raydirection >= 0 */
flipCoords(rayorigin, raydirection, sign, nsubspacevars);
for( i = f_max - 1; i >= 0; --i)
lambda[i] = SCIPinfinity(scip);
/* calculate negquotient, initialize perm, facets[0], p, and q */
p = 0.5 * nsubspacevars;
q = 0.0;
for( i = nsubspacevars - 1; i >= 0; --i )
{
/* calculate negquotient, the ratio of rayorigin and raydirection, paying special attention to the case raydirection[i] == 0 */
if( SCIPisFeasZero(scip, raydirection[i]) )
{
if( rayorigin[i] < 0 )
negquotient[i] = SCIPinfinity(scip);
else
negquotient[i] = -SCIPinfinity(scip);
}
else
negquotient[i] = - (rayorigin[i] / raydirection[i]);
perm[i] = i;
/* initialization of facets[0] to the all-one facet with p and q its characteristic values */
facets[0][i] = TRUE;
p -= rayorigin[i];
q += raydirection[i];
}
assert(SCIPisPositive(scip, q));
/* resort the coordinates in nonincreasing order of negquotient */
SCIPsortDownRealRealRealBoolPtr( negquotient, raydirection, rayorigin, sign, (void**) subspacevars, nsubspacevars);
#ifndef NDEBUG
for( i = 0; i < nsubspacevars; i++ )
assert( raydirection[i] >= 0 );
for( i = 1; i < nsubspacevars; i++ )
assert( negquotient[i - 1] >= negquotient[i] );
#endif
/* finished initialization */
/* find the first facet of the octahedron hit by a ray shot from rayorigin into direction raydirection */
for( i = 0; i < nsubspacevars && negquotient[i] * q > p; ++i )
{
facets[0][i] = FALSE;
p += 2 * rayorigin[i];
q -= 2 * raydirection[i];
assert(SCIPisPositive(scip, p));
assert(SCIPisPositive(scip, q));
}
/* avoid dividing by values close to 0.0 */
if( !SCIPisFeasPositive(scip, q) )
continue;
/* assert necessary for flexelint */
assert(q > 0);
lambda[0] = p / q;
nfacets = 1;
/* find the first facets hit by the ray */
for( i = 0; i < nfacets && i < f_first; ++i)
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
/* construct the first ffirst possible solutions */
for( i = 0; i < nfacets && i < f_first; ++i )
{
SCIP_CALL( SCIPcreateSol(scip, &first_sols[i], heur) );
SCIP_CALL( getSolFromFacet(scip, facets[i], first_sols[i], sign, subspacevars, nsubspacevars) );
assert( first_sols[i] != NULL );
}
/* try, whether there is a row violated by all of the first ffirst solutions */
cons_viol = FALSE;
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
for( i = nrows - 1; i >= 0; --i )
{
if( !SCIProwIsLocal(rows[i]) )
{
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real rowval;
SCIP_Real* coeffs;
int nnonzerovars;
int k;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]);
rhs = SCIProwGetRhs(rows[i]);
coeffs = SCIProwGetVals(rows[i]);
nnonzerovars = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[0], SCIPcolGetVar(cols[j]));
/* if the row's lhs is violated by the first sol, test, whether it is violated by the next ones, too */
if( lhs > rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( lhs <= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* dito for the right hand side */
else if( rhs < rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( rhs >= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* break as soon as one row is violated by all of the ffirst solutions */
if( cons_viol )
break;
}
}
if( !cons_viol )
{
/* if there was no row violated by all solutions, try whether one or more of them are feasible */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
assert(first_sols[i] != NULL);
SCIP_CALL( SCIPtrySol(scip, first_sols[i], FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
/* search for further facets and construct and try solutions out of facets fixed as closest ones */
for( i = f_first; i < f_max; ++i)
{
if( i >= nfacets )
break;
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
SCIP_CALL( getSolFromFacet(scip, facets[i], sol, sign, subspacevars, nsubspacevars) );
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
}
/* finished OCTANE */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
SCIP_CALL( SCIPfreeSol(scip, &first_sols[i]) );
}
}
heurdata->lastrule = r;
if( *result == SCIP_FOUNDSOL )
++(heurdata->nsuccess);
/* free temporary memory */
SCIPfreeBufferArray(scip, &first_sols);
for( i = f_max; i >= 0; --i )
SCIPfreeBufferArray(scip, &facets[i]);
SCIPfreeBufferArray(scip, &facets);
SCIPfreeBufferArray(scip, &lambda);
SCIPfreeBufferArray(scip, &perm);
SCIPfreeBufferArray(scip, &sign);
SCIPfreeBufferArray(scip, &negquotient);
SCIPfreeBufferArray(scip, &raydirection);
SCIPfreeBufferArray(scip, &rayorigin);
SCIPfreeBufferArray(scip, &subspacevars);
SCIPfreeBufferArray(scip, &fracspace);
return SCIP_OKAY;
}
