HybridBrancher.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURHYBRIDBRANCHER_H
#define MINOTAURHYBRIDBRANCHER_H
 
#include "Brancher.h"
 
namespace Minotaur
{
 
class Engine;
class Timer;
typedef Engine* EnginePtr;
 
struct StrBrStats {
  UInt calls;      
  UInt engProbs;   
  UInt nodePruned; 
  double time;     
};
// A class to select a variable for branching using Hybrid branching.
class HybridBrancher : public Brancher
{
public:
  HybridBrancher(EnvPtr env, HandlerVector& handlers);
 
  ~HybridBrancher();
 
  void doStronger();
 
  // base class function.
  Branches findBranches(RelaxationPtr rel, NodePtr node, ConstSolutionPtr sol,
                        SolutionPoolPtr s_pool, BrancherStatus& br_status,
                        ModVector& mods);
 
  // base class function.
  std::string getName() const;
 
  void reliabilitySetup(UInt max_cands, UInt max_iter, UInt thresh);
 
  void setEngine(EnginePtr engine);
 
  void setProblem(ProblemPtr p);
 
  // base class function.
  void updateAfterSolve(NodePtr node, ConstSolutionPtr sol);
 
  void writeStats(std::ostream& out) const;
  void statsTable()const;
 
private:
  std::vector<std::string> variableNames_;
  EnginePtr engine_;
 
  const double eTol_;
 
  BrCandVector gencands_;
 
  HandlerVector handlers_;
 
  bool init_;
 
  UInt maxCands_;
 
  UInt maxIterations_;
 
  const static std::string me_;
 
  ModVector mods_;
 
  ProblemPtr p_;
 
   UIntVector fracCount_;
 
   UIntVector unfixedCount_;
   void updateFracCount_();
   void updateUnfixedCount_();
 
   UIntVector actualTimesUp_;
 
   UIntVector actualTimesDown_;
 
  DoubleVector pseudoDown_;
 
  DoubleVector pseudoUp_;
 
  RelaxationPtr rel_;
 
  BrVarCandSet relCands_;
 
  bool reliability_;
 
  StrBrStats* stats_;
 
  BrancherStatus status_;
 
  bool stronger_;
 
  const Timer* timer_;
 
  UInt thresh_;
 
  UIntVector timesDown_;
 
  UIntVector timesUp_;
 
  BrVarCandSet unrelCands_;
 
  DoubleVector x_;
 
  BrCandPtr findBestCandidate_(const double objval, SolutionPoolPtr s_pool);
 
  void findCandidates_(bool& should_prune);
 
  UInt findMaxTSR_();
 
  void freeCandidates_(BrCandPtr no_del);
 
  void getPCScore_(BrCandPtr cand, double* ch_dn, double* ch_up, double* score);
 
  double getScore_(const double& up_score, const double& down_score);
 
  void initialize_(RelaxationPtr rel);
 
  bool isReliable_(int pcostIndex);
 
  bool shouldPrune_(const double& chcutoff, const double& change,
                    const EngineStatus& status, bool* is_rel);
 
  double sortUnrelCands_(DoubleVector& vio);
 
  void strongBranch_(BrCandPtr cand, double& obj_up, double& obj_down,
                     EngineStatus& status_up, EngineStatus& status_down,
                     SolutionPoolPtr s_pool);
 
  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);
};
typedef HybridBrancher* HybridBrancherPtr;
} // namespace Minotaur
#endif