MultiSolHeur.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull  
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
#ifndef MULTISOLHEUR_H
#define MULTISOLHEUR_H
 
#include "CutManager.h"
#include "Heuristic.h"
#include "MILPEngine.h"
#include "Relaxation.h"
#include "Solution.h"
#include "Types.h"
 
namespace Minotaur {
  class Engine;
  class Problem;
 
  struct MultiSolHeurStats {
    UInt milpS;        
    UInt nlpS;         
    UInt nlpLim;        
    UInt nlpInf;       
    UInt nlpOthr;      
    UInt cuts;         
    double time;       
  };
 
  class MultiSolHeur : public Heuristic {
 
  public:
 
    MultiSolHeur();
 
    MultiSolHeur(EnvPtr env, ProblemPtr p, EnginePtr nlpe, MILPEnginePtr milpe);
    virtual ~MultiSolHeur();
 
    //to ub
    void solveAtSol(ConstSolutionPtr sol, RelaxationPtr rel, SolutionPoolPtr sPool);
 
    void solve(NodePtr, RelaxationPtr, SolutionPoolPtr) {};
 
    void writeStats(std::ostream &out) const;
 
  private:
 
    const static std::string me_;
    
    EnvPtr env_;
 
    ProblemPtr minlp_;
    
    ProblemPtr miqp_;
 
    EnginePtr nlpe_;
    
    MILPEnginePtr milpe_;
    
    //SolutionPoolPtr sPool_;
 
    LoggerPtr logger_;
 
    double ub_;
    
    double lb_;
  
    VariablePtr objVar_;
 
    SolutionPtr bestSol_;
  
    bool newSolFound_;
 
    double intTol_;
 
    double objATol_;
    
    double solATol_;
 
    double objRTol_;
    
    double solRTol_;
 
    std::vector<ConstraintPtr> nlCons_;
 
    double * xC_;
 
    MultiSolHeurStats* stats_;
 
    Timer* timer_;
  
  
  
    std::stack<Modification *> mods_; 
    
    void cutToCons_(const double *nlpx, const double *lpx,
                           SeparationStatus *status);
 
    void cutsAtLpSol_(const double *lpx, SeparationStatus *status);
 
    void addCut_(const double *nlpx, const double *lpx,
                        ConstraintPtr con,
                        SeparationStatus *status);
 
    void linearAt_(FunctionPtr f, double fval, const double *x,
                          double *c, LinearFunctionPtr *lf, int *error);
 
    FunctionPtr newObj_(const double * x0, const double * x);
    void relMods_(const double *x);
 
    void undoMods_();
 
    void solveMILP(SolveStatus &status);
    //void solveMILP(RelaxationPtr rel, SolveStatus &status);
 
    void findCenter_();
 
    void findSol_(ConstSolutionPtr sol, SolutionPoolPtr sPool,
                            bool &isTerm,
                            //double oldBest, bool &isTerm,
                            std::vector<SolutionPtr> & infSols,
                            std::vector<SolutionPtr> & limSols);
    void ifOnlyNonlinObj_();  
 
    void ifNonlinCons_();
    
    void improveSol_(const double * x0);
 
    void itrMilpSolve_(SolutionPoolPtr sPool);
 
    void fixInts_(const double *x);
 
    void newMIQP_(RelaxationPtr rel, const double * x0,
                            SolutionPoolPtr sPool);
 
    void solveNLP_();
 
    void unfixInts_();
 
  };
 
  typedef MultiSolHeur* MultiSolHeurPtr;
 
}
 
#endif