static int
optimize_and_report (CPXENVptr env, CPXLPptr lp,
int *solstat_p, double *objval_p)
{
int status = 0;
double x[NUMCOLS];
double pi[TOTROWS];
double slack[TOTROWS];
double dj[NUMCOLS];
int i, j;
int cur_numrows, cur_numcols;
status = CPXXqpopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize QP.\n");
goto TERMINATE;
}
status = CPXXsolution (env, lp, solstat_p, objval_p, x, pi, slack, dj);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write the output to the screen. */
printf ("\nSolution status = %d\n", *solstat_p);
printf ("Solution value = %f\n\n", *objval_p);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is, rather than using what was passed to CPXXcopylp.
cur_numrows and cur_numcols store the current number of rows and
columns, respectively. */
cur_numrows = CPXXgetnumrows (env, lp);
cur_numcols = CPXXgetnumcols (env, lp);
for (i = 0; i < cur_numrows; i++) {
printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]);
}
for (j = 0; j < cur_numcols; j++) {
printf ("Column %d: Value = %10f Reduced cost = %10f\n",
j, x[j], dj[j]);
}
TERMINATE:
return (status);
} /* END optimize_and_report */
int
main (void)
{
/* Declare pointers for the variables and arrays that will contain
the data which define the LP problem. The setproblemdata() routine
allocates space for the problem data. */
char *probname = NULL;
CPXDIM numcols;
CPXDIM numrows;
int objsen;
double *obj = NULL;
double *rhs = NULL;
char *sense = NULL;
CPXNNZ *matbeg = NULL;
CPXDIM *matcnt = NULL;
CPXDIM *matind = NULL;
double *matval = NULL;
double *lb = NULL;
double *ub = NULL;
CPXNNZ *qmatbeg = NULL;
CPXDIM *qmatcnt = NULL;
CPXDIM *qmatind = NULL;
double *qmatval = NULL;
/* Declare and allocate space for the variables and arrays where we
will store the optimization results including the status, objective
value, variable values, dual values, row slacks and variable
reduced costs. */
int solstat;
double objval;
double x[NUMCOLS];
double pi[NUMROWS];
double slack[NUMROWS];
double dj[NUMCOLS];
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
CPXDIM i, j;
CPXDIM cur_numrows, cur_numcols;
/* Initialize the CPLEX environment */
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Fill in the data for the problem. */
status = setproblemdata (&probname, &numcols, &numrows, &objsen, &obj,
&rhs, &sense, &matbeg, &matcnt, &matind,
&matval, &lb, &ub, &qmatbeg, &qmatcnt,
&qmatind, &qmatval);
if ( status ) {
fprintf (stderr, "Failed to build problem data arrays.\n");
goto TERMINATE;
}
/* Create the problem. */
lp = CPXXcreateprob (env, &status, probname);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create problem.\n");
goto TERMINATE;
}
/* Now copy the LP part of the problem data into the lp */
status = CPXXcopylp (env, lp, numcols, numrows, objsen, obj, rhs,
sense, matbeg, matcnt, matind, matval,
lb, ub, NULL);
if ( status ) {
fprintf (stderr, "Failed to copy problem data.\n");
goto TERMINATE;
}
status = CPXXcopyquad (env, lp, qmatbeg, qmatcnt, qmatind, qmatval);
if ( status ) {
fprintf (stderr, "Failed to copy quadratic matrix.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXXqpopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize QP.\n");
goto TERMINATE;
}
status = CPXXsolution (env, lp, &solstat, &objval, x, pi, slack, dj);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write the output to the screen. */
printf ("\nSolution status = %d\n", solstat);
printf ("Solution value = %f\n\n", objval);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is, rather than using what was passed to CPXXcopylp.
cur_numrows and cur_numcols store the current number of rows and
columns, respectively. */
cur_numrows = CPXXgetnumrows (env, lp);
cur_numcols = CPXXgetnumcols (env, lp);
for (i = 0; i < cur_numrows; i++) {
printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]);
}
for (j = 0; j < cur_numcols; j++) {
printf ("Column %d: Value = %10f Reduced cost = %10f\n",
j, x[j], dj[j]);
}
/* Finally, write a copy of the problem to a file. */
status = CPXXwriteprob (env, lp, "qpex1.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
TERMINATE:
/* Free up the problem as allocated by CPXXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
/* Free up the problem data arrays, if necessary. */
free_and_null ((char **) &probname);
free_and_null ((char **) &obj);
free_and_null ((char **) &rhs);
free_and_null ((char **) &sense);
free_and_null ((char **) &matbeg);
free_and_null ((char **) &matcnt);
free_and_null ((char **) &matind);
free_and_null ((char **) &matval);
free_and_null ((char **) &lb);
free_and_null ((char **) &ub);
free_and_null ((char **) &qmatbeg);
free_and_null ((char **) &qmatcnt);
free_and_null ((char **) &qmatind);
free_and_null ((char **) &qmatval);
return (status);
} /* END main */
int
main (int argc,
char *argv[])
{
int status = 0;
/* Declare and allocate space for the variables and arrays where
we will store the optimization results, including the status,
objective value, and variable values */
int solstat;
double objval, relobj;
double *x = NULL;
MYCB info;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CPXLPptr lpclone = NULL;
CPXDIM j;
CPXDIM cur_numcols;
/* Check the command line arguments */
if ( argc != 2 ) {
usage (argv[0]);
goto TERMINATE;
}
/* Initialize the CPLEX environment */
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
/* Turn on traditional search for use with control callbacks */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_Search, CPX_MIPSEARCH_TRADITIONAL);
if ( status ) goto TERMINATE;
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* We transfer a problem with semi-continuous or semi-integer
variables to a MIP problem by adding variables and
constraints. So in MIP callbacks, the size of the problem
is changed and this example won't work for such problems */
if ( CPXXgetnumsemicont (env, lp) + CPXXgetnumsemiint (env, lp) ) {
fprintf (stderr,
"Not for problems with semi-continuous or semi-integer variables.\n");
goto TERMINATE;
}
/* The size of the problem should be obtained by asking CPLEX what
the actual size is. cur_numcols store the current number
of columns */
cur_numcols = CPXXgetnumcols (env, lp);
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "Memory allocation failed.\n");
goto TERMINATE;
}
/* Solve relaxation of MIP */
/* Clone original model */
lpclone = CPXXcloneprob (env, lp, &status);
if ( status ) {
fprintf (stderr, "Failed to clone problem.\n");
goto TERMINATE;
}
/* Relax */
status = CPXXchgprobtype (env, lpclone, CPXPROB_LP);
if ( status ) {
fprintf (stderr, "Failed to relax problem.\n");
goto TERMINATE;
}
/* Solve LP relaxation of original model using "default"
LP solver */
status = CPXXlpopt (env, lpclone);
if ( status ) {
fprintf (stderr, "Failed to solve relaxation.\n");
goto TERMINATE;
}
printf ("Solution status %d.\n", CPXXgetstat(env,lpclone));
status = CPXXsolution (env, lpclone, NULL, &relobj, x, NULL,
NULL, NULL);
if ( status ) {
fprintf (stderr, "Failed to extract solution.\n");
goto TERMINATE;
}
printf ("\nLP relaxation objective: %.4e\n\n", relobj);
/* Set up solve callback */
info.count = 0;
info.mip = lp;
info.relx = x;
status = CPXXsetsolvecallbackfunc (env, &solvecallback,
(void *) &info);
if ( status ) {
fprintf (stderr, "Failed to set solve callback.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution */
status = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
status = CPXXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
if ( fabs (x[j]) > 1e-10 ) {
printf ( "Column %d: Value = %17.10g\n", j, x[j]);
}
}
TERMINATE:
/* Free the solution vector */
free_and_null ((char **) &x);
/* Free the problem as allocated by CPXXcreateprob and
CPXXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the cloned lp as allocated by CPXXcloneprob,
if necessary */
if ( lpclone != NULL ) {
status = CPXXfreeprob (env, &lpclone);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors
will be seen if the CPXPARAM_ScreenOutput parameter is set to
CPX_ON */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (void)
{
char probname[16]; /* Problem name is max 16 characters */
/* Declare and allocate space for the variables and arrays where we
will store the optimization results including the status, objective
value, variable values, dual values, row slacks and variable
reduced costs. */
int solstat;
double objval;
double x[NUMCOLS];
double pi[NUMROWS];
double slack[NUMROWS];
double dj[NUMCOLS];
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
CPXDIM i, j;
CPXDIM cur_numrows, cur_numcols;
char errmsg[CPXMESSAGEBUFSIZE];
CPXCHANNELptr cpxerror = NULL;
CPXCHANNELptr cpxwarning = NULL;
CPXCHANNELptr cpxresults = NULL;
CPXCHANNELptr ourchannel = NULL;
char *errorlabel = "cpxerror";
char *warnlabel = "cpxwarning";
char *reslabel = "cpxresults";
char *ourlabel = "Our Channel";
CPXFILEptr fpout = NULL;
/* Initialize the CPLEX environment */
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
/* Since the message handler is yet to be set up, we'll call our
messaging function directly to print out any errors */
if ( env == NULL ) {
ourmsgfunc ("Our Message", "Could not open CPLEX environment.\n");
goto TERMINATE;
}
/* Now get the standard channels. If an error, just call our
message function directly. */
status = CPXXgetchannels (env, &cpxresults, &cpxwarning, &cpxerror, NULL);
if ( status ) {
ourmsgfunc ("Our Message", "Could not get standard channels.\n");
CPXXgeterrorstring (env, status, errmsg);
ourmsgfunc ("Our Message", errmsg);
goto TERMINATE;
}
/* Now set up the error channel first. The label will be "cpxerror" */
status = CPXXaddfuncdest (env, cpxerror, errorlabel, ourmsgfunc);
if ( status ) {
ourmsgfunc ("Our Message", "Could not set up error message handler.\n");
CPXXgeterrorstring (env, status, errmsg);
ourmsgfunc ("Our Message", errmsg);
}
/* Now that we have the error message handler set up, all CPLEX
generated errors will go through ourmsgfunc. So we don't have
to use CPXXgeterrorstring to determine the text of the message.
We can also use CPXXmsg to do any other printing. */
status = CPXXaddfuncdest (env, cpxwarning, warnlabel, ourmsgfunc);
if ( status ) {
CPXXmsg (cpxerror, "Failed to set up handler for cpxwarning.\n");
goto TERMINATE;
}
status = CPXXaddfuncdest (env, cpxresults, reslabel, ourmsgfunc);
if ( status ) {
CPXXmsg (cpxerror, "Failed to set up handler for cpxresults.\n");
goto TERMINATE;
}
/* Now turn on the iteration display. */
status = CPXXsetintparam (env, CPXPARAM_Simplex_Display, 2);
if ( status ) {
CPXXmsg (cpxerror, "Failed to turn on simplex display level.\n");
goto TERMINATE;
}
/* Create the problem. */
strcpy (probname, "example");
lp = CPXXcreateprob (env, &status, probname);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. */
if ( lp == NULL ) {
CPXXmsg (cpxerror, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now populate the problem with the data. */
status = populatebycolumn (env, lp);
if ( status ) {
CPXXmsg (cpxerror, "Failed to populate problem data.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXXlpopt (env, lp);
if ( status ) {
CPXXmsg (cpxerror, "Failed to optimize LP.\n");
goto TERMINATE;
}
status = CPXXsolution (env, lp, &solstat, &objval, x, pi, slack, dj);
if ( status ) {
CPXXmsg (cpxerror, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write the output to the screen. We will also write it to a
file as well by setting up a file destination and a function
destination. */
ourchannel = CPXXaddchannel (env);
if ( ourchannel == NULL ) {
CPXXmsg (cpxerror, "Failed to set up our private channel.\n");
goto TERMINATE;
}
fpout = CPXXfopen ("lpex5.msg", "w");
if ( fpout == NULL ) {
CPXXmsg (cpxerror, "Failed to open lpex5.msg file for output.\n");
goto TERMINATE;
}
status = CPXXaddfpdest (env, ourchannel, fpout);
if ( status ) {
CPXXmsg (cpxerror, "Failed to set up output file destination.\n");
goto TERMINATE;
}
status = CPXXaddfuncdest (env, ourchannel, ourlabel, ourmsgfunc);
if ( status ) {
CPXXmsg (cpxerror, "Failed to set up our output function.\n");
goto TERMINATE;
}
/* Now any message to channel ourchannel will go into the file
and into the file opened above. */
CPXXmsg (ourchannel, "\nSolution status = %d\n", solstat);
CPXXmsg (ourchannel, "Solution value = %f\n\n", objval);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is, rather than using sizes from when the problem
was built. cur_numrows and cur_numcols store the current number
of rows and columns, respectively. */
cur_numrows = CPXXgetnumrows (env, lp);
cur_numcols = CPXXgetnumcols (env, lp);
for (i = 0; i < cur_numrows; i++) {
CPXXmsg (ourchannel, "Row %d: Slack = %10f Pi = %10f\n",
i, slack[i], pi[i]);
}
for (j = 0; j < cur_numcols; j++) {
CPXXmsg (ourchannel, "Column %d: Value = %10f Reduced cost = %10f\n",
j, x[j], dj[j]);
}
/* Finally, write a copy of the problem to a file. */
status = CPXXwriteprob (env, lp, "lpex5.lp", NULL);
if ( status ) {
CPXXmsg (cpxerror, "Failed to write LP to disk.\n");
goto TERMINATE;
}
TERMINATE:
/* First check if ourchannel is open */
if ( ourchannel != NULL ) {
int chanstat;
chanstat = CPXXdelfuncdest (env, ourchannel, ourlabel, ourmsgfunc);
if ( chanstat ) {
strcpy (errmsg, "CPXXdelfuncdest failed.\n");
ourmsgfunc ("Our Message", errmsg);
if (!status) status = chanstat;
}
if ( fpout != NULL ) {
chanstat = CPXXdelfpdest (env, ourchannel, fpout);
if ( chanstat ) {
strcpy (errmsg, "CPXXdelfpdest failed.\n");
ourmsgfunc ("Our Message", errmsg);
if (!status) status = chanstat;
}
CPXXfclose (fpout);
}
chanstat = CPXXdelchannel (env, &ourchannel);
if ( chanstat ) {
strcpy (errmsg, "CPXXdelchannel failed.\n");
ourmsgfunc ("Our Message", errmsg);
if (!status) status = chanstat;
}
}
/* Free up the problem as allocated by CPXXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
strcpy (errmsg, "CPXXfreeprob failed.\n");
ourmsgfunc ("Our Message", errmsg);
}
}
/* Now delete our function destinations from the 3 CPLEX channels. */
if ( cpxresults != NULL ) {
int chanstat;
chanstat = CPXXdelfuncdest (env, cpxresults, reslabel, ourmsgfunc);
if ( chanstat && !status ) {
status = chanstat;
strcpy (errmsg, "Failed to delete cpxresults function.\n");
ourmsgfunc ("Our Message", errmsg);
}
}
if ( cpxwarning != NULL ) {
int chanstat;
chanstat = CPXXdelfuncdest (env, cpxwarning, warnlabel, ourmsgfunc);
if ( chanstat && !status ) {
status = chanstat;
strcpy (errmsg, "Failed to delete cpxwarning function.\n");
ourmsgfunc ("Our Message", errmsg);
}
}
if ( cpxerror != NULL ) {
int chanstat;
chanstat = CPXXdelfuncdest (env, cpxerror, errorlabel, ourmsgfunc);
if ( chanstat && !status ) {
status = chanstat;
strcpy (errmsg, "Failed to delete cpxerror function.\n");
ourmsgfunc ("Our Message", errmsg);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
strcpy (errmsg, "Could not close CPLEX environment.\n");
ourmsgfunc ("Our Message", errmsg);
CPXXgeterrorstring (env, status, errmsg);
ourmsgfunc ("Our Message", errmsg);
}
}
return (status);
} /* END main */
static int
steelt_opt_and_soln (void (CPXPUBLIC *errmsgfunc)(void *, const char *),
void *handle, int numprod, int tweeks, double const *rate,
double const *inv0, double const *avail,
double const *flatmarket, double const *prodcost,
double const *invcost, double const *flatrevenue,
int *lpstat_p, double *objval_p, double *flatmake,
double *flatinv, double *flatsell, int buildbycolumn)
{
char const *probname = "steelT";
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CPXCHANNELptr cpxerror = NULL;
CPXCHANNELptr cpxwarning = NULL;
int status = 0;
int lpstat;
double objval;
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. We'll call the errmsgfunc with the error, because
we can't call CPXXmsg if CPXXopenCPLEX failed. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
if ( errmsgfunc != NULL ) {
(*errmsgfunc) (handle, "Could not open CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
(*errmsgfunc) (handle, errmsg);
}
goto TERMINATE;
}
status = CPXXgetchannels (env, NULL, &cpxwarning, &cpxerror, NULL);
if ( status ) {
if ( errmsgfunc != NULL ) {
(*errmsgfunc) (handle, "Error in CPXXgetchannels.\n");
}
goto TERMINATE;
}
if ( errmsgfunc != NULL ) {
status = CPXXaddfuncdest (env, cpxerror, handle, errmsgfunc);
if ( !status ) {
status = CPXXaddfuncdest (env, cpxwarning, handle, errmsgfunc);
}
if ( status ) {
(*errmsgfunc) (handle, "Error in CPXXaddfuncdest.\n");
goto TERMINATE;
}
}
/* Now that the channels have the error message function, we can
use CPXXmsg for errors. */
/* Create the problem */
lp = CPXXcreateprob (env, &status, probname);
if ( lp == NULL ) {
status = -2;
CPXXmsg (cpxerror, "Failed to create LP.\n");
goto TERMINATE;
}
if ( buildbycolumn )
status = colsteel (numprod, tweeks, rate, inv0, avail, flatmarket,
prodcost, invcost, flatrevenue, env, lp);
else
status = rowsteel (numprod, tweeks, rate, inv0, avail, flatmarket,
prodcost, invcost, flatrevenue, env, lp);
if ( status ) goto TERMINATE;
status = CPXXlpopt (env, lp);
if ( status ) {
CPXXmsg (cpxerror,"Optimization failed. Status %d.\n", status);
goto TERMINATE;
}
status = CPXXsolution (env, lp, &lpstat, &objval, NULL, NULL, NULL, NULL);
if ( status ) {
CPXXmsg (cpxerror, "Solution failed. Status %d.\n", status);
goto TERMINATE;
}
*objval_p = objval;
*lpstat_p = lpstat;
/* Now get the solution. Use the fact that the variables are
* added in the order Make, Inv, Sell, and that the slices of
* the x vector can be used to copy over the solution into
* the flat... arrays. */
/* Get the Make variables */
status = CPXXgetx (env, lp, flatmake, 0, numprod*tweeks-1);
if ( status ) {
CPXXmsg (cpxerror, "CPXXgetx failed to get Make solution. Status %d.\n",
status);
goto TERMINATE;
}
/* Get the Inv variables */
status = CPXXgetx (env, lp, flatinv, numprod*tweeks, 2*numprod*tweeks-1);
if ( status ) {
CPXXmsg (cpxerror, "CPXXgetx failed to get Inv solution. Status %d.\n",
status);
goto TERMINATE;
}
/* Get the Sell variables */
status = CPXXgetx (env, lp, flatsell, 2*numprod*tweeks,
3*numprod*tweeks-1);
if ( status ) {
CPXXmsg (cpxerror, "CPXXgetx failed to get Sell solution. Status %d.\n",
status);
goto TERMINATE;
}
TERMINATE:
if ( lp != NULL ) CPXXfreeprob (env, &lp);
if ( errmsgfunc != NULL && env != NULL ) {
int dfstat;
dfstat = CPXXdelfuncdest (env, cpxerror, handle, errmsgfunc);
if ( !dfstat ) {
dfstat = CPXXdelfuncdest (env, cpxwarning, handle, errmsgfunc);
}
if ( dfstat ) {
(*errmsgfunc) (handle, "CPXXdelfuncdest failed.\n");
}
if ( dfstat && !status ) status = dfstat;
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
int closestat;
closestat = CPXXcloseCPLEX (&env);
if ( closestat && errmsgfunc != NULL) {
char errmsg[CPXMESSAGEBUFSIZE];
(*errmsgfunc) (handle, "Could not close CPLEX environment.\n");
CPXXgeterrorstring (env, closestat, errmsg);
(*errmsgfunc) (handle, errmsg);
}
if ( closestat && !status ) status = closestat;
}
return (status);
} /* END steelt_opt_and_soln */
