KnapCovHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURKNAPCOVHANDLER_H
#define MINOTAURKNAPCOVHANDLER_H
 
#include "Handler.h"
#include "Types.h"
#include "Solution.h"
#include "Variable.h"
#include "Relaxation.h"
#include "CoverCutGenerator.h"
 
namespace Minotaur {
 
  // Pointers for knapsack cover cut handler are defined.
  class KnapCovHandler;
  typedef KnapCovHandler *KnapCovHandlerPtr;
  typedef const KnapCovHandler *ConstKnapCovHandler;
 
  class Logger;
 
 
  struct KCStats
  {
    UInt knaps;     
    UInt cuts;      
    UInt extended;  
    UInt simple;    
    UInt gns;       
    UInt singlectwo;  
    double time;  
    UInt cutdel;  
  };
 
  class KnapCovHandler : public Handler {
  public:
    KnapCovHandler();
 
    KnapCovHandler(EnvPtr env, ProblemPtr problem);
 
    ~KnapCovHandler();
 
    void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) {};
 
    void relaxInitInc(RelaxationPtr, SolutionPool *, bool *) {};
 
    void relaxNodeFull(NodePtr, RelaxationPtr, bool *) {};
 
    void relaxNodeInc(NodePtr, RelaxationPtr, bool *) {};
 
    bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation,
                    bool &should_prune, double &inf_meas);
 
 
    void separate(ConstSolutionPtr, NodePtr, RelaxationPtr,
                  CutManager *cutman, SolutionPoolPtr, ModVector &p_mods,
                  ModVector &r_mods, bool *, SeparationStatus *status);
 
    virtual void getBranchingCandidates(RelaxationPtr, const DoubleVector &,
                                        ModVector &, BrVarCandSet &,
                                        BrCandVector &, bool &) {};
 
    virtual ModificationPtr getBrMod(BrCandPtr, DoubleVector &, RelaxationPtr,
                                     BranchDirection)
    {
      return ModificationPtr();
    };
 
    virtual Branches getBranches(BrCandPtr, DoubleVector &, RelaxationPtr,
                                 SolutionPoolPtr)
    {
      return Branches();
    };
 
    SolveStatus presolve(PreModQ *, bool *, Solution **) { return Finished; };
 
    //void postsolveGetX(const double *, UInt, DoubleVector *) {};
 
    // Does nothing.
    virtual bool presolveNode(RelaxationPtr, NodePtr, SolutionPoolPtr,
                              ModVector &, ModVector &)
    {
      return false;
    };
 
    // Write name.
    std::string getName() const;
 
    void writeStats(std::ostream &) const;
 
    // void updateStats(ConsCovCutGenStatsPtr covstats);
 
    // Return specific statistics.
    UInt KC_knaps() { return stats_->knaps; }
    UInt KC_cuts() { return stats_->cuts; }
    UInt KC_extended() { return stats_->extended; }
    UInt KC_simple() { return stats_->simple; }
    UInt KC_gns() { return stats_->gns; }
    UInt KC_singlectwo() { return stats_->singlectwo; }
    double KC_time() { return stats_->time; }
 
  private:
    EnvPtr env_;
 
    ProblemPtr minlp_;
 
    LoggerPtr logger_;
 
    KCStats *stats_;
 
    // Number of variables in the MINLP.
    size_t numvars_;
 
    double intTol_;
 
    static const std::string me_;
  };
}  //namespace Minotaur
 
 
#endif  // MINOTAURKNAPCOVHANDLER_H