/***********************************************************************
Xpress Optimizer Examples
=========================
file goal_example.c
```````````````````
Demonstrates how to implement traditional goal programming
using Xpress.
(c) 2017 Fair Isaac Corporation
***********************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "xprs.h"
#include <math.h>
#include <memory.h>
#include <string.h>
#include <ctype.h>
#if defined(WIN32) || defined(_WIN32)
#else
#define strcmpi stricmp
#define stricmp strcasecmp
#define strnicmp strncasecmp
#endif
/* Calls an Xpress optimizer function and checks the return code.
* If the call fails then the function
* - prints a short error message to stderr,
* - sets variable 'returnCode' to the error,
* - and branches to label 'cleanup'.
*/
#define CHECK_RETURN(call) do { \
int result_ = call; \
if ( result_ != 0 ) { \
fprintf(stderr, "Line %d: %s failed with %d\n", \
__LINE__, #call, result_); \
returnCode = result_; \
goto cleanup; \
} \
} while (0)
/* XPRS optimizer message callback */
static void XPRS_CC messagecb(XPRSprob cbprob, void* cbdata,
const char *msg, int len, int msgtype)
{
(void)cbprob; /* unused (the problem for which the message is issued) */
(void)cbdata; /* unused (the data passed to XPRSaddcbmessage()) */
switch(msgtype)
{
case 4: /* error */
case 3: /* warning */
case 2: /* not used */
case 1: /* information */
printf("%*s\n", len, msg);
break;
default: /* exiting - buffers need flushing */
fflush(stdout);
break;
}
}
struct GoalConstraint_s {
double dCost;
int iRow;
};
typedef struct GoalConstraint_s * GoalConstraint;
struct GoalObjective_s {
double dTolerance;
int iRow;
int iOptimizationSense;
int bFractionIsPercentage;
};
typedef struct GoalObjective_s * GoalObjective;
struct SlackPair_s {
int iSlack_Pos;
int iSlack_Neg;
};
typedef struct SlackPair_s * SlackPair;
struct Goal_s {
int bArchimedianOtherwisePreemptive;
int bConstraintsOtherwiseObjective;
GoalConstraint gc;
int gc_count;
GoalObjective go;
int go_count;
};
typedef struct Goal_s * Goal;
static int AddSlack(XPRSprob prob, int iRow, int iSlackSign,
double dSlackCost, int *iNewColIndex)
{
int returnCode = 0;
double obj = dSlackCost, dmatval = (iSlackSign > 0 ? 1.0 : -1.0);
double bdl = 0.0, bdu = XPRS_PLUSINFINITY;
int mrwind = iRow, mstart[] = {0, 1};
/* Slack will go on the end of the column set */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_COLS, iNewColIndex) );
CHECK_RETURN( XPRSaddcols(prob, 1 /*newcol*/, 1 /*newnz*/, &obj, mstart,
&mrwind, &dmatval, &bdl, &bdu) );
cleanup:
return returnCode;
}
static int GcArray_AddRecord(GoalConstraint *gc, int *gc_count)
{
int returnCode = 0;
if(!*gc) {
if(!(*gc = malloc(sizeof(**gc) * (*gc_count + 1)))) {
perror("malloc");
returnCode = -2;
goto cleanup;
}
} else {
GoalConstraint gc_temp;
if(!(gc_temp = realloc(*gc, sizeof(**gc) * (*gc_count + 1)))) {
perror("realloc");
returnCode = -2;
goto cleanup;
}
*gc = gc_temp;
}
(*gc_count)++;
cleanup:
return returnCode;
}
static int GoArray_AddRecord(GoalObjective *go, int *go_count)
{
int returnCode = 0;
if(!*go) {
if(!(*go = malloc(sizeof(**go) * (*go_count + 1)))) {
perror("malloc");
returnCode = -2;
goto cleanup;
}
} else {
GoalObjective go_temp;
if(!(go_temp = realloc(*go, sizeof(**go) * (*go_count + 1)))) {
perror("realloc");
returnCode = -2;
goto cleanup;
}
*go = go_temp;
}
(*go_count)++;
cleanup:
return returnCode;
}
static int SpArray_AddRecord(SlackPair *sp, int *sp_count)
{
int returnCode = 0;
if(!*sp) {
if(!(*sp = malloc(sizeof(**sp) * (*sp_count + 1)))) {
perror("malloc");
returnCode = -2;
goto cleanup;
}
} else {
SlackPair sp_temp;
if(!(sp_temp = realloc(*sp, sizeof(**sp) * (*sp_count + 1)))) {
perror("realloc");
returnCode = -2;
goto cleanup;
}
*sp = sp_temp;
}
(*sp_count)++;
cleanup:
return returnCode;
}
static int RelaxConstraint(XPRSprob prob, int iRow,
int bArchimedianOtherwisePreemptive,
double dArchimedianWeight, SlackPair *sp,
int * sp_count)
{
int returnCode = 0;
char qrtype;
double dCost = (bArchimedianOtherwisePreemptive ? dArchimedianWeight : 0.0);
SlackPair sp_;
CHECK_RETURN( XPRSgetrowtype(prob, &qrtype, iRow, iRow) );
CHECK_RETURN( SpArray_AddRecord(sp, sp_count) );
sp_ = &(*sp)[*sp_count - 1];
sp_->iSlack_Pos = -1;
sp_->iSlack_Neg = -1;
switch(qrtype) {
case('N') :
break;
case('L') :
case('P') :
AddSlack(prob, iRow, -1 /*iSlackSign*/, dCost, &sp_->iSlack_Neg);
break;
case('G') :
case('Q') :
AddSlack(prob, iRow, 1 /*iSlackSign*/, dCost, &sp_->iSlack_Pos);
break;
case('E') :
case('R') :
AddSlack(prob, iRow, 1 /*iSlackSign*/, dCost, &sp_->iSlack_Pos);
AddSlack(prob, iRow, -1 /*iSlackSign*/, dCost, &sp_->iSlack_Neg);
break;
default :
fprintf(stderr, "Unexpected row type '%c'\n", qrtype);
returnCode = -1;
goto cleanup;
}
cleanup:
return returnCode;
}
static int RunGoal_Preemptive_Constraint(XPRSprob prob, int bRunMip,
GoalConstraint GoalRows,
int iGoalRows_Count,
int *bIsInfeasible)
{
int returnCode = 0;
int i, j, nRows, nCols, iStatus, bHaveBasis;
double dObjVal, dZero = 0.0, dOne = 1.0;
SlackPair sp = NULL;
int sp_count = 0;
char cBoth = 'B';
int *rstatus = NULL, *cstatus = NULL;
int bWriteGoalProbs = 0;
*bIsInfeasible = 0;
/* Ensure the problem is in the original state */
CHECK_RETURN( XPRSpostsolve(prob) );
/* Add the appropriate slacks for the goals */
for(i = 0; i < iGoalRows_Count; i++) {
CHECK_RETURN( RelaxConstraint(prob, GoalRows[i].iRow,
0 /*bArchimedianOtherwisePreemptive*/,
0.0 /*dArchimedianWeight*/,
&sp, &sp_count) );
}
/* Setup arrays to store basis and zero all costs */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_ROWS, &nRows) );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_COLS, &nCols) );
if(!(rstatus = malloc(sizeof(*rstatus) * nRows)) ||
!(cstatus = malloc(sizeof(*cstatus) * nCols))) {
perror("malloc");
returnCode = -2;
goto cleanup;
}
for(j = 0; j < nCols; j++) {
CHECK_RETURN( XPRSchgobj(prob, 1, &j, &dZero) );
}
if(bWriteGoalProbs) {
CHECK_RETURN( XPRSwriteprob(prob, "goal\\pc_goal0", "") );
}
/* Loop through the goal constraints */
bHaveBasis = 0;
for(i = 0; i < sp_count; i++) {
/* Skip non-binding goal rows */
if(sp[i].iSlack_Neg < 0 && sp[i].iSlack_Pos < 0) continue;
/* Set the slack cost(s) on the goal row to 1.0 */
if(sp[i].iSlack_Neg >= 0) CHECK_RETURN( XPRSchgobj(prob, 1,
&sp[i].iSlack_Neg, &dOne) );
if(sp[i].iSlack_Pos >= 0) CHECK_RETURN( XPRSchgobj(prob, 1,
&sp[i].iSlack_Pos, &dOne) );
if(bHaveBasis) {
/* We have a basis from the last goal solve use this to hot start this
solve */
CHECK_RETURN( XPRSloadbasis(prob, rstatus, cstatus) );
}
if(bWriteGoalProbs) {
char buff[256];
sprintf(buff, "goal\\pc_goal%i", i + 1);
CHECK_RETURN( XPRSwriteprob(prob, buff, "") );
}
/* Solve the LP and get the solve status */
CHECK_RETURN( XPRSmipoptimize(prob, "l") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_MIP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_LPOBJVAL, &dObjVal) );
if(dObjVal != 0.0) {
/* Exit if we can't satisfy the current goal constraint */
*bIsInfeasible = 1;
goto cleanup;
}
/* Update the hot start basis */
if(!bHaveBasis) {
CHECK_RETURN( XPRSgetbasis(prob, rstatus, cstatus) );
bHaveBasis = 1;
}
/* Run the MIP search if required */
if(bRunMip) {
/* Solve the MIP search and get the solve status */
CHECK_RETURN( XPRSmipoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added
to the rows */
if(iStatus != XPRS_MIP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_MIPOBJVAL, &dObjVal) );
if(dObjVal != 0.0) {
/* Exit if we can't satisfy the current goal constraint */
*bIsInfeasible = 1;
goto cleanup;
}
}
/*
Restore the problem to the original state and fix the
slacks on the current goal row to zero ready to process
the next goal row.
*/
CHECK_RETURN( XPRSpostsolve(prob) );
if(sp[i].iSlack_Neg >= 0) CHECK_RETURN( XPRSchgbounds(prob, 1,
&sp[i].iSlack_Neg, &cBoth, &dZero) );
if(sp[i].iSlack_Pos >= 0) CHECK_RETURN( XPRSchgbounds(prob, 1,
&sp[i].iSlack_Pos, &cBoth, &dZero) );
}
cleanup:
free(sp);
free(rstatus);
free(cstatus);
return returnCode;
}
static int RunGoal_Preemptive_Objective(XPRSprob prob, int bRunMip,
GoalObjective GoalObjs,
int iGoalGoalObjs_Count,
int *bIsInfeasible, double *dObjRhs_)
{
int returnCode = 0;
int i, j, nRows, nCols, iStatus, bHaveBasis, ncoeffs;
double dObjVal, dZero = 0.0;
int *rstatus = NULL, *cstatus = NULL;
int bWriteGoalProbs = 0;
int mstart[2];
int *mclind = NULL;
double *dcmatval = NULL;
double dRhs, dMatRhs, dMatObRhs;
*bIsInfeasible = 0;
/* Ensure the problem is in the original state */
CHECK_RETURN( XPRSpostsolve(prob) );
/* Setup arrays to store basis and zero all costs */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_ROWS, &nRows) );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_COLS, &nCols) );
if(!(rstatus = malloc(sizeof(*rstatus) * nRows)) ||
!(cstatus = malloc(sizeof(*cstatus) * nCols)) ||
!(mclind = malloc(sizeof(*mclind) * nCols)) ||
!(dcmatval = malloc(sizeof(*dcmatval) * nCols)))
{
perror("malloc");
returnCode = -2;
goto cleanup;
}
if(bWriteGoalProbs) {
CHECK_RETURN( XPRSwriteprob(prob, "goal\\po_goal0", "") );
}
/* Loop through the goal objectives */
bHaveBasis = 0;
for(i = 0; i < iGoalGoalObjs_Count; i++) {
CHECK_RETURN( XPRSgetrhs(prob, &dMatRhs, GoalObjs[i].iRow,
GoalObjs[i].iRow) );
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_OBJRHS, &dMatObRhs) );
/* Copy the row coefficients into the objective */
CHECK_RETURN( XPRSgetrows(prob, mstart, mclind, dcmatval, nCols, &ncoeffs,
GoalObjs[i].iRow, GoalObjs[i].iRow) );
for(j = 0; j < nCols; j++) {
CHECK_RETURN( XPRSchgobj(prob, 1, &j, &dZero) );
}
CHECK_RETURN( XPRSchgobj(prob, ncoeffs, mclind, dcmatval) );
if(bHaveBasis) {
/* We have a basis from the last goal solve use this to hot start this
solve */
CHECK_RETURN( XPRSloadbasis(prob, rstatus, cstatus) );
}
if(bRunMip) {
/* Ensure that we restart the MIP solve each time */
CHECK_RETURN( XPRSpostsolve(prob) );
}
if(bWriteGoalProbs) {
char buff[256];
sprintf(buff, "goal\\po_goal%i", i + 1);
CHECK_RETURN( XPRSwriteprob(prob, buff, "") );
}
/* Solve the LP and get the solve status */
if(GoalObjs[i].iOptimizationSense >= 0) {
CHECK_RETURN( XPRSchgobjsense(prob, XPRS_OBJ_MINIMIZE) );
} else {
CHECK_RETURN( XPRSchgobjsense(prob, XPRS_OBJ_MAXIMIZE) );
}
CHECK_RETURN( XPRSmipoptimize(prob, "l") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_MIP_LP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_LPOBJVAL, &dObjVal) );
/* Update the hot start basis */
if(!bHaveBasis) {
CHECK_RETURN( XPRSgetbasis(prob, rstatus, cstatus) );
bHaveBasis = 1;
}
/* Run the MIP search if required */
if(bRunMip) {
/* Solve the MIP search and get the solve status */
CHECK_RETURN( XPRSmipoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added
to the rows */
if(iStatus != XPRS_MIP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_MIPOBJVAL, &dObjVal) );
}
/* Constraint the row to the objective we have calculated */
dObjVal -= dMatRhs + dMatObRhs;
if(GoalObjs[i].iOptimizationSense >= 0) {
char qLE = 'L';
CHECK_RETURN( XPRSchgrowtype(prob, 1, &GoalObjs[i].iRow, &qLE) );
if(GoalObjs[i].bFractionIsPercentage) {
dRhs = dObjVal + fabs(dObjVal) * GoalObjs[i].dTolerance * 0.01 +
dMatRhs;
} else {
dRhs = dObjVal + GoalObjs[i].dTolerance + dMatRhs;
}
} else {
char qGE = 'G';
CHECK_RETURN( XPRSchgrowtype(prob, 1, &GoalObjs[i].iRow, &qGE) );
if(GoalObjs[i].bFractionIsPercentage) {
dRhs = dObjVal - fabs(dObjVal) * GoalObjs[i].dTolerance * 0.01 +
dMatRhs;
} else {
dRhs = dObjVal - GoalObjs[i].dTolerance + dMatRhs;
}
}
if(dObjRhs_) *dObjRhs_ = dMatRhs + dMatObRhs;
CHECK_RETURN( XPRSchgrhs(prob, 1, &GoalObjs[i].iRow, &dRhs) );
}
cleanup:
free(rstatus);
free(cstatus);
free(mclind);
free(dcmatval);
return returnCode;
}
static int RunGoal_Archimedian_Constraint(XPRSprob prob, int bRunMip,
GoalConstraint GoalRows,
int iGoalRows_Count,
int *bIsInfeasible)
{
int returnCode = 0;
int i, j, iStatus, nCols;
double dZero = 0.0;
SlackPair sp = NULL;
int sp_count = 0;
int bWriteGoalProbs = 0;
*bIsInfeasible = 0;
/* Ensure the problem is in the original state */
CHECK_RETURN( XPRSpostsolve(prob) );
/* Zero all costs */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_COLS, &nCols) );
for(j = 0; j < nCols; j++) {
CHECK_RETURN( XPRSchgobj(prob, 1, &j, &dZero) );
}
/* Add the appropriate slacks for the goals (with associated costs for
satisfying those goals) */
for(i = 0; i < iGoalRows_Count; i++) {
CHECK_RETURN( RelaxConstraint(prob, GoalRows[i].iRow,
1 /*bArchimedianOtherwisePreemptive*/,
GoalRows[i].dCost /*dArchimedianWeight*/,
&sp, &sp_count) );
}
if(bWriteGoalProbs) {
CHECK_RETURN( XPRSwriteprob(prob, "goal\\ac_goal", "") );
}
/* Solve the LP and get the solve status */
CHECK_RETURN( XPRSlpoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_LPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_LP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
/* Run the MIP search if required */
if(bRunMip) {
/* Solve the MIP search and get the solve status */
CHECK_RETURN( XPRSmipoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_MIP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
}
cleanup:
free(sp);
return returnCode;
}
static int RunGoal_Archimedian_Objective(XPRSprob prob, int bRunMip,
GoalObjective GoalObjs,
int iGoalGoalObjs_Count,
int *bIsInfeasible,
double *dObjRhs_)
{
int returnCode = 0;
int i, j, nRows, nCols, iStatus, ncoeffs;
double dObjVal;
int bWriteGoalProbs = 0;
int mstart[2];
int *mclind = NULL;
double *dcmatval = NULL;
double *dcost = NULL;
double dObjRhs, dMatRhs;
*bIsInfeasible = 0;
/* Ensure the problem is in the original state */
CHECK_RETURN( XPRSpostsolve(prob) );
/* Setup arrays to store basis and zero all costs */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_ROWS, &nRows) );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_COLS, &nCols) );
if(!(mclind = malloc(sizeof(*mclind) * nCols)) ||
!(dcmatval = malloc(sizeof(*dcmatval) * nCols)) ||
!(dcost = malloc(sizeof(*dcost) * nCols)))
{
perror("malloc");
returnCode = -2;
goto cleanup;
}
memset(dcost, 0, sizeof(double) * nCols);
/* Loop through the goal objectives and sum up the row coefficients into the
cost function */
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_OBJRHS, &dObjRhs) );
for(i = 0; i < iGoalGoalObjs_Count; i++) {
CHECK_RETURN( XPRSgetrows(prob, mstart, mclind, dcmatval, nCols, &ncoeffs,
GoalObjs[i].iRow, GoalObjs[i].iRow) );
for(j = 0; j < ncoeffs; j++) {
dcost[mclind[j]] += dcmatval[j] * GoalObjs[i].dTolerance *
GoalObjs[i].iOptimizationSense;
}
CHECK_RETURN( XPRSgetrhs(prob, &dMatRhs, GoalObjs[i].iRow,
GoalObjs[i].iRow) );
dObjRhs += dMatRhs * GoalObjs[i].dTolerance *
GoalObjs[i].iOptimizationSense;
}
/* Add the new cost function to the problem */
for(j = 0; j < nCols; j++) {
CHECK_RETURN( XPRSchgobj(prob, 1, &j, &dcost[j]) );
}
if(bWriteGoalProbs) {
CHECK_RETURN( XPRSwriteprob(prob, "goal\\ao_goal", "") );
}
if(bRunMip) {
/* Ensure that we restart the MIP solve each time */
CHECK_RETURN( XPRSpostsolve(prob) );
}
/* Solve the LP and get the solve status */
CHECK_RETURN( XPRSchgobjsense(prob, XPRS_OBJ_MINIMIZE) );
CHECK_RETURN( XPRSlpoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_LPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_LP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_LPOBJVAL, &dObjVal) );
/* Run the MIP search if required */
if(bRunMip) {
/* Solve the MIP search and get the solve status */
CHECK_RETURN( XPRSmipoptimize(prob, "") );
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPSTATUS, &iStatus) );
/* Exit if the problem is infeasible even with the slacks we have added to
the rows */
if(iStatus != XPRS_MIP_OPTIMAL) {
*bIsInfeasible = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_MIPOBJVAL, &dObjVal) );
}
cleanup:
if(dObjRhs_) *dObjRhs_ = dObjRhs;
free(dcost);
free(mclind);
free(dcmatval);
return returnCode;
}
static int Read_Record_GoalObjective(XPRSprob prob, FILE *f,
int bArchimedianOtherwisePreemptive,
GoalObjective go, int *bEof)
{
int returnCode = 0;
char buff[1024], *p;
*bEof = 0;
memset(go, -1, sizeof(*go));
/* Read the row name */
if(!fgets(buff, sizeof(buff), f)) {
*bEof = 1;
goto cleanup;
}
buff[strlen(buff) - 1] = '\0';
if(!*buff) {
*bEof = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetindex(prob, 1, buff, &go->iRow) );
if(go->iRow < 0) {
returnCode = -1;
goto cleanup;
}
if(bArchimedianOtherwisePreemptive) {
/* Read multiplier */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
go->dTolerance = strtod(buff, &p);
if(!isspace(*p)) {
returnCode = -1;
goto cleanup;
}
/* Read sense */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
if(strnicmp(buff, "mi", 2) == 0) {
go->iOptimizationSense = 1;
} else if(strnicmp(buff, "ma", 2) == 0) {
go->iOptimizationSense = -1;
} else {
returnCode = -1;
goto cleanup;
}
} else {
/* Read sense */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
if(strnicmp(buff, "mi", 2) == 0) {
go->iOptimizationSense = 1;
} else if(strnicmp(buff, "ma", 2) == 0) {
go->iOptimizationSense = -1;
} else {
returnCode = -1;
goto cleanup;
}
/* Read multiplier interpretation */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
if(tolower(*buff) == 'p') {
go->bFractionIsPercentage = 1;
} else if(tolower(*buff) == 'd') {
go->bFractionIsPercentage = 0;
} else {
returnCode = -1;
goto cleanup;
}
/* Read multiplier */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
go->dTolerance = strtod(buff, &p);
if(!isspace(*p)) {
returnCode = -1;
goto cleanup;
}
}
cleanup:
return returnCode;
}
static int Read_Record_GoalConstraint(XPRSprob prob, FILE *f,
int bArchimedianOtherwisePreemptive,
GoalConstraint gc, int *bEof)
{
int returnCode = 0;
char buff[1024], *p;
*bEof = 0;
memset(gc, -1, sizeof(*gc));
/* Read the row name */
if(!fgets(buff, sizeof(buff), f)) {
*bEof = 1;
goto cleanup;
}
buff[strlen(buff) - 1] = '\0';
if(!*buff) {
*bEof = 1;
goto cleanup;
}
CHECK_RETURN( XPRSgetindex(prob, 1, buff, &gc->iRow) );
if(gc->iRow < 0) {
returnCode = -1;
goto cleanup;
}
if(bArchimedianOtherwisePreemptive) {
/* Read multiplier */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
gc->dCost = strtod(buff, &p);
if(!isspace(*p)) {
returnCode = -1;
goto cleanup;
}
}
cleanup:
return returnCode;
}
static int Read_Goal_Directives(XPRSprob prob, const char *sFileName, Goal g)
{
int returnCode = 0;
FILE *f = NULL;
char buff[1024];
int bEof;
memset(g, 0, sizeof(*g));
if(strlen(sFileName) + strlen(".gol") >= sizeof(buff)) {
returnCode = -1;
goto cleanup;
}
if(strlen(sFileName) < strlen(".gol")) {
strcpy(buff, sFileName);
strcat(buff, ".gol");
} else {
strcpy(buff, sFileName);
if(stricmp(buff + strlen(buff) - strlen(".gol"), ".gol")) {
strcat(buff, ".gol");
}
}
if(!(f = fopen(buff, "r"))) {
returnCode = -1;
goto cleanup;
}
/* Read Archimedian or Preemptive */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
switch(tolower(buff[0])) {
case('a') : g->bArchimedianOtherwisePreemptive = 1; break;
case('p') : g->bArchimedianOtherwisePreemptive = 0; break;
default : returnCode = -1; goto cleanup;
}
/* Read Constraints or Objective */
if(!fgets(buff, sizeof(buff), f)) {
returnCode = -1;
goto cleanup;
}
switch(tolower(buff[0])) {
case('c') : g->bConstraintsOtherwiseObjective = 1; break;
case('o') : g->bConstraintsOtherwiseObjective = 0; break;
default : returnCode = -1; goto cleanup;
}
/* Read records to end-of-file */
for(;;) {
if(g->bConstraintsOtherwiseObjective) {
CHECK_RETURN( GcArray_AddRecord(&g->gc, &g->gc_count) );
CHECK_RETURN( Read_Record_GoalConstraint(prob, f,
g->bArchimedianOtherwisePreemptive,
&g->gc[g->gc_count - 1], &bEof) );
if(bEof) {g->gc_count--; break;}
} else {
CHECK_RETURN( GoArray_AddRecord(&g->go, &g->go_count) );
CHECK_RETURN( Read_Record_GoalObjective(prob, f,
g->bArchimedianOtherwisePreemptive,
&g->go[g->go_count - 1], &bEof) );
if(bEof) {g->go_count--; break;}
}
}
cleanup:
if (f) {
fclose(f);
}
return returnCode;
}
int Goal_Run_One(XPRSprob prob, const char *sGoalFileBaseName, double *dResult)
{
int returnCode = 0;
int bIsInfeasible, iMipEnts, bRunMip;
struct Goal_s g = {0};
double dObjVal, dObjRhs;
/* Read .gol file directives */
CHECK_RETURN( Read_Goal_Directives(prob, sGoalFileBaseName, &g) );
/* Decide if we are solving a MIP */
CHECK_RETURN( XPRSgetintattrib(prob, XPRS_MIPENTS, &iMipEnts) );
bRunMip = !iMipEnts ? 0 : 1;
/* Run the goal */
dObjRhs = 0;
if(g.bConstraintsOtherwiseObjective) {
if(g.bArchimedianOtherwisePreemptive) {
CHECK_RETURN( RunGoal_Archimedian_Constraint(prob, bRunMip, g.gc,
g.gc_count,
&bIsInfeasible) );
} else {
CHECK_RETURN( RunGoal_Preemptive_Constraint(prob, bRunMip, g.gc,
g.gc_count,
&bIsInfeasible) );
}
} else {
if(g.bArchimedianOtherwisePreemptive) {
CHECK_RETURN( RunGoal_Archimedian_Objective(prob, bRunMip, g.go,
g.go_count,
&bIsInfeasible, &dObjRhs) );
} else {
CHECK_RETURN( RunGoal_Preemptive_Objective(prob, bRunMip, g.go,
g.go_count,
&bIsInfeasible, &dObjRhs) );
}
}
/* Log results */
CHECK_RETURN( XPRSgetdblattrib(prob, XPRS_LPOBJVAL, &dObjVal) );
dObjVal -= dObjRhs;
*dResult = dObjVal;
cleanup:
/* Free memory allocated in Read_Goal_Directives */
if (g.go) { free(g.go); }
if (g.gc) { free(g.gc); }
return returnCode;
}
int main(void) {
int returnCode = 0;
XPRSprob prob = NULL;
double dObjVal;
/* Initialize the optimizer. */
if ( XPRSinit("") != 0 ) {
char message[512];
XPRSgetlicerrmsg(message, sizeof(message));
fprintf(stderr, "Licensing error: %s\n", message);
return 1;
}
/* Create a new problem and immediately register a message handler.
* Once we have a message handler installed, errors will produce verbose
* error messages on the console and we can limit ourselves to minimal
* error handling in the code here.
*/
CHECK_RETURN( XPRScreateprob(&prob) );
CHECK_RETURN( XPRSaddcbmessage(prob, messagecb, NULL, 0) );
#define DIRECTORY_MATRICES ""
#define DIRECTORY_GOALFILE ""
CHECK_RETURN( XPRSsetintcontrol(prob, XPRS_KEEPNROWS, 1) );
/* Preemptive Objective */
CHECK_RETURN( XPRSreadprob(prob, DIRECTORY_MATRICES "goalobj1","") );
CHECK_RETURN( Goal_Run_One(prob, DIRECTORY_GOALFILE "gc1", &dObjVal) );
/* Archimedian Objective */
CHECK_RETURN( XPRSreadprob(prob, DIRECTORY_MATRICES "goalobj1","") );
CHECK_RETURN( Goal_Run_One(prob, DIRECTORY_GOALFILE "gd1", &dObjVal) );
/* Preemptive Constraint */
CHECK_RETURN( XPRSreadprob(prob, DIRECTORY_MATRICES "goalcon3","") );
CHECK_RETURN( Goal_Run_One(prob, DIRECTORY_GOALFILE "ga3", &dObjVal) );
/* Archimedian Constraint */
CHECK_RETURN( XPRSreadprob(prob, DIRECTORY_MATRICES "goalcon3","") );
CHECK_RETURN( Goal_Run_One(prob, DIRECTORY_GOALFILE "gb3", &dObjVal) );
cleanup:
if (returnCode > 0) {
/* There was an error with the solver. Get the error code and error message.
* If prob is still NULL then the error was in XPRScreateprob() and
* we cannot find more detailed error information.
*/
if (prob != NULL) {
int errorCode = -1;
char errorMessage[512] = {0};
XPRSgetintattrib(prob, XPRS_ERRORCODE, &errorCode);
XPRSgetlasterror(prob, errorMessage);
fprintf(stderr, "Error %d: %s\n", errorCode, errorMessage);
}
}
/* Free the resources (variables are initialized so that this is valid
* even in case of error).
*/
XPRSdestroyprob(prob);
XPRSfree();
return returnCode;
}
|
