/** returns a score value for the given variable based on the active constraints that the variable appears in */
static
SCIP_Real getNActiveConsScore(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< working solution */
SCIP_VAR* var, /**< variable to get the score value for */
SCIP_Real* downscore, /**< pointer to store the score for branching downwards */
SCIP_Real* upscore /**< pointer to store the score for branching upwards */
)
{
SCIP_COL* col;
SCIP_ROW** rows;
SCIP_Real* vals;
int nrows;
int r;
int nactrows;
SCIP_Real nlprows;
SCIP_Real downcoefsum;
SCIP_Real upcoefsum;
SCIP_Real score;
assert(downscore != NULL);
assert(upscore != NULL);
*downscore = 0.0;
*upscore = 0.0;
if( SCIPvarGetStatus(var) != SCIP_VARSTATUS_COLUMN )
return 0.0;
col = SCIPvarGetCol(var);
assert(col != NULL);
rows = SCIPcolGetRows(col);
vals = SCIPcolGetVals(col);
nrows = SCIPcolGetNLPNonz(col);
nactrows = 0;
downcoefsum = 0.0;
upcoefsum = 0.0;
for( r = 0; r < nrows; ++r )
{
SCIP_ROW* row;
SCIP_Real activity;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real dualsol;
row = rows[r];
/* calculate number of active constraint sides, i.e., count equations as two */
lhs = SCIProwGetLhs(row);
rhs = SCIProwGetRhs(row);
/* @todo this is suboptimal because activity is calculated by looping over all nonzeros of this row, need to
* store LP activities instead (which cannot be retrieved if no LP was solved at this node)
*/
activity = SCIPgetRowSolActivity(scip, row, sol);
dualsol = SCIProwGetDualsol(row);
if( SCIPisFeasEQ(scip, activity, lhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(row);
if( SCIPisFeasPositive(scip, dualsol) )
{
if( coef > 0.0 )
downcoefsum += coef;
else
upcoefsum -= coef;
}
}
else if( SCIPisFeasEQ(scip, activity, rhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(row);
if( SCIPisFeasNegative(scip, dualsol) )
{
if( coef > 0.0 )
upcoefsum += coef;
else
downcoefsum -= coef;
}
}
}
/* use the number of LP rows for normalization */
nlprows = (SCIP_Real)SCIPgetNLPRows(scip);
upcoefsum /= nlprows;
downcoefsum /= nlprows;
/* calculate the score using SCIP's branch score. Pass NULL as variable to not have the var branch factor influence
* the result
*/
score = nactrows / nlprows + SCIPgetBranchScore(scip, NULL, downcoefsum, upcoefsum);
assert(score <= 3.0);
assert(score >= 0.0);
*downscore = downcoefsum;
*upscore = upcoefsum;
return score;
}
/** checks if a given branching candidate is better than a previous one and updates the best branching candidate accordingly */
static
SCIP_RETCODE updateBestCandidate(
SCIP* scip, /**< SCIP data structure */
SCIP_BRANCHRULEDATA* branchruledata, /**< branching rule data */
SCIP_VAR** bestvar, /**< best branching candidate */
SCIP_Real* bestbrpoint, /**< branching point for best branching candidate */
SCIP_Real* bestscore, /**< score of best branching candidate */
SCIP_VAR* cand, /**< branching candidate to consider */
SCIP_Real candscoremin, /**< minimal score of branching candidate */
SCIP_Real candscoremax, /**< maximal score of branching candidate */
SCIP_Real candscoresum, /**< sum of scores of branching candidate */
SCIP_Real candsol /**< proposed branching point of branching candidate */
)
{
SCIP_Real candbrpoint;
SCIP_Real branchscore;
SCIP_Real deltaminus;
SCIP_Real deltaplus;
SCIP_Real pscostdown;
SCIP_Real pscostup;
char strategy;
assert(scip != NULL);
assert(branchruledata != NULL);
assert(bestvar != NULL);
assert(bestbrpoint != NULL);
assert(bestscore != NULL);
assert(cand != NULL);
/* a branching variable candidate should either be an active problem variable or a multi-aggregated variable */
assert(SCIPvarIsActive(SCIPvarGetProbvar(cand)) ||
SCIPvarGetStatus(SCIPvarGetProbvar(cand)) == SCIP_VARSTATUS_MULTAGGR);
if( SCIPvarGetStatus(SCIPvarGetProbvar(cand)) == SCIP_VARSTATUS_MULTAGGR )
{
/* for a multi-aggregated variable, we call updateBestCandidate function recursively with all variables in the multi-aggregation */
SCIP_VAR** multvars;
int nmultvars;
int i;
SCIP_Bool success;
SCIP_Real multvarlb;
SCIP_Real multvarub;
cand = SCIPvarGetProbvar(cand);
multvars = SCIPvarGetMultaggrVars(cand);
nmultvars = SCIPvarGetMultaggrNVars(cand);
/* if we have a candidate branching point, then first register only aggregation variables
* for which we can compute a corresponding branching point too (see also comments below)
* if this fails, then register all (unfixed) aggregation variables, thereby forgetting about candsol
*/
success = FALSE;
if( candsol != SCIP_INVALID ) /*lint !e777*/
{
SCIP_Real* multscalars;
SCIP_Real minact;
SCIP_Real maxact;
SCIP_Real aggrvarsol;
SCIP_Real aggrvarsol1;
SCIP_Real aggrvarsol2;
multscalars = SCIPvarGetMultaggrScalars(cand);
/* for computing the branching point, we need the current bounds of the multi-aggregated variable */
minact = SCIPcomputeVarLbLocal(scip, cand);
maxact = SCIPcomputeVarUbLocal(scip, cand);
for( i = 0; i < nmultvars; ++i )
{
/* skip fixed variables */
multvarlb = SCIPcomputeVarLbLocal(scip, multvars[i]);
multvarub = SCIPcomputeVarUbLocal(scip, multvars[i]);
if( SCIPisEQ(scip, multvarlb, multvarub) )
continue;
assert(multscalars != NULL);
assert(multscalars[i] != 0.0);
/* we cannot ensure that both the upper bound in the left node and the lower bound in the right node
* will be candsol by a clever choice for the branching point of multvars[i],
* but we can try to ensure that at least one of them will be at candsol
*/
if( multscalars[i] > 0.0 )
{
/* cand >= candsol
* if multvars[i] >= (candsol - (maxact - multscalars[i] * ub(multvars[i]))) / multscalars[i]
* = (candsol - maxact) / multscalars[i] + ub(multvars[i])
*/
aggrvarsol1 = (candsol - maxact) / multscalars[i] + multvarub;
/* cand <= candsol
* if multvars[i] <= (candsol - (minact - multscalar[i] * lb(multvars[i]))) / multscalars[i]
* = (candsol - minact) / multscalars[i] + lb(multvars[i])
*/
aggrvarsol2 = (candsol - minact) / multscalars[i] + multvarlb;
}
else
{
/* cand >= candsol
* if multvars[i] <= (candsol - (maxact - multscalars[i] * lb(multvars[i]))) / multscalars[i]
* = (candsol - maxact) / multscalars[i] + lb(multvars[i])
*/
aggrvarsol2 = (candsol - maxact) / multscalars[i] + multvarlb;
/* cand <= candsol
* if multvars[i] >= (candsol - (minact - multscalar[i] * ub(multvars[i]))) / multscalars[i]
* = (candsol - minact) / multscalars[i] + ub(multvars[i])
*/
aggrvarsol1 = (candsol - minact) / multscalars[i] + multvarub;
}
/* by the above choice, aggrvarsol1 <= ub(multvars[i]) and aggrvarsol2 >= lb(multvars[i])
* if aggrvarsol1 <= lb(multvars[i]) or aggrvarsol2 >= ub(multvars[i]), then choose the other one
* if both are out of bounds, then give up
* if both are inside bounds, then choose the one closer to 0.0 (someone has better idea???)
*/
if( SCIPisFeasLE(scip, aggrvarsol1, multvarlb) )
{
if( SCIPisFeasGE(scip, aggrvarsol2, multvarub) )
continue;
else
aggrvarsol = aggrvarsol2;
}
else
{
if( SCIPisFeasGE(scip, aggrvarsol2, multvarub) )
aggrvarsol = aggrvarsol1;
else
aggrvarsol = REALABS(aggrvarsol1) < REALABS(aggrvarsol2) ? aggrvarsol1 : aggrvarsol2;
}
success = TRUE;
SCIP_CALL( updateBestCandidate(scip, branchruledata, bestvar, bestbrpoint, bestscore,
multvars[i], candscoremin, candscoremax, candscoresum, aggrvarsol) );
}
}
if( !success )
for( i = 0; i < nmultvars; ++i )
{
/* skip fixed variables */
multvarlb = SCIPcomputeVarLbLocal(scip, multvars[i]);
multvarub = SCIPcomputeVarUbLocal(scip, multvars[i]);
if( SCIPisEQ(scip, multvarlb, multvarub) )
continue;
SCIP_CALL( updateBestCandidate(scip, branchruledata, bestvar, bestbrpoint, bestscore,
multvars[i], candscoremin, candscoremax, candscoresum, SCIP_INVALID) );
}
assert(*bestvar != NULL); /* if all variables were fixed, something is strange */
return SCIP_OKAY;
}
/* select branching point for this variable */
candbrpoint = SCIPgetBranchingPoint(scip, cand, candsol);
assert(candbrpoint >= SCIPvarGetLbLocal(cand));
assert(candbrpoint <= SCIPvarGetUbLocal(cand));
/* we cannot branch on a huge value for a discrete variable, because we simply cannot enumerate such huge integer values in floating point
* arithmetics
*/
if( SCIPvarGetType(cand) != SCIP_VARTYPE_CONTINUOUS && (SCIPisHugeValue(scip, candbrpoint) || SCIPisHugeValue(scip, -candbrpoint)) )
return SCIP_OKAY;
assert(SCIPvarGetType(cand) == SCIP_VARTYPE_CONTINUOUS || !SCIPisIntegral(scip, candbrpoint));
if( SCIPvarGetType(cand) == SCIP_VARTYPE_CONTINUOUS )
strategy = (branchruledata->strategy == 'u' ? branchruledata->updatestrategy : branchruledata->strategy);
else
strategy = (branchruledata->strategy == 'u' ? 'l' : branchruledata->strategy);
switch( strategy )
{
case 'l':
if( SCIPisInfinity(scip, SCIPgetSolVal(scip, NULL, cand)) || SCIPgetSolVal(scip, NULL, cand) <= SCIPadjustedVarUb(scip, cand, candbrpoint) )
deltaminus = 0.0;
else
deltaminus = SCIPgetSolVal(scip, NULL, cand) - SCIPadjustedVarUb(scip, cand, candbrpoint);
if( SCIPisInfinity(scip, -SCIPgetSolVal(scip, NULL, cand)) || SCIPgetSolVal(scip, NULL, cand) >= SCIPadjustedVarLb(scip, cand, candbrpoint) )
deltaplus = 0.0;
else
deltaplus = SCIPadjustedVarLb(scip, cand, candbrpoint) - SCIPgetSolVal(scip, NULL, cand);
break;
case 'd':
if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) )
deltaminus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaminus = SCIPadjustedVarUb(scip, cand, candbrpoint) - SCIPvarGetLbLocal(cand);
if( SCIPisInfinity(scip, SCIPvarGetUbLocal(cand)) )
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaplus = SCIPvarGetUbLocal(cand) - SCIPadjustedVarLb(scip, cand, candbrpoint);
break;
case 's':
if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) )
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaplus = SCIPadjustedVarUb(scip, cand, candbrpoint) - SCIPvarGetLbLocal(cand);
if( SCIPisInfinity(scip, SCIPvarGetUbLocal(cand)) )
deltaminus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaminus = SCIPvarGetUbLocal(cand) - SCIPadjustedVarLb(scip, cand, candbrpoint);
break;
case 'v':
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
deltaminus = deltaplus;
break;
default :
SCIPerrorMessage("branching strategy %c unknown\n", strategy);
SCIPABORT();
return SCIP_INVALIDDATA; /*lint !e527*/
}
if( SCIPisInfinity(scip, deltaminus) || SCIPisInfinity(scip, deltaplus) )
{
branchscore = SCIPinfinity(scip);
}
else
{
pscostdown = SCIPgetVarPseudocostVal(scip, cand, -deltaminus);
pscostup = SCIPgetVarPseudocostVal(scip, cand, deltaplus);
branchscore = SCIPgetBranchScore(scip, cand, pscostdown, pscostup);
assert(!SCIPisNegative(scip, branchscore));
}
SCIPdebugMessage("branching score variable <%s>[%g,%g] = %g; wscore = %g; type=%d bestbrscore=%g\n",
SCIPvarGetName(cand), SCIPvarGetLbLocal(cand), SCIPvarGetUbLocal(cand), branchscore, WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum),
SCIPvarGetType(cand), *bestscore);
if( SCIPisInfinity(scip, branchscore) )
branchscore = 0.9*SCIPinfinity(scip);
if( SCIPisSumGT(scip, branchscore, *bestscore) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
else if( SCIPisSumEQ(scip, branchscore, *bestscore)
&& !(SCIPisInfinity(scip, -SCIPvarGetLbLocal(*bestvar)) && SCIPisInfinity(scip, SCIPvarGetUbLocal(*bestvar))) )
{
/* if best candidate so far is not unbounded to both sides, maybe take new candidate */
if( (SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) || SCIPisInfinity(scip, SCIPvarGetUbLocal(cand))) &&
(SCIPisInfinity(scip, -SCIPvarGetLbLocal(*bestvar)) || SCIPisInfinity(scip, SCIPvarGetUbLocal(*bestvar))) )
{
/* if both variables are unbounded but one of them is bounded on one side, take the one with the larger bound on this side (hope that this avoids branching on always the same variable) */
if( SCIPvarGetUbLocal(cand) > SCIPvarGetUbLocal(*bestvar) || SCIPvarGetLbLocal(cand) < SCIPvarGetLbLocal(*bestvar) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
else if( SCIPvarGetType(*bestvar) == SCIPvarGetType(cand) )
{
/* if both have the same type, take the one with larger diameter */
if( SCIPvarGetUbLocal(*bestvar) - SCIPvarGetLbLocal(*bestvar) < SCIPvarGetUbLocal(cand) - SCIPvarGetLbLocal(cand) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
else if( SCIPvarGetType(*bestvar) > SCIPvarGetType(cand) )
{
/* take the one with better type ("more discrete") */
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
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;
}
