largeres1.c

Go to the documentation of this file.

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

int COI_CALLCONV LR_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.        */
 /*                                                               */
 /*   Initial value = 35.0                                        */
 /*                                                               */
   CURR[0]  = 35.0 ;
 /*                                                               */
 /*   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.0 and type Equality                                */
 /*                                                               */
   RHS[0]  = 10.0 ;
   TYPE[0] = 0    ;
 /*                                                               */
 /*   Information about the Jacobian. CONOPT expects a columnwise */
 /*   representation in Rowno, Value, Nlflag and Colsta.    */
 /*                                                               */
 /*   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]                                                   */
 /*   0:    0                                                     */
 /*                                                               */
   COLSTA[0] =  0 ;
   COLSTA[1] =  1 ;
   ROWNO[0]  =  0 ;
 /*                                                               */
 /*   Nonlinearity Structure: L = 0 are linear and NL = 1 are nonlinear */
 /*        X[0]                                                   */
 /*   0:    NL                                                    */
 /*                                                               */
   NLFLAG[0] =  1 ;
 /*                                                               */
 /*   Value (Linear only)                                         */
 /*        X[0]                                                   */
 /*   0:    NL                                                    */
 /*                                                               */
   return 0;
}
 
 

int COI_CALLCONV LR_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: exp(x) = 10                                              */
 /*                                                                   */
 
   if ( ROWNO == 0 ) {
 /*                                                                   */
 /*   Mode = 1 or 3. Function value: G = P * Out                      */
 /*                                                                   */
      if ( MODE == 1 || MODE == 3 )
         *G    = exp(X[0]);
 /*                                                                   */
 /*   Mode = 2 or 3: Derivative values:                               */
 /*                                                                   */
      if ( MODE == 2 || MODE == 3 ) {
         JAC[0] = exp(X[0]);
         }
      }
   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, 1  );      /* 1 variables                       */
   COI_Error +=  COIDEF_NumCon    ( CntVect, 1  );      /* 1 constraints                     */
   COI_Error +=  COIDEF_NumNz     ( CntVect, 1  );      /* 1 nonzeros in the Jacobian        */
   COI_Error +=  COIDEF_NumNlNz   ( CntVect, 1  );      /* 1 of which are nonlinear          */
   COI_Error +=  COIDEF_OptDir    ( CntVect, 1  );      /* Maximize                          */
   COI_Error +=  COIDEF_ObjVar    ( CntVect, 0  );      /* Objective is variable 0           */
   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_Optfile   ( CntVect, "largeres.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, &LR_ReadMatrix);  /* Register the callback ReadMatrix  */
   COI_Error +=  COIDEF_FDEval    ( CntVect, &LR_FDEval);      /* Register the callback FDEval      */
 
#if defined(CONOPT_LICENSE_INT_1) && defined(CONOPT_LICENSE_INT_2) && defined(CONOPT_LICENSE_INT_3) && defined(CONOPT_LICENSE_TEXT)
   COI_Error +=  COIDEF_License   ( CntVect, CONOPT_LICENSE_INT_1, CONOPT_LICENSE_INT_2, CONOPT_LICENSE_INT_3, CONOPT_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 != 400 ) {
      c_log( "Expected return code 400, Saw", COI_Error); }
 
   c_log( "Successful Solve", OK );
}