square2.c

Go to the documentation of this file.

 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "coiheader.h"
#include "comdecl.h"
 

int COI_CALLCONV Sq_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* USRMEM )
{
 /*   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                                         */
 /*                                                               */
 /*   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.                                   */
 /*                                                               */
 /*   Constraint 0                                                */
 /*   Rhs = 10 and type Eguality                                  */
 /*                                                               */
   RHS[0]  = 10 ;
   TYPE[0] = 0    ;
 /*                                                               */
 /*   Constraint 1                                                */
 /*   Rhs = 0 and type Equality                                   */
 /*                                                               */
   TYPE[1] = 0    ;
 /*                                                               */
 /*   Constraint 2                                                */
 /*   Rhs = 9 and type Less Than Inequality                       */
 /*                                                               */
   RHS[2]  = 9 ;
   TYPE[2] = 2 ;
 /*                                                               */
 /*   Information about the Jacobian. We use the standard method with */
 /*   Rowno, Value, Nlflag and Colsta and we do not use Colno.    */
 /*                                                               */
 /*   Colsta = Start of column indices (No Defaults):             */
 /*   Rowno  = Row indices                                        */
 /*   Value  = Value of derivative (by default only linear        */
 /*                                 derivatives are used)         */
 /*   Nlflag = 0 for linear and 1 for nonlinear derivative        */
 /*            (not needed for completely linear models)          */
 /*                                                               */
 /*   Indices                                                     */
 /*        X[0]  X[1]                                             */
 /*   0:    0     3                                               */
 /*   1:    1     4                                               */
 /*   2:    2     5                                               */
 /*                                                               */
   COLSTA[0] =  0 ;
   COLSTA[1] =  3 ;
   COLSTA[2] =  6 ;
   ROWNO[0]  =  0 ;
   ROWNO[1]  =  1 ;
   ROWNO[2]  =  2 ;
   ROWNO[3]  =  0 ;
   ROWNO[4]  =  1 ;
   ROWNO[5]  =  2 ;
 /*                                                               */
 /*   Nonlinearity Structure: L = 0 are linear and NL = 1 are nonlinear */
 /*   Although the model is linear we label constraint 1 and 2 as nonlinear */
 /*        X[0]  X[1]                                             */
 /*   0:    L     L                                               */
 /*   1:    NL    NL                                              */
 /*   2:    NL    NL                                              */
 /*                                                               */
   NLFLAG[0] =  0 ;
   NLFLAG[1] =  1 ;
   NLFLAG[2] =  1 ;
   NLFLAG[3] =  0 ;
   NLFLAG[4] =  1 ;
   NLFLAG[5] =  1 ;
 /*                                                               */
 /*   Value (Linear only)                                         */
 /*        X[0]  X[1]                                             */
 /*   0:    1     1                                               */
 /*   1:    NL    NL                                              */
 /*   2:    NL    NL                                              */
 /*                                                               */
   VALUE[0]  = 1. ;
   VALUE[3]  = 1. ;
 
   return 0;
}
 
 

int COI_CALLCONV Sq_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, void* USRMEM )
{
 /*                                                                   */
 /*   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.c"

int main(int argc, char** argv)
{
   c_log( "Starting to execute", START );
 
 /*
   Tell CONOPT about the sizes in the model
 */
   COI_Error +=  COIDEF_NumVar    ( CntVect, 2  );       /* 2 variables                       */
   COI_Error +=  COIDEF_NumCon    ( CntVect, 3  );       /* 3 constraints                     */
   COI_Error +=  COIDEF_NumNz     ( CntVect, 6  );       /* 6 nonzeros in the Jacobian        */
   COI_Error +=  COIDEF_NumNlNz   ( CntVect, 4  );       /* 4 of which are nonlinear          */
   COI_Error +=  COIDEF_DebugFV   ( CntVect, 0  );       /* 0 means no debugging, 1 each iter */
   COI_Error +=  COIDEF_StdOut    ( CntVect, 0  );       /* 1 means Allow output to StdOut    */
   COI_Error +=  COIDEF_Square    ( CntVect, 1  );       /* 1 means Square system             */
   COI_Error +=  COIDEF_Optfile   ( CntVect, "square.opt");     /* Register the options file  */
 /*
   Register the necessary callback routines with CONOPT
 */
   COI_Error +=  COIDEF_Message   ( CntVect, &Std_Message  );  /* Register the callback Message     */
   COI_Error +=  COIDEF_ErrMsg    ( CntVect, &Std_ErrMsg   );  /* Register the callback ErrMsg      */
   COI_Error +=  COIDEF_Status    ( CntVect, &Std_Status   );  /* Register the callback Status      */
   COI_Error +=  COIDEF_Solution  ( CntVect, &Std_Solution );  /* Register the callback Solution    */
   COI_Error +=  COIDEF_ReadMatrix( CntVect, &Sq_ReadMatrix);  /* Register the callback ReadMatrix  */
   COI_Error +=  COIDEF_FDEval    ( CntVect, &Sq_FDEval);      /* Register the callback FDEval      */
 
#if defined(LICENSE_INT_1) && defined(LICENSE_INT_2) && defined(LICENSE_INT_3) && defined(LICENSE_TEXT)
   COI_Error +=  COIDEF_License   ( CntVect, LICENSE_INT_1, LICENSE_INT_2, LICENSE_INT_3, LICENSE_TEXT);
#endif
 
   if ( COI_Error ) {
      printf("Skipping COI_Solve due to setup errors. COI_Error = %d\n",COI_Error);
      c_log( "Skipping Solve due to setup errors", COI_Error);
      }
   COI_Error =  COI_Solve        ( CntVect );           /* Optimize                      */
   printf("After solving. COI_Error =%d\n",COI_Error);
   if ( COI_Error ) {
      c_log( "Errors encountered during solution", COI_Error); }
   else if ( stacalls == 0 || solcalls == 0 ) {
      c_log( "Status or Solution routine was not called", -1); }
   else if ( sstat != 1 || mstat < 4 || mstat > 5 ) {
      c_log( "Solver or Model status not as expected (1,4) or (1,5)", -1); }
 
   c_log( "Successful Solve", OK );
}