conopt.hpp

Go to the documentation of this file.

 
#ifndef _CONOPT_HPP_
#define _CONOPT_HPP_
 
#include <algorithm>
#include <array>
#include <string>
#include <vector>
 
#include "conopt.h"
 
class ConoptMessageHandler;
class ConoptModelData;
class ConoptSolution;
class ConoptStatus;

class Conopt {
public:
  static constexpr double Infinity = 1e+20;

   COI_API Conopt(std::string modelName = "conopt-model");

   COI_API ~Conopt();

   COI_API int solve();

   COI_API int checkModelAndParameters();

   COI_API coiHandle_t controlVector();

   COI_API void printStatus();

   COI_API std::string getName();
 
   /* model data methods */

   COI_API void loadModel(ConoptModelData& modeldata);
 
   /* optimisation status methods */

   COI_API int modelStatus();

   COI_API int solutionStatus();

   COI_API int iterations();

   COI_API double objectiveValue();
 
   /* solution methods */

   COI_API const std::vector<double>& getVariableValues();

   COI_API const std::vector<double>& getVariableMarginals();

   COI_API const std::vector<int>& getVariableBasisStatus();

   COI_API const std::vector<int>& getVariableStatus();

   COI_API const std::vector<double>& getConstraintValues();

   COI_API const std::vector<double>& getConstraintMarginals();

   COI_API const std::vector<int>& getConstraintBasisStatus();

   COI_API const std::vector<int>& getConstraintStatus();
 
   /* message handler methods */

   COI_API void setMessageHandler(ConoptMessageHandler& msghandler);

   COI_API int sendMessage(std::string msg);

   COI_API void setVerbosityLevel(int verblevel);
 
#if 0
 
 
   virtual int Option(int ncall, double* rval, int* ival, int* lval, char* name, void* usrmem)
   {
      return 0;
   }

   virtual int TriOrd(int mode, int type, int status, int rowno, int colno, int inf, double value, double resid,
      void* usrmem)
   {
      return 0;
   }
 
 
#endif

   static COI_API std::array<int, 3> version();

   COI_API int debugFV(int debugfv);

   COI_API int squareModel(int square);

   COI_API int setLicense(int licint1, int licint2, int licint3, std::string licstring);

   COI_API int setItLim(int itlim);

   COI_API int setErrLim(int errlim);

   COI_API int fVincLin(int fvinclin);

   COI_API int fVforAll(int fvforall);

   COI_API int setMaxSup(int maxsup);

   COI_API int allowEmptyRow(int emptyrow);

   COI_API int allowEmptyCol(int emptycol);

   COI_API int debug2D(int debug2d);

   COI_API int disCont(int discont);
 

   COI_API int clearM(int clearm);

   COI_API int setResLim(double reslim);

   COI_API int setMaxHeap(double maxheap);

   COI_API int setThreadS(int threads);

   COI_API int setThreadF(int threadf);

   COI_API int setThread2D(int thread2d);

   COI_API int setThreadC(int threadc);

   COI_API int getMaxThreads();

   COI_API double getMaxHeapUsed();

   COI_API int getRangeErrors();
 
private:
   std::string name;
 
   int coi_error_;
   coiHandle_t cntVect_;
 
   ConoptModelData* modeldata_;
   ConoptSolution* solution_;
   ConoptStatus* status_;
 
   /* message handling objects. We create a default message handler, which can be replaced by the user if necessary */
   ConoptMessageHandler* defmessage_;
   ConoptMessageHandler* message_;
};
 
/*******************
 * ConoptModelData *
 *******************/
 
#ifdef _MSC_VER
#pragma warning( push )
// disable warning on using STL (members without a DLL interface) in ConoptModelData (class with a DLL interface)
#pragma warning( disable: 1744 )
#endif

enum class ConoptConstraintType
{
   Eq = 0,     
   GtEq,       
   LtEq,       
   Free        
};

enum class ConoptObjectiveElement
{
   Variable = 0,     
   Constraint        
};

enum class ConoptSense
{
   Minimize = -1,    
   Maximize = 1      
};

enum class ConoptSDEvaluationType
{
   None = 0,
   Constraint,
   Lagrangian
};

struct ConoptVariable
{
   ConoptVariable(int idx, double low, double up, double cur = 0, int varstat = -1)
      :  index(idx),
         lower(low),
         upper(up),
         curr(cur),
         varstatus(varstat)
   {
      consindex_.clear();
      value_.clear();
      nlflag_.clear();
 
      sortorder_.clear();
   }

   void addNonzero(int conindex, double value, int nlflag)
   {
      sortorder_.push_back(consindex_.size());
 
      consindex_.push_back(conindex);
      value_.push_back(value);
      nlflag_.push_back(nlflag);
 
   }

   void sortNonzeros()
   {
      std::sort(sortorder_.begin(), sortorder_.end(),
         [&](int a, int b){
            return consindex_[a] < consindex_[b];
         });
   }
 
   int index;        
   double lower;     
   double upper;     
   double curr;      
   int varstatus;    
 
   /* matrix information */
   std::vector<int> consindex_;     
   std::vector<double> value_;      
   std::vector<int> nlflag_;        
 
   /* information required to sort the non-zeros by consindex */
   std::vector<int> sortorder_;     
};
 

struct ConoptConstraint
{
   ConoptConstraint(int idx, ConoptConstraintType type, double bound, int slackstat)
      :  index(idx),
         constype(type),
         rhs(bound),
         slackstatus(slackstat)
   {
   }
 
   int index;                 
   ConoptConstraintType constype; 
   double rhs;                
   int slackstatus;           
};
 

class COI_API ConoptModelData {
public:
   ConoptModelData();

   virtual ~ConoptModelData();

   virtual int readMatrix(double lower[], double curr[], double upper[], int vsta[], int type[], double rhs[],
      int esta[], int colsta[], int rowno[], double value[], int nlflag[], int numvar, int numcon, int numnz);

   void setProblemDimension(
      unsigned int   numvar,                 
      unsigned int   numcons,                
      unsigned int   numnz,                  
      unsigned int   numnlnz                 
   );

   int addConstraint(
      ConoptConstraintType constype,         
      double         rhs,                    
      int            slackstatus = -1        
   );

   int addConstraint(
      ConoptConstraintType constype,         
      double         rhs,                    
      const std::vector<int>& varindex,      
      const std::vector<double>& value,      
      const std::vector<int>&    nlflag,     
      int            slackstatus = -1        
   );

   int addVariable(
      double         lower,                  
      double         upper,                  
      double         curr = 0,               
      int            varstatus = -1          
   );

   int addVariable(
      double         lower,                  
      double         upper,                  
      const std::vector<int>& consindex,     
      const std::vector<double>& value,      
      const std::vector<int>&    nlflag,     
      double         curr = 0,               
      int            varstatus = -1          
   );

   void setObjectiveElement(ConoptObjectiveElement elem, int elemindex);

   void setOptimizationSense(ConoptSense sense);

   void setInitialStatusOption(int inistat);

   int numVar() const;

   int numCons() const;

   int numHessianNonzeros() const;

   const ConoptVariable& getVariable(int index) const;

   ConoptVariable& getVariable(int index);

   const ConoptConstraint& getConstraint(int index) const;

   ConoptConstraint& getConstraint(int index);

   void setSDEvaluationType(ConoptSDEvaluationType sdevaltype);

   void setSDLagrangianStructure(
      const std::vector<int>& rownum,        
      const std::vector<int>& colnum         
   );

   const std::vector<int>& getSDLagrangianRowNumbers() const;

   const std::vector<int>& getSDLagrangianColumnNumbers() const;
 
   /* callback methods for function and derivative evaluations */

   virtual int FDEval(const double x[], double* g, double jac[], int rowno, const int jacnum[], int mode, int ignerr,
      int* errcnt, int numvar, int numjac, int thread)
   {
      return 0;
   }
 
   /* The optional callback routines for first derivative evaluations */

   virtual int FDEvalIni(const double x[], const int rowlist[], int mode, int listsize, int numthread, int ignerr,
      int* errcnt, int numvar)
   {
      return 0;
   }

   virtual int FDEvalEnd(int ignerr, int* errcnt)
   {
      return 0;
   }

   virtual int FDInterval(const double xmin[], const double xmax[], double* gmin, double* gmax, double jmin[],
      double jamx[], int rowno, const int jacnum[], int mode, double pinf, int numvar, int numjac)
   {
      return 0;
   }
 
   /* The optional callback routines for the second derivative evaulations */
 
#if 0 // not sure whether this is needed to C and C++.
   virtual int SDLagrSize(int* nodrv, int numvar, int numcon, int* nhess, int maxhess)
   {
      return 0;
   }
#endif

   virtual int SDLagrVal(const double x[], const double u[], const int hsrw[], const int hscl[], double hsvl[],
      int* nodrv, int numvar, int numcon, int nhess)
   {
      return 0;
   }

   virtual int SDDirLagr(const double x[], const double dx[], const double u[], double d2g[], int newpt, int* nodrv,
      int numvar, int numcon)
   {
      return 0;
   }

   virtual int SDDir(const double x[], const double dx[], double d2g[], int rowno, const int jacnum[], int* nodrv,
      int numvar, int numjac, int thread)
   {
      return 0;
   }

   virtual int SDDirIni(const double x[], const double dx[], const int rowlist[], int listsize, int numthread,
      int newpt, int* nodrv, int numvar)
   {
      return 0;
   }

   virtual int SDDirEnd(int* nodrv)
   {
      return 0;
   }
 
 
 
   friend class Conopt;
 
private:
 
   /* clears the model data */
   void clear()
   {
      variables_.clear();
      constraints_.clear();
 
      hessrownum_.clear();
      hesscolnum_.clear();
 
      numvar_ = 0;
      numcons_ = 0;
      numnz_ = 0;
      numnlnz_ = 0;
      numhessnz_ = -1;
      optsense_ = (int)(ConoptSense::Minimize);
      objectivecon_ = -1;
      objectivevar_ = -1;
 
      inistat_ = 0;
   }
 
   unsigned int numvar_;
   unsigned int numcons_;
   unsigned int numnz_;
   unsigned int numnlnz_;
   int numhessnz_;
   int optsense_;
   int objectivecon_;
   int objectivevar_;
 
   int inistat_;
 
   bool probdimset_;
   ConoptSDEvaluationType sdevaltype_;
 
   std::vector<ConoptVariable> variables_;
   std::vector<ConoptConstraint> constraints_;
 
   std::vector<int> hessrownum_;
   std::vector<int> hesscolnum_;
};
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
/************************
 * ConoptMessageHandler *
 ************************/
 
#ifdef _MSC_VER
#pragma warning( push )
// disable warning on using STL (members without a DLL interface) in ConoptMessageHandler (class with a DLL interface)
#pragma warning( disable: 1744 )
#endif

enum class ConoptVerbosityLevel
{
   VerbLevelMin = 0,
   None,          
   Normal,        
   Error,         
   Debug,         
   VerbLevelMax
};
 
struct ConoptAlgProgress
{
   int               iteration;              
   int               phase;                  
   int               numinfeas;              
   int               numnopt;                
   int               numsuper;               
   double            suminfeas;              
   double            objvalue;               
   double            rgmax;                  
   double            step;                   
   int               numvar;                 
};

class COI_API ConoptMessageHandler {
public:
   ConoptMessageHandler();

   virtual ~ConoptMessageHandler();

   virtual int message(
      int            smsg,                   
      int            dmsg,                   
      int            nmsg,                   
      const std::vector<std::string>& msgv   
   );

   virtual int errorMessage(
      int            rowno,                  
      int            colno,                  
      int            posno,                  
      const std::string& msg                 
   );
 
   virtual int progress(
      const ConoptAlgProgress& progressdata  
   )
   {
      return 0;
   }

   int sendMessage(const std::string& msg);

   void setVerbosityLevel(ConoptVerbosityLevel verblevel);
 
   friend class Conopt;
private:
   ConoptVerbosityLevel verblevel_;
};
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif // _CONOPT_HPP_