Handler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURHANDLER_H
#define MINOTAURHANDLER_H
 
#include "Types.h"
 
namespace Minotaur
{
 
class CutManager;
class Engine;
class Node;
class Relaxation;
class PreMod;
class Solution;
class SolutionPool;
class Solution;
typedef Relaxation* RelaxationPtr;
typedef PreMod* PreModPtr;
typedef const Solution* ConstSolutionPtr;
typedef SolutionPool* SolutionPoolPtr;
typedef std::deque<PreModPtr> PreModQ;
typedef PreModQ::iterator PreModQIter;
typedef PreModQ::const_iterator PreModQConstIter;
 
class Handler
{
public:
  Handler(){};
 
  virtual ~Handler(){};
 
  virtual void addConstraint(ConstraintPtr newcon)
  {
    cons_.push_back(newcon);
  };
 
  virtual ConstraintVector::const_iterator consBegin() const
  {
    return cons_.begin();
  };
 
  virtual ConstraintVector::const_iterator consEnd() const
  {
    return cons_.end();
  };
 
  virtual int fixNodeErr(RelaxationPtr, ConstSolutionPtr, SolutionPoolPtr,
                         bool&);
 
  virtual Branches getBranches(BrCandPtr cand, DoubleVector& x,
                               RelaxationPtr rel, SolutionPoolPtr s_pool) = 0;
 
  virtual void getBranchingCandidates(RelaxationPtr rel, const DoubleVector& x,
                                      ModVector& mods, BrVarCandSet& cands,
                                      BrCandVector& gencands, bool& is_inf) = 0;
 
  virtual ModificationPtr getBrMod(BrCandPtr cand, DoubleVector& x,
                                   RelaxationPtr rel, BranchDirection dir) = 0;
 
  virtual std::string getName() const = 0;
 
  bool getStrongerMods(RelaxationPtr rel, NodePtr node, SolutionPoolPtr s_pool,
                       ModVector& p_mods, ModVector& r_mods);
  virtual bool isFeasible(ConstSolutionPtr sol, RelaxationPtr rel,
                          bool& should_prune, double& inf_meas) = 0;
 
  virtual bool isNeeded()
  {
    return !cons_.empty();
  }
 
  virtual SolveStatus presolve(PreModQ* pre_mods, bool* changed,
                               Solution** sol) = 0;
 
  virtual bool presolveNode(RelaxationPtr rel, NodePtr node,
                            SolutionPoolPtr s_pool, ModVector& p_mods,
                            ModVector& r_mods) = 0;
 
  virtual bool postSolveRootNode(RelaxationPtr, SolutionPoolPtr,
                                 ConstSolutionPtr, ModVector&, ModVector&)
  {
    // Do Nothing
    // Only used for QuadHandler as of now
    return true;
  };
 
  virtual void relaxInitFull(RelaxationPtr rel, SolutionPool *sp,
                             bool* is_inf) = 0;
 
  virtual void relaxInitInc(RelaxationPtr rel, SolutionPool *sp,
                            bool* is_inf) = 0;
 
  virtual void relaxNodeFull(NodePtr node, RelaxationPtr rel, bool* is_inf) = 0;
 
  virtual void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool* is_inf) = 0;
 
  virtual void removeCuts(RelaxationPtr, ConstSolutionPtr) { }
 
  virtual void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel,
                        CutManager* cutman, SolutionPoolPtr s_pool,
                        ModVector& p_mods, ModVector& r_mods, bool* sol_found,
                        SeparationStatus* status) = 0;
 
  virtual void setModFlags(bool mod_prob, bool mod_rel)
  {
    modProb_ = mod_prob;
    modRel_ = mod_rel;
  };
 
  virtual void simplePresolve(ProblemPtr, SolutionPoolPtr, ModVector&,
                              SolveStatus& status)
  {
    // Do Nothing
    status = Finished;
  }
 
  void undoStrongerMods(ProblemPtr p, RelaxationPtr rel, ModVector& p_mods,
                        ModVector& r_mods);
 
  virtual void writeStats(std::ostream&) const {};
 
protected:
  ConstraintVector cons_;
 
  bool modProb_;
 
  bool modRel_;
};
 
} // namespace Minotaur
#endif