BranchAndBound.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURBRANCHANDBOUND_H
#define MINOTAURBRANCHANDBOUND_H
 
#include "Types.h"
#include "Environment.h"
#include "Brancher.h"
#include "Heuristic.h"
#include "NodeProcessor.h"
#include "NodeRelaxer.h"
#include "Problem.h"
#include "Relaxation.h"
#include "SolutionPool.h"
#include "TreeManager.h"
 
namespace Minotaur {
 
  struct  BabOptions;
  struct  BabStats;
  typedef BabOptions* BabOptionsPtr;
 
 
  class BranchAndBound {
 
  public:
    BranchAndBound();
 
    BranchAndBound(EnvPtr env, ProblemPtr problem);
 
    virtual ~BranchAndBound();
 
    void addPreRootHeur(HeurPtr h);
 
    double getPerGap();
 
    double getLb();
 
    NodeProcessorPtr getNodeProcessor();
 
    NodeRelaxerPtr getNodeRelaxer(); 
 
    /*
     * \brief Return solution from the last solve. If no solution was found, return
     * NULL.
     */
    SolutionPtr getSolution();
 
    /*
     * \brief Return solution from the root node solve. If no solution was found, return
     * NULL.
     */
    //SolutionPtr getRootSolution();
 
    SolveStatus getStatus();
 
    TreeManagerPtr getTreeManager(); 
 
    double getUb();
 
    UInt numProcNodes();
 
    void setLogLevel(LogLevel level);
 
    void setNodeProcessor(NodeProcessorPtr p);
 
    void setNodeRelaxer(NodeRelaxerPtr nr);
 
    void shouldCreateRoot(bool b);
 
    void solve();
 
    double totalTime();
 
    void writeStats(std::ostream & out);
 
    void writeStats();
 
  private:
    EnvPtr env_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    NodeProcessorPtr nodePrcssr_;
 
    NodeRelaxerPtr nodeRlxr_;
 
    BabOptionsPtr options_;
 
    HeurVector preHeurs_;
 
    ProblemPtr problem_;
 
    SolutionPoolPtr solPool_;
 
    BabStats *stats_;
 
    SolveStatus status_;
 
    const Timer *timer_;
   
    TreeManagerPtr tm_;
 
    NodePtr processRoot_(bool *should_prune, bool *should_dive);
 
    bool shouldPrune_(NodePtr node);
 
    bool shouldStop_();
 
    void showStatus_(bool current_uncounted,bool last_line);
 
    void showStatusHead_();
  };
 
  struct BabStats 
  {
    BabStats();
 
    UInt nodesProc;
 
    double timeUsed;
 
    double updateTime;
  };
 
 
  struct BabOptions
  {
    BabOptions();
 
    BabOptions(EnvPtr env);
 
    bool createRoot;
 
    double logInterval;
 
    UInt nodeLimit;
 
    double perGapLimit;
 
    UInt solLimit;
 
    double timeLimit;
  };
 
  typedef BranchAndBound* BranchAndBoundPtr;
}
#endif