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 (int argc, char *argv[])
{
int status = 0;
int solstat;
/* 17 city problem */
const char* filename = "../../../examples/data/atsp.dat";
/* ATSP instance */
double **arc_cost = NULL;
CPXDIM num_nodes;
/* data required to print the optimal ATSP tour */
double objval;
CPXDIM num_x_cols;
double *x = NULL;
CPXDIM i, j;
CPXDIM *succ = NULL;
/* Cplex environment and master ILP */
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
/* Decide when Benders' cuts are going to be separated:
0: only when a integer solution if found
(i.e., wherefrom == CPX_CALLBACK_MIP_CUT_FEAS )
1: even to cut-off fractional solutions,
at the end of the cplex cut-loop
(i.e., wherefrom == CPX_CALLBACK_MIP_CUT_LAST ||
wherefrom == CPX_CALLBACK_MIP_CUT_FEAS ) */
int separate_fractional_solutions;
/* Cut callback data structure */
USER_CBHANDLE user_cbhandle;
user_cbhandle.env = NULL;
user_cbhandle.lp = NULL;
user_cbhandle.x = NULL;
user_cbhandle.indices = NULL;
user_cbhandle.ray = NULL;
user_cbhandle.cutval = NULL;
user_cbhandle.cutind = NULL;
/* Check the command line arguments */
if ( argc != 2 && argc != 3) {
usage (argv[0]);
goto TERMINATE;
}
if ( (argv[1][0] != '1' && argv[1][0] != '0') ||
argv[1][1] != '\0' ) {
usage (argv[0]);
goto TERMINATE;
}
separate_fractional_solutions = ( argv[1][0] == '0' ? 0 : 1 );
printf ("Benders' cuts separated to cut off: ");
if ( separate_fractional_solutions ) {
printf ("Integer and fractional infeasible solutions.\n");
}
else {
printf ("Only integer infeasible solutions.\n");
}
fflush (stdout);
if ( argc == 3 ) filename = argv[2];
/* Read the ATSP instance */
status = read_ATSP (filename, &arc_cost, &num_nodes);
if ( status ) {
fprintf (stderr, "Error in read_ATSP, status = %d\n", status);
goto TERMINATE;
}
/* Init the CPLEX environment */
env = CPXXopenCPLEX (&status);
if ( env == NULL ) {
fprintf (stderr, "Failure in CPXXopenCPLEX, status = %d.\n", status);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr, "Failed to turn on screen indicator, status = %d.\n",
status);
goto TERMINATE;
}
/* Set MIP log interval to 1 */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1);
if ( status ) {
fprintf (stderr,
"Failed to set CPXPARAM_MIP_Interval, status = %d.\n", status);
goto TERMINATE;
}
/* Create the master ILP */
lp = CPXXcreateprob (env, &status, "master_ILP.lp");
if ( lp == NULL ) {
fprintf (stderr, "Failure in CPXXcreateprob, status = %d.\n", status);
goto TERMINATE;
}
status = create_master_ILP (env, lp, arc_cost, num_nodes);
if ( status ) {
fprintf (stderr,
"Failed to create the master ILP.\n");
goto TERMINATE;
}
/* Init the cut callback data structure */
status = init_user_cbhandle (&user_cbhandle, num_nodes,
separate_fractional_solutions);
if ( status ) {
fprintf (stderr,
"Failed to init the cut callback data structure, status = %d.\n",
status);
goto TERMINATE;
}
/* Set up environment parameters to use the function benders_callback
as cut callback function */
status = set_benders_callback (env, &user_cbhandle);
if ( status ) {
fprintf (stderr,
"Failure in function set_benders_callback: status = %d.\n",
status);
goto TERMINATE;
}
/* Optimize the problem and obtain solution status */
status = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP, status = %d.\n", status);
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("\nSolution status: %d\n", solstat);
/* Write out the objective value */
if ( CPXXgetobjval (env, lp, &objval) ) {
printf ("Failed to obtain objective value.\n");
}
else {
printf ("Objective value: %17.10e\n", objval);
}
if ( solstat == CPXMIP_OPTIMAL ) {
/* Write out the optimal tour */
num_x_cols = CPXXgetnumcols (env, lp);
x = malloc (num_x_cols * sizeof(*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for x array.\n");
status = -1;
goto TERMINATE;
}
status = CPXXgetx (env, lp, x, 0, num_x_cols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution, status = %d.\n", status);
goto TERMINATE;
}
succ = malloc (num_nodes * sizeof(*succ));
if ( succ == NULL ) {
fprintf (stderr, "No memory for succ array.\n");
status = -1;
goto TERMINATE;
}
for (j = 0; j < num_nodes; ++j)
succ[j] = -1;
for (i = 0; i < num_nodes; ++i) {
for (j = 0; j < num_nodes; ++j) {
if ( fabs (x[i * num_nodes + j]) > 1e-03 )
succ[i] = j;
}
}
printf ("Optimal tour:\n");
i = 0;
while ( succ[i] != 0 ) {
printf ("%d, ", i);
i = succ[i];
}
printf ("%d\n", i);
}
else {
printf ("Solution status is not CPX_STAT_OPTIMAL\n");
}
TERMINATE:
/* Free the allocated memory if necessary */
free_and_null ((char **) &x);
free_and_null ((char **) &succ);
if ( arc_cost != NULL ) {
for (i = 0; i < num_nodes; ++i) {
free_and_null ((char **) &(arc_cost[i]));
}
}
free_and_null ((char **) &arc_cost);
status = free_user_cbhandle (&user_cbhandle);
if ( status ) {
fprintf (stderr, "free_user_cbhandle failed, status = %d.\n",
status);
}
if ( lp != NULL ) {
int local_status = CPXXfreeprob (env, &lp);
if ( local_status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
local_status);
status = local_status;
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
int local_status = CPXXcloseCPLEX (&env);
if ( local_status ) {
fprintf (stderr,
"Could not close CPLEX environment, status = %d.\n",
local_status);
status = local_status;
}
}
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;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CPXDIM j;
CPXDIM cur_numcols;
int wantorig = 1;
int nameind = 1;
/* Check the command line arguments */
if ( argc != 2 ) {
if ( argc != 3 ||
argv[1][0] != '-' ||
argv[1][1] != 'r' ) {
usage (argv[0]);
goto TERMINATE;
}
wantorig = 0;
nameind = 2;
}
/* 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;
}
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (env, &status, argv[nameind]);
/* 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[nameind], NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* Set up to use MIP callbacks */
status = CPXXsetnodecallbackfunc (env, userselectnode, NULL) ||
CPXXsetbranchcallbackfunc (env, usersetbranch, NULL) ||
CPXXsetsolvecallbackfunc (env, usersolve, NULL);
if ( wantorig ) {
/* Assure linear mappings between the presolved and original
models */
status = CPXXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Let MIP callbacks work on the original model */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_CallbackReducedLP,
CPX_OFF);
if ( status ) goto TERMINATE;
}
/* Set MIP log interval to 1 */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1);
if ( 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;
/* 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);
cur_numcols = CPXXgetnumcols (env, lp);
/* Allocate space for solution */
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
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 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
myoptimize (CPXENVptr env, CPXLPptr lp, double true_objval)
{
int status = 0;
int solstat = 0;
CPXDIM j;
double objval;
double *x = NULL;
CPXDIM cur_numcols = CPXXgetnumcols (env, lp);
/* 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);
/* Allocate space for solution */
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
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 ) {
char *colname[1];
char namestore[6];
CPXSIZE surplus = 0;
status = CPXXgetcolname (env, lp, colname, namestore, 6,
&surplus, j, j);
if ( status ) {
namestore[0] = 0;
colname[0] = namestore;
}
printf ( "Column %3d (%5s): Value = %17.10g\n", j, colname[0], x[j]);
}
}
TERMINATE:
free_and_null ((char **) &x);
return (status);
}
int
main (void)
{
/* Declare variables and arrays where we will store the
optimization results including the status, objective value,
and variable values. */
int solstat;
double objval;
CPXDIM colcnt = 0;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int m, p;
/* 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;
}
/* Formulate and solve the problem */
lp = CPXXcreateprob (env, &status, "food manufacturing");
/* 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 LP.\n");
goto TERMINATE;
}
/* Build the model */
status = buildmodel (env, lp);
if ( status ) {
fprintf (stderr, "Failed to build model.\n");
goto TERMINATE;
}
/* Write a copy of the problem to a file. */
status = CPXXwriteprob (env, lp, "foodmanu.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\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);
/* Write solution status, objective and solution vector to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"No MIP objective value available. Exiting...\n");
goto TERMINATE;
}
printf ("Solution value (maximum profit) = %f\n\n", objval);
colcnt = NUMVARS*NUMMONTHS*NUMPRODUCTS;
x = malloc (colcnt * sizeof(*x));
if ( x == NULL ) {
status = CPXERR_NO_MEMORY;
fprintf (stderr, "Could not allocate memory for solution.\n");
goto TERMINATE;
}
status = CPXXgetx (env, lp, x, 0, colcnt - 1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
for (m = 0; m < NUMMONTHS; m++) {
printf ("Month %d \n", m);
printf (" . buy ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex(m, p, BUY)]);
printf ("\n");
printf (" . use ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, USE)]);
printf ("\n");
printf (" . store ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, STORE)]);
printf ("\n");
}
/* Free problem */
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", status);
goto TERMINATE;
}
TERMINATE:
free_and_null ((char **) &x);
/* 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);
}
}
return (status);
} /* END main */
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;
char *ctype = 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, and row slacks. */
int solstat;
double objval;
double x[NUMCOLS];
double slack[NUMROWS];
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, &ctype, &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 LP.\n");
goto TERMINATE;
}
/* Now copy 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;
}
/* Now copy the ctype array */
status = CPXXcopyctype (env, lp, ctype);
if ( status ) {
fprintf (stderr, "Failed to copy ctype\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 = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIQP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
/* Write the output to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"No MIQP objective value available. Exiting...\n");
goto TERMINATE;
}
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);
status = CPXXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
status = CPXXgetslack (env, lp, slack, 0, cur_numrows-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal slack values.\n");
goto TERMINATE;
}
for (i = 0; i < cur_numrows; i++) {
printf ("Row %d: Slack = %10f\n", i, slack[i]);
}
for (j = 0; j < cur_numcols; j++) {
printf ("Column %d: Value = %10f\n", j, x[j]);
}
/* Finally, write a copy of the problem to a file. */
status = CPXXwriteprob (env, lp, "miqpex1.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 **) &ctype);
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 uselogcallback = 0;
LOGINFO myloginfo;
int usetimelimcallback = 0;
TIMELIMINFO mytimeliminfo;
int useterminate = 0;
volatile int terminator;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int solstat;
int status = 0;
/* Check the command line arguments */
if (( argc != 3 ) ||
( strchr ("lta", argv[2][0]) == NULL ) ) {
usage (argv[0]);
goto TERMINATE;
}
switch (argv[2][0]) {
case 'l':
uselogcallback = 1;
break;
case 't':
usetimelimcallback = 1;
break;
case 'a':
useterminate = 1;
break;
default:
break;
}
/* 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;
}
/* 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;
}
if ( usetimelimcallback ) {
double t;
status = CPXXgettime (env, &t);
if ( status ) {
fprintf (stderr, "Failed to initialize timer.\n");
goto TERMINATE;
}
mytimeliminfo.acceptablegap = 10.0;
mytimeliminfo.aborted = 0;
mytimeliminfo.timestart = t;
mytimeliminfo.timelim = 1.0;
status = CPXXsetinfocallbackfunc (env, timelimcallback, &mytimeliminfo);
if ( status ) {
fprintf (stderr, "Failed to set time limit callback function.\n");
goto TERMINATE;
}
}
else if ( uselogcallback ) {
/* Set overall node limit in case callback conditions are not met */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Limits_Nodes, 5000);
if ( status ) goto TERMINATE;
status = CPXXgettime (env, &myloginfo.timestart);
if ( status ) {
fprintf (stderr, "Failed to query time.\n");
goto TERMINATE;
}
status = CPXXgetdettime (env, &myloginfo.dettimestart);
if ( status ) {
fprintf (stderr, "Failed to query deterministic time.\n");
goto TERMINATE;
}
myloginfo.numcols = CPXXgetnumcols (env, lp);
myloginfo.lastincumbent = CPXXgetobjsen (env, lp) * 1e+35;
myloginfo.lastlog = -10000;
status = CPXXsetinfocallbackfunc (env, logcallback, &myloginfo);
if ( status ) {
fprintf (stderr, "Failed to set logging callback function.\n");
goto TERMINATE;
}
/* Turn off CPLEX logging */
status = CPXXsetintparam (env, CPXPARAM_MIP_Display, 0);
if ( status ) goto TERMINATE;
}
else if ( useterminate) {
status = CPXXsetterminate (env, &terminator);
if ( status ) {
fprintf (stderr, "Failed to set terminator.\n");
goto TERMINATE;
}
/* Typically, you would pass the terminator variable to
another thread or pass it to an interrupt handler,
and monitor for some event to occur. When it does,
set terminator to a non-zero value.
To illustrate its use without creating a thread or
an interrupt handler, terminate immediately by setting
terminator before the solve.
*/
terminator = 1;
}
/* 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);
TERMINATE:
/* Free up the problem as allocated by CPXXcreateprob, if necessary */
if ( lp != NULL ) {
int xstatus = CPXXfreeprob (env, &lp);
if ( xstatus ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", xstatus);
status = xstatus;
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
int xstatus = 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);
status = xstatus;
}
}
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;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CPXDIM j;
CPXDIM cur_numcols;
const char * datadir = argc <= 1 ? "../../../examples/data" : argv[1];
char *noswot = NULL;
noswot = (char *) malloc (strlen (datadir) + 1 + strlen("noswot.mps") + 1);
sprintf (noswot, "%s/noswot.mps", datadir);
/* 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 != 0 ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1000);
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (env, &status, "noswot");
/* 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, noswot, NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* Set parameters */
/* Assure linear mappings between the presolved and original
models */
status = CPXXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Create user cuts for noswot problem */
status = addusercuts (env, lp);
if ( status ) 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);
cur_numcols = CPXXgetnumcols (env, lp);
/* Allocate space for solution */
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
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 filename */
free_and_null ((char **) &noswot);
/* 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 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)
{
/* Declare variables and arrays where we will store the
optimization results including the status, objective value,
and variable values. */
int solstat;
double objval;
double x[2*NUMEDGES]; /* One flow variable and one fixed charge indicator
for each edge */
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int j;
/* 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;
}
/* Create the problem. */
lp = CPXXcreateprob (env, &status, "fixnet");
/* 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 LP.\n");
goto TERMINATE;
}
/* Build the fixed-charge network flow model using
indicator constraints. */
status = buildnetwork (env, lp);
if ( status ) {
fprintf (stderr, "Failed to build network.\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);
/* Write solution status and objective to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr, "No MIP objective value available. Exiting...\n");
goto TERMINATE;
}
printf ("Solution value = %f\n", objval);
printf ("Solution vector:\n");
dumpx (env, lp);
status = CPXXgetx (env, lp, x, 0, 2*NUMEDGES-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
/* Make sure flow satisfies fixed-charge constraints */
for (j = 0; j < NUMEDGES; j++) {
if ( x[j] > 0.0001 && x[NUMEDGES+j] < 0.9999 ) {
printf ("WARNING : Edge from %d to %d has non-zero flow %.3f\n",
orig[j], dest[j], x[j]);
printf (" : fixed-charge indicator has value %.6f.\n",
x[NUMEDGES+j]);
}
}
printf("\n");
/* Finally, write a copy of the problem to a file. */
status = CPXXwriteprob (env, lp, "fixnet.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
/* Free problem */
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", status);
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);
}
}
return (status);
} /* END main */
int
main (int argc, char *argv[])
{
/* 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;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
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 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;
}
/* 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;
}
/* 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);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is. cur_numcols stores the current number
of columns. */
cur_numcols = CPXXgetnumcols (env, lp);
/* Allocate space for solution */
x = malloc (cur_numcols*sizeof(*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
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++) {
printf ( "Column %d: Value = %17.10g\n", j, x[j]);
}
TERMINATE:
/* Free up the solution */
free_and_null ((char **) &x);
/* 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);
}
}
return (status);
} /* END main */