square2.cpp

Go to the documentation of this file.

 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include "conopt.hpp"
 
class Sq2_ModelData : public ConoptModelData
{
public:
   Sq2_ModelData() {}

   void buildModel()
   {
      /*   Information about Variables:                                */
      /*   Default: Lower = -Inf, Curr = 0, and Upper = +inf.          */
      /*   Default: the status information in Vsta is not used.        */
      /*                                                               */
      /*   Model  x0 + x1 = 10                                         */
      /*          x0 - x1 = 0                                          */
      /*          x0 + x1 <= 9                                         */
      /*                                                               */
      addVariable(-Conopt::Infinity, Conopt::Infinity, 0.0); // x0
      addVariable(-Conopt::Infinity, Conopt::Infinity, 0.0); // x1
 
      /*   Information about Constraints:                              */
      /*   Default: Rhs = 0                                            */
      /*   Default: the status information in Esta and the function    */
      /*            value in FV are not used.                          */
      /*   Default: Type: There is no default.                         */
      /*            0 = Equality,                                      */
      /*            1 = Greater than or equal,                         */
      /*            2 = Less than or equal,                            */
      /*            3 = Non binding.                                   */
      /*                                                                         */
      /*   Nonlinearity Structure: L = 0 are linear and NL = 1 are nonlinear     */
      /*   Although the model is linear we label constraint 1 and 2 as nonlinear */
      /*   Value (Linear only)                                                   */
      /*        X[0]  X[1]                                                       */
      /*   0:    1     1                                                         */
      /*   1:    NL    NL                                                        */
      /*   2:    NL    NL                                                        */
      /*                                                                         */
      /*                                                               */
      /*   Constraint 0                                                */
      /*   Rhs = 10 and type Equality                                  */
      /*                                                               */
      addConstraint(ConoptConstraintType::Eq, 10.0, {0, 1}, {1, 1}, {0, 0});
 
      /*                                                               */
      /*   Constraint 1                                                */
      /*   Rhs = 0 and type Equality                                   */
      /*                                                               */
      addConstraint(ConoptConstraintType::Eq, 0.0, {0, 1}, {0, 0}, {1, 1});
 
      /*                                                               */
      /*   Constraint 2                                                */
      /*   Rhs = 9 and type Less Than Inequality                       */
      /*                                                               */
      addConstraint(ConoptConstraintType::LtEq, 9.0, {0, 1}, {0, 0}, {1, 1});
   }

   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) override
   {
      /*                                                                   */
      /*   Row 0: linear                                                   */
      /*                                                                   */
      if (rowno == 0)
      {
         return 1; /* This should not happen                             */
      }
      /*                                                                   */
      /*   Row 1: The function appers as nonlinear                         */
      /*                                                                   */
      else if (rowno == 1)
      {
         /*                                                                   */
         /*   Mode = 1 or 3: Function value                                   */
         /*                                                                   */
         if (mode == 1 || mode == 3)
            *g = x[0] - x[1];
         /*                                                                   */
         /*   Mode = 2 or 3: Derivatives                                      */
         /*                                                                   */
         if (mode == 2 || mode == 3)
         {
            jac[0] = 1.;
            jac[1] = -1.;
         }
      }
      /*                                                                   */
      /*   Row 2: The function appers as nonlinear                         */
      /*                                                                   */
      else if (rowno == 2)
      {
         /*                                                                   */
         /*   Mode = 1 or 3: Function value                                   */
         /*                                                                   */
         if (mode == 1 || mode == 3)
            *g = x[0] + x[1];
         /*                                                                   */
         /*   Mode = 2 or 3: Derivatives                                      */
         /*                                                                   */
         if (mode == 2 || mode == 3)
         {
            jac[0] = 1.;
            jac[1] = 1.;
         }
      }
      return 0;
   }
};
 
#include "std.cpp"

int main(int argc, char **argv)
{
   int COI_Error = 0;
 
   // getting the program name from the executable path
   std::string pname = getProgramName(argv[0]);
 
   // initialising the Conopt Object
   Conopt conopt(pname);
   Sq2_ModelData modeldata;
   Tut_MessageHandler msghandler(pname);
 
   // adding the message handler to the conopt interface
   conopt.setMessageHandler(msghandler);
 
   // building the model
   modeldata.buildModel();
 
   // loading the model in the conopt object
   conopt.loadModel(modeldata);
 
   // tell conopt this is a square system (critical!)
   conopt.squareModel(1);
 
#if defined(CONOPT_LICENSE_INT_1) && defined(CONOPT_LICENSE_INT_2) &&                              \
      defined(CONOPT_LICENSE_INT_3) && defined(CONOPT_LICENSE_TEXT)
   std::string license = CONOPT_LICENSE_TEXT;
   COI_Error += conopt.setLicense(
         CONOPT_LICENSE_INT_1, CONOPT_LICENSE_INT_2, CONOPT_LICENSE_INT_3, license);
#endif
 
   if (COI_Error)
   {
      cpp_log(conopt,
            "Skipping COI_Solve due to license error. COI_Error = " + std::to_string(COI_Error));
      return COI_Error;
   }
 
   COI_Error = conopt.solve(); /* Optimize                      */
 
   if (COI_Error)
   {
      cpp_log(conopt, "Errors encountered during solution");
      return -1;
   }
   // checking the statuses and objective value
   else if (conopt.solutionStatus() != 1 || conopt.modelStatus() < 4 || conopt.modelStatus() > 5)
   {
      cpp_log(conopt, "Solver or Model status not as expected (1,4) or (1,5)");
      return -1;
   }
 
   // printing the final status of the optimisation
   conopt.printStatus();
 
   cpp_log(conopt, "Successful Solve");
 
   return 0;
}