void
OsiPresolve::postsolve(bool updateStatus)
{
// Messages
CoinMessages messages = CoinMessage(presolvedModel_->messages().language());
if (!presolvedModel_->isProvenOptimal()) {
presolvedModel_->messageHandler()->message(COIN_PRESOLVE_NONOPTIMAL,
messages)
<<CoinMessageEol;
}
// this is the size of the original problem
const int ncols0 = ncols_;
const int nrows0 = nrows_;
const CoinBigIndex nelems0 = nelems_;
// reality check
assert(ncols0==originalModel_->getNumCols());
assert(nrows0==originalModel_->getNumRows());
// this is the reduced problem
int ncols = presolvedModel_->getNumCols();
int nrows = presolvedModel_->getNumRows();
double *acts = new double [nrows0];
double *sol = new double [ncols0];
CoinZeroN(acts,nrows0);
CoinZeroN(sol,ncols0);
unsigned char * rowstat=NULL;
unsigned char * colstat = NULL;
CoinWarmStartBasis * presolvedBasis =
dynamic_cast<CoinWarmStartBasis*>(presolvedModel_->getWarmStart());
if (!presolvedBasis)
updateStatus=false;
if (updateStatus) {
colstat = new unsigned char[ncols0+nrows0];
# ifdef ZEROFAULT
memset(colstat,0,((ncols0+nrows0)*sizeof(char))) ;
# endif
rowstat = colstat + ncols0;
int i;
for (i=0;i<ncols;i++) {
colstat[i] = presolvedBasis->getStructStatus(i);
}
for (i=0;i<nrows;i++) {
rowstat[i] = presolvedBasis->getArtifStatus(i);
}
}
delete presolvedBasis;
# if PRESOLVE_CONSISTENCY > 0
if (updateStatus)
{ int basicCnt = 0 ;
int i ;
for (i = 0 ; i < ncols ; i++)
{ if (colstat[i] == CoinWarmStartBasis::basic) basicCnt++ ; }
for (i = 0 ; i < nrows ; i++)
{ if (rowstat[i] == CoinWarmStartBasis::basic) basicCnt++ ; }
assert (basicCnt == nrows) ;
}
# endif
/*
Postsolve back to the original problem. The CoinPostsolveMatrix object
assumes ownership of sol, acts, colstat, and rowstat.
*/
CoinPostsolveMatrix prob(presolvedModel_, ncols0, nrows0, nelems0,
presolvedModel_->getObjSense(),
sol, acts, colstat, rowstat);
postsolve(prob);
# if PRESOLVE_CONSISTENCY > 0
if (updateStatus)
{ int basicCnt = 0 ;
int i ;
for (i = 0 ; i < ncols0 ; i++)
{ if (prob.getColumnStatus(i) == CoinWarmStartBasis::basic) basicCnt++ ; }
for (i = 0 ; i < nrows0 ; i++)
{ if (prob.getRowStatus(i) == CoinWarmStartBasis::basic) basicCnt++ ; }
assert (basicCnt == nrows0) ;
}
# endif
originalModel_->setColSolution(sol);
if (updateStatus) {
CoinWarmStartBasis *basis =
dynamic_cast<CoinWarmStartBasis *>(presolvedModel_->getEmptyWarmStart());
basis->setSize(ncols0,nrows0);
int i;
for (i=0;i<ncols0;i++) {
CoinWarmStartBasis::Status status = static_cast<CoinWarmStartBasis::Status> (prob.getColumnStatus(i));
/* FIXME: these asserts seem correct, but seem to reveal some bugs in CoinPresolve */
// assert(status != CoinWarmStartBasis::atLowerBound || originalModel_->getColLower()[i] > -originalModel_->getInfinity());
// assert(status != CoinWarmStartBasis::atUpperBound || originalModel_->getColUpper()[i] < originalModel_->getInfinity());
basis->setStructStatus(i,status);
}
for (i=0;i<nrows0;i++) {
CoinWarmStartBasis::Status status = static_cast<CoinWarmStartBasis::Status> (prob.getRowStatus(i));
/* FIXME: these asserts seem correct, but seem to reveal some bugs in CoinPresolve */
// assert(status != CoinWarmStartBasis::atUpperBound || originalModel_->getRowLower()[i] > -originalModel_->getInfinity());
// assert(status != CoinWarmStartBasis::atLowerBound || originalModel_->getRowUpper()[i] < originalModel_->getInfinity());
basis->setArtifStatus(i,status);
}
originalModel_->setWarmStart(basis);
delete basis ;
}
}
void
CbcTreeArray::cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective)
{
int j;
int nNodes = size();
int lastNode = nNodes + 1;
CbcNode ** nodeArray = new CbcNode * [lastNode];
int * depth = new int [lastNode];
int k = 0;
int kDelete = lastNode;
bestPossibleObjective = 1.0e100 ;
/*
Destructively scan the heap. Nodes to be retained go into the front of
nodeArray, nodes to be deleted into the back. Store the depth in a
correlated array for nodes to be deleted.
*/
for (j = 0; j < nNodes; j++) {
CbcNode * node = nodes_.front();
nodes_.front()->setOnTree(false);
std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
nodes_.pop_back();
double value = node ? node->objectiveValue() : COIN_DBL_MAX;
if (node && value >= cutoff) {
// double check in case node can change its mind!
value = node->checkIsCutoff(cutoff);
}
if (value >= cutoff || !node->active()) {
if (node) {
nodeArray[--kDelete] = node;
depth[kDelete] = node->depth();
}
} else {
bestPossibleObjective = CoinMin(bestPossibleObjective, value);
nodeArray[k++] = node;
}
}
if (lastNode_) {
double value = lastNode_->objectiveValue();
bestPossibleObjective = CoinMin(bestPossibleObjective, value);
if (value >= cutoff || !lastNode_->active()) {
nodeArray[--kDelete] = lastNode_;
depth[kDelete] = lastNode_->depth();
lastNode_ = NULL;
}
}
CbcCompareDefault * compareDefault
= dynamic_cast<CbcCompareDefault *> (comparison_.test_);
assert (compareDefault);
compareDefault->setBestPossible(bestPossibleObjective);
compareDefault->setCutoff(cutoff);
/*
Rebuild the heap using the retained nodes.
*/
for (j = 0; j < k; j++) {
CbcNode * node = nodeArray[j];
node->setOnTree(true);
nodes_.push_back(node);
std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
}
/*
Sort the list of nodes to be deleted, nondecreasing.
*/
CoinSort_2(depth + kDelete, depth + lastNode, nodeArray + kDelete);
/*
Work back from deepest to shallowest. In spite of the name, addCuts1 is
just a preparatory step. When it returns, the following will be true:
* all cuts are removed from the solver's copy of the constraint system;
* lastws will be a basis appropriate for the specified node;
* variable bounds will be adjusted to be appropriate for the specified
node;
* addedCuts_ (returned via addedCuts()) will contain a list of cuts that
should be added to the constraint system at this node (but they have
not actually been added).
Then we scan the cut list for the node. Decrement the reference count
for the cut, and if it's gone to 0, really delete it.
I don't yet see why the checks for status != basic and addedCuts_[i] != 0
are necessary. When reconstructing a node, these checks are used to skip
over loose cuts, excluding them from the reconstituted basis. But here
we're just interested in correcting the reference count. Tight/loose
should make no difference.
Arguably a separate routine should be used in place of addCuts1. It's
doing more work than needed, modifying the model to match a subproblem
at a node that will be discarded. Then again, we seem to need the basis.
*/
for (j = lastNode - 1; j >= kDelete; j--) {
CbcNode * node = nodeArray[j];
CoinWarmStartBasis *lastws = model->getEmptyBasis() ;
model->addCuts1(node, lastws);
// Decrement cut counts
assert (node);
//assert (node->nodeInfo());
int numberLeft = (node->nodeInfo()) ? node->nodeInfo()->numberBranchesLeft() : 0;
int i;
for (i = 0; i < model->currentNumberCuts(); i++) {
// take off node
CoinWarmStartBasis::Status status =
lastws->getArtifStatus(i + model->numberRowsAtContinuous());
if (status != CoinWarmStartBasis::basic &&
model->addedCuts()[i]) {
if (!model->addedCuts()[i]->decrement(numberLeft))
delete model->addedCuts()[i];
}
}
// node should not have anything pointing to it
if (node->nodeInfo())
node->nodeInfo()->throwAway();
delete node ;
delete lastws ;
}
delete [] nodeArray;
delete [] depth;
}
