MINLPDiving.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull  
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
 #ifndef MINOTAURMINLPDIVING_H
 #define MINOTAURMINLPDIVING_H
 
 #include "Heuristic.h"
 #include <vector>
 #include <stack>
 #include "Types.h"
 
 namespace Minotaur {
   class Engine;
   class LinearHandler;
   class Problem;
   class Solution;
   class Timer;
   class VarBoundMod;
   typedef const Solution* ConstSolutionPtr;
   typedef VarBoundMod* VarBoundModPtr;
 
   typedef enum {
     Floor,        
     Ceil,         
     Nearest,      
     Farthest      
   } Direction;
 
   typedef enum {
     Least,     
     Most       
   } Order;
 
   typedef enum {
     Fractional,     
     VectorLength,   
     LexBound,       
     ReducedCost     
   } Scoretype;
 
   struct DivingheurStats {
     UInt numNLPs[4];       
     UInt numInfeas[4];     
     UInt errors[4];        
     UInt numSol[4];        
     double time[4];        
     UInt iterations[4];    
     UInt totalNLPs;        
     UInt totalSol;         
     UInt numLocal;         
     double best_obj_value; 
     double totalTime;      
   };
 
   class MINLPDiving : public Heuristic {
   public:
 
     MINLPDiving(EnvPtr env, ProblemPtr p, EnginePtr e);
 
     ~MINLPDiving();
 
     void solve(NodePtr node, RelaxationPtr rel, SolutionPoolPtr s_pool); 
 
     void writeStats(std::ostream &out) const;
 
   protected:
 
     const static std::string me_;
 
     DoubleVector avgDual_;
 
     EnginePtr e_;
 
     EnvPtr env_;
 
     double* gradientObj_;
 
     double intTol_;
 
     ModVector lastNodeMods_;
 
     LinearHandler *lh_;
 
     LoggerPtr logger_;
 
     UInt maxNLP_;
 
     UInt maxSol_;
 
     std::stack<VarBoundModPtr> mods_;
 
     UInt nSelector_;
 
     ProblemPtr p_;
 
     DoubleVector score_;
 
     DivingheurStats *stats_;
 
     Timer* timer_;
 
     UIntVector violated_;
 
     typedef UInt (MINLPDiving::*FuncPtr) (UInt numfrac, 
                                           const double* x, Direction d, Order o);
 
     void backtrack_(UInt n_flipped);
 
     UInt FracBounds_(UInt numfrac, const double* x, 
                      Direction d, Order o);
 
     void getScore_(const double* x, Scoretype s);
 
     void implementDive_(int i, const double*x, SolutionPoolPtr s_pool);
 
     UInt isFrac_(const double* x);
 
     UInt LexBounds_(UInt numfrac, const double* x, 
                     Direction d, Order o);
 
     UInt ReducedCost_(UInt numfrac, const double* x, 
                       Direction d, Order o);
 
     void restoreBounds_(double* LB_copy, double* UB_copy, UInt vars);
 
     double rounding_(double value, Direction d);
 
     void saveBounds_(double* LB_copy, double* UB_copy, UInt vars);
 
     FuncPtr selectHeur_(int i, Direction &d, Order &o);
 
     bool shouldDive_();
 
     void sort_(UInt left, UInt right);
 
     void updateAvgDual_(ConstSolutionPtr sol);
 
     UInt VectorLength_(UInt numfrac, const double* x, 
                        Direction d, Order o);
 
     bool vectorFlag_(UInt min_vlength);
 
   };
 
   typedef MINLPDiving* MINLPDivingPtr;
}
#endif