std.c

Go to the documentation of this file.

/* std.c
   This file has some 'standard' implementations for the mandatory
   callback routines Message, ErrMsg, Status, and Solution.
   The routines use global file pointers, defined in the header file
   comdecl.h, so they are only intended as examples that can be used
   for further refinements.                                           */
 
int COI_CALLCONV Std_Message( int SMSG, int DMSG, int NMSG, char* MSGV[], void* USRMEM  )
{
/* This implementation is writing the screen file to stdout
   the documentation file to a file opened in main with the name
   document.txt and the status file to a file with the name
   status.txt.                                                        */
   int i;
 
   for( i=0; i<SMSG;i++ )  printf(   "%s\n", MSGV[i]);
   for( i=0; i<DMSG;i++ ) fprintf(fd,"%s\n", MSGV[i]);
   for( i=0; i<SMSG;i++ ) fprintf(fs,"%s\n", MSGV[i]);
 
#ifdef flush
      fflush(fd); fflush(fs);
#endif
   return 0;
}
 
int COI_CALLCONV Std_ErrMsg( int ROWNO, int COLNO, int POSNO, const char* MSG, void* USRMEM )
{
/* Standard ErrMsg routine. Write to Documentation and Status file*/
   if ( ROWNO == -1 )      fprintf(fd,"Variable %d : ",COLNO);
   else if ( COLNO == -1 ) fprintf(fd,"Equation %d : ",ROWNO);
   else                    fprintf(fd,"Variable %d appearing in Equation %d : ", COLNO, ROWNO);
   fprintf(fd,"%s\n", MSG);
 
   if ( ROWNO == -1 )      fprintf(fs,"Variable %d : ",COLNO);
   else if ( COLNO == -1 ) fprintf(fs,"Equation %d : ",ROWNO);
   else                    fprintf(fs,"Variable %d appearing in Equation %d : ", COLNO, ROWNO);
   fprintf(fs,"%s\n", MSG);
 
#ifdef flush
      fflush(fd); fflush(fs);
#endif
   return 0;
}
 
int COI_CALLCONV Std_Status( int MODSTA, int SOLSTA, int ITER, double OBJVAL, void* USRMEM )
{
/* Standard Status routine. Write to all files */
   printf("\n");
   printf("CONOPT has finished Optimizing\n");
   printf("Model status    = %8d\n", MODSTA);
   printf("Solver status   = %8d\n", SOLSTA);
   printf("Iteration count = %8d\n", ITER);
   printf("Objective value = %10f\n", OBJVAL);
 
   fprintf(fd,"\n");
   fprintf(fd,"CONOPT has finished Optimizing\n");
   fprintf(fd,"Model status    = %8d\n", MODSTA);
   fprintf(fd,"Solver status   = %8d\n", SOLSTA);
   fprintf(fd,"Iteration count = %8d\n", ITER);
   fprintf(fd,"Objective value = %10f\n", OBJVAL);
 
   fprintf(fs,"\n");
   fprintf(fs,"Model status    = %8d\n", MODSTA);
   fprintf(fs,"Solver status   = %8d\n", SOLSTA);
   fprintf(fs,"Objective value = %10f\n", OBJVAL);
 
   stacalls++;
   OBJ   = OBJVAL;
   mstat = MODSTA;
   sstat = SOLSTA;
#ifdef flush
      fflush(fd); fflush(fs);
#endif
   return 0;
}
 
int COI_CALLCONV Std_Solution( const double XVAL[], const double XMAR[], const int XBAS[], const int XSTA[],
                           const double YVAL[], const double YMAR[], const int YBAS[], const int YSTA[],
                           int NUMVAR, int NUMCON, void* USRMEM )
{
/* Standard Solution routine */
   int i;
   char *status[4] = {"Lower","Upper","Basic","Super"};
   fprintf(fd,"\n Variable   Solution value    Reduced cost    Status\n\n");
   for ( i=0; i<NUMVAR; i++ )
      fprintf(fd,"%6d%18f%18f%10s\n", i, XVAL[i], XMAR[i], status[XBAS[i]] );
   fprintf(fd,"\n Constrnt   Activity level    Marginal cost   Status\n\n");
   for ( i=0; i<NUMCON; i++ )
      fprintf(fd,"%6d%18f%18f%10s\n", i, YVAL[i], YMAR[i], status[YBAS[i]] );
 
   solcalls++;
#ifdef flush
      fflush(fd);
#endif
   return 0;
}
 
int COI_CALLCONV Std_TriOrd( int mode, int type, int status, int irow, int icol, int inf, double value, double resid, void* USRMEM )
/*
  Simple implementation of the TriOrd callback routine.
*/
{
   enum types { Pretriangular   =  1, /* Fix a structural variable from an equality equation              */
                FixedColumn     =  2, /* Fix a structural variable from equal lower and upper bouunds     */
                DependentRow    =  3, /* All structural variables are fixed and the row is feasible       */
                RedundantRow    =  4, /* The row is feasible due to bounds on all variables.              */
                ImpliedLower    =  5, /* Change a simple inequality to a lower bound                      */
                ImpliedUpper    =  6, /* Change a simple inequality to an upper bound                     */
                ImpliedRange    =  7, /* Change a ranged constraint into both a lower and an upper bound
                                         This routine is called twice, first with lower then with upper
                                         bound                                                            */
                ForcedLower     =  8, /* A variable is forced to the lower bound by a ForcingLower or     */
                                      /* ForcingUpper constraint.                                         */
                ForcedUpper     =  9, /* A variable is forced to the upper bound by a ForcingLower or     */
                                      /* ForcingUpper constraint.                                         */
                ForcedValue     = 10, /* A variable if forced to a value equal to an implied but not      */
                                      /* original bound by a ForcingLower or ForcingUpper constraint      */
                ForcingLower    = 11, /* A constraint is forcing all variables in it to a bound           */
                                      /* and it works as an =L= constraint.                               */
                ForcingUpper    = 12, /* A constraint is forcing all variables in it to a bound           */
                                      /* and it works as an =G= constraint.                               */
/*
  Any of the next actions will terminate the pre-processor and there can therefore only be one of them
  and only in an infeasible model.
*/
                PreTriaInfeasB  = 13, /* An equation has only one nonfixed variable, but it cannot        */
                                      /* be solved either because the variable will exceed a bound.       */
                PreTriaInfeasP  = 14, /* An equation has only one nonfixed variable, but it cannot        */
                                      /* be solved either because the pivot (derivative) is too small.    */
                ForcingInfeas   = 15, /* A constraint is infeasible due to bounds on all variables        */
                InconsistentRow = 16  /* All structural variables are fixed and the row in infeasible     */
                                      /* or the row is feasible due to bounds on all variables.           */
                };
 
   if ( -1 == mode )
      fprintf(fd,"\n The preprocessing transformation are described below in detection order:'\n\n");
   else if ( -2 == mode )
      fprintf(fd,"\n The order of the critical transformations is:\n\n");
   switch (type) {
      case Pretriangular:
         if ( 0 == inf )
            fprintf(fd,"Equation %6d solved with respect to variable %6d. Value= %18f\n", irow, icol, value );
         else if ( 1 == inf )
            fprintf(fd,"Equation %6d solved with respect to variable %6d. Value=  +Infinity\n", irow, icol );
         else
            fprintf(fd,"Equation %6d solved with respect to variable %6d. Value=  -Infinity\n", irow, icol );
         break;
      case FixedColumn:
         fprintf(fd,"Variable %6d fixed at value= %18f\n", icol, value );
         break;
      case DependentRow:
         fprintf(fd,"Equation %6d is dependent (all variables are fixed).\n", irow );
         break;
      case RedundantRow:
         fprintf(fd,"Equation %6d is redundant (will later be solved with respect to the slack.\n", irow );
         break;
      case ImpliedLower:
         fprintf(fd,"Equation %6d turned into lower bound on variable %6d. Bound= %18f\n", irow, icol, value );
         break;
      case ImpliedUpper:
         fprintf(fd,"Equation %6d turned into upper bound on variable %6d. Bound= %18f\n", irow, icol, value );
         break;
      case ImpliedRange:
         fprintf(fd,"Ranged Equation %6d turned into two bounds on variable %6d. Bound= %18f\n", irow, icol, value );
         break;
      case ForcedLower:
         fprintf(fd,"Variable %6d forced to lower bound= %18f\n", icol, value );
         break;
      case ForcedUpper:
         fprintf(fd,"Variable %6d forced to upper bound= %18f\n", icol, value );
         break;
      case ForcedValue:
         fprintf(fd,"Variable %6d forced to implied bound= %18f\n", icol, value );
         break;
      case ForcingLower:
         fprintf(fd,"Previous variables were forced by equation %6d binding as a less than or equal constraint.\n", irow );
         break;
      case ForcingUpper:
         fprintf(fd,"Previous variables were forced by equation %6d binding as a greater than or equal constraint.\n", irow );
         break;
      case PreTriaInfeasB:
         fprintf(fd,"Equation %6d cannot be solved with respect to variable %6d due to bounds. Value= %18f\n", irow, icol, value );
         break;
      case PreTriaInfeasP:
         fprintf(fd,"Equation %6d cannot be solved with respect to variable %6d. Infeasibility has local minimum at %18f\n", irow, icol, value );
         break;
      case ForcingInfeas:
         fprintf(fd,"Equation %6d is still infeasible after the above variables have been moved to the best bounds.\n", irow );
         break;
      case InconsistentRow:
         fprintf(fd,"Equation %6d cannot be solved. No free variables left.\n", irow );
         break;
      default:
         fprintf(fd,"Pretriangular action= %6d not implemented yet.\n", type );
         exit(1);
   }
   if ( resid != 0.0 ) fprintf(fd,"Residual after last transformation= %18f\n", resid );
 
   return 0;
}
 
void c_log( char *msgt, int code )
{
/* c_log manages the initialization and the return code file.
   It is called exactly twice:
   The first time with code = START and
   the second with code = ReturnCode for overall program.
   During the START call we allocate and initialize the CONOPT
   control vector, read the name of the program from stdin, and
   open the files <progname>.lst on fd and <progname>.sta on fs.
   During the second call we close these files, free the control
   vector, and exit with 0 if code = OK and otherwise exit with
   the value of code.
   The test in the first argument, msgt, is written to the return
   code file <progname>.rc.  */
 
   FILE *fc;
   int i;
   int c;
   char msgc[256];
 
   if ( code == START )
   {
      i = 0; /* Read the name of the program without extension from stdin */
      while ( (c = getchar()) != EOF && i < MAXLINE ) pname[i++] = (char)c;
      pname[i-1] = '\0'; /* remove eof and new-line chars */
      coiCreate(&CntVect);
      if (NULL==CntVect) {
         printf("Could not create CONOPT object: %s\n", msgc);
         strcpy(fname,pname); strcat(fname,".rc" );
         fc = fopen(fname,"w");
         fprintf(fc,"%s: Could not create CONOPT object.\n", pname );
         fclose(fc);
         exit(1);
      }
      strcpy(fname,pname); strcat(fname,".lst" );
      fd = fopen(fname,"w");
      strcpy(fname,pname); strcat(fname,".sta" );
      fs = fopen(fname,"w");
   }
   strcpy(fname,pname); strcat(fname,".rc" );
   fc = fopen(fname,"w");
   fprintf(fc,"%s: %s.\n", pname, msgt );
   fclose(fc);
   if ( code != START )
   {
      fclose(fd);
      fclose(fs);
      coiFree(&CntVect);
      coiFinalize();
      if ( code == OK )
         exit(0);
      else
         exit(code);
   }
}