C++ CbcNode类代码示例

// Remove the top node from the heap
void
CbcTree::pop()
{
    
#   if CBC_DEBUG_HEAP > 2
    CbcNode *node = nodes_.front() ;
    CbcNodeInfo *info = node->nodeInfo() ;
    assert(info) ;
    std::cout
      << "  HEAP: Popping node " << node->nodeNumber()
      << "(" << std::hex << node << std::dec
      << ") obj " << node->objectiveValue()
      << ", ref " << info->decrement(0)
      << ", todo " << info->numberBranchesLeft()
      << ", refd by " << info->numberPointingToThis() << "." << std::endl ;
#   endif
#   if CBC_DEBUG_HEAP > 0
    validateHeap() ;
#   endif
    nodes_.front()->setOnTree(false);
    std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
    nodes_.pop_back();

#   if CBC_DEBUG_HEAP > 0
    validateHeap() ;
#   endif

}

double
CbcBranchToFixLots::infeasibility(const OsiBranchingInformation * /*info*/,
                                  int &preferredWay) const
{
    preferredWay = -1;
    CbcNode * node = model_->currentNode();
    int depth;
    if (node)
        depth = CoinMax(node->depth(), 0);
    else
        return 0.0;
    if (depth_ < 0) {
        return 0.0;
    } else if (depth_ > 0) {
        if ((depth % depth_) != 0)
            return 0.0;
    }
    if (djTolerance_ != -1.234567) {
        if (!shallWe())
            return 0.0;
        else
            return 1.0e20;
    } else {
        // See if 3 in same row and sum <FIX_IF_LESS?
        int numberRows = matrixByRow_.getNumRows();
        const double * solution = model_->testSolution();
        const int * column = matrixByRow_.getIndices();
        const CoinBigIndex * rowStart = matrixByRow_.getVectorStarts();
        const int * rowLength = matrixByRow_.getVectorLengths();
        double bestSum = 1.0;
        int nBest = -1;
        OsiSolverInterface * solver = model_->solver();
        for (int i = 0; i < numberRows; i++) {
            int numberUnsatisfied = 0;
            double sum = 0.0;
            for (int j = rowStart[i]; j < rowStart[i] + rowLength[i]; j++) {
                int iColumn = column[j];
                if (solver->isInteger(iColumn)) {
                    double solValue = solution[iColumn];
                    if (solValue > 1.0e-5 && solValue < FIX_IF_LESS) {
                        numberUnsatisfied++;
                        sum += solValue;
                    }
                }
            }
            if (numberUnsatisfied >= 3 && sum < FIX_IF_LESS) {
                // possible
                if (numberUnsatisfied > nBest ||
                        (numberUnsatisfied == nBest && sum < bestSum)) {
                    nBest = numberUnsatisfied;
                    bestSum = sum;
                }
            }
        }
        if (nBest > 0)
            return 1.0e20;
        else
            return 0.0;
    }
}

// Start dive
void
CbcCompareDefault::startDive(CbcModel * model)
{
    // Get best - using ? criterion
    double saveWeight = weight_;
    weight_ = 0.5 * saveWeight_; //0.0;
    // Switch off to get best
    startNodeNumber_ = -1;
    afterNodeNumber_ = -1;
    CbcNode * best = model->tree()->bestAlternate();
    startNodeNumber_ = best->nodeNumber();
    // send signal to setComparison
    setupForDiving_ = true ;
    /*
      TODO (review when fixing cleanDive and setComparison)
      Both afterNodeNumber_ and weight_ must not change
      after setComparison is invoked, as that will change
      the behaviour of test(). I replaced the overload on
      afterNodeNumber_ (magic number -2) with a boolean. Weight_
      is more problematic. Either it's correct before calling
      setComparison, or it needs to be cut from the tie-breaking
      part of test() during a dive, or there needs to be a new
      attribute to save and restore it around the dive. Otherwise
      heap checks fail in debug builds with Visual Studio.
      
      Given that weight_ was restored immediately after the call
      to setComparison, there should be no change in behaviour
      in terms of calls to test().
      -- lh, 100921 --
    */
    afterNodeNumber_ = model->tree()->maximumNodeNumber();
    weight_ = saveWeight ;
    // redo tree
    model->tree()->setComparison(*this);
    setupForDiving_ = false ;
}

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());
//.........这里部分代码省略.........

// Gets best node and takes off heap
CbcNode *
CbcTreeArray::bestNode(double cutoff)
{
    CbcNode * best = NULL;
    // See if we want last node or best on heap
    if (lastNode_) {
#ifdef CBCTREE_PRINT
        printf("Best lastNode_ %x (%x at depth %d) - nodeNumber %d obj %g\n",
               lastNode_, lastNode_->nodeInfo(), lastNode_->depth(),
               lastNode_->nodeNumber(), lastNode_->objectiveValue());
#endif
        assert (lastNode_->onTree());
        int nodeNumber = lastNode_->nodeNumber();
        bool useLastNode = false;
        if (nodeNumber + 1 == maximumNodeNumber_) {
            // diving - look further
            CbcCompareDefault * compareDefault
            = dynamic_cast<CbcCompareDefault *> (comparison_.test_);
            assert (compareDefault);
            double bestPossible = compareDefault->getBestPossible();
            double cutoff = compareDefault->getCutoff();
            double objValue = lastNode_->objectiveValue();
            if (cutoff < 1.0e20) {
                if (objValue - bestPossible < 0.999*(cutoff - bestPossible))
                    useLastNode = true;
            } else {
                useLastNode = true;
            }
        }
        if (useLastNode) {
            lastNode_->setOnTree(false);
            best = lastNode_;
            lastNode_ = NULL;
            assert(best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo());
            if (best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo())
                assert (best->nodeInfo()->numberBranchesLeft());
            if (best->objectiveValue() >= cutoff) {
                // double check in case node can change its mind!
                best->checkIsCutoff(cutoff);
            }
            lastNodePopped_ = best;
            return best;
        } else {
            // put on tree
            nodes_.push_back(lastNode_);
            lastNode_->setNodeNumber(maximumNodeNumber_);
            maximumNodeNumber_++;
            lastNode_ = NULL;
            std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
        }
    }
    while (!best && nodes_.size()) {
        best = nodes_.front();
        if (best)
            assert(best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo());
        if (best && best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo())
            assert (best->nodeInfo()->numberBranchesLeft());
        if (best && best->objectiveValue() >= cutoff) {
            // double check in case node can change its mind!
            best->checkIsCutoff(cutoff);
        }
        if (!best || best->objectiveValue() >= cutoff) {
            // let code get rid of it
            assert (best);
        }
    }
    lastNodePopped_ = best;
#ifdef CBCTREE_PRINT
    if (best)
        printf("Heap returning node %x (%x at depth %d) - nodeNumber %d - obj %g\n",
               best, best->nodeInfo(), best->depth(),
               best->nodeNumber(), best->objectiveValue());
    else
        printf("Heap returning Null\n");
#endif
    if (best) {
        // take off
        std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
        nodes_.pop_back();
    }
#ifdef DEBUG_CBC_HEAP
    if (best) {
        int n = nodes_.size();
        bool good = true;
        for (int i = 0; i < n; i++) {
            // temp
            assert (nodes_[i]);
            if (!comparison_.compareNodes(nodes_[i], best)) {
                good = false;
                CbcNode * x = nodes_[i];
                printf("i=%d x is better nun %d depth %d obj %g, best nun %d depth %d obj %g\n", i,
                       x->numberUnsatisfied(), x->depth(), x->objectiveValue(),
                       best->numberUnsatisfied(), best->depth(), best->objectiveValue());
            }
        }
        if (!good) {
            // compare best to all
            int i;
            for (i = 0; i < n; i++) {
//.........这里部分代码省略.........

void CbcTree::validateHeap ()
{
  if (comparison_.test_ == 0) {
    std::cout
      << " Invalid heap (no predicate)!" << std::endl ;
    return ;
  }
  std::vector<CbcNode *>::const_iterator curNode,lastNode ;
  curNode = nodes_.begin() ;
  lastNode = nodes_.end() ;
  int curNdx = 0 ;
  int parNdx = 0 ;
  if (curNode == lastNode) return ;
  if (*curNode == 0) {
    std::cout
      << " Invalid heap[" << curNdx << "] (null entry)!" << std::endl ;
  }
  std::vector<CbcNode *>::const_iterator parent ;
  std::vector<CbcNode*>::const_iterator &child = curNode ;
  for (parent = curNode ; ++curNode != lastNode ; ++parent, ++parNdx) {
    curNdx++ ;
    if (*parent == 0) {
      std::cout
        << " Invalid heap[" << parNdx << "] (parent null entry)!" << std::endl ;
      curNode++ ;
      curNdx++ ;
      continue ;
    }
    if (*curNode == 0) {
      std::cout
        << " Invalid heap[" << curNdx << "] (left child null entry)!"
	<< std::endl ;
    } else {
      if (!check_pred(*comparison_.test_,*parent,*child)) {
        std::cout
          << " Invalid heap (left child better)!" << std::endl ;
        CbcNode *node = *parent ; 
        std::cout
          << "   Parent [" << parNdx << "] (" << std::hex << node << std::dec
          << ") unsat " << node->numberUnsatisfied() << ", depth "
	  << node->depth() << ", obj " << node->objectiveValue() << "."
	  << std::endl ;
        node = *child ;
        std::cout
          << "   Child [" << curNdx << "] (" << std::hex << node << std::dec
          << ") unsat " << node->numberUnsatisfied() << ", depth "
	  << node->depth() << ", obj " << node->objectiveValue() << "."
	  << std::endl ;
      }
    }
    curNode++ ;
    curNdx++ ;
    if (curNode == lastNode) break ;
    if (*curNode == 0) {
      std::cout
        << " Invalid heap[" << curNdx << "] (right child null entry)!"
	<< std::endl ;
    } else {
      if (!check_pred(*comparison_.test_,*parent,*child)) {
        std::cout
          << " Invalid heap (right child better)!" << std::endl ;
        CbcNode *node = *parent ;
        std::cout
          << "   Parent [" << parNdx << "] (" << std::hex << node << std::dec
          << ") unsat " << node->numberUnsatisfied() << ", depth "
	  << node->depth() << ", obj " << node->objectiveValue() << "."
	  << std::endl ;
        node = *child ;
        std::cout
          << "   Child [" << curNdx << "] (" << std::hex << node << std::dec
          << ") unsat " << node->numberUnsatisfied() << ", depth "
	  << node->depth() << ", obj " << node->objectiveValue() << "."
	  << std::endl ;
      }
    }
  }
  return ;
}

/*
  Return the best node from the heap.

  Note that best is offered a chance (checkIsCutoff) to reevaluate
  itself and make arbitrary changes. A caller should be prepared
  to check that the returned node is acceptable.

  There's quite a bit of suspect code here, much of it disabled in
  some way. The net effect at present is to return the top node on
  the heap after offering the node an opportunity to reevaluate itself.
  Documentation for checkIsCutoff() puts no restrictions on allowable
  changes. -- lh, 100921 --
*/
CbcNode *
CbcTree::bestNode(double cutoff)
{
# if CBC_DEBUG_HEAP > 0
  validateHeap() ;
# endif
/*
  This code is problematic. As of 100921, there's really no loop.
  If front() == null, an assert will trigger. checkIsCutoff seems to be
  work in progress; comments assert that it can make pretty much arbitrary
  changes to best. If best can change its objective, there's a good
  possibility the heap is invalid.
*/
    CbcNode * best = NULL;
    while (!best && nodes_.size()) {
        best = nodes_.front();
        if (best)
            assert(best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo());
        if (best && best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo())
            assert (best->nodeInfo()->numberBranchesLeft());
        if (best && best->objectiveValue() >= cutoff) {
            // double check in case node can change its mind!
            best->checkIsCutoff(cutoff);
        }
        if (!best || best->objectiveValue() >= cutoff) {
#ifdef JJF_ZERO
            // take off
            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
            nodes_.pop_back();
            delete best;
            best = NULL;
#else
            // let code get rid of it
            assert (best);
#endif
        }
    }
/*
  See if the comparison object wants us to do a full scan with the
  alternative criteria. The net effect is to confirm best by the
  alternative criteria, or identify a competitor and erase it.

  This code is problematic. Nulling an arbitrary node will in general
  break the heap property. Disabled some time ago, as noted in several
  places.
*/
    if (false && best && comparison_.test_->fullScan()) {
        CbcNode * saveBest = best;
        size_t n = nodes_.size();
        size_t iBest = -1;
        for (size_t i = 0; i < n; i++) {
            // temp
            assert (nodes_[i]);
            assert (nodes_[i]->nodeInfo());
            if (nodes_[i] && nodes_[i]->objectiveValue() != COIN_DBL_MAX && nodes_[i]->nodeInfo())
                assert (nodes_[i]->nodeInfo()->numberBranchesLeft());
            if (nodes_[i] && nodes_[i]->objectiveValue() < cutoff
                    && comparison_.alternateTest(best, nodes_[i])) {
                best = nodes_[i];
                iBest = i;
            }
        }
        if (best == saveBest) {
            // can pop
            // take off
            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
            nodes_.pop_back();
        } else {
            // make impossible
            nodes_[iBest] = NULL;
        }
    } else if (best) {
#       if CBC_DEBUG_HEAP > 2
        CbcNode *node = nodes_.front() ;
        CbcNodeInfo *info = node->nodeInfo() ;
        assert(info) ;
        std::cout
          << "  bestNode: Popping node " << node->nodeNumber()
          << "(" << std::hex << node << std::dec
          << ") obj " << node->objectiveValue()
          << ", ref " << info->decrement(0)
          << ", todo " << info->numberBranchesLeft()
          << ", refd by " << info->numberPointingToThis() << "." << std::endl ;
#       endif
        // take off
        std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
        nodes_.pop_back();
//.........这里部分代码省略.........

// Gets best node and takes off heap
CbcNode *
CbcTree::bestNode(double cutoff)
{
    CbcNode * best = NULL;
    while (!best && nodes_.size()) {
        best = nodes_.front();
        if (best)
            assert(best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo());
        if (best && best->objectiveValue() != COIN_DBL_MAX && best->nodeInfo())
            assert (best->nodeInfo()->numberBranchesLeft());
        if (best && best->objectiveValue() >= cutoff) {
            // double check in case node can change its mind!
            best->checkIsCutoff(cutoff);
        }
        if (!best || best->objectiveValue() >= cutoff) {
#ifdef JJF_ZERO
            // take off
            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
            nodes_.pop_back();
            delete best;
            best = NULL;
#else
// let code get rid of it
assert (best);
#endif
        }
    }
    // switched off for now
    if (best && comparison_.test_->fullScan() && false) {
        CbcNode * saveBest = best;
        int n = nodes_.size();
        int iBest = -1;
        for (int i = 0; i < n; i++) {
            // temp
            assert (nodes_[i]);
            assert (nodes_[i]->nodeInfo());
            if (nodes_[i] && nodes_[i]->objectiveValue() != COIN_DBL_MAX && nodes_[i]->nodeInfo())
                assert (nodes_[i]->nodeInfo()->numberBranchesLeft());
            if (nodes_[i] && nodes_[i]->objectiveValue() < cutoff
                    && comparison_.alternateTest(best, nodes_[i])) {
                best = nodes_[i];
                iBest = i;
            }
        }
        if (best == saveBest) {
            // can pop
            // take off
            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
            nodes_.pop_back();
        } else {
            // make impossible
            nodes_[iBest] = NULL;
        }
    } else if (best) {
        // take off
#ifdef JJF_ZERO
        std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
        nodes_.pop_back();
#else
realpop();
#endif
    }
#ifdef DEBUG_CBC_HEAP
    if (best) {
        int n = nodes_.size();
        bool good = true;
        for (int i = 0; i < n; i++) {
            // temp
            assert (nodes_[i]);
            if (!comparison_.compareNodes(nodes_[i], best)) {
                good = false;
                CbcNode * x = nodes_[i];
                printf("i=%d x is better nun %d depth %d obj %g, best nun %d depth %d obj %g\n", i,
                       x->numberUnsatisfied(), x->depth(), x->objectiveValue(),
                       best->numberUnsatisfied(), best->depth(), best->objectiveValue());
            }
        }
        if (!good) {
            // compare best to all
            int i;
            for (i = 0; i < n; i++) {
                CbcNode * x = nodes_[i];
                printf("i=%d x is nun %d depth %d obj %g", i,
                       x->numberUnsatisfied(), x->depth(), x->objectiveValue());
                if (!comparison_.compareNodes(x, best)) {
                    printf(" - best is worse!\n");
                } else {
                    printf("\n");
                }
            }
            // Now compare amongst rest
            for (i = 0; i < n; i++) {
                CbcNode * x = nodes_[i];
                printf("For i=%d ", i);
                for (int j = i + 1; j < n; j++) {
                    CbcNode * y = nodes_[j];
                    if (!comparison_.compareNodes(x, y)) {
                        printf(" b %d", j);
                    } else {
//.........这里部分代码省略.........