UnoEngine.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURUnoENGINE_H
#define MINOTAURUnoENGINE_H
 
#include "NLPEngine.h"
#include "Solution.h"
#include "Uno.hpp"
#include "WarmStart.h"
#include "ingredients/constraint_relaxation_strategy/ConstraintRelaxationStrategyFactory.hpp"
#include "ingredients/globalization_mechanism/GlobalizationMechanismFactory.hpp"
#include "model/ModelFactory.hpp"
#include "tools/Logger.hpp"
#include "tools/Options.hpp"
 
namespace uno
{
class UnoApplication;
class UnoFunInterface;
class Model;
}  // namespace uno
 
namespace Minotaur
{
 
class Environment;
class UnoEngine;
class Problem;
class Timer;
typedef Environment* EnvPtr;
typedef UnoEngine* UnoEnginePtr;
typedef Problem* ProblemPtr;
 
// thread based statistics
struct UnoStats
{
  UInt calls;       
  UInt opt;         
  UInt reopt;       
  UInt iters;       
  double ptime;     
  UInt strCalls;    
  UInt strIters;    
  double strTime;   
  double time;      
  double walltime;  
};
 
class UnoSolution;
typedef UnoSolution* UnoSolPtr;
typedef const UnoSolution* ConstUnoSolPtr;
 
class UnoSolution : public Solution
{
public:
  UnoSolution();
 
  UnoSolution(const double* x, ProblemPtr problem);
 
  UnoSolution(const double* x, double objval, ProblemPtr problem);
 
  UnoSolution(ConstUnoSolPtr);
 
  ~UnoSolution();
 
  const double* getLowerDualOfVars() const
  {
    return dualXLow_;
  };
 
  const double* getUpperDualOfVars() const
  {
    return dualXUp_;
  };
 
  // base class
  void setDualOfVars(const double*)
  {
    assert(!"implement me!");
  };
 
  void setDualOfVars(const double* lower, const double* upper);
 
  void write(std::ostream& out) const;
 
private:
  double* dualXLow_;
 
  double* dualXUp_;
};
 
class UnoWarmStart;
typedef UnoWarmStart* UnoWarmStartPtr;
typedef const UnoWarmStart* ConstUnoWarmStartPtr;
 
class UnoWarmStart : public WarmStart
{
public:
  UnoWarmStart();
 
  UnoWarmStart(ConstUnoWarmStartPtr ws);
 
  ~UnoWarmStart();
 
  UnoSolPtr getPoint();
 
  // Implement WarmStart::hasInfo().
  bool hasInfo();
 
  void setPoint(UnoSolPtr sol);
 
  // Implement WarmStart::write().
  void write(std::ostream& out) const;
 
private:
  UnoSolPtr sol_;
};
 
// ----------------------------------------------------------------------- //
// ----------------------------------------------------------------------- //
 
class UnoEngine : public NLPEngine
{
public:
  friend class Problem;
 
  UnoEngine(EnvPtr env);
 
  ~UnoEngine();
 
  // Base class method
  void addConstraint(ConstraintPtr c);
 
  void changeBound(ConstraintPtr cons, BoundType lu, double new_val);
 
  // Implement Engine::changeBound(VariablePtr, BoundType, double).
  void changeBound(VariablePtr var, BoundType lu, double new_val);
 
  // Implement Engine::changeBound(VariablePtr, double, double).
  void changeBound(VariablePtr var, double new_lb, double new_ub);
 
  // Implement Engine::changeConstraint().
  void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf, double lb,
                        double ub);
 
  // Implement Engine::changeConstraint().
  void changeConstraint(ConstraintPtr, NonlinearFunctionPtr);
 
  // change objective.
  void changeObj(FunctionPtr f, double cb);
 
  void clear();
 
  void disableStrBrSetup();
 
  EnginePtr emptyCopy();
 
  void enableStrBrSetup();
 
  // Implement Engine::fillStats()
  void fillStats(std::vector<double>&);
 
  // get name.
  std::string getName() const;
 
  // Implement Engine::getSolution().
  ConstSolutionPtr getSolution();
 
  // Implement Engine::getSolutionValue().
  double getSolutionValue();
 
  // Implement Engine::getStatus().
  EngineStatus getStatus();
 
  // Implement Engine::getWarmStart().
  ConstWarmStartPtr getWarmStart();
 
  // Implement Engine::getWarmStartCopy().
  WarmStartPtr getWarmStartCopy();
 
  void load(ProblemPtr problem);
 
  // Implement Engine::loadFromWarmStart().
  void loadFromWarmStart(const WarmStartPtr ws);
 
  // Convert 'min f' to 'min -f'.
  void negateObj();
 
  // base class method.
  void removeCons(std::vector<ConstraintPtr>& delcons);
 
  // Implement Engine::resetIterationLimit().
  void resetIterationLimit();
 
  // Implement Engine::setIterationLimit().
  void setIterationLimit(int limit);
 
  // Implement Engine::setDualObjLimit().
  int setDualObjLimit(double)
  {
    return 1;
  };
 
  void setOptionsForSingleSolve();
 
  void setOptionsForRepeatedSolve();
 
  EngineStatus solve();
 
  void writeStats(std::ostream& out) const;
 
private:
  bool bndChanged_;
 
  bool consChanged_;
 
  // double *dual_x_l_;
 
  // double *dual_x_u_;
 
  // double *dual_g_;
 
  EnvPtr env_;
 
  const double etol_;
 
  // bool justLoaded_;
 
  // LoggerPtr logger_;
 
  static const int maxIterLimit_ = 3000;
 
  static const std::string me_;
 
  // uno::UnoApplication  *myapp_;
 
  // usually gets freed automatically when myapp_ is deleted.
  // In case myapp_->Optimize or myapp_->Reoptimize are
  // not called even once, then we have to free it (see
  // UnoStats::opt, reopt).
  // uno::UnoFunInterface *mynlp_;
 
  // bool prepareWs_;
 
  // bool presolve_();
 
  ProblemPtr problem_;
  std::unique_ptr<uno::Uno> uno_;
  std::shared_ptr<uno::Iterate> initial_iterate;
  std::shared_ptr<uno::Model> model_;
  std::unique_ptr<uno::Model> uno_model_;
  uno::Options options;
  UnoSolPtr sol_;
 
  // UnoStats *stats_;
 
  // bool strBr_;
 
  // Timer *timer_;
 
  // bool useWs_;
 
  // UnoWarmStartPtr ws_;
 
  // UnoWarmStartPtr wsSb_;
 
  void setOptionsForProb_();
};
}  // namespace Minotaur
 
#endif