/** propagate the given binary variable/column using the root reduced cost stored in the SCIP internal data structers
* and check if the implictions can be useful. Deppending on that implictions are used or not used during the search to
* strength the reduced costs.
*/
static
SCIP_RETCODE propagateRootRedcostBinvar(
SCIP* scip, /**< SCIP data structure */
SCIP_PROPDATA* propdata, /**< propagator data structure */
SCIP_VAR* var, /**< variable to use for propagation */
SCIP_COL* col, /**< LP column of the variable */
SCIP_Real cutoffbound, /**< the current cutoff bound */
int* nchgbds /**< pointer to count the number of bound changes */
)
{
SCIP_Real rootredcost;
SCIP_Real rootsol;
SCIP_Real rootlpobjval;
assert(SCIPgetDepth(scip) == 0);
/* skip binary variable if it is locally fixed */
if( SCIPvarGetLbLocal(var) > 0.5 || SCIPvarGetUbLocal(var) < 0.5 )
return SCIP_OKAY;
rootredcost = SCIPvarGetBestRootRedcost(var);
rootsol = SCIPvarGetBestRootSol(var);
rootlpobjval = SCIPvarGetBestRootLPObjval(var);
if( SCIPisFeasZero(scip, rootredcost) )
return SCIP_OKAY;
assert(rootlpobjval != SCIP_INVALID); /*lint !e777*/
if( rootsol > 0.5 )
{
assert(!SCIPisFeasPositive(scip, rootredcost));
/* update maximum reduced cost of a single binary variable */
propdata->maxredcost = MAX(propdata->maxredcost, -rootredcost);
if( rootlpobjval - rootredcost > cutoffbound )
{
SCIPdebugMessage("globally fix binary variable <%s> to 1.0\n", SCIPvarGetName(var));
SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
(*nchgbds)++;
return SCIP_OKAY;
}
}
else
{
assert(!SCIPisFeasNegative(scip, rootredcost));
/* update maximum reduced cost of a single binary variable */
propdata->maxredcost = MAX(propdata->maxredcost, rootredcost);
if( rootlpobjval + rootredcost > cutoffbound )
{
SCIPdebugMessage("globally fix binary variable <%s> to 0.0\n", SCIPvarGetName(var));
SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
(*nchgbds)++;
return SCIP_OKAY;
}
}
/* evaluate if the implications are useful; the implications are seen to be useful if they provide an increase for
* the root reduced costs
*/
if( !propdata->usefullimplics )
{
SCIP_Real lbredcost;
SCIP_Real ubredcost;
lbredcost = SCIPgetVarImplRedcost(scip, var, FALSE);
assert(!SCIPisFeasPositive(scip, lbredcost));
ubredcost = SCIPgetVarImplRedcost(scip, var, TRUE);
assert(!SCIPisFeasNegative(scip, ubredcost));
switch( SCIPcolGetBasisStatus(col) )
{
case SCIP_BASESTAT_LOWER:
ubredcost -= SCIPgetVarRedcost(scip, var);
assert(!SCIPisFeasNegative(scip, ubredcost));
break;
case SCIP_BASESTAT_UPPER:
lbredcost -= SCIPgetVarRedcost(scip, var);
assert(!SCIPisFeasPositive(scip, lbredcost));
break;
case SCIP_BASESTAT_BASIC:
case SCIP_BASESTAT_ZERO:
default:
break;
}
propdata->usefullimplics = (lbredcost < 0.0) || (ubredcost > 0.0);
}
return SCIP_OKAY;
}
/** propagate the given none binary variable/column using the reduced cost */
static
SCIP_RETCODE propagateRedcostVar(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable to use for propagation */
SCIP_COL* col, /**< LP column of the variable */
SCIP_Real lpobjval, /**< objective value of the current LP */
SCIP_Real cutoffbound, /**< the current cutoff bound */
int* nchgbds /**< pointer to count the number of bound changes */
)
{
SCIP_Real redcost;
switch( SCIPcolGetBasisStatus(col) )
{
case SCIP_BASESTAT_LOWER:
redcost = SCIPgetColRedcost(scip, col);
assert(!SCIPisFeasNegative(scip, redcost) || SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) );
if( SCIPisFeasPositive(scip, redcost) )
{
SCIP_Real oldlb;
SCIP_Real oldub;
oldlb = SCIPvarGetLbLocal(var);
oldub = SCIPvarGetUbLocal(var);
assert(SCIPisEQ(scip, oldlb, SCIPcolGetLb(col)));
assert(SCIPisEQ(scip, oldub, SCIPcolGetUb(col)));
if( SCIPisFeasLT(scip, oldlb, oldub) )
{
SCIP_Real newub;
SCIP_Bool strengthen;
/* calculate reduced cost based bound */
newub = (cutoffbound - lpobjval) / redcost + oldlb;
/* check, if new bound is good enough:
* - integer variables: take all possible strengthenings
* - continuous variables: strengthening must cut part of the variable's dynamic range, and
* at least 20% of the current domain
*/
if( SCIPvarIsIntegral(var) )
{
newub = SCIPadjustedVarUb(scip, var, newub);
strengthen = (newub < oldub - 0.5);
}
else
strengthen = (newub < SCIPcolGetMaxPrimsol(col) && newub <= 0.2 * oldlb + 0.8 * oldub);
if( strengthen )
{
/* strengthen upper bound */
SCIPdebugMessage("redcost strengthening upper bound: <%s> [%g,%g] -> [%g,%g] (ub=%g, lb=%g, redcost=%g)\n",
SCIPvarGetName(var), oldlb, oldub, oldlb, newub, cutoffbound, lpobjval, redcost);
SCIP_CALL( SCIPchgVarUb(scip, var, newub) );
(*nchgbds)++;
}
}
}
break;
case SCIP_BASESTAT_BASIC:
break;
case SCIP_BASESTAT_UPPER:
redcost = SCIPgetColRedcost(scip, col);
assert(!SCIPisFeasPositive(scip, redcost) || SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) );
if( SCIPisFeasNegative(scip, redcost) )
{
SCIP_Real oldlb;
SCIP_Real oldub;
oldlb = SCIPvarGetLbLocal(var);
oldub = SCIPvarGetUbLocal(var);
assert(SCIPisEQ(scip, oldlb, SCIPcolGetLb(col)));
assert(SCIPisEQ(scip, oldub, SCIPcolGetUb(col)));
if( SCIPisFeasLT(scip, oldlb, oldub) )
{
SCIP_Real newlb;
SCIP_Bool strengthen;
/* calculate reduced cost based bound */
newlb = (cutoffbound - lpobjval) / redcost + oldub;
/* check, if new bound is good enough:
* - integer variables: take all possible strengthenings
* - continuous variables: strengthening must cut part of the variable's dynamic range, and
* at least 20% of the current domain
*/
if( SCIPvarIsIntegral(var) )
{
newlb = SCIPadjustedVarLb(scip, var, newlb);
strengthen = (newlb > oldlb + 0.5);
}
else
strengthen = (newlb > SCIPcolGetMinPrimsol(col) && newlb >= 0.8 * oldlb + 0.2 * oldub);
/* check, if new bound is good enough: at least 20% strengthening for continuous variables */
if( strengthen )
{
/* strengthen lower bound */
SCIPdebugMessage("redcost strengthening lower bound: <%s> [%g,%g] -> [%g,%g] (ub=%g, lb=%g, redcost=%g)\n",
SCIPvarGetName(var), oldlb, oldub, newlb, oldub, cutoffbound, lpobjval, redcost);
SCIP_CALL( SCIPchgVarLb(scip, var, newlb) );
(*nchgbds)++;
}
}
}
break;
case SCIP_BASESTAT_ZERO:
assert(SCIPisFeasZero(scip, SCIPgetColRedcost(scip, col)));
break;
default:
SCIPerrorMessage("invalid basis state\n");
return SCIP_INVALIDDATA;
}
return SCIP_OKAY;
}
/** presolving execution method */
static
SCIP_DECL_PRESOLEXEC(presolExecTrivial)
{ /*lint --e{715}*/
SCIP_VAR** vars;
int nvars;
int v;
assert(result != NULL);
*result = SCIP_DIDNOTFIND;
/* get the problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* scan the variables for trivial bound reductions
* (loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array)
*/
for( v = nvars-1; v >= 0; --v )
{
SCIP_Real lb;
SCIP_Real ub;
SCIP_Bool infeasible;
SCIP_Bool fixed;
/* get variable's bounds */
lb = SCIPvarGetLbGlobal(vars[v]);
ub = SCIPvarGetUbGlobal(vars[v]);
/* is variable integral? */
if( SCIPvarGetType(vars[v]) != SCIP_VARTYPE_CONTINUOUS )
{
SCIP_Real newlb;
SCIP_Real newub;
/* round fractional bounds on integer variables */
newlb = SCIPfeasCeil(scip, lb);
newub = SCIPfeasFloor(scip, ub);
/* check bounds on variable for infeasibility */
if( newlb > newub + 0.5 )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible: integral variable <%s> has bounds [%.17f,%.17f] rounded to [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, newub);
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
/* fix variables with equal bounds */
if( newlb > newub - 0.5 )
{
SCIPdebugMessage("fixing integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, newub);
SCIP_CALL( SCIPfixVar(scip, vars[v], newlb, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
}
else
{
/* round fractional bounds */
if( !SCIPisFeasEQ(scip, lb, newlb) )
{
SCIPdebugMessage("rounding lower bound of integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, ub);
SCIP_CALL( SCIPchgVarLb(scip, vars[v], newlb) );
(*nchgbds)++;
}
if( !SCIPisFeasEQ(scip, ub, newub) )
{
SCIPdebugMessage("rounding upper bound of integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), newlb, ub, newlb, newub);
SCIP_CALL( SCIPchgVarUb(scip, vars[v], newub) );
(*nchgbds)++;
}
}
}
else
{
/* check bounds on continuous variable for infeasibility */
if( SCIPisFeasGT(scip, lb, ub) )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible: continuous variable <%s> has bounds [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub);
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
/* fix variables with equal bounds */
if( SCIPisEQ(scip, lb, ub) )
{
SCIP_Real fixval;
#ifdef FIXSIMPLEVALUE
fixval = SCIPselectSimpleValue(lb - 0.9 * SCIPepsilon(scip), ub + 0.9 * SCIPepsilon(scip), MAXDNOM);
#else
fixval = (lb + ub)/2;
#endif
SCIPdebugMessage("fixing continuous variable <%s>[%.17f,%.17f] to %.17f\n",
SCIPvarGetName(vars[v]), lb, ub, fixval);
SCIP_CALL( SCIPfixVar(scip, vars[v], fixval, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
}
}
}
return SCIP_OKAY;
}
/** propagate the given binary variable/column using the reduced cost */
static
SCIP_RETCODE propagateRedcostBinvar(
SCIP* scip, /**< SCIP data structure */
SCIP_PROPDATA* propdata, /**< propagator data structure */
SCIP_VAR* var, /**< variable to use for propagation */
SCIP_COL* col, /**< LP column of the variable */
SCIP_Real requiredredcost, /**< required reduset cost to be able to fix a binary variable */
int* nchgbds, /**< pointer to count the number of bound changes */
SCIP_Bool* cutoff /**< pointer to store if an cutoff was detected */
)
{
SCIP_Real lbredcost;
SCIP_Real ubredcost;
SCIP_Real redcost;
/* skip binary variable if it is locally fixed */
if( SCIPvarGetLbLocal(var) > 0.5 || SCIPvarGetUbLocal(var) < 0.5 )
return SCIP_OKAY;
/* first use the redcost cost to fix the binary variable */
switch( SCIPcolGetBasisStatus(col) )
{
case SCIP_BASESTAT_LOWER:
redcost = SCIPgetVarRedcost(scip, var);
assert(!SCIPisFeasNegative(scip, redcost));
if( redcost > requiredredcost )
{
SCIPdebugMessage("variable <%s>: fixed 0.0 (requiredredcost <%g>, redcost <%g>)\n",
SCIPvarGetName(var), requiredredcost, redcost);
SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
(*nchgbds)++;
return SCIP_OKAY;
}
break;
case SCIP_BASESTAT_UPPER:
redcost = SCIPgetVarRedcost(scip, var);
assert(!SCIPisFeasPositive(scip, redcost));
if( -redcost > requiredredcost )
{
SCIPdebugMessage("variable <%s>: fixed 1.0 (requiredredcost <%g>, redcost <%g>)\n",
SCIPvarGetName(var), requiredredcost, redcost);
SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
(*nchgbds)++;
return SCIP_OKAY;
}
break;
case SCIP_BASESTAT_BASIC:
return SCIP_OKAY;
case SCIP_BASESTAT_ZERO:
assert(SCIPisFeasZero(scip, SCIPgetColRedcost(scip, col)));
return SCIP_OKAY;
default:
SCIPerrorMessage("invalid basis state\n");
return SCIP_INVALIDDATA;
}
/* second, if the implications should be used and if the implications are seen to be promising used the implied
* reduced costs to fix the binary variable
*/
if( propdata->useimplics && propdata->usefullimplics )
{
/* collect implied reduced costs if the variable would be fixed to its lower bound */
lbredcost = SCIPgetVarImplRedcost(scip, var, FALSE);
assert(!SCIPisFeasPositive(scip, lbredcost) || SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) );
/* collect implied reduced costs if the variable would be fixed to its upper bound */
ubredcost = SCIPgetVarImplRedcost(scip, var, TRUE);
assert(!SCIPisFeasNegative(scip, ubredcost) || SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) );
if( -lbredcost > requiredredcost && ubredcost > requiredredcost )
{
SCIPdebugMessage("variable <%s>: cutoff (requiredredcost <%g>, lbredcost <%g>, ubredcost <%g>)\n",
SCIPvarGetName(var), requiredredcost, lbredcost, ubredcost);
(*cutoff) = TRUE;
}
else if( -lbredcost > requiredredcost )
{
SCIPdebugMessage("variable <%s>: fixed 1.0 (requiredredcost <%g>, redcost <%g>, lbredcost <%g>)\n",
SCIPvarGetName(var), requiredredcost, redcost, lbredcost);
SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
(*nchgbds)++;
}
else if( ubredcost > requiredredcost )
{
SCIPdebugMessage("variable <%s>: fixed 0.0 (requiredredcost <%g>, redcost <%g>, ubredcost <%g>)\n",
SCIPvarGetName(var), requiredredcost, redcost, ubredcost);
SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
(*nchgbds)++;
}
/* update maximum reduced cost of a single binary variable */
propdata->maxredcost = MAX3(propdata->maxredcost, -lbredcost, ubredcost);
}
return SCIP_OKAY;
}
/**
* Selects a variable from a set of candidates by strong branching
*
* @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
* SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
*
* @note The variables in the lpcands array must have a fractional value in the current LP solution
*/
SCIP_RETCODE SCIPselectVarPseudoStrongBranching(
SCIP* scip, /**< original SCIP data structure */
SCIP_VAR** pseudocands, /**< branching candidates */
SCIP_Bool* skipdown, /**< should down branchings be skipped? */
SCIP_Bool* skipup, /**< should up branchings be skipped? */
int npseudocands, /**< number of branching candidates */
int npriopseudocands, /**< number of priority branching candidates */
SCIP_Bool allowaddcons, /**< is the branching rule allowed to add constraints? */
int* bestpseudocand, /**< best candidate for branching */
SCIP_Real* bestdown, /**< objective value of the down branch for bestcand */
SCIP_Real* bestup, /**< objective value of the up branch for bestcand */
SCIP_Real* bestscore, /**< score for bestcand */
SCIP_Bool* bestdownvalid, /**< is bestdown a valid dual bound for the down branch? */
SCIP_Bool* bestupvalid, /**< is bestup a valid dual bound for the up branch? */
SCIP_Real* provedbound, /**< proved dual bound for current subtree */
SCIP_RESULT* result /**< result pointer */
)
{
SCIP_Real lpobjval;
SCIP_Bool allcolsinlp;
SCIP_Bool exactsolve;
#ifndef NDEBUG
SCIP_Real cutoffbound;
cutoffbound = SCIPgetCutoffbound(scip);
#endif
assert(scip != NULL);
assert(pseudocands != NULL);
assert(bestpseudocand != NULL);
assert(skipdown != NULL);
assert(skipup != NULL);
assert(bestdown != NULL);
assert(bestup != NULL);
assert(bestscore != NULL);
assert(bestdownvalid != NULL);
assert(bestupvalid != NULL);
assert(provedbound != NULL);
assert(result != NULL);
assert(SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL);
/* get current LP objective bound of the local sub problem and global cutoff bound */
lpobjval = SCIPgetLPObjval(scip);
/* check, if we want to solve the problem exactly, meaning that strong branching information is not useful
* for cutting off sub problems and improving lower bounds of children
*/
exactsolve = SCIPisExactSolve(scip);
/* check, if all existing columns are in LP, and thus the strong branching results give lower bounds */
allcolsinlp = SCIPallColsInLP(scip);
/* if only one candidate exists, choose this one without applying strong branching */
*bestpseudocand = 0;
*bestdown = lpobjval;
*bestup = lpobjval;
*bestdownvalid = TRUE;
*bestupvalid = TRUE;
*bestscore = -SCIPinfinity(scip);
*provedbound = lpobjval;
if( npseudocands > 1 )
{
SCIP_BRANCHRULE* branchrule;
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_Real solval;
SCIP_Real down;
SCIP_Real up;
SCIP_Real downgain;
SCIP_Real upgain;
SCIP_Real score;
SCIP_Bool integral;
SCIP_Bool lperror;
SCIP_Bool downvalid;
SCIP_Bool upvalid;
SCIP_Bool downinf;
SCIP_Bool upinf;
SCIP_Bool downconflict;
SCIP_Bool upconflict;
int nsbcalls;
int i;
int c;
branchrule = SCIPfindBranchrule(scip, BRANCHRULE_NAME);
assert(branchrule != NULL);
/* get branching rule data */
branchruledata = SCIPbranchruleGetData(branchrule);
assert(branchruledata != NULL);
/* initialize strong branching */
SCIP_CALL( SCIPstartStrongbranch(scip, FALSE) );
/* search the full strong candidate:
* cycle through the candidates, starting with the position evaluated in the last run
*/
nsbcalls = 0;
for( i = 0, c = branchruledata->lastcand; i < npseudocands; ++i, ++c )
{
c = c % npseudocands;
assert(pseudocands[c] != NULL);
/* we can only apply strong branching on COLUMN variables that are in the current LP */
if( !SCIPvarIsInLP(pseudocands[c]) )
continue;
solval = SCIPvarGetLPSol(pseudocands[c]);
integral = SCIPisFeasIntegral(scip, solval);
SCIPdebugMessage("applying strong branching on %s variable <%s>[%g,%g] with solution %g\n",
integral ? "integral" : "fractional", SCIPvarGetName(pseudocands[c]), SCIPvarGetLbLocal(pseudocands[c]),
SCIPvarGetUbLocal(pseudocands[c]), solval);
up = -SCIPinfinity(scip);
down = -SCIPinfinity(scip);
if( integral )
{
SCIP_CALL( SCIPgetVarStrongbranchInt(scip, pseudocands[c], INT_MAX,
skipdown[c] ? NULL : &down, skipup[c] ? NULL : &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );
}
else
{
SCIP_CALL( SCIPgetVarStrongbranchFrac(scip, pseudocands[c], INT_MAX,
skipdown[c] ? NULL : &down, skipup[c] ? NULL : &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );
}
nsbcalls++;
/* display node information line in root node */
if( SCIPgetDepth(scip) == 0 && nsbcalls % 100 == 0 )
{
SCIP_CALL( SCIPprintDisplayLine(scip, NULL, SCIP_VERBLEVEL_HIGH, TRUE) );
}
/* check for an error in strong branching */
if( lperror )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
"(node %"SCIP_LONGINT_FORMAT") error in strong branching call for variable <%s> with solution %g\n",
SCIPgetNNodes(scip), SCIPvarGetName(pseudocands[c]), solval);
break;
}
/* evaluate strong branching */
down = MAX(down, lpobjval);
up = MAX(up, lpobjval);
downgain = down - lpobjval;
upgain = up - lpobjval;
assert(!allcolsinlp || exactsolve || !downvalid || downinf == SCIPisGE(scip, down, cutoffbound));
assert(!allcolsinlp || exactsolve || !upvalid || upinf == SCIPisGE(scip, up, cutoffbound));
assert(downinf || !downconflict);
assert(upinf || !upconflict);
/* check if there are infeasible roundings */
if( downinf || upinf )
{
assert(allcolsinlp);
assert(!exactsolve);
/* if for both infeasibilities, a conflict constraint was created, we don't need to fix the variable by hand,
* but better wait for the next propagation round to fix them as an inference, and potentially produce a
* cutoff that can be analyzed
*/
if( allowaddcons && downinf == downconflict && upinf == upconflict )
{
*result = SCIP_CONSADDED;
break; /* terminate initialization loop, because constraint was added */
}
else if( downinf && upinf )
{
if( integral )
{
SCIP_Bool infeasible;
SCIP_Bool fixed;
/* both bound changes are infeasible: variable can be fixed to its current value */
SCIP_CALL( SCIPfixVar(scip, pseudocands[c], solval, &infeasible, &fixed) );
assert(!infeasible);
assert(fixed);
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> integral variable <%s> is infeasible in both directions\n",
SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
else
{
/* both roundings are infeasible: the node is infeasible */
*result = SCIP_CUTOFF;
SCIPdebugMessage(" -> fractional variable <%s> is infeasible in both directions\n",
SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because node is infeasible */
}
}
else if( downinf )
{
SCIP_Real newlb;
/* downwards rounding is infeasible -> change lower bound of variable to upward rounding */
newlb = SCIPfeasCeil(scip, solval);
if( SCIPvarGetLbLocal(pseudocands[c]) < newlb - 0.5 )
{
SCIP_CALL( SCIPchgVarLb(scip, pseudocands[c], newlb) );
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> variable <%s> is infeasible in downward branch\n", SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
}
else
{
SCIP_Real newub;
/* upwards rounding is infeasible -> change upper bound of variable to downward rounding */
assert(upinf);
newub = SCIPfeasFloor(scip, solval);
if( SCIPvarGetUbLocal(pseudocands[c]) > newub + 0.5 )
{
SCIP_CALL( SCIPchgVarUb(scip, pseudocands[c], newub) );
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> variable <%s> is infeasible in upward branch\n", SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
}
}
else if( allcolsinlp && !exactsolve && downvalid && upvalid )
{
SCIP_Real minbound;
/* the minimal lower bound of both children is a proved lower bound of the current subtree */
minbound = MIN(down, up);
*provedbound = MAX(*provedbound, minbound);
}
/* check for a better score, if we are within the maximum priority candidates */
if( c < npriopseudocands )
{
if( integral )
{
if( skipdown[c] )
{
downgain = 0.0;
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
}
else if( skipup[c] )
{
upgain = 0.0;
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
}
else
{
SCIP_Real gains[3];
gains[0] = downgain;
gains[1] = 0.0;
gains[2] = upgain;
score = SCIPgetBranchScoreMultiple(scip, pseudocands[c], 3, gains);
}
}
else
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
if( score > *bestscore )
{
*bestpseudocand = c;
*bestdown = down;
*bestup = up;
*bestdownvalid = downvalid;
*bestupvalid = upvalid;
*bestscore = score;
}
}
else
score = 0.0;
/* update pseudo cost values */
if( !downinf )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, pseudocands[c],
solval-SCIPfeasCeil(scip, solval-1.0), downgain, 1.0) );
}
if( !upinf )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, pseudocands[c],
solval-SCIPfeasFloor(scip, solval+1.0), upgain, 1.0) );
}
SCIPdebugMessage(" -> var <%s> (solval=%g, downgain=%g, upgain=%g, score=%g) -- best: <%s> (%g)\n",
SCIPvarGetName(pseudocands[c]), solval, downgain, upgain, score,
SCIPvarGetName(pseudocands[*bestpseudocand]), *bestscore);
}
/* remember last evaluated candidate */
branchruledata->lastcand = c;
/* end strong branching */
SCIP_CALL( SCIPendStrongbranch(scip) );
}
return SCIP_OKAY;
}
