UnambRelBrancher.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURUNAMBRELBRANCHER_H
#define MINOTAURUNAMBRELBRANCHER_H
 
#include "Brancher.h"
 
namespace Minotaur {
 
class Engine;
class Timer;
typedef Engine* EnginePtr;
 
struct UnambRelBrStats {
  UInt bndChange;  
  UInt calls;      
  UInt engProbs;   
  UInt iters;      
  UInt strBrCalls; 
  double strTime;  
};
 
 
class UnambRelBrancher : public Brancher {
 
public:
  UnambRelBrancher(EnvPtr env, HandlerVector & handlers);
 
  ~UnambRelBrancher();
 
  // 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, IntVector candsPos,
                               IntVector candsPosRel,
                               IntVector candsPosUnRel);
 
  void findCandidates_(NodePtr node, IntVector & candPositions,
                               IntVector & candsPosRel, 
                               IntVector & candsPosUnRel);
 
  void freeCandidates_(BrCandPtr no_del);
 
  void getPCScore_(BrCandPtr cand, double *ch_down, double *ch_up, 
                   double *score, NodePtr node, IntVector candsPos,
                   UInt cnt);
 
  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 &index, int i, const double &new_cost, 
                    DoubleVector cost, UIntVector count,
                    bool newCand, bool updateDown, bool strngBrnched, 
                    NodePtr node);
 
  void useStrongBranchInfo_(BrCandPtr cand, const double & chcutoff,
                            double & change_up, double & change_down, 
                            const EngineStatus & status_up,
                            const EngineStatus & status_down,
                            NodePtr node, int candPosition);
 
  void writeScore_(BrCandPtr cand, double score, double change_up, 
                   double change_down);
 
  void writeScores_(std::ostream &out);
 
  void writeScores_(std::ostream &out, NodePtr node, IntVector candsPosRel,
                    IntVector candsPosUnrel);
 
  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_;
 
  UnambRelBrStats * stats_;
 
  BrancherStatus status_;
 
  Timer *timer_;
 
  UIntVector timesDown_;
 
  UIntVector timesUp_;
 
  UInt thresh_;
 
  bool trustCutoff_;
 
  std::vector<BrCandPtr> unrelCands_;
 
  DoubleVector x_;
 
};
typedef UnambRelBrancher* UnambRelBrancherPtr;
}
#endif