Overview over CONOPT routines – C users

To start CONOPT you will in general have to go through 7 steps:

1. Create and initialize a control vector where you can register size characteristics and callback routines for your model. The control vector can also be used to register other information such as user memory and working memory. The standard declaration and execution sections for this task are:

   #include "coiheader.h"
   ..
   int COI_Error;
   int CntSize;
   int *CntVect;
   ..
   CntSize = COIDEF_Size();
   CntVect = (int *)malloc( CntSize*sizeof(int) );
   COI_Error = COIDEF_Ini( CntVect );

1. Define the basic sizes of the model. Declarations and execution are shown below. Note that the sizes are passed to COIDEF_Xx routines by address and it is therefore convenient to declare variables and pass their address:

   int NumVar, NumCon, NumNZ, NumNlNz;
   ..
   NumVar = XX; NumCon = YY; NumNZ = ZZ; NumNlNz = UU;
   COI_Error +=  COIDEF_NumVar    ( CntVect, &NumVar  );
   COI_Error +=  COIDEF_NumCon    ( CntVect, &NumCon  );
   COI_Error +=  COIDEF_NumNz     ( CntVect, &NumNZ   );
   COI_Error +=  COIDEF_NumNlNz   ( CntVect, &NumNlNz );

1. Define that you use C vectors with first index 0 and that you use C argument passing conventions:

   int Base;
   ..
   Base   = 0;
   COI_Error +=  COIDEF_Base      ( CntVect, &Base    );
   COI_Error +=  COIDEF_C         ( CntVect    );

1. Define the optimization direction and the objective function or the objective variable:

   int OptDir;
   int ObjCon;
      -or-
   int ObjVar;
   ..
   OptDir = -1 or +1; ObjCon = XX; -or- ObjVar = XX;
   COI_Error +=  COIDEF_OptDir    ( CntVect, &OptDir  );
   COI_Error +=  COIDEF_ObjCon    ( CntVect, &ObjCon  );
      -or-
   COI_Error +=  COIDEF_ObjVar    ( CntVect, &ObjVar  );

   Note

   The index of the objective is interpreted according to the base defined in COIDEF_Base().

   The routines used above are all described in section The Control Vector where a number of similar optional routines also are described.

1. Register your callback routines. The standard execution section for this task is:

   COI_Error +=  COIDEF_ReadMatrix( CntVect, &My_ReadMatrix);
   COI_Error +=  COIDEF_FDEval    ( CntVect, &My_FDEval);
   COI_Error +=  COIDEF_Status    ( CntVect, &My_Statu   );
   COI_Error +=  COIDEF_Solution  ( CntVect, &My_Solution );
   COI_Error +=  COIDEF_Message   ( CntVect, &My_Message  );
   COI_Error +=  COIDEF_ErrMsg    ( CntVect, &My_ErrMsg   );
   .. etc. for registration of optional callback routines

   where My_ReadMatrix, My_FDEval, ... etc are procedures that conveniently can be placed before the procedure in which the registration above takes place. The list above includes all mandatory callback routines.

   Note

   FDEval only is mandatory for nonlinear models.

   
   

2. Register your CONOPT license. The license consists of a string defining the user and three integers with information about the type and date of the license:

   char LicString[] = "Lic_String";
   int LicCode1 = 451;
   int LicCode2 =  44;
   int LicCode3 = 543;
   ..
   COI_Error +=    COIDEF_License(CntVect,&LicCode1,&LicCode2,&LicCode3,
               LicString,strlen(LicString));

   The license routines are described in section The Control Vector. The license is usually distributed in the form of an include file named conoptc.lic that contains the correct version of the first four lines. If you add a copy of this file to the directory with your other C files then you can in most cases replace the four license defining lines by

   #include “conoptc.lic”

1. Call CONOPT. The standard call is:

   COI_Error = COI_Solve( CntVect );

   COI_Solve() will start CONOPT. CONOPT will allocate memory and it will call the user defined callback routine registered with COIDEF_ReadMatrix(), here called My_ReadMatrix, to set up the model. During the optimization, CONOPT will repeatedly need information about the nonlinear functions and their first derivatives and for this purpose it will call the user defined callback registered with COIDEF_FDEval(), here called My_FDEval. During the optimization CONOPT will send messages to the modeler using the callback routine registered with COIDEF_Message(), here called My_Message, and it may also call the error message routine registered with COIDEF_ErrMsg(), here called My_ErrMsg. When the optimization is finished, CONOPT will call two output routines that return the solution to the modeler. They are registered with COIDEF_Status() and COIDEF_Solution() and are here called My_Status and My_Solution. Finally, COI_Solve() will return.

   Several optional callback routines may be called if they have been registered. They can provide more information about the model from the modeler to CONOPT or more information about the solution process from CONOPT to the modeler.