ReliabilityBrancher.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURRELIABILITYBRANCHER_H
#define MINOTAURRELIABILITYBRANCHER_H
 
#include "Brancher.h"
 
namespace Minotaur {
 
class Engine;
class Timer;
typedef Engine* EnginePtr;
 
struct RelBrStats {
  UInt bndChange;  
  UInt calls;      
  UInt engProbs;   
  UInt iters;      
  UInt strBrCalls; 
  double strTime;  
};
 
 
class ReliabilityBrancher : public Brancher {
 
public:
  ReliabilityBrancher(EnvPtr env, HandlerVector & handlers);
 
  ~ReliabilityBrancher();
 
  // base class function.
  Branches findBranches(RelaxationPtr rel, NodePtr node, 
                        ConstSolutionPtr sol, SolutionPoolPtr s_pool, 
                        BrancherStatus & br_status, ModVector &mods);
 
  bool getTrustCutoff();
 
  UInt getIterLim();
 
  // base class function.
  std::string getName() const;
 
  UInt getThresh() const;
 
  void initialize(RelaxationPtr rel);
 
  void setTrustCutoff(bool val);
 
  void setEngine(EnginePtr engine);
 
  void setIterLim(UInt k);
 
  void setMaxDepth(UInt k);
 
  void setMinNodeDist(UInt k);
 
  void setThresh(UInt k);
 
  // base class function.
  void updateAfterSolve(NodePtr node, ConstSolutionPtr sol);
 
  void writeStats(std::ostream &out) const;
 
private:
 
  BrCandPtr findBestCandidate_(const double objval, double cutoff, 
                               NodePtr node);
 
  void findCandidates_();
 
  void freeCandidates_(BrCandPtr no_del);
 
  void getPCScore_(BrCandPtr cand, double *ch_down, double *ch_up, 
                   double *score);
 
  double getScore_(const double & up_score, const double & down_score);
 
  bool shouldPrune_(const double &chcutoff, const double &change, 
                    const EngineStatus & status, bool *is_rel);
 
  void strongBranch_(BrCandPtr cand, double & obj_up, double & obj_down, 
                     EngineStatus & status_up, EngineStatus & status_down);
 
  void updatePCost_(const int &i, const double &new_cost, 
                    DoubleVector &cost, UIntVector &count);
 
  void useStrongBranchInfo_(BrCandPtr cand, const double & chcutoff,
                            double & change_up, double & change_down, 
                            const EngineStatus & status_up,
                            const EngineStatus & status_down);
 
  void writeScore_(BrCandPtr cand, double score, double change_up, 
                   double change_down);
 
  void writeScores_(std::ostream &out);
 
  EnginePtr engine_;
 
  const double eTol_;
 
  HandlerVector handlers_;
 
  bool init_;
 
  UIntVector lastStrBranched_;
 
  UInt maxDepth_;
 
  UInt maxIterations_;
 
  UInt maxStrongCands_;
 
  const static std::string me_; 
 
  UInt minNodeDist_;
 
  ModVector mods_;
 
  DoubleVector pseudoDown_;
 
  DoubleVector pseudoUp_;
 
  RelaxationPtr rel_;
 
  std::vector<BrCandPtr> relCands_;
 
  RelBrStats * stats_;
 
  BrancherStatus status_;
 
  Timer *timer_;
 
  UIntVector timesDown_;
 
  UIntVector timesUp_;
 
  UInt thresh_;
 
  bool trustCutoff_;
 
  std::vector<BrCandPtr> unrelCands_;
 
  DoubleVector x_;
 
};
typedef ReliabilityBrancher* ReliabilityBrancherPtr;
}
#endif