LinearHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURLINEARHANDLER_H
#define MINOTAURLINEARHANDLER_H
 
#include "Handler.h"
 
namespace Minotaur
{
 
struct LinPresolveStats {
  int iters;    
  double time;  
  double timeN; 
  int varDel;   
  int conDel;   
  int var2Bin;  
  int var2Int;  
  int vBnd;     
  int cBnd;     
  int cImp;     
  int bImpl;    
  int nMods;    
};
 
struct LinPresolveOpts {
  bool doPresolve; 
 
  bool showStats; 
 
  int maxIters; 
 
  bool purgeVars; 
 
  bool purgeCons; 
 
  bool dualFix; 
 
  bool coeffImp; 
};
 
class LinearHandler : public Handler
{
public:
  LinearHandler();
 
  LinearHandler(EnvPtr env, ProblemPtr problem);
 
  ~LinearHandler();
 
  // Does nothing.
  void relaxInitFull(RelaxationPtr rel, SolutionPool* sp, bool* is_inf);
 
  // Does nothing.
  void relaxInitInc(RelaxationPtr rel, SolutionPool* sp, bool* is_inf);
 
  // Does nothing.
  void relaxNodeFull(NodePtr node, RelaxationPtr rel, bool* is_inf);
 
  // Does nothing.
  void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool* is_inf);
 
  bool isFeasible(ConstSolutionPtr, RelaxationPtr, bool&, double&)
  {
    return true;
  }
 
  bool isNeeded()
  {
    return true;
  }
 
  void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel,
                CutManager* cutman, SolutionPoolPtr s_pool, ModVector& p_mods,
                ModVector& r_mods, bool* sol_found, SeparationStatus* status);
 
  virtual void getBranchingCandidates(RelaxationPtr, const DoubleVector&,
                                      ModVector&, BrVarCandSet&, BrCandVector&,
                                      bool&){};
 
  virtual ModificationPtr getBrMod(BrCandPtr, DoubleVector&, RelaxationPtr,
                                   BranchDirection)
  {
    return ModificationPtr();
  }; // NULL
 
  virtual Branches getBranches(BrCandPtr, DoubleVector&, RelaxationPtr,
                               SolutionPoolPtr)
  {
    return Branches();
  }; // NULL
 
  // presolve.
  virtual SolveStatus presolve(PreModQ* pre_mods, bool* changed,
                               Solution** sol);
 
  // Implement Handler::presolveNode().
  virtual bool presolveNode(RelaxationPtr p, NodePtr node,
                            SolutionPoolPtr s_pool, ModVector& p_mods,
                            ModVector& r_mods);
 
  // Write name
  virtual std::string getName() const;
 
  const LinPresolveOpts* getOpts() const;
 
  void setPreOptMaxIters(int val)
  {
    pOpts_->maxIters = val;
  };
 
  void setPreOptPurgeVars(bool val)
  {
    pOpts_->purgeVars = val;
  };
 
  void setPreOptPurgeCons(bool val)
  {
    pOpts_->purgeCons = val;
  };
 
  void setPreOptDualFix(bool val)
  {
    pOpts_->dualFix = val;
  };
 
  void setPreOptCoeffImp(bool val)
  {
    pOpts_->coeffImp = val;
  };
 
  void simplePresolve(ProblemPtr p, SolutionPoolPtr spool, ModVector& t_mods,
                      SolveStatus& status);
 
  void writePreStats(std::ostream& out) const;
 
  // Write statistics.
  void writeStats(std::ostream& out) const;
 
protected:
  EnvPtr env_;
 
  ProblemPtr problem_;
 
  LoggerPtr logger_;
 
 
  const double intTol_;
 
  bool chkDupRows_;
 
  const double eTol_;
 
  const double infty_;
 
  LinPresolveStats* pStats_;
 
  LinPresolveOpts* pOpts_;
 
  VarQueue linVars_;
 
  static const std::string me_;
 
  void chkIntToBin_(VariablePtr v);
 
  void chkSing_(bool* changed);
 
  void coeffImp_(bool* changed);
  void computeImpBounds_(ConstraintPtr c, VariablePtr z, double zval,
                         double* lb, double* ub);
  void copyBndsFromRel_(RelaxationPtr rel, ModVector& p_mods);
 
  void delFixedVars_(bool* changed);
 
  void dualFix_(bool* changed);
  void domRows_(bool* changed);
  void dupRows_(bool* changed);
 
  SolveStatus checkBounds_(ProblemPtr p);
 
  void changeBFlag_(VariablePtr v);
 
  void findLinVars_();
 
  void findAllBinCons_();
  void fixToCont_();
 
  void getLfBnds_(LinearFunctionPtr lf, double* lo, double* up);
  void getSingLfBnds_(LinearFunctionPtr lf, double* lo, double* up);
 
  SolveStatus linBndTighten_(ProblemPtr p, bool apply_to_prob,
                             ConstraintPtr c_ptr, bool* changed, ModQ* mods,
                             UInt* nintmods);
 
  void purgeVars_(PreModQ* pre_mods);
 
  void relax_(ProblemPtr p, RelaxationPtr rel, bool* is_inf);
 
  void substVars_(bool* changed, PreModQ* pre_mods);
 
  void tightenInts_(ProblemPtr p, bool apply_to_prob, bool* changed,
                    ModQ* mods);
 
  bool treatDupRows_(ConstraintPtr c1, ConstraintPtr c2, double mult,
                     bool* changed);
 
  void updateLfBoundsFromLb_(ProblemPtr p, bool apply_to_prob,
                             LinearFunctionPtr lf, double lb, double uu,
                             bool is_sing, bool* changed, ModQ* mods,
                             UInt* nintmods);
 
  void updateLfBoundsFromUb_(ProblemPtr p, bool apply_to_prob,
                             LinearFunctionPtr lf, double ub, double ll,
                             bool is_sing, bool* changed, ModQ* mods,
                             UInt* nintmods);
 
  SolveStatus varBndsFromCons_(ProblemPtr p, bool apply_to_prob, bool* changed,
                               ModQ* mods, UInt* nintmods);
 
  SolveStatus varBndsFromObj_(ProblemPtr p, double ub, bool apply_to_prob,
                              bool* changed, ModQ* mods);
};
typedef LinearHandler* LinearHandlerPtr;
typedef const LinearHandler* ConstLinearHandlerPtr;
} // namespace Minotaur
#endif