mp_trans.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"
 
#define ni 30
#define nj 50
double Tot = 5000.0;
double A[ni];
double B[nj];
double Cost[ni*nj];
 
void defdata()
{
   int i,j,k;
   double si, sj;
 
   si = 0; for ( i = 0; i < ni; i++ ) { si = si + i+1; };
   sj = 0; for ( j = 0; j < nj; j++ ) { sj = sj + j+1; };
   for ( i = 0; i < ni; i++ ) { A[i] = Tot*(i+1)/si; };
   for ( j = 0; j < nj; j++ ) { B[j] = Tot*(j+1)/sj; };
   k = 0;
   for ( i = 0; i < ni; i++ ) {
      for ( j = 0; j < nj; j++ )
         { Cost[k] = i+1 + 2*(j+1); k++; };
      }
}
 

int COI_CALLCONV Trans_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 )
{
  int i, j, k, l;
 /*                                                               */
 /*   Information about Variables:                                */
 /*   Default: Lower = -Inf, Curr = 0, and Upper = +inf.          */
 /*   Default: the status information in Vsta is not used.        */
 /*                                                               */
   k = 0;
   for ( i = 0; i < ni; i++ ) {
      for ( j = 0; j < nj; j++ )
         { LOWER[k] = 0.0; k++; };
      }
 
 /*   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.                                   */
 /*                                                               */
   for ( i=0; i<ni; i++ ) {
      RHS[i]  = A[i] ;
      TYPE[i] = 1;
      }
   for ( j=0; j<nj; j++ ) {
      RHS[ni+j]  = B[j] ;
      TYPE[ni+j] = 2;
      }
 /*   Constraint Objective                                        */
 /*   Rhs = 0.0 and type =E=                                      */
 /*                                                               */
   TYPE[ni+nj] = 0    ;
 /*                                                               */
 /*   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(i,j)  obj                                             */
 /*  i:     1                                                     */
 /*  j:     1                                                     */
 /*  obj  cost    -1                                              */
 
   k = 0;  /* counter for current variable  */
   l = 0;  /* counter for current nonzero   */
   for ( i = 0; i < ni; i++ ) {
      for ( j = 0; j < nj; j++ ) {
         COLSTA[k] = l;
         ROWNO[l]  = i;
         NLFLAG[l] = 0;
         VALUE[l]  = 1.0;
         l++;
         ROWNO[l]  = ni+j;
         NLFLAG[l] = 0;
         VALUE[l]  = 1.0;
         l++;
         ROWNO[l]  = ni+nj;
         NLFLAG[l] = 0;
         VALUE[l]  = Cost[k];
         l++;
         k++;
      }
   }
   COLSTA[k] = l;
   ROWNO[l]  = ni+nj;
   NLFLAG[l] = 0;
   VALUE[l]  = -1.0;
   l++; k++;
   COLSTA[k] = l;
   return 0;
}
 

int COI_CALLCONV Trans_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 )
{
 /*                                                                   */
 /*   The model is linear and the routine should not be called        */
 /*   so we return 1 = error                                          */
 /*                                                                   */
   return 1;
}
 
#include "std.c"

int main(int argc, char** argv)
{
   c_log( "Starting to execute", START );
 
   defdata();
 /*
   Tell CONOPT about the sizes in the model
 */
   COI_Error +=  COIDEF_NumVar    ( CntVect, ni*nj+1      );       /* ni*nj+1 variables                       */
   COI_Error +=  COIDEF_NumCon    ( CntVect, ni+nj+1      );       /* ni+nj+1 constraints                     */
   COI_Error +=  COIDEF_NumNz     ( CntVect, 3*ni*nj+1    );       /* 3*ni*nj+1 nonzeros in the Jacobian      */
   COI_Error +=  COIDEF_NumNlNz   ( CntVect, 0            );       /* 0 of which are nonlinear                */
   COI_Error +=  COIDEF_OptDir    ( CntVect, -1           );       /* Minimize                                */
   COI_Error +=  COIDEF_ObjVar    ( CntVect, ni*nj        );       /* Objective is variable ni*nj             */
   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          */
 /*
   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, &Trans_ReadMatrix);  /* Register the callback ReadMatrix  */
   COI_Error +=  COIDEF_FDEval    ( CntVect, &Trans_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("1 Thread: End of Trans Example 1. Return code =%d\n",COI_Error);
   if ( COI_Error ) {
      c_log( "1 Thread: Errors encountered during first solve", COI_Error); }
   else if ( stacalls == 0 || solcalls == 0 ) {
      c_log( "1 Thread: Status or Solution routine was not called during first solve called", -1); }
   else if ( !( sstat == 1 && mstat == 1 ) ) {
      c_log( "1 Thread: Solver or Model status was not as expected (1,1)", -1); }
   else if ( fabs( OBJ-438333.3333 ) > 0.001 ) {
      c_log( "1 Thread: Incorrect objective returned from first solve", -1); };
 
/* Register free use of threads and run again                                            */
 
   COI_Error +=  COIDEF_ThreadS  ( CntVect, 0 ); /* 0 means take what you can get        */
   COI_Error =  COI_Solve        ( CntVect );           /* Optimize                      */
   printf("Multi Thread: End of Trans Example 1. Return code =%d\n",COI_Error);
   if ( COI_Error ) {
      c_log( "Multi Thread: Errors encountered during second solve", COI_Error); }
   else if ( stacalls == 0 || solcalls == 0 ) {
      c_log( "Multi Thread: Status or Solution routine was not called during first second called", -1); }
   else if ( !( sstat == 1 && mstat == 1 ) ) {
      c_log( "Multi Thread: Solver or Model status was not as expected (1,1)", -1); }
   else if ( fabs( OBJ-438333.3333 ) > 0.001 ) {
      c_log( "Multi Thread: Incorrect objective returned from second solve", -1); };
 
   c_log( "Successful Solve", OK );
}