/*
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 {
