BonDiver.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation 2007
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// Pierre Bonami, International Business Machines Corporation
//
// Date : 09/01/2007

#ifndef BonDiver_H
#define BonDiver_H

#include "BonminConfig.h"
#include "CbcCompareBase.hpp"
#include "CbcTree.hpp"
#include "IpRegOptions.hpp"
#include "IpOptionsList.hpp"
#include "CbcCompareActual.hpp"
#include "BonRegisteredOptions.hpp"
#include <list>
namespace Bonmin
{
  class BabSetupBase;
  class CbcDiver : public CbcTree
  {
  public:
    CbcDiver();

    CbcDiver(const CbcDiver &rhs);

    CbcDiver & operator=(const CbcDiver &rhs);

    virtual ~CbcDiver();

    virtual CbcTree * clone() const;


    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);
    virtual void pop();
    virtual CbcNode * bestNode(double cutoff);


    virtual bool empty();
    virtual int size()
    {
      return (static_cast<int>(nodes_.size()) + (nextOnBranch_ != NULL) );
    }
    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    virtual double getBestPossibleObjective();


    virtual void endSearch()
    {
      nextOnBranch_ = NULL;
    }

    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);

    void initialize(BabSetupBase &b);

  private:
    bool treeCleaning_;
    CbcNode * nextOnBranch_;
    bool stop_diving_on_cutoff_;
  };


  class CbcProbedDiver : public CbcTree
  {
  public:
    CbcProbedDiver();

    CbcProbedDiver(const CbcProbedDiver &rhs);

    CbcProbedDiver & operator=(const CbcProbedDiver &rhs);

    virtual ~CbcProbedDiver();

    virtual CbcTree * clone() const;


    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);
    virtual void pop();
    virtual CbcNode * bestNode(double cutoff);


    virtual bool empty();
    virtual int size()
    {
      return (static_cast<int>(nodes_.size()) + (nextOnBranch_ != NULL) + (candidateChild_ != NULL) );
    }
    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    virtual double getBestPossibleObjective();


    virtual void endSearch()
    {
      nextOnBranch_ = NULL;
    }

    void initialize(BabSetupBase &b);

  private:
    bool treeCleaning_;
    CbcNode * nextOnBranch_;
    CbcNode * candidateChild_;
    bool stop_diving_on_cutoff_;
  };


  class CbcDfsDiver :public CbcTree
  {
  public:
    enum ComparisonModes{
      Enlarge,
      FindSolutions,
      CloseBound,
      LimitTreeSize};
    CbcDfsDiver();

    CbcDfsDiver(const CbcDfsDiver &rhs);

    CbcDfsDiver & operator=(const CbcDfsDiver &rhs);

    virtual ~CbcDfsDiver();

    virtual CbcTree * clone() const;


    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);
    virtual void pop();
    virtual CbcNode * bestNode(double cutoff);


    virtual bool empty();
    virtual int size()
    {
      return static_cast<int>(nodes_.size()) + diveListSize_;
    }
    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    virtual double getBestPossibleObjective();

//#ifdef COIN_HAS_BONMIN
    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);

    void initialize(BabSetupBase &b);
//#endif
    virtual void endSearch()
    {}

    void setComparisonMode(ComparisonModes newMode);
    ComparisonModes getComparisonMode()
    {
      return mode_;
    }
  protected:
    int treeCleaning_;
    std::list<CbcNode *> dive_;
    int diveListSize_;
    int divingBoardDepth_;
    double cutoff_;
    int nBacktracks_;
    int maxDepthBFS_;
    int maxDiveBacktracks_;
    int maxDiveDepth_;
    ComparisonModes mode_;
  private:
    void pushDiveOntoHeap(double cutoff);

  };

  class DiverCompare : public CbcCompareBase
  {
  public:
    // Default Constructor
    DiverCompare ():
        CbcCompareBase(),
        diver_(NULL),
        numberSolToStopDive_(5),
        numberNodesToLimitTreeSize_(1000000),
        comparisonDive_(NULL),
        comparisonBound_(NULL)
    {}


    virtual ~DiverCompare()
    {
      delete comparisonDive_;
      delete comparisonBound_;
    }

    // Copy constructor
    DiverCompare ( const DiverCompare & rhs):
        CbcCompareBase(rhs),
        diver_(rhs.diver_),
        numberSolToStopDive_(rhs.numberSolToStopDive_),
        numberNodesToLimitTreeSize_(rhs.numberNodesToLimitTreeSize_),
        comparisonDive_(rhs.comparisonDive_->clone()),
        comparisonBound_(rhs.comparisonBound_->clone())
    {}

    // Assignment operator
    DiverCompare & operator=( const DiverCompare& rhs)
    {
      if (this != &rhs) {
        CbcCompareBase::operator=(rhs);
        diver_ = rhs.diver_;
        numberSolToStopDive_ = rhs.numberSolToStopDive_;
        numberNodesToLimitTreeSize_ = rhs.numberNodesToLimitTreeSize_;
        delete comparisonDive_;
        delete comparisonBound_;
        comparisonDive_ = NULL;
        comparisonBound_ = NULL;
        if (rhs.comparisonDive_) comparisonDive_ = rhs.comparisonDive_->clone();
        if (rhs.comparisonBound_) comparisonBound_ = rhs.comparisonBound_->clone();
      }
      return *this;
    }

    virtual CbcCompareBase * clone() const
    {
      return new DiverCompare(*this);
    }

    virtual bool test (CbcNode * x, CbcNode * y);

    virtual bool newSolution(CbcModel * model);

    virtual bool newSolution(CbcModel * model,
        double objectiveAtContinuous,
        int numberInfeasibilitiesAtContinuous);

    virtual bool every1000Nodes(CbcModel * model,int numberNodes);

    void setDiver(CbcDfsDiver * diver)
    {
      diver_ = diver;
    }

    void setNumberSolToStopDive(int val)
    {
      numberSolToStopDive_ = val;
    }

    void setNumberNodesToLimitTreeSize(int val)
    {
      numberNodesToLimitTreeSize_ = val;
    }

    void setComparisonDive(const CbcCompareBase & val)
    {
      comparisonDive_ = val.clone();
    }
    void setComparisonBound(const CbcCompareBase & val)
    {
      comparisonBound_ = val.clone();
    }
  private:
    CbcDfsDiver * diver_;
    int numberSolToStopDive_;
    int numberNodesToLimitTreeSize_;
    CbcCompareBase * comparisonDive_;
    CbcCompareBase * comparisonBound_;
    CbcCompareDepth comparisonDepth_;
  };

}/* Ends bonmin namespace.*/

#endif