const CoinPresolveAction *implied_free_action::presolve (
CoinPresolveMatrix *prob, const CoinPresolveAction *next, int &fill_level)
{
# if PRESOLVE_DEBUG > 0 || PRESOLVE_CONSISTENCY > 0
# if PRESOLVE_DEBUG > 0
std::cout
<< "Entering implied_free_action::presolve, fill level " << fill_level
<< "." << std::endl ;
# endif
presolve_consistent(prob) ;
presolve_links_ok(prob) ;
presolve_check_sol(prob) ;
presolve_check_nbasic(prob) ;
# endif
# if PRESOLVE_DEBUG > 0 || COIN_PRESOLVE_TUNING > 0
const int startEmptyRows = prob->countEmptyRows() ;
const int startEmptyColumns = prob->countEmptyCols() ;
# if COIN_PRESOLVE_TUNING > 0
double startTime = 0.0 ;
if (prob->tuning_) startTime = CoinCpuTime() ;
# endif
# endif
/*
Unpack the row- and column-major representations.
*/
const int m = prob->nrows_ ;
const int n = prob->ncols_ ;
const CoinBigIndex *rowStarts = prob->mrstrt_ ;
int *rowLengths = prob->hinrow_ ;
const int *colIndices = prob->hcol_ ;
const double *rowCoeffs = prob->rowels_ ;
presolvehlink *rlink = prob->rlink_ ;
CoinBigIndex *colStarts = prob->mcstrt_ ;
int *colLengths = prob->hincol_ ;
int *rowIndices = prob->hrow_ ;
double *colCoeffs = prob->colels_ ;
presolvehlink *clink = prob->clink_ ;
/*
Column bounds, row bounds, cost, integrality.
*/
double *clo = prob->clo_ ;
double *cup = prob->cup_ ;
double *rlo = prob->rlo_ ;
double *rup = prob->rup_ ;
double *cost = prob->cost_ ;
const unsigned char *integerType = prob->integerType_ ;
/*
Documented as `inhibit x+y+z = 1 mods'. From the code below, it's clear
that this is intended to avoid removing SOS equalities with length >= 5
(hardcoded).
*/
const bool stopSomeStuff = ((prob->presolveOptions()&0x04) != 0) ;
/*
Ignore infeasibility. `Fix' is overly optimistic.
*/
const bool fixInfeasibility = ((prob->presolveOptions_&0x4000) != 0) ;
/*
Defaults to 0.0.
*/
const double feasTol = prob->feasibilityTolerance_ ;
# if 0
/*
Tentatively moved to be a front-end function for useless_constraint_action,
much as make_fixed is a front-end for make_fixed_action. This bit of code
left for possible tuning.
-- lh, 121127 --
Original comment: This needs to be made faster.
*/
# ifdef COIN_LIGHTWEIGHT_PRESOLVE
if (prob->pass_ == 1) {
#else
if (prob->presolveOptions_&0x10) {
# endif
next = testRedundant(prob,next) ;
if (prob->status_&0x01 != 0) {
if ((prob->presolveOptions_&0x4000) != 0)
prob->status_ &= !0x01 ;
else
return (next) ;
}
# if 1 //def COIN_LIGHTWEIGHT_PRESOLVE
}
# endif
# endif
/*
implied_free and subst take a fair bit of effort to scan for candidates.
This is a hook to allow a presolve driver to avoid that work.
*/
if (prob->pass_ > 15 && (prob->presolveOptions_&0x10000) != 0) {
fill_level = 2 ;
return (next) ;
}
/*
Set up to collect implied_free actions.
*/
action *actions = new action [n] ;
# ifdef ZEROFAULT
CoinZeroN(reinterpret_cast<char *>(actions),n*sizeof(action)) ;
# endif
int nactions = 0 ;
int *implied_free = prob->usefulColumnInt_ ;
int *whichFree = implied_free+n ;
int numberFree = 0 ;
/*
Arrays to hold row activity (row lhs) min and max values. Each row lhs bound
is held as two components: a sum of finite column bounds and a count of
infinite column bounds.
*/
int *infiniteDown = new int[m] ;
int *infiniteUp = new int[m] ;
double *maxDown = new double[m] ;
double *maxUp = new double[m] ;
/*
Overload infiniteUp with row status codes:
-1: L(i)/U(i) not yet computed,
-2: do not use (empty or useless row),
-3: give up (infeasible)
-4: chosen as implied free row
*/
for (int i = 0 ; i < m ; i++) {
if (rowLengths[i] > 1)
infiniteUp[i] = -1 ;
else
infiniteUp[i] = -2 ;
}
// Get rid of rows with prohibited columns
if (prob->anyProhibited_) {
for (int i = 0 ; i < m ; i++) {
CoinBigIndex rStart = rowStarts[i];
CoinBigIndex rEnd = rStart+rowLengths[i];
bool badRow=false;
for (CoinBigIndex j = rStart; j < rEnd; ++j) {
if (prob->colProhibited(colIndices[j])) {
badRow=true;
break;
}
}
if (badRow)
infiniteUp[i] = -2 ;
}
}
// Can't go on without a suitable finite infinity, can we?
#ifdef USE_SMALL_LARGE
const double large = 1.0e10 ;
#else
const double large = 1.0e20 ;
#endif
/*
Decide which columns we're going to look at. There are columns already queued
in colsToDo_, but sometimes we want to look at all of them. Don't suck in
prohibited columns. See comments at the head of the routine for fill_level.
NOTE the overload on usefulColumnInt_. It was assigned above to whichFree
(indices of interesting columns). We'll be ok because columns are
consumed out of look at one per main loop iteration, but not all
columns are interesting.
Original comment: if gone from 2 to 3 look at all
*/
int numberLook = prob->numberColsToDo_ ;
int iLook ;
int *look = prob->colsToDo_ ;
if (fill_level < 0) {
look = prob->usefulColumnInt_+n ;
if (!prob->anyProhibited()) {
CoinIotaN(look,n,0) ;
numberLook = n ;
} else {
numberLook = 0 ;
for (iLook = 0 ; iLook < n ; iLook++)
if (!prob->colProhibited(iLook))
look[numberLook++] = iLook ;
}
}
/*
Step through the columns of interest looking for suitable x(tgt).
Interesting columns are limited by number of nonzeros to minimise fill-in
during substitution.
*/
bool infeas = false ;
const int maxLook = abs(fill_level) ;
for (iLook = 0 ; iLook < numberLook ; iLook++) {
const int tgtcol = look[iLook] ;
const int tgtcol_len = colLengths[tgtcol] ;
if (tgtcol_len <= 0 || tgtcol_len > maxLook) continue ;
/*
Set up to reconnoiter the column.
The initial value for ait_max is chosen to make sure that anything that
satisfies the stability check is big enough to use (though we'd clearly like
something better).
*/
const CoinBigIndex kcs = colStarts[tgtcol] ;
const CoinBigIndex kce = kcs+tgtcol_len ;
const bool singletonCol = (tgtcol_len == 1) ;
bool possibleRow = false ;
bool singletonRow = false ;
double ait_max = 20*ZTOLDP2 ;
/*
If this is a singleton column, the only concern is that the row is not a
singleton row (that has its own, simpler, transform: slack_doubleton). But
make sure we're not dealing with some tiny a(it).
Note that there's no point in marking a singleton row. By definition, we
won't encounter it again.
*/
if (singletonCol) {
const int i = rowIndices[kcs] ;
singletonRow = (rowLengths[i] == 1) ;
possibleRow = (fabs(colCoeffs[kcs]) > ZTOLDP2) ;
} else {
/*
If the column is not a singleton, we'll need a numerically stable
substitution formula. Check that this is possible. One of the entangled
rows must be an equality with a numerically stable coefficient, at least
.1*MAX{i}a(it).
*/
for (CoinBigIndex kcol = kcs ; kcol < kce ; ++kcol) {
const int i = rowIndices[kcol] ;
if (rowLengths[i] == 1) {
singletonRow = true ;
break ;
}
const double abs_ait = fabs(colCoeffs[kcol]) ;
ait_max = CoinMax(ait_max,abs_ait) ;
if (fabs(rlo[i]-rup[i]) < feasTol && abs_ait > .1*ait_max) {
possibleRow = true ;
}
}
}
if (singletonRow || !possibleRow) continue ;
/*
The column has possibilities. Walk the column, calculate row activity
bounds L(i) and U(i) for suitable entangled rows, then calculate the
improvement (if any) on the column bounds for l(j) and u(j). The goal is to
satisfy the implied free condition over all entangled rows and find at least
one row suitable for a substitution formula (if the column is not a natural
singleton).
Suitable: If this is a natural singleton, we need to look at the single
entangled constraint. If we're attempting to create a singleton by
substitution, only look at equalities with stable coefficients. If x(t) is
integral, make sure the scaled rhs will be integral.
*/
# if PRESOLVE_DEBUG > 2
std::cout
<< " Checking x(" << tgtcol << "), " << tgtcol_len << " nonzeros"
<< ", l(" << tgtcol << ") " << clo[tgtcol] << ", u(" << tgtcol
<< ") " << cup[tgtcol] << ", c(" << tgtcol << ") " << cost[tgtcol]
<< "." << std::endl ;
# endif
const double lt = clo[tgtcol] ;
const double ut = cup[tgtcol] ;
double impliedLow = -COIN_DBL_MAX ;
double impliedHigh = COIN_DBL_MAX ;
int subst_ndx = -1 ;
int subst_len = n ;
for (CoinBigIndex kcol = kcs ; kcol < kce ; ++kcol) {
const int i = rowIndices[kcol] ;
assert(infiniteUp[i] != -3) ;
if (infiniteUp[i] <= -2) continue ;
const double ait = colCoeffs[kcol] ;
const int leni = rowLengths[i] ;
const double rloi = rlo[i] ;
const double rupi = rup[i] ;
/*
A suitable row for substitution must
* be an equality;
* the entangled coefficient must be large enough to be numerically stable;
* if x(t) is integer, the constant term in the substitution formula must be
integer.
*/
bool rowiOK = (fabs(rloi-rupi) < feasTol) && (fabs(ait) > .1*ait_max) ;
rowiOK = rowiOK && ((integerType[tgtcol] == 0) ||
(fabs((rloi/ait)-floor((rloi/ait)+0.5)) < feasTol)) ;
/*
If we don't already have L(i) and U(i), calculate now. Check for useless and
infeasible constraints when that's done.
*/
int infUi = 0 ;
int infLi = 0 ;
double maxUi = 0.0 ;
double maxLi = 0.0 ;
const CoinBigIndex krs = rowStarts[i] ;
const CoinBigIndex kre = krs+leni ;
if (infiniteUp[i] == -1) {
for (CoinBigIndex krow = krs ; krow < kre ; ++krow) {
const double aik = rowCoeffs[krow] ;
const int k = colIndices[krow] ;
const double lk = clo[k] ;
const double uk = cup[k] ;
if (aik > 0.0) {
if (uk < large)
maxUi += uk*aik ;
else
++infUi ;
if (lk > -large)
maxLi += lk*aik ;
else
++infLi ;
} else if (aik < 0.0) {
if (uk < large)
maxLi += uk*aik ;
else
++infLi ;
if (lk > -large)
maxUi += lk*aik ;
else
++infUi ;
}
}
const double maxUinf = maxUi+infUi*1.0e31 ;
const double maxLinf = maxLi-infLi*1.0e31 ;
if (maxUinf <= rupi+feasTol && maxLinf >= rloi-feasTol) {
infiniteUp[i] = -2 ;
} else if (maxUinf < rloi-feasTol && !fixInfeasibility) {
prob->status_|= 1 ;
infeas = true ;
prob->messageHandler()->message(COIN_PRESOLVE_ROWINFEAS,
prob->messages())
<< i << rloi << rupi << CoinMessageEol ;
infiniteUp[i] = -3 ;
} else if (maxLinf > rupi+feasTol && !fixInfeasibility) {
prob->status_|= 1 ;
infeas = true ;
prob->messageHandler()->message(COIN_PRESOLVE_ROWINFEAS,
prob->messages())
<< i << rloi << rupi << CoinMessageEol ;
infiniteUp[i] = -3 ;
} else {
infiniteUp[i] = infUi ;
infiniteDown[i] = infLi ;
maxUp[i] = maxUi ;
maxDown[i] = maxLi ;
}
} else {
infUi = infiniteUp[i] ;
infLi = infiniteDown[i] ;
maxUi = maxUp[i] ;
maxLi = maxDown[i] ;
}
# if PRESOLVE_DEBUG > 2
std::cout
<< " row(" << i << ") " << leni << " nonzeros, blow " << rloi
<< ", L (" << infLi << "," << maxLi
<< "), U (" << infUi << "," << maxUi
<< "), b " << rupi ;
if (infeas) std::cout << " infeas" ;
if (infiniteUp[i] == -2) std::cout << " useless" ;
std::cout << "." << std::endl ;
# endif
/*
If we're infeasible, no sense checking further; escape the implied bound
loop. The other possibility is that we've just discovered the constraint
is useless, in which case we just move on to the next one in the column.
*/
if (infeas) break ;
if (infiniteUp[i] == -2) continue ;
assert(infiniteUp[i] >= 0 && infiniteUp[i] <= leni) ;
/*
At this point we have L(i) and U(i), expressed as finite and infinite
components, and constraint i is neither useless or infeasible. Calculate
the implied bounds l'(t) and u'(t) on x(t). The calculation (for a(it) > 0)
is
u'(t) <= (b(i) - (L(i)-a(it)l(t)))/a(it) = l(t)+(b(i)-L(i))/a(it)
l'(t) >= (blow(i) - (U(i)-a(it)u(t)))/a(it) = u(t)+(blow(i)-U(i))/a(it)
Insert the appropriate flips for a(it) < 0. Notice that if there's exactly
one infinite contribution to L(i) or U(i) and x(t) is responsible, then the
finite portion of L(i) or U(i) is already correct.
Cut some slack for possible numerical inaccuracy if the finite portion of
L(i) or U(i) is very large. If the new bound is very large, force it to
infinity.
*/
double ltprime = -COIN_DBL_MAX ;
double utprime = COIN_DBL_MAX ;
if (ait > 0.0) {
if (rloi > -large) {
if (!infUi) {
assert(ut < large) ;
ltprime = ut+(rloi-maxUi)/ait ;
if (fabs(maxUi) > 1.0e8 && !singletonCol)
ltprime -= 1.0e-12*fabs(maxUi) ;
} else if (infUi == 1 && ut > large) {
ltprime = (rloi-maxUi)/ait ;
if (fabs(maxUi) > 1.0e8 && !singletonCol)
ltprime -= 1.0e-12*fabs(maxUi) ;
} else {
ltprime = -COIN_DBL_MAX ;
}
impliedLow = CoinMax(impliedLow,ltprime) ;
}
if (rupi < large) {
if (!infLi) {
assert(lt > -large) ;
utprime = lt+(rupi-maxLi)/ait ;
if (fabs(maxLi) > 1.0e8 && !singletonCol)
utprime += 1.0e-12*fabs(maxLi) ;
} else if (infLi == 1 && lt < -large) {
utprime = (rupi-maxLi)/ait ;
if (fabs(maxLi) > 1.0e8 && !singletonCol)
utprime += 1.0e-12*fabs(maxLi) ;
} else {
utprime = COIN_DBL_MAX ;
}
impliedHigh = CoinMin(impliedHigh,utprime) ;
}
} else {
if (rloi > -large) {
if (!infUi) {
assert(lt > -large) ;
utprime = lt+(rloi-maxUi)/ait ;
if (fabs(maxUi) > 1.0e8 && !singletonCol)
utprime += 1.0e-12*fabs(maxUi) ;
} else if (infUi == 1 && lt < -large) {
utprime = (rloi-maxUi)/ait ;
if (fabs(maxUi) > 1.0e8 && !singletonCol)
utprime += 1.0e-12*fabs(maxUi) ;
} else {
utprime = COIN_DBL_MAX ;
}
impliedHigh = CoinMin(impliedHigh,utprime) ;
}
if (rupi < large) {
if (!infLi) {
assert(ut < large) ;
ltprime = ut+(rupi-maxLi)/ait ;
if (fabs(maxLi) > 1.0e8 && !singletonCol)
ltprime -= 1.0e-12*fabs(maxLi) ;
} else if (infLi == 1 && ut > large) {
ltprime = (rupi-maxLi)/ait ;
if (fabs(maxLi) > 1.0e8 && !singletonCol)
ltprime -= 1.0e-12*fabs(maxLi) ;
} else {
ltprime = -COIN_DBL_MAX ;
}
impliedLow = CoinMax(impliedLow,ltprime) ;
}
}
# if PRESOLVE_DEBUG > 2
std::cout
<< " row(" << i << ") l'(" << tgtcol << ") " << ltprime
<< ", u'(" << tgtcol << ") " << utprime ;
if (lt <= impliedLow && impliedHigh <= ut)
std::cout << "; implied free satisfied" ;
std::cout << "." << std::endl ;
# endif
/*
For x(t) integral, see if a substitution formula based on row i will
preserve integrality. The final check in this clause aims to preserve
SOS equalities (i.e., don't eliminate a non-trivial SOS equality from
the system using this transform).
Note that this can't be folded into the L(i)/U(i) loop because the answer
changes with x(t).
Original comment: can only accept if good looking row
*/
if (integerType[tgtcol]) {
possibleRow = true ;
bool allOnes = true ;
for (CoinBigIndex krow = krs ; krow < kre ; ++krow) {
const int j = colIndices[krow] ;
const double scaled_aij = rowCoeffs[krow]/ait ;
if (fabs(scaled_aij) != 1.0)
allOnes = false ;
if (!integerType[j] ||
fabs(scaled_aij-floor(scaled_aij+0.5)) > feasTol) {
possibleRow = false ;
break ;
}
}
if (rloi == 1.0 && leni >= 5 && stopSomeStuff && allOnes)
possibleRow = false ;
rowiOK = rowiOK && possibleRow ;
}
/*
Do we have a winner? If we have an incumbent, prefer the one with fewer
coefficients.
*/
if (rowiOK) {
if (subst_ndx < 0 || (leni < subst_len)) {
# if PRESOLVE_DEBUG > 2
std::cout
<< " row(" << i << ") now candidate for x(" << tgtcol << ")."
<< std::endl ;
# endif
subst_ndx = i ;
subst_len = leni ;
}
}
}
if (infeas) break ;
/*
Can we do the transform? If so, subst_ndx will have a valid row.
Record the implied free variable and the equality we'll use to substitute
it out. Take the row out of the running --- we can't use the same row
for two substitutions.
*/
if (lt <= impliedLow && impliedHigh <= ut &&
(subst_ndx >= 0 || singletonRow)) {
implied_free[numberFree] = subst_ndx ;
infiniteUp[subst_ndx] = -4 ;
whichFree[numberFree++] = tgtcol ;
# if PRESOLVE_DEBUG > 1
std::cout
<< " x(" << tgtcol << ") implied free by row " << subst_ndx
<< std::endl ;
# endif
}
}
delete[] infiniteDown ;
delete[] infiniteUp ;
delete[] maxDown ;
delete[] maxUp ;
/*
If we're infeasible, there's nothing more to be done.
*/
if (infeas) {
# if PRESOLVE_SUMMARY > 0 || PRESOLVE_DEBUG > 0
std::cout << " IMPLIED_FREE: infeasible." << std::endl ;
# endif
return (next) ;
}
/*
We have a list of implied free variables, each with a row that can be used
to substitute the variable to singleton status if the variable is not a
natural singleton. The loop here will only process natural singletons.
We'll hand the remainder to subst_constraint_action below, if there is
a remainder.
The natural singletons processed here are compressed out of whichFree and
implied_free.
*/
int unprocessed = 0 ;
for (iLook = 0 ; iLook < numberFree ; iLook++) {
const int tgtcol = whichFree[iLook] ;
if (colLengths[tgtcol] != 1) {
whichFree[unprocessed] = whichFree[iLook] ;
implied_free[unprocessed] = implied_free[iLook] ;
unprocessed++ ;
continue ;
}
const int tgtrow = implied_free[iLook] ;
const int tgtrow_len = rowLengths[tgtrow] ;
const CoinBigIndex kcs = colStarts[tgtcol] ;
const double tgtcol_coeff = colCoeffs[kcs] ;
const double tgtcol_cost = cost[tgtcol] ;
const CoinBigIndex krs = rowStarts[tgtrow] ;
const CoinBigIndex kre = krs+tgtrow_len ;
if (tgtcol_cost != 0.0) {
// Check costs don't make unstable
//double minOldCost=COIN_DBL_MAX;
double maxOldCost=0.0;
//double minNewCost=COIN_DBL_MAX;
double maxNewCost=0.0;
for (CoinBigIndex krow = krs ; krow < kre ; krow++) {
const int j = colIndices[krow] ;
if (j != tgtcol) {
double oldCost = cost[j] ;
double newCost = oldCost - (tgtcol_cost*rowCoeffs[krow])/tgtcol_coeff ;
oldCost = fabs(oldCost);
newCost = fabs(newCost);
//minOldCost=CoinMin(minOldCost,oldCost);
maxOldCost=CoinMax(maxOldCost,oldCost);
//minNewCost=CoinMin(minNewCost,newCost);
maxNewCost=CoinMax(maxNewCost,newCost);
}
}
if (maxNewCost>1000.0*(maxOldCost+1.0) && maxOldCost) {
//printf("too big %d tgtcost %g maxOld %g maxNew %g\n",
// tgtcol,tgtcol_cost,maxOldCost,maxNewCost);
continue;
}
}
/*
Initialise the postsolve action. We need to remember the row and column.
*/
action *s = &actions[nactions++] ;
s->row = tgtrow ;
s->col = tgtcol ;
s->clo = clo[tgtcol] ;
s->cup = cup[tgtcol] ;
s->rlo = rlo[tgtrow] ;
s->rup = rup[tgtrow] ;
s->ninrow = tgtrow_len ;
s->rowels = presolve_dupmajor(rowCoeffs,colIndices,tgtrow_len,krs) ;
s->costs = NULL ;
/*
We're processing a singleton, hence no substitutions in the matrix, but we
do need to fix up the cost vector. The substitution formula is
x(t) = (rhs(i) - SUM{j\t}a(ik)x(k))/a(it)
hence
c'(k) = c(k)-c(t)a(ik)/a(it)
and there's a constant offset
c(t)rhs(i)/a(it).
where rhs(i) is one of blow(i) or b(i).
For general constraints where blow(i) != b(i), we need to take a bit
of care. If only one of blow(i) or b(i) is finite, that's the one to
use. Where we have two finite but unequal bounds, choose the bound that
will result in the most favourable value for x(t). For minimisation, if
c(t) < 0 we want to maximise x(t), so choose b(i) if a(it) > 0, blow(i)
if a(it) < 0. A bit of case analysis says choose b(i) when c(t)a(it) <
0, blow(i) when c(t)a(it) > 0. We shouldn't be here if both row bounds
are infinite.
Fortunately, the objective coefficients are not affected by this.
*/
if (tgtcol_cost != 0.0) {
double tgtrow_rhs = rup[tgtrow] ;
if (fabs(rlo[tgtrow]-rup[tgtrow]) > feasTol) {
const double rlot = rlo[tgtrow] ;
const double rupt = rup[tgtrow] ;
if (rlot > -COIN_DBL_MAX && rupt < COIN_DBL_MAX) {
if ((tgtcol_cost*tgtcol_coeff) > 0)
tgtrow_rhs = rlot ;
else
tgtrow_rhs = rupt ;
} else if (rupt >= COIN_DBL_MAX) {
tgtrow_rhs = rlot ;
}
}
assert(fabs(tgtrow_rhs) <= large) ;
double *save_costs = new double[tgtrow_len] ;
for (CoinBigIndex krow = krs ; krow < kre ; krow++) {
const int j = colIndices[krow] ;
save_costs[krow-krs] = cost[j] ;
cost[j] -= (tgtcol_cost*rowCoeffs[krow])/tgtcol_coeff ;
}
prob->change_bias((tgtcol_cost*tgtrow_rhs)/tgtcol_coeff) ;
cost[tgtcol] = 0.0 ;
s->costs = save_costs ;
}
/*
Remove the row from the column-major representation, queuing up each column
for reconsideration. Then remove the row from the row-major representation.
*/
for (CoinBigIndex krow = krs ; krow < kre ; krow++) {
const int j = colIndices[krow] ;
presolve_delete_from_col(tgtrow,j,colStarts,colLengths,rowIndices,
colCoeffs) ;
if (colLengths[j] == 0) {
PRESOLVE_REMOVE_LINK(prob->clink_,j) ;
} else {
prob->addCol(j) ;
}
}
PRESOLVE_REMOVE_LINK(clink,tgtcol) ;
colLengths[tgtcol] = 0 ;
PRESOLVE_REMOVE_LINK(rlink,tgtrow) ;
rowLengths[tgtrow] = 0 ;
rlo[tgtrow] = 0.0 ;
rup[tgtrow] = 0.0 ;
}
/*
We're done with the natural singletons. Trim actions to length and create
the postsolve object.
*/
if (nactions) {
# if PRESOLVE_SUMMARY > 0 || PRESOLVE_DEBUG > 0
printf("NIMPLIED FREE: %d\n", nactions) ;
# endif
action *actions1 = new action[nactions] ;
CoinMemcpyN(actions, nactions, actions1) ;
next = new implied_free_action(nactions,actions1,next) ;
}
delete [] actions ;
# if PRESOLVE_DEBUG > 0
std::cout
<< " IMPLIED_FREE: identified " << numberFree
<< " implied free transforms, processed " << numberFree-unprocessed
<< " natural singletons." << std::endl ;
# endif
/*
Now take a stab at the columns that aren't natural singletons, if there are
any left.
*/
if (unprocessed != 0) {
// if not integer - don't allow much fill
if (!prob->anyInteger())
{
int numberFree=unprocessed;
int nBad=0;
unprocessed=0;
// Take out ones that make much denser or might lead to instability
/*
Unpack the row- and column-major representations.
*/
CoinBigIndex *rowStarts = prob->mrstrt_ ;
int *rowLengths = prob->hinrow_ ;
double *rowCoeffs = prob->rowels_ ;
int *colIndices = prob->hcol_ ;
CoinBigIndex *colStarts = prob->mcstrt_ ;
int *colLengths = prob->hincol_ ;
double *colCoeffs = prob->colels_ ;
int *rowIndices = prob->hrow_ ;
/*
This array is used to hold the indices of columns involved in substitutions,
where we have the potential for cancellation. At the end they'll be
checked to eliminate any actual zeros that may result.
NOTE that usefulColumnInt_ is already in use for parameters implied_free and
whichFree when this routine is called from implied_free.
*/
int *rowsUsed = &prob->usefulRowInt_[0] ;
int nRowsUsed = 0 ;
/*
Open a loop to process the (equality r, implied free variable t) pairs
in whichFree and implied_free.
It can happen that removal of (row, natural singleton) pairs back in
implied_free will reduce the length of column t. It can also happen
that previous processing here has resulted in fillin or cancellation. So
check again for column length and exclude natural singletons and overly
dense columns.
*/
for (int iLook = 0 ; iLook < numberFree ; iLook++) {
const int tgtcol = whichFree[iLook] ;
const int tgtrow = implied_free[iLook] ;
if (colLengths[tgtcol] < 2 || colLengths[tgtcol] > maxLook) {
# if PRESOLVE_DEBUG > 3
std::cout
<< " skipping eqn " << tgtrow << " x(" << tgtcol
<< "); length now " << colLengths[tgtcol] << "." << std::endl ;
# endif
continue ;
}
CoinBigIndex tgtcs = colStarts[tgtcol] ;
CoinBigIndex tgtce = tgtcs+colLengths[tgtcol] ;
/*
A few checks to make sure that the candidate pair is still suitable.
Processing candidates earlier in the list can eliminate coefficients.
* Don't use this pair if any involved row i has become a row singleton
or empty.
* Don't use this pair if any involved row has been modified as part of
the processing for a previous candidate pair on this call.
* Don't use this pair if a(i,tgtcol) has become zero.
The checks on a(i,tgtcol) seem superfluous but it's possible that
implied_free identified two candidate pairs to eliminate the same column. If
we've already processed one of them, we could be in trouble.
*/
double tgtcoeff = 0.0 ;
bool dealBreaker = false ;
for (CoinBigIndex kcol = tgtcs ; kcol < tgtce ; ++kcol) {
const int i = rowIndices[kcol] ;
if (rowLengths[i] < 2 || prob->rowUsed(i)) {
dealBreaker = true ;
break ;
}
const double aij = colCoeffs[kcol] ;
if (fabs(aij) <= ZTOLDP2) {
dealBreaker = true ;
break ;
}
if (i == tgtrow) tgtcoeff = aij ;
}
if (dealBreaker == true) {
# if PRESOLVE_DEBUG > 3
std::cout
<< " skipping eqn " << tgtrow << " x(" << tgtcol
<< "); deal breaker (1)." << std::endl ;
# endif
continue ;
}
/*
Check for numerical stability.A large coeff_factor will inflate the
coefficients in the substitution formula.
*/
dealBreaker = false ;
for (CoinBigIndex kcol = tgtcs ; kcol < tgtce ; ++kcol) {
const double coeff_factor = fabs(colCoeffs[kcol]/tgtcoeff) ;
if (coeff_factor > 10.0)
dealBreaker = true ;
}
if (dealBreaker == true) {
# if PRESOLVE_DEBUG > 3
std::cout
<< " skipping eqn " << tgtrow << " x(" << tgtcol
<< "); deal breaker (2)." << std::endl ;
# endif
continue ;
}
/*
Count up the total number of coefficients in entangled rows and mark them as
contaminated.
*/
int ntotels = 0 ;
for (CoinBigIndex kcol = tgtcs ; kcol < tgtce ; ++kcol) {
const int i = rowIndices[kcol] ;
ntotels += rowLengths[i] ;
PRESOLVEASSERT(!prob->rowUsed(i)) ;
prob->setRowUsed(i) ;
rowsUsed[nRowsUsed++] = i ;
}
CoinBigIndex tgtrs = rowStarts[tgtrow] ;
CoinBigIndex tgtre = tgtrs+rowLengths[tgtrow] ;
// kill small if wanted
int relax= (prob->presolveOptions()&0x60000)>>17;
double tolerance = 1.0e-12;
for (int i=0;i<relax;i++)
tolerance *= 10.0;
/*
Sort the target row for efficiency
*/
CoinSort_2(colIndices+tgtrs,colIndices+tgtre,rowCoeffs+tgtrs) ;
CoinBigIndex start=colStarts[tgtcol];
CoinBigIndex end = start+colLengths[tgtcol];
numberBadElements=0;
int numberFill=-rowLengths[tgtrow];
for (int colndx = start ; colndx < end ; ++colndx) {
int i = rowIndices[colndx] ;
if (i == tgtrow) continue ;
double ait = colCoeffs[colndx] ;
double coeff_factor = -ait/tgtcoeff ;
CoinBigIndex krs = rowStarts[i] ;
CoinBigIndex kre = krs+rowLengths[i] ;
/*
Sort the row for efficiency and call add_row to do the actual business of
changing coefficients due to substitution. This has the potential to trigger
compaction of the row-major bulk store, so update bulk store indices.
*/
CoinSort_2(colIndices+krs,colIndices+kre,rowCoeffs+krs) ;
numberFill += check_row(rowStarts,rowCoeffs,colIndices,
rowLengths,coeff_factor,tolerance,i,tgtrow);
}
if (numberBadElements||3*numberFill>2*(colLengths[tgtcol]+rowLengths[tgtrow])) {
//printf("Bad subst col %d row %d - %d small elements, fill %d\n",
// tgtcol,tgtrow,numberBadElements,numberFill);
if (numberBadElements)
nBad++;
} else {
whichFree[unprocessed]=tgtcol;
implied_free[unprocessed++]=tgtrow;
//printf("Good subst col %d row %d - fill %d\n",
// tgtcol,tgtrow,numberFill);
}
}
/*
That's it, we've processed all the candidate pairs.
Clear the row used flags.
*/
for (int i = 0 ; i < nRowsUsed ; i++) prob->unsetRowUsed(rowsUsed[i]) ;
#if CLP_USEFUL_PRINTOUT
printf("%d allowed through out of %d - %d on coefficient\n",
unprocessed,numberFree,nBad);
#endif
}
next = subst_constraint_action::presolve(prob,implied_free,whichFree,
unprocessed,next,maxLook) ;
}
/*
Give some feedback to the presolve driver. If we aren't finding enough
candidates and haven't reached the limit, bump fill_level and return a
negated value. The presolve driver can tweak this value or simply return
it on the next call. See the top of the routine for a full explanation.
*/
if (numberFree < 30 && maxLook < prob->maxSubstLevel_) {
fill_level = -(maxLook+1) ;
} else {
fill_level = maxLook ;
}
# if COIN_PRESOLVE_TUNING > 0
double thisTime ;
if (prob->tuning_) thisTime = CoinCpuTime() ;
# endif
# if PRESOLVE_CONSISTENCY > 0 || PRESOLVE_DEBUG > 0
presolve_consistent(prob) ;
presolve_links_ok(prob) ;
presolve_check_sol(prob) ;
presolve_check_nbasic(prob) ;
# endif
# if PRESOLVE_DEBUG > 0 || COIN_PRESOLVE_TUNING > 0
int droppedRows = prob->countEmptyRows()-startEmptyRows ;
int droppedColumns = prob->countEmptyCols()-startEmptyColumns ;
std::cout
<< "Leaving implied_free_action::presolve, fill level " << fill_level
<< ", " << droppedRows << " rows, "
<< droppedColumns << " columns dropped" ;
# if COIN_PRESOLVE_TUNING > 0
std::cout << " in " << thisTime-startTime << "s" ;
# endif
std::cout << "." << std::endl ;
# endif
return (next) ;
}
/*
*
* The col rep and row rep must be consistent.
*/
const CoinPresolveAction *tripleton_action::presolve(CoinPresolveMatrix *prob,
const CoinPresolveAction *next)
{
double startTime = 0.0;
int startEmptyRows=0;
int startEmptyColumns = 0;
if (prob->tuning_) {
startTime = CoinCpuTime();
startEmptyRows = prob->countEmptyRows();
startEmptyColumns = prob->countEmptyCols();
}
double *colels = prob->colels_;
int *hrow = prob->hrow_;
CoinBigIndex *mcstrt = prob->mcstrt_;
int *hincol = prob->hincol_;
int ncols = prob->ncols_;
double *clo = prob->clo_;
double *cup = prob->cup_;
double *rowels = prob->rowels_;
int *hcol = prob->hcol_;
CoinBigIndex *mrstrt = prob->mrstrt_;
int *hinrow = prob->hinrow_;
int nrows = prob->nrows_;
double *rlo = prob->rlo_;
double *rup = prob->rup_;
presolvehlink *clink = prob->clink_;
presolvehlink *rlink = prob->rlink_;
const unsigned char *integerType = prob->integerType_;
double *cost = prob->cost_;
int numberLook = prob->numberRowsToDo_;
int iLook;
int * look = prob->rowsToDo_;
const double ztolzb = prob->ztolzb_;
action * actions = new action [nrows];
# ifdef ZEROFAULT
// initialise alignment padding bytes
memset(actions,0,nrows*sizeof(action)) ;
# endif
int nactions = 0;
int *zeros = prob->usefulColumnInt_; //new int[ncols];
char * mark = reinterpret_cast<char *>(zeros+ncols);
memset(mark,0,ncols);
int nzeros = 0;
// If rowstat exists then all do
unsigned char *rowstat = prob->rowstat_;
double *acts = prob->acts_;
// unsigned char * colstat = prob->colstat_;
# if PRESOLVE_CONSISTENCY
presolve_links_ok(prob) ;
# endif
// wasfor (int irow=0; irow<nrows; irow++)
for (iLook=0;iLook<numberLook;iLook++) {
int irow = look[iLook];
if (hinrow[irow] == 3 &&
fabs(rup[irow] - rlo[irow]) <= ZTOLDP) {
double rhs = rlo[irow];
CoinBigIndex krs = mrstrt[irow];
CoinBigIndex kre = krs + hinrow[irow];
int icolx, icoly, icolz;
double coeffx, coeffy, coeffz;
CoinBigIndex k;
/* locate first column */
for (k=krs; k<kre; k++) {
if (hincol[hcol[k]] > 0) {
break;
}
}
PRESOLVEASSERT(k<kre);
coeffx = rowels[k];
if (fabs(coeffx) < ZTOLDP2)
continue;
icolx = hcol[k];
/* locate second column */
for (k++; k<kre; k++) {
if (hincol[hcol[k]] > 0) {
break;
}
}
PRESOLVEASSERT(k<kre);
coeffy = rowels[k];
if (fabs(coeffy) < ZTOLDP2)
continue;
icoly = hcol[k];
/* locate third column */
for (k++; k<kre; k++) {
if (hincol[hcol[k]] > 0) {
break;
}
}
PRESOLVEASSERT(k<kre);
coeffz = rowels[k];
if (fabs(coeffz) < ZTOLDP2)
continue;
icolz = hcol[k];
// For now let's do obvious one
if (coeffx*coeffz>0.0) {
if(coeffx*coeffy>0.0)
continue;
} else if (coeffx*coeffy>0.0) {
int iTemp = icoly;
icoly=icolz;
icolz=iTemp;
double dTemp = coeffy;
coeffy=coeffz;
coeffz=dTemp;
} else {
int iTemp = icoly;
icoly=icolx;
icolx=iTemp;
double dTemp = coeffy;
coeffy=coeffx;
coeffx=dTemp;
}
// Not all same sign and y is odd one out
// don't bother with fixed variables
if (!(fabs(cup[icolx] - clo[icolx]) < ZTOLDP) &&
!(fabs(cup[icoly] - clo[icolx]) < ZTOLDP) &&
!(fabs(cup[icolz] - clo[icoly]) < ZTOLDP)) {
assert (coeffx*coeffz>0.0&&coeffx*coeffy<0.0);
// Only do if does not give implicit bounds on x and z
double cx = - coeffx/coeffy;
double cz = - coeffz/coeffy;
/* don't do if y integer for now */
if (integerType[icoly]) {
#define PRESOLVE_DANGEROUS
#ifndef PRESOLVE_DANGEROUS
continue;
#else
if (!integerType[icolx]||!integerType[icolz])
continue;
if (cx!=floor(cx+0.5)||cz!=floor(cz+0.5))
continue;
#endif
}
double rhsRatio = rhs/coeffy;
if (clo[icoly]>-1.0e30) {
if (clo[icolx]<-1.0e30||clo[icolz]<-1.0e30)
continue;
if (cx*clo[icolx]+cz*clo[icolz]+rhsRatio<clo[icoly]-ztolzb)
continue;
}
if (cup[icoly]<1.0e30) {
if (cup[icolx]>1.0e30||cup[icolz]>1.0e30)
continue;
if (cx*cup[icolx]+cz*cup[icolz]+rhsRatio>cup[icoly]+ztolzb)
continue;
}
CoinBigIndex krowx,krowy,krowz;
/* find this row in each of the columns and do counts */
bool singleton=false;
for (k=mcstrt[icoly]; k<mcstrt[icoly]+hincol[icoly]; k++) {
int jrow=hrow[k];
if (hinrow[jrow]==1)
singleton=true;
if (jrow == irow)
krowy=k;
else
prob->setRowUsed(jrow);
}
int nDuplicate=0;
for (k=mcstrt[icolx]; k<mcstrt[icolx]+hincol[icolx]; k++) {
int jrow=hrow[k];
if (jrow == irow)
krowx=k;
else if (prob->rowUsed(jrow))
nDuplicate++;;
}
for (k=mcstrt[icolz]; k<mcstrt[icolz]+hincol[icolz]; k++) {
int jrow=hrow[k];
if (jrow == irow)
krowz=k;
else if (prob->rowUsed(jrow))
nDuplicate++;;
}
int nAdded=hincol[icoly]-3-nDuplicate;
for (k=mcstrt[icoly]; k<mcstrt[icoly]+hincol[icoly]; k++) {
int jrow=hrow[k];
prob->unsetRowUsed(jrow);
}
// let singleton rows be taken care of first
if (singleton)
continue;
//if (nAdded<=1)
//printf("%d elements added, hincol %d , dups %d\n",nAdded,hincol[icoly],nDuplicate);
if (nAdded>2)
continue;
// it is possible that both x/z and y are singleton columns
// that can cause problems
if ((hincol[icolx] == 1 ||hincol[icolz] == 1) && hincol[icoly] == 1)
continue;
// common equations are of the form ax + by = 0, or x + y >= lo
{
action *s = &actions[nactions];
nactions++;
PRESOLVE_DETAIL_PRINT(printf("pre_tripleton %dR %dC %dC %dC E\n",
irow,icoly,icolx,icolz));
s->row = irow;
s->icolx = icolx;
s->icolz = icolz;
s->icoly = icoly;
s->cloy = clo[icoly];
s->cupy = cup[icoly];
s->costy = cost[icoly];
s->rlo = rlo[irow];
s->rup = rup[irow];
s->coeffx = coeffx;
s->coeffy = coeffy;
s->coeffz = coeffz;
s->ncoly = hincol[icoly];
s->colel = presolve_dupmajor(colels, hrow, hincol[icoly],
mcstrt[icoly]);
}
// costs
// the effect of maxmin cancels out
cost[icolx] += cost[icoly] * cx;
cost[icolz] += cost[icoly] * cz;
prob->change_bias(cost[icoly] * rhs / coeffy);
//if (cost[icoly]*rhs)
//printf("change %g col %d cost %g rhs %g coeff %g\n",cost[icoly]*rhs/coeffy,
// icoly,cost[icoly],rhs,coeffy);
if (rowstat) {
// update solution and basis
int numberBasic=0;
if (prob->columnIsBasic(icoly))
numberBasic++;
if (prob->rowIsBasic(irow))
numberBasic++;
if (numberBasic>1) {
if (!prob->columnIsBasic(icolx))
prob->setColumnStatus(icolx,CoinPrePostsolveMatrix::basic);
else
prob->setColumnStatus(icolz,CoinPrePostsolveMatrix::basic);
}
}
// Update next set of actions
{
prob->addCol(icolx);
int i,kcs,kce;
kcs = mcstrt[icoly];
kce = kcs + hincol[icoly];
for (i=kcs;i<kce;i++) {
int row = hrow[i];
prob->addRow(row);
}
kcs = mcstrt[icolx];
kce = kcs + hincol[icolx];
for (i=kcs;i<kce;i++) {
int row = hrow[i];
prob->addRow(row);
}
prob->addCol(icolz);
kcs = mcstrt[icolz];
kce = kcs + hincol[icolz];
for (i=kcs;i<kce;i++) {
int row = hrow[i];
prob->addRow(row);
}
}
/* transfer the colx factors to coly */
bool no_mem = elim_tripleton("ELIMT",
mcstrt, rlo, acts, rup, colels,
hrow, hcol, hinrow, hincol,
clink, ncols, rlink, nrows,
mrstrt, rowels,
cx,
cz,
rhs / coeffy,
irow, icolx, icoly,icolz);
if (no_mem)
throwCoinError("out of memory",
"tripleton_action::presolve");
// now remove irow from icolx and icolz in the col rep
// better if this were first.
presolve_delete_from_col(irow,icolx,mcstrt,hincol,hrow,colels) ;
presolve_delete_from_col(irow,icolz,mcstrt,hincol,hrow,colels) ;
// eliminate irow entirely from the row rep
hinrow[irow] = 0;
// eliminate irow entirely from the row rep
PRESOLVE_REMOVE_LINK(rlink, irow);
// eliminate coly entirely from the col rep
PRESOLVE_REMOVE_LINK(clink, icoly);
cost[icoly] = 0.0;
rlo[irow] = 0.0;
rup[irow] = 0.0;
if (!mark[icolx]) {
mark[icolx]=1;
zeros[nzeros++]=icolx;
}
if (!mark[icolz]) {
mark[icolz]=1;
zeros[nzeros++]=icolz;
}
}
# if PRESOLVE_CONSISTENCY
presolve_links_ok(prob) ;
presolve_consistent(prob);
# endif
}
}
if (nactions) {
# if PRESOLVE_SUMMARY
printf("NTRIPLETONS: %d\n", nactions);
# endif
action *actions1 = new action[nactions];
CoinMemcpyN(actions, nactions, actions1);
next = new tripleton_action(nactions, actions1, next);
if (nzeros) {
next = drop_zero_coefficients_action::presolve(prob, zeros, nzeros, next);
}
}
//delete[]zeros;
deleteAction(actions,action*);
if (prob->tuning_) {
double thisTime=CoinCpuTime();
int droppedRows = prob->countEmptyRows() - startEmptyRows ;
int droppedColumns = prob->countEmptyCols() - startEmptyColumns;
printf("CoinPresolveTripleton(8) - %d rows, %d columns dropped in time %g, total %g\n",
droppedRows,droppedColumns,thisTime-startTime,thisTime-prob->startTime_);
}
return (next);
}
/*
It is always the case that one of the variables of a doubleton is, or
can be made, implied free, but neither will necessarily be a singleton.
Since in the case of a doubleton the number of non-zero entries will never
increase if one is eliminated, it makes sense to always eliminate them.
The col rep and row rep must be consistent.
*/
const CoinPresolveAction
*doubleton_action::presolve (CoinPresolveMatrix *prob,
const CoinPresolveAction *next)
{
# if PRESOLVE_DEBUG > 0 || PRESOLVE_CONSISTENCY > 0
# if PRESOLVE_DEBUG > 0
std::cout
<< "Entering doubleton_action::presolve; considering "
<< prob->numberRowsToDo_ << " rows." << std::endl ;
# endif
presolve_consistent(prob) ;
presolve_links_ok(prob) ;
presolve_check_sol(prob) ;
presolve_check_nbasic(prob) ;
# endif
# if PRESOLVE_DEBUG > 0 || COIN_PRESOLVE_TUNING > 0
int startEmptyRows = 0 ;
int startEmptyColumns = 0 ;
startEmptyRows = prob->countEmptyRows() ;
startEmptyColumns = prob->countEmptyCols() ;
# if COIN_PRESOLVE_TUNING > 0
double startTime = 0.0 ;
if (prob->tuning_) startTime = CoinCpuTime() ;
# endif
# endif
const int n = prob->ncols_ ;
const int m = prob->nrows_ ;
/*
Unpack column-major and row-major representations, along with rim vectors.
*/
CoinBigIndex *colStarts = prob->mcstrt_ ;
int *colLengths = prob->hincol_ ;
double *colCoeffs = prob->colels_ ;
int *rowIndices = prob->hrow_ ;
presolvehlink *clink = prob->clink_ ;
double *clo = prob->clo_ ;
double *cup = prob->cup_ ;
CoinBigIndex *rowStarts = prob->mrstrt_ ;
int *rowLengths = prob->hinrow_ ;
double *rowCoeffs = prob->rowels_ ;
int *colIndices = prob->hcol_ ;
presolvehlink *rlink = prob->rlink_ ;
double *rlo = prob->rlo_ ;
double *rup = prob->rup_ ;
const unsigned char *integerType = prob->integerType_ ;
double *cost = prob->cost_ ;
int numberLook = prob->numberRowsToDo_ ;
int *look = prob->rowsToDo_ ;
const double ztolzb = prob->ztolzb_ ;
const double ztolzero = 1.0e-12 ;
action *actions = new action [m] ;
int nactions = 0 ;
/*
zeros will hold columns that should be groomed to remove explicit zeros when
we're finished.
fixed will hold columns that have ended up as fixed variables.
*/
int *zeros = prob->usefulColumnInt_ ;
int nzeros = 0 ;
int *fixed = zeros+n ;
int nfixed = 0 ;
unsigned char *rowstat = prob->rowstat_ ;
double *acts = prob->acts_ ;
double *sol = prob->sol_ ;
/*
More like `ignore infeasibility'.
*/
bool fixInfeasibility = ((prob->presolveOptions_&0x4000) != 0) ;
/*
Open the main loop to scan for doubleton candidates.
*/
for (int iLook = 0 ; iLook < numberLook ; iLook++) {
const int tgtrow = look[iLook] ;
/*
We need an equality with two coefficients. Avoid isolated constraints, lest
both variables vanish.
Failure of the assert indicates that the row- and column-major
representations are out of sync.
*/
if ((rowLengths[tgtrow] != 2) ||
(fabs(rup[tgtrow]-rlo[tgtrow]) > ZTOLDP)) continue ;
const CoinBigIndex krs = rowStarts[tgtrow] ;
int tgtcolx = colIndices[krs] ;
int tgtcoly = colIndices[krs+1] ;
PRESOLVEASSERT(colLengths[tgtcolx] > 0 || colLengths[tgtcoly] > 0) ;
if (colLengths[tgtcolx] == 1 && colLengths[tgtcoly] == 1) continue ;
/*
Avoid prohibited columns and fixed columns. Make sure the coefficients are
nonzero.
JJF - test should allow one to be prohibited as long as you leave that
one. I modified earlier code but hope I have got this right.
*/
if (prob->colProhibited(tgtcolx) && prob->colProhibited(tgtcoly))
continue ;
if (fabs(rowCoeffs[krs]) < ZTOLDP2 || fabs(rowCoeffs[krs+1]) < ZTOLDP2)
continue ;
if ((fabs(cup[tgtcolx]-clo[tgtcolx]) < ZTOLDP) ||
(fabs(cup[tgtcoly]-clo[tgtcoly]) < ZTOLDP)) continue ;
# if PRESOLVE_DEBUG > 2
std::cout
<< " row " << tgtrow << " colx " << tgtcolx << " coly " << tgtcoly
<< " passes preliminary eval." << std::endl ;
# endif
/*
Find this row in each column. The indices are not const because we may flip
them below, once we decide which column will be eliminated.
*/
CoinBigIndex krowx =
presolve_find_row(tgtrow,colStarts[tgtcolx],
colStarts[tgtcolx]+colLengths[tgtcolx],rowIndices) ;
double coeffx = colCoeffs[krowx] ;
CoinBigIndex krowy =
presolve_find_row(tgtrow,colStarts[tgtcoly],
colStarts[tgtcoly]+colLengths[tgtcoly],rowIndices) ;
double coeffy = colCoeffs[krowy] ;
const double rhs = rlo[tgtrow] ;
/*
Avoid obscuring a requirement for integrality.
If only one variable is integer, keep it and substitute for the continuous
variable.
If both are integer, substitute only for the forms x = k*y (k integral
and non-empty intersection on bounds on x) or x = 1-y, where both x and
y are binary.
flag bits for integerStatus: 0x01: x integer; 0x02: y integer
This bit of code works because 0 is continuous, 1 is integer. Make sure
that's true.
*/
assert((integerType[tgtcolx] == 0) || (integerType[tgtcolx] == 1)) ;
assert((integerType[tgtcoly] == 0) || (integerType[tgtcoly] == 1)) ;
int integerX = integerType[tgtcolx];
int integerY = integerType[tgtcoly];
/* if one prohibited then treat that as integer. This
may be pessimistic - but will catch SOS etc */
if (prob->colProhibited2(tgtcolx))
integerX=1;
if (prob->colProhibited2(tgtcoly))
integerY=1;
int integerStatus = (integerY<<1)|integerX ;
if (integerStatus == 3) {
int good = 0 ;
double rhs2 = rhs ;
if (coeffx < 0.0) {
coeffx = -coeffx ;
rhs2 += 1 ;
}
if ((cup[tgtcolx] == 1.0) && (clo[tgtcolx] == 0.0) &&
(fabs(coeffx-1.0) < 1.0e-7) && !prob->colProhibited2(tgtcoly))
good = 1 ;
if (coeffy < 0.0) {
coeffy = -coeffy ;
rhs2 += 1 ;
}
if ((cup[tgtcoly] == 1.0) && (clo[tgtcoly] == 0.0) &&
(fabs(coeffy-1.0) < 1.0e-7) && !prob->colProhibited2(tgtcolx))
good |= 2 ;
if (!(good == 3 && fabs(rhs2-1.0) < 1.0e-7))
integerStatus = -1 ;
/*
Not x+y = 1. Try for ax+by = 0
*/
if (integerStatus < 0 && rhs == 0.0) {
coeffx = colCoeffs[krowx] ;
coeffy = colCoeffs[krowy] ;
double ratio ;
bool swap = false ;
if (fabs(coeffx) > fabs(coeffy)) {
ratio = coeffx/coeffy ;
} else {
ratio = coeffy/coeffx ;
swap = true ;
}
ratio = fabs(ratio) ;
if (fabs(ratio-floor(ratio+0.5)) < ztolzero) {
integerStatus = swap ? 2 : 1 ;
}
}
/*
One last try --- just require an integral substitution formula.
But ax+by = 0 above is a subset of ax+by = c below and should pass the
test below. For that matter, so will x+y = 1. Why separate special cases
above? -- lh, 121106 --
*/
if (integerStatus < 0) {
bool canDo = false ;
coeffx = colCoeffs[krowx] ;
coeffy = colCoeffs[krowy] ;
double ratio ;
bool swap = false ;
double rhsRatio ;
if (fabs(coeffx) > fabs(coeffy)) {
ratio = coeffx/coeffy ;
rhsRatio = rhs/coeffx ;
} else {
ratio = coeffy/coeffx ;
rhsRatio = rhs/coeffy ;
swap = true ;
}
ratio = fabs(ratio) ;
if (fabs(ratio-floor(ratio+0.5)) < ztolzero) {
// possible
integerStatus = swap ? 2 : 1 ;
// but check rhs
if (rhsRatio==floor(rhsRatio+0.5))
canDo=true ;
}
# ifdef COIN_DEVELOP2
if (canDo)
printf("Good CoinPresolveDoubleton tgtcolx %d (%g and bounds %g %g) tgtcoly %d (%g and bound %g %g) - rhs %g\n",
tgtcolx,colCoeffs[krowx],clo[tgtcolx],cup[tgtcolx],
tgtcoly,colCoeffs[krowy],clo[tgtcoly],cup[tgtcoly],rhs) ;
else
printf("Bad CoinPresolveDoubleton tgtcolx %d (%g) tgtcoly %d (%g) - rhs %g\n",
tgtcolx,colCoeffs[krowx],tgtcoly,colCoeffs[krowy],rhs) ;
# endif
if (!canDo)
continue ;
}
}
/*
We've resolved integrality concerns. If we concluded that we need to
switch the roles of x and y because of integrality, do that now. If both
variables are continuous, we may still want to swap for numeric stability.
Eliminate the variable with the larger coefficient.
*/
if (integerStatus == 2) {
CoinSwap(tgtcoly,tgtcolx) ;
CoinSwap(krowy,krowx) ;
} else if (integerStatus == 0) {
if (fabs(colCoeffs[krowy]) < fabs(colCoeffs[krowx])) {
CoinSwap(tgtcoly,tgtcolx) ;
CoinSwap(krowy,krowx) ;
}
}
/*
Don't eliminate y just yet if it's entangled in a singleton row (we want to
capture that explicit bound in a column bound).
*/
const CoinBigIndex kcsy = colStarts[tgtcoly] ;
const CoinBigIndex kcey = kcsy+colLengths[tgtcoly] ;
bool singletonRow = false ;
for (CoinBigIndex kcol = kcsy ; kcol < kcey ; kcol++) {
if (rowLengths[rowIndices[kcol]] == 1) {
singletonRow = true ;
break ;
}
}
// skip if y prohibited
if (singletonRow || prob->colProhibited2(tgtcoly)) continue ;
coeffx = colCoeffs[krowx] ;
coeffy = colCoeffs[krowy] ;
# if PRESOLVE_DEBUG > 2
std::cout
<< " doubleton row " << tgtrow << ", keep x(" << tgtcolx
<< ") elim x(" << tgtcoly << ")." << std::endl ;
# endif
PRESOLVE_DETAIL_PRINT(printf("pre_doubleton %dC %dC %dR E\n",
tgtcoly,tgtcolx,tgtrow)) ;
/*
Capture the existing columns and other information before we start to modify
the constraint system. Save the shorter column.
*/
action *s = &actions[nactions] ;
nactions++ ;
s->row = tgtrow ;
s->icolx = tgtcolx ;
s->clox = clo[tgtcolx] ;
s->cupx = cup[tgtcolx] ;
s->costx = cost[tgtcolx] ;
s->icoly = tgtcoly ;
s->costy = cost[tgtcoly] ;
s->rlo = rlo[tgtrow] ;
s->coeffx = coeffx ;
s->coeffy = coeffy ;
s->ncolx = colLengths[tgtcolx] ;
s->ncoly = colLengths[tgtcoly] ;
if (s->ncoly < s->ncolx) {
s->colel = presolve_dupmajor(colCoeffs,rowIndices,colLengths[tgtcoly],
colStarts[tgtcoly],tgtrow) ;
s->ncolx = 0 ;
} else {
s->colel = presolve_dupmajor(colCoeffs,rowIndices,colLengths[tgtcolx],
colStarts[tgtcolx],tgtrow) ;
s->ncoly = 0 ;
}
/*
Move finite bound information from y to x, so that y is implied free.
a x + b y = c
l1 <= x <= u1
l2 <= y <= u2
l2 <= (c - a x) / b <= u2
b/-a > 0 ==> (b l2 - c) / -a <= x <= (b u2 - c) / -a
b/-a < 0 ==> (b u2 - c) / -a <= x <= (b l2 - c) / -a
*/
{
double lo1 = -PRESOLVE_INF ;
double up1 = PRESOLVE_INF ;
if (-PRESOLVE_INF < clo[tgtcoly]) {
if (coeffx*coeffy < 0)
lo1 = (coeffy*clo[tgtcoly]-rhs)/-coeffx ;
else
up1 = (coeffy*clo[tgtcoly]-rhs)/-coeffx ;
}
if (cup[tgtcoly] < PRESOLVE_INF) {
if (coeffx*coeffy < 0)
up1 = (coeffy*cup[tgtcoly]-rhs)/-coeffx ;
else
lo1 = (coeffy*cup[tgtcoly]-rhs)/-coeffx ;
}
/*
Don't forget the objective coefficient.
costy y = costy ((c - a x) / b) = (costy c)/b + x (costy -a)/b
*/
cost[tgtcolx] += (cost[tgtcoly]*-coeffx)/coeffy ;
prob->change_bias((cost[tgtcoly]*rhs)/coeffy) ;
/*
The transfer of bounds could make x infeasible. Patch it up if the problem
is minor or if the user was so incautious as to instruct us to ignore it.
Prefer an integer value if there's one nearby. If there's nothing to be
done, break out of the main loop.
*/
{
double lo2 = CoinMax(clo[tgtcolx],lo1) ;
double up2 = CoinMin(cup[tgtcolx],up1) ;
if (lo2 > up2) {
if (lo2 <= up2+prob->feasibilityTolerance_ || fixInfeasibility) {
double nearest = floor(lo2+0.5) ;
if (fabs(nearest-lo2) < 2.0*prob->feasibilityTolerance_) {
lo2 = nearest ;
up2 = nearest ;
} else {
lo2 = up2 ;
}
} else {
prob->status_ |= 1 ;
prob->messageHandler()->message(COIN_PRESOLVE_COLINFEAS,
prob->messages())
<< tgtcolx << lo2 << up2 << CoinMessageEol ;
break ;
}
}
# if PRESOLVE_DEBUG > 2
std::cout
<< " x(" << tgtcolx << ") lb " << clo[tgtcolx] << " --> " << lo2
<< ", ub " << cup[tgtcolx] << " --> " << up2 << std::endl ;
# endif
clo[tgtcolx] = lo2 ;
cup[tgtcolx] = up2 ;
/*
Do we have a solution to maintain? If so, take a stab at it. If x ends up at
bound, prefer to set it nonbasic, but if we're short of basic variables
after eliminating y and the logical for the row, make it basic.
This code will snap the value of x to bound if it's within the primal
feasibility tolerance.
*/
if (rowstat && sol) {
int numberBasic = 0 ;
double movement = 0 ;
if (prob->columnIsBasic(tgtcolx))
numberBasic++ ;
if (prob->columnIsBasic(tgtcoly))
numberBasic++ ;
if (prob->rowIsBasic(tgtrow))
numberBasic++ ;
if (sol[tgtcolx] <= lo2+ztolzb) {
movement = lo2-sol[tgtcolx] ;
sol[tgtcolx] = lo2 ;
prob->setColumnStatus(tgtcolx,
CoinPrePostsolveMatrix::atLowerBound) ;
} else if (sol[tgtcolx] >= up2-ztolzb) {
movement = up2-sol[tgtcolx] ;
sol[tgtcolx] = up2 ;
prob->setColumnStatus(tgtcolx,
CoinPrePostsolveMatrix::atUpperBound) ;
}
if (numberBasic > 1)
prob->setColumnStatus(tgtcolx,CoinPrePostsolveMatrix::basic) ;
/*
We need to compensate if x was forced to move. Beyond that, even if x
didn't move, we've forced y = (c-ax)/b, and that might not have been
true before. So even if x didn't move, y may have moved. Note that the
constant term c/b is subtracted out as the constraints are modified,
so we don't include it when calculating movement for y.
*/
if (movement) {
const CoinBigIndex kkcsx = colStarts[tgtcolx] ;
const CoinBigIndex kkcex = kkcsx+colLengths[tgtcolx] ;
for (CoinBigIndex kcol = kkcsx ; kcol < kkcex ; kcol++) {
int row = rowIndices[kcol] ;
if (rowLengths[row])
acts[row] += movement*colCoeffs[kcol] ;
}
}
movement = ((-coeffx*sol[tgtcolx])/coeffy)-sol[tgtcoly] ;
if (movement) {
const CoinBigIndex kkcsy = colStarts[tgtcoly] ;
const CoinBigIndex kkcey = kkcsy+colLengths[tgtcoly] ;
for (CoinBigIndex kcol = kkcsy ; kcol < kkcey ; kcol++) {
int row = rowIndices[kcol] ;
if (rowLengths[row])
acts[row] += movement*colCoeffs[kcol] ;
}
}
}
if (lo2 == up2)
fixed[nfixed++] = tgtcolx ;
}
}
/*
We're done transferring bounds from y to x, and we've patched up the
solution if one existed to patch. One last thing to do before we eliminate
column y and the doubleton row: put column x and the entangled rows on
the lists of columns and rows to look at in the next round of transforms.
*/
{
prob->addCol(tgtcolx) ;
const CoinBigIndex kkcsy = colStarts[tgtcoly] ;
const CoinBigIndex kkcey = kkcsy+colLengths[tgtcoly] ;
for (CoinBigIndex kcol = kkcsy ; kcol < kkcey ; kcol++) {
int row = rowIndices[kcol] ;
prob->addRow(row) ;
}
const CoinBigIndex kkcsx = colStarts[tgtcolx] ;
const CoinBigIndex kkcex = kkcsx+colLengths[tgtcolx] ;
for (CoinBigIndex kcol = kkcsx ; kcol < kkcex ; kcol++) {
int row = rowIndices[kcol] ;
prob->addRow(row) ;
}
}
/*
Empty tgtrow in the column-major matrix. Deleting the coefficient for
(tgtrow,tgtcoly) is a bit costly (given that we're about to drop the whole
column), but saves the trouble of checking for it in elim_doubleton.
*/
presolve_delete_from_col(tgtrow,tgtcolx,
colStarts,colLengths,rowIndices,colCoeffs) ;
presolve_delete_from_col(tgtrow,tgtcoly,
colStarts,colLengths,rowIndices,colCoeffs) ;
/*
Drop tgtrow in the row-major representation: set the length to 0
and reclaim the major vector space in bulk storage.
*/
rowLengths[tgtrow] = 0 ;
PRESOLVE_REMOVE_LINK(rlink,tgtrow) ;
/*
Transfer the colx factors to coly. This modifies coefficients in column x
as it removes coefficients in column y.
*/
bool no_mem = elim_doubleton("ELIMD",
colStarts,rlo,rup,colCoeffs,
rowIndices,colIndices,rowLengths,colLengths,
clink,n,
rowStarts,rowCoeffs,
-coeffx/coeffy,
rhs/coeffy,
tgtrow,tgtcolx,tgtcoly) ;
if (no_mem)
throwCoinError("out of memory","doubleton_action::presolve") ;
/*
Eliminate coly entirely from the col rep. We'll want to groom colx to remove
explicit zeros.
*/
colLengths[tgtcoly] = 0 ;
PRESOLVE_REMOVE_LINK(clink, tgtcoly) ;
cost[tgtcoly] = 0.0 ;
rlo[tgtrow] = 0.0 ;
rup[tgtrow] = 0.0 ;
zeros[nzeros++] = tgtcolx ;
# if PRESOLVE_CONSISTENCY > 0
presolve_consistent(prob) ;
presolve_links_ok(prob) ;
# endif
}
/*
Tidy up the collected actions and clean up explicit zeros and fixed
variables. Don't bother unless we're feasible (status of 0).
*/
if (nactions && !prob->status_) {
# if PRESOLVE_SUMMARY > 0
printf("NDOUBLETONS: %d\n", nactions) ;
# endif
action *actions1 = new action[nactions] ;
CoinMemcpyN(actions, nactions, actions1) ;
next = new doubleton_action(nactions, actions1, next) ;
if (nzeros)
next = drop_zero_coefficients_action::presolve(prob, zeros, nzeros, next) ;
if (nfixed)
next = remove_fixed_action::presolve(prob, fixed, nfixed, next) ;
}
deleteAction(actions,action*) ;
# if COIN_PRESOLVE_TUNING > 0
if (prob->tuning_) double thisTime = CoinCpuTime() ;
# endif
# if PRESOLVE_CONSISTENCY > 0 || PRESOLVE_DEBUG > 0
presolve_check_sol(prob) ;
# endif
# if PRESOLVE_DEBUG > 0 || COIN_PRESOLVE_TUNING > 0
int droppedRows = prob->countEmptyRows()-startEmptyRows ;
int droppedColumns = prob->countEmptyCols()-startEmptyColumns ;
std::cout
<< "Leaving doubleton_action::presolve, " << droppedRows << " rows, "
<< droppedColumns << " columns dropped" ;
# if COIN_PRESOLVE_TUNING > 0
std::cout << " in " << thisTime-startTime << "s" ;
# endif
std::cout << "." << std::endl ;
# endif
return (next) ;
}
/*
* It is always the case that one of the variables of a doubleton
* will be (implied) free, but neither will necessarily be a singleton.
* Since in the case of a doubleton the number of non-zero entries
* will never increase, though, it makes sense to always eliminate them.
*
* The col rep and row rep must be consistent.
*/
const CoinPresolveAction
*doubleton_action::presolve (CoinPresolveMatrix *prob,
const CoinPresolveAction *next)
{
double startTime = 0.0;
int startEmptyRows=0;
int startEmptyColumns = 0;
if (prob->tuning_) {
startTime = CoinCpuTime();
startEmptyRows = prob->countEmptyRows();
startEmptyColumns = prob->countEmptyCols();
}
double *colels = prob->colels_;
int *hrow = prob->hrow_;
CoinBigIndex *mcstrt = prob->mcstrt_;
int *hincol = prob->hincol_;
int ncols = prob->ncols_;
double *clo = prob->clo_;
double *cup = prob->cup_;
double *rowels = prob->rowels_;
int *hcol = prob->hcol_;
CoinBigIndex *mrstrt = prob->mrstrt_;
int *hinrow = prob->hinrow_;
int nrows = prob->nrows_;
double *rlo = prob->rlo_;
double *rup = prob->rup_;
presolvehlink *clink = prob->clink_;
presolvehlink *rlink = prob->rlink_;
const unsigned char *integerType = prob->integerType_;
double *cost = prob->cost_;
int numberLook = prob->numberRowsToDo_;
int iLook;
int * look = prob->rowsToDo_;
const double ztolzb = prob->ztolzb_;
action * actions = new action [nrows];
int nactions = 0;
int *zeros = prob->usefulColumnInt_; //new int[ncols];
int nzeros = 0;
int *fixed = zeros+ncols; //new int[ncols];
int nfixed = 0;
unsigned char *rowstat = prob->rowstat_;
double *acts = prob->acts_;
double * sol = prob->sol_;
bool fixInfeasibility = (prob->presolveOptions_&16384)!=0;
# if PRESOLVE_CONSISTENCY
presolve_consistent(prob) ;
presolve_links_ok(prob) ;
# endif
// wasfor (int irow=0; irow<nrows; irow++)
for (iLook=0;iLook<numberLook;iLook++) {
int irow = look[iLook];
if (hinrow[irow] == 2 &&
fabs(rup[irow] - rlo[irow]) <= ZTOLDP) {
double rhs = rlo[irow];
CoinBigIndex krs = mrstrt[irow];
int icolx, icoly;
CoinBigIndex k;
icolx = hcol[krs];
icoly = hcol[krs+1];
if (hincol[icolx]<=0||hincol[icoly]<=0) {
// should never happen ?
//printf("JJF - doubleton column %d has %d entries and %d has %d\n",
// icolx,hincol[icolx],icoly,hincol[icoly]);
continue;
}
// check size
if (fabs(rowels[krs]) < ZTOLDP2 || fabs(rowels[krs+1]) < ZTOLDP2)
continue;
// See if prohibited for any reason
if (prob->colProhibited(icolx) || prob->colProhibited(icolx))
continue;
// don't bother with fixed variables
if (!(fabs(cup[icolx] - clo[icolx]) < ZTOLDP) &&
!(fabs(cup[icoly] - clo[icoly]) < ZTOLDP)) {
double coeffx, coeffy;
/* find this row in each of the columns */
CoinBigIndex krowx = presolve_find_row(irow, mcstrt[icolx], mcstrt[icolx] + hincol[icolx], hrow);
CoinBigIndex krowy = presolve_find_row(irow, mcstrt[icoly], mcstrt[icoly] + hincol[icoly], hrow);
/*
Check for integrality: If one variable is integer, keep it and substitute
for the continuous variable. If both are integer, substitute only for the
forms x = k * y (k integral and non-empty intersection on bounds on x)
or x = 1-y, where both x and y are binary.
flag bits for integerStatus: 1>>0 x integer
1>>1 y integer
*/
int integerStatus=0;
if (integerType[icolx]) {
if (integerType[icoly]) {
// both integer
int good = 0;
double rhs2 = rhs;
double value;
value=colels[krowx];
if (value<0.0) {
value = - value;
rhs2 += 1;
}
if (cup[icolx]==1.0&&clo[icolx]==0.0&&fabs(value-1.0)<1.0e-7)
good =1;
value=colels[krowy];
if (value<0.0) {
value = - value;
rhs2 += 1;
}
if (cup[icoly]==1.0&&clo[icoly]==0.0&&fabs(value-1.0)<1.0e-7)
good |= 2;
if (good==3&&fabs(rhs2-1.0)<1.0e-7)
integerStatus = 3;
else
integerStatus=-1;
if (integerStatus==-1&&!rhs) {
// maybe x = k * y;
double value1 = colels[krowx];
double value2 = colels[krowy];
double ratio;
bool swap=false;
if (fabs(value1)>fabs(value2)) {
ratio = value1/value2;
} else {
ratio = value2/value1;
swap=true;
}
ratio=fabs(ratio);
if (fabs(ratio-floor(ratio+0.5))<1.0e-12) {
// possible
integerStatus = swap ? 2 : 1;
//printf("poss type %d\n",integerStatus);
}
}
} else {
integerStatus = 1;
}
} else if (integerType[icoly]) {
integerStatus = 2;
}
if (integerStatus<0) {
// can still take in some cases
bool canDo=false;
double value1 = colels[krowx];
double value2 = colels[krowy];
double ratio;
bool swap=false;
double rhsRatio;
if (fabs(value1)>fabs(value2)) {
ratio = value1/value2;
rhsRatio = rhs/value1;
} else {
ratio = value2/value1;
rhsRatio = rhs/value2;
swap=true;
}
ratio=fabs(ratio);
if (fabs(ratio-floor(ratio+0.5))<1.0e-12) {
// possible
integerStatus = swap ? 2 : 1;
// but check rhs
if (rhsRatio==floor(rhsRatio+0.5))
canDo=true;
}
#ifdef COIN_DEVELOP2
if (canDo)
printf("Good CoinPresolveDoubleton icolx %d (%g and bounds %g %g) icoly %d (%g and bound %g %g) - rhs %g\n",
icolx,colels[krowx],clo[icolx],cup[icolx],
icoly,colels[krowy],clo[icoly],cup[icoly],rhs);
else
printf("Bad CoinPresolveDoubleton icolx %d (%g) icoly %d (%g) - rhs %g\n",
icolx,colels[krowx],icoly,colels[krowy],rhs);
#endif
if (!canDo)
continue;
}
if (integerStatus == 2) {
CoinSwap(icoly,icolx);
CoinSwap(krowy,krowx);
}
// HAVE TO JIB WITH ABOVE swapS
// if x's coefficient is something like 1000, but y's only something like -1,
// then when we postsolve, if x's is close to being out of tolerance,
// then y is very likely to be (because y==1000x) . (55)
// It it interesting that the number of doubletons found may depend
// on which column is substituted away (this is true of baxter.mps).
if (!integerStatus) {
if (fabs(colels[krowy]) < fabs(colels[krowx])) {
CoinSwap(icoly,icolx);
CoinSwap(krowy,krowx);
}
}
#if 0
//?????
if (integerType[icolx] &&
clo[icoly] != -PRESOLVE_INF &&
cup[icoly] != PRESOLVE_INF) {
continue;
}
#endif
{
CoinBigIndex kcs = mcstrt[icoly];
CoinBigIndex kce = kcs + hincol[icoly];
for (k=kcs; k<kce; k++) {
if (hinrow[hrow[k]] == 1) {
break;
}
}
// let singleton rows be taken care of first
if (k<kce)
continue;
}
coeffx = colels[krowx];
coeffy = colels[krowy];
// it is possible that both x and y are singleton columns
// that can cause problems
if (hincol[icolx] == 1 && hincol[icoly] == 1)
continue;
// BE CAUTIOUS and avoid very large relative differences
// if this is not done in baxter, then the computed solution isn't optimal,
// but gets it in 11995 iterations; the postsolve goes to iteration 16181.
// with this, the solution is optimal, but takes 18825 iters; postsolve 18871.
#if 0
if (fabs(coeffx) * max_coeff_factor <= fabs(coeffy))
continue;
#endif
#if 0
if (only_zero_rhs && rhs != 0)
continue;
if (reject_doubleton(mcstrt, colels, hrow, hincol,
-coeffx / coeffy,
max_coeff_ratio,
irow, icolx, icoly))
continue;
#endif
// common equations are of the form ax + by = 0, or x + y >= lo
{
PRESOLVE_DETAIL_PRINT(printf("pre_doubleton %dC %dC %dR E\n",
icoly,icolx,irow));
action *s = &actions[nactions];
nactions++;
s->row = irow;
s->icolx = icolx;
s->clox = clo[icolx];
s->cupx = cup[icolx];
s->costx = cost[icolx];
s->icoly = icoly;
s->costy = cost[icoly];
s->rlo = rlo[irow];
s->coeffx = coeffx;
s->coeffy = coeffy;
s->ncolx = hincol[icolx];
s->ncoly = hincol[icoly];
if (s->ncoly<s->ncolx) {
// Take out row
s->colel = presolve_dupmajor(colels,hrow,hincol[icoly],
mcstrt[icoly],irow) ;
s->ncolx=0;
} else {
s->colel = presolve_dupmajor(colels,hrow,hincol[icolx],
mcstrt[icolx],irow) ;
s->ncoly=0;
}
}
/*
* This moves the bounds information for y onto x,
* making y free and allowing us to substitute it away.
*
* a x + b y = c
* l1 <= x <= u1
* l2 <= y <= u2 ==>
*
* l2 <= (c - a x) / b <= u2
* b/-a > 0 ==> (b l2 - c) / -a <= x <= (b u2 - c) / -a
* b/-a < 0 ==> (b u2 - c) / -a <= x <= (b l2 - c) / -a
*/
{
double lo1 = -PRESOLVE_INF;
double up1 = PRESOLVE_INF;
//PRESOLVEASSERT((coeffx < 0) == (coeffy/-coeffx < 0));
// (coeffy/-coeffx < 0) == (coeffy<0 == coeffx<0)
if (-PRESOLVE_INF < clo[icoly]) {
if (coeffx * coeffy < 0)
lo1 = (coeffy * clo[icoly] - rhs) / -coeffx;
else
up1 = (coeffy * clo[icoly] - rhs) / -coeffx;
}
if (cup[icoly] < PRESOLVE_INF) {
if (coeffx * coeffy < 0)
up1 = (coeffy * cup[icoly] - rhs) / -coeffx;
else
lo1 = (coeffy * cup[icoly] - rhs) / -coeffx;
}
// costy y = costy ((c - a x) / b) = (costy c)/b + x (costy -a)/b
// the effect of maxmin cancels out
cost[icolx] += cost[icoly] * (-coeffx / coeffy);
prob->change_bias(cost[icoly] * rhs / coeffy);
if (0 /*integerType[icolx]*/) {
abort();
/* no change possible for now */
#if 0
lo1 = trunc(lo1);
up1 = trunc(up1);
/* trunc(3.5) == 3.0 */
/* trunc(-3.5) == -3.0 */
/* I think this is ok */
if (lo1 > clo[icolx]) {
(clo[icolx] <= 0.0)
clo[icolx] = ? ilo
clo[icolx] = ilo;
cup[icolx] = iup;
}
#endif
} else {
