AMPLInterface.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURAMPLINTERFACE_H
#define MINOTAURAMPLINTERFACE_H
 
#include "Types.h"
 
//#include "nlp.h"
//#undef filename
 
struct expr;
typedef double efunc(expr*);
struct ASL;
 
namespace Minotaur {
class   CGraph;
class   CNode;
class   Environment;
class   LinearFunction;
class   PolynomialFunction;
class   Problem;
class   QuadraticFunction;
class   Solution;
typedef CGraph* CGraphPtr;
typedef Environment* EnvironmentPtr;
typedef LinearFunction* LinearFunctionPtr;
typedef PolynomialFunction* PolyFunPtr;
typedef QuadraticFunction* QuadraticFunctionPtr;
typedef const Solution* ConstSolutionPtr;
}
 
namespace MINOTAUR_AMPL {
 
class AMPLNonlinearFunction;
typedef AMPLNonlinearFunction* AMPLNlfPtr;
 
typedef enum {
  FReader,    
  FGReader,   
  FGHReader,  
  PFGReader,  
  PFGHReader  
} ReaderType;
 
 
class AMPLInterface;
typedef AMPLInterface * AMPLInterfacePtr;
 
 
// ------------------------------------------------------------------------ //
// ------------------------------------------------------------------------ //
 
class AMPLInterface {
public:
  AMPLInterface(Minotaur::EnvPtr env, std::string solver="minotaurampl");
 
  ~AMPLInterface();
 
  void freeASL();
 
  ASL * getAsl();
 
  const double * getInitialPoint() const;
 
  Minotaur::UInt getNumDefs() const;
 
  ReaderType getReaderType();
 
  Minotaur::ProblemPtr readInstance(std::string fname);
 
  void writeSolution(Minotaur::ConstSolutionPtr sol,
                     Minotaur::SolveStatus status);
 
  void writeProblem(std::ostream &out) const;
private:
  Minotaur::EnvPtr env_;
 
  std::map <efunc*, int> functionMap_;
 
  const double intTol_;
 
  Minotaur::LoggerPtr logger_;
 
  static const std::string me_;
 
  ASL *myAsl_;
 
  int nCons_;
 
  int nDefVars_;
 
  int nDefVarsBco_;
 
  int nDefVarsCo1_;
 
  int nVars_;
 
  ReaderType readerType_;
 
  std::vector<Minotaur::VariablePtr> vars_;
 
  const double zTol_;
 
  void addDefinedVars_(Minotaur::ProblemPtr instance);
 
  void addLinearConstraint_(int i, Minotaur::ProblemPtr problemPtr);
 
  void addLinearObjective_(int i, Minotaur::ProblemPtr problemPtr);
 
  void addLinearTermsFromConstr_(Minotaur::LinearFunctionPtr &lf, int i);
 
  void addLinearTermsFromObj_(Minotaur::LinearFunctionPtr &lf, int i);
 
  void addOptions_();
 
  void addQuadraticConstraint_(int i, Minotaur::ProblemPtr problemPtr);
 
  void addQuadraticDefCons_(Minotaur::ProblemPtr instance);
  void addQuadraticDefCons2_(Minotaur::ProblemPtr instance);
 
  void addQuadraticObjective_(int i, Minotaur::ProblemPtr problemPtr);
 
  void addVariablesFromASL_(Minotaur::ProblemPtr problemPtr);
 
  void addSOS_(Minotaur::ProblemPtr instance);
 
  Minotaur::ProblemPtr copyInstanceFromASL_();
  Minotaur::ProblemPtr copyInstanceFromASL2_();
 
  void createFunctionMap_();
 
  Minotaur::ProblemType findProblemType_();
 
  void findVars_(expr *e_ptr, std::set<int> & vars);
 
 
  Minotaur::CNode* getCGraph_(expr *e_ptr, Minotaur::CGraphPtr cgraph, 
                              Minotaur::ProblemPtr instance);
 
  Minotaur::FunctionType getConstraintsType_();
 
  Minotaur::FunctionType getConstraintType_(int i);
 
  Minotaur::FunctionType getDef1ConstraintType_(int i);
 
  Minotaur::FunctionType getDefConstraintType_(int i);
 
  Minotaur::FunctionType getExpressionType_(expr *e_ptr);
 
  Minotaur::ProblemPtr getInstanceFromASL_(
                                           std::vector<std::set<int> > &vids);
  Minotaur::FunctionType getMultExpressionType_(expr *e_ptr);
 
  Minotaur::FunctionType getObjFunctionType_(Minotaur::UInt obj_index=0);
 
  void getOptionsFromEnv_(std::string pre);
 
  Minotaur::FunctionType getPMExpressionType_(expr *e_ptr);
 
  void getPoly_(Minotaur::LinearFunctionPtr & lfPtr, 
                Minotaur::QuadraticFunctionPtr & qfPtr, 
                Minotaur::PolyFunPtr & pfPtr, 
                double & c, expr *e_ptr);
 
  Minotaur::FunctionType getPow1ExpressionType_(expr *e_ptr);
 
  Minotaur::FunctionType getSumlistExpressionType_(expr *e_ptr);
 
  void readFile_(std::string *fname, ReaderType readerType);
 
  Minotaur::ProblemPtr readInstanceASL_(std::string fname);
  Minotaur::ProblemPtr readInstanceCG_(std::string fname);
 
  void saveNlVars_(std::vector<std::set<int> > &vars);
 
  void unsupportedOp_(int opcode);
 
  void writeExpression_(expr *e_ptr, std::ostream &out) const;
 
  void writeExpression_(int i, bool is_obj, std::ostream &out) const;
 
  void writeLin_(Minotaur::UInt i, bool is_obj, std::ostream &out) const;
};
 
} // namespace MINOTAUR_AMPL
 
#endif