int
main (void)
{
char probname[16]; /* Problem name is max 16 characters */
int cstat[NUMCOLS];
int rstat[NUMROWS];
/* 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;
int i, j;
int cur_numrows, cur_numcols;
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. 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");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem. */
strcpy (probname, "example");
lp = CPXcreateprob (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 populate the problem with the data. */
status = populatebycolumn (env, lp);
if ( status ) {
fprintf (stderr, "Failed to populate problem data.\n");
goto TERMINATE;
}
/* We assume we know the optimal basis. Variables 1 and 2 are basic,
while variable 0 is at its upper bound */
cstat[0] = CPX_AT_UPPER;
cstat[1] = CPX_BASIC;
cstat[2] = CPX_BASIC;
/* The row statuses are all nonbasic for this problem */
rstat[0] = CPX_AT_LOWER;
rstat[1] = CPX_AT_LOWER;
/* Now copy the basis */
status = CPXcopybase (env, lp, cstat, rstat);
if ( status ) {
fprintf (stderr, "Failed to copy the basis.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXlpopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize LP.\n");
goto TERMINATE;
}
status = CPXsolution (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", objval);
printf ("Iteration count = %d\n\n", CPXgetitcnt (env, lp));
/* 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 = CPXgetnumrows (env, lp);
cur_numcols = CPXgetnumcols (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 = CPXwriteprob (env, lp, "lpex6.sav", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
TERMINATE:
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. 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");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
//*******************************************************************
long CSolver:: GetIntCount() {
//! return CPXgetintc(m_env,m_lp);
return CPXgetitcnt(m_env, m_lp);
}
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* MATLAB memory structures */
const mxArray *c,*A,*b,*l,*u,*le,*ge,*maxIterPtr;
/* Return arguments */
double *matlpstat,*objval,*x,*pi,*cstat,*itcnt;
/* Other declarations */
char *sense,errorMsg[255];
int rows,cols,maxIter,*matbeg,*matcnt,*matind;
double *c_ptr,*b_ptr,*matval,*l_ptr,*u_ptr,*slack,*dj;
int matrixSize,status,i,j,le_size,ge_size,m,n;
double *le_ptr = NULL,*ge_ptr = NULL;
int *istat,lpstat;
//CPXENVptr env;
//CPXLPptr lp = NULL;
/* Assign pointers to MATLAB memory stuctures */
c = prhs[C_IN];
A = prhs[A_IN];
b = prhs[B_IN];
l = prhs[L_IN];
u = prhs[U_IN];
c_ptr = mxGetPr(c);
b_ptr = mxGetPr(b);
l_ptr = mxGetPr(l);
u_ptr = mxGetPr(u);
rows = mxGetM(b);
cols = mxGetM(c);
/* Build the matrix of coefficients, taking sparsity into account. */
if (mxIsSparse(A)){
/* Sparse */
matbeg = mxGetJc(A); /* beginnings of each column */
matcnt = (int*)mxCalloc(cols,sizeof(int)); /* # of entries in each col */
for (i = 0; i < cols; i++)
matcnt[i] = matbeg[i+1] - matbeg[i];
matind = mxGetIr(A); /* row locations */
matval = mxGetPr(A); /* actual coefficients */
} else {
/* Dense */
m = mxGetM(A);
n = mxGetN(A);
matbeg = (int*)mxCalloc(n,sizeof(int));
matcnt = (int*)mxCalloc(n,sizeof(int));
matind = (int*)mxCalloc(m*n,sizeof(int));
matval = mxGetPr(A);
for (j = 0; j < n; j++) {
matbeg[j] = j*m;
for (i = 0; i < m; i++)
matind[j*m + i] = i;
matcnt[j] = m;
}
}
/* Initialize all constraints to be equality constraints (default). */
sense = (char*)mxCalloc(rows,sizeof(char));
for(i = 0; i < rows; i++)
sense[i] = 'E';
/* If "<=" constraints given, set them up. */
if(nrhs > MANDATORY_ARGS){
le = prhs[LE_IN];
le_ptr = mxGetPr(le);
le_size = mxGetM(le);
for(i = 0; i < le_size; i++)
sense[(int)(le_ptr[i]-1)] = 'L';
}
/* If ">=" constraints given, set them up. */
if(nrhs > MANDATORY_ARGS + 1){
ge = prhs[GE_IN];
ge_ptr = mxGetPr(ge);
ge_size = mxGetM(ge);
for(i = 0; i < ge_size; i++)
sense[(int)(ge_ptr[i]-1)] = 'G';
}
/* Set up maximum number of iterations */
if (nrhs > MANDATORY_ARGS + 2) {
maxIterPtr = prhs[MI_IN];
maxIter = (int)mxGetScalar(maxIterPtr);
} else
maxIter = MAX_ITER_DEFAULT;
/* Output to MATLAB */
plhs[OBJ_OUT] = mxCreateDoubleMatrix(1,1,mxREAL);
plhs[X_OUT] = mxCreateDoubleMatrix(cols,1,mxREAL);
plhs[PI_OUT] = mxCreateDoubleMatrix(rows,1,mxREAL);
plhs[STAT_OUT] = mxCreateDoubleMatrix(1,1,mxREAL);
plhs[CSTAT_OUT] = mxCreateDoubleMatrix(cols,1,mxREAL);
plhs[ITER_OUT] = mxCreateDoubleMatrix(1,1,mxREAL);
objval = mxGetPr(plhs[OBJ_OUT]);
x = mxGetPr(plhs[X_OUT]);
pi = mxGetPr(plhs[PI_OUT]);
matlpstat = mxGetPr(plhs[STAT_OUT]);
cstat = mxGetPr(plhs[CSTAT_OUT]);
istat = (int*)mxCalloc(cols,sizeof(int));
itcnt = mxGetPr(plhs[ITER_OUT]);
if (!initialized)
{
mexPrintf("MEX-file: lp_cplex_mex opening cplex environment\n");
/* Open CPLEX environment */
env = CPXopenCPLEXdevelop(&status);
if (!env) {
printf(CPXgeterrorstring(env,status,errorMsg));
mexErrMsgTxt("\nCould not open CPLEX environment.");
}
/* Create CPLEX problem space */
lp = CPXcreateprob(env, &status, "matlab");
if (!lp) {
printf(CPXgeterrorstring(env,status,errorMsg));
CPXcloseCPLEX(&env);
mexErrMsgTxt("\nCould not create CPLEX problem.");
}
mexAtExit(cleanup);
initialized = 1;
}
/* Copy LP into CPLEX environment */
status = CPXcopylp(env, lp, cols, rows, MINIMIZE, c_ptr, b_ptr, sense,
matbeg, matcnt, matind, matval, l_ptr, u_ptr, NULL);
if (status) {
printf(CPXgeterrorstring(env,status,errorMsg));
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
mexErrMsgTxt("\nCould not copy CPLEX problem.");
}
/* Set iteration limit. */
status = CPXsetintparam(env, CPX_PARAM_ITLIM, maxIter);
if (status) {
printf(CPXgeterrorstring(env,status,errorMsg));
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
mexErrMsgTxt("\nCould not set number of iterations.");
}
/* Perform optimization */
status = CPXprimopt(env,lp);
if (status) {
printf(CPXgeterrorstring(env,status,errorMsg));
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
mexErrMsgTxt("\nOptimization error.");
}
/* Obtain solution */
status = CPXsolution(env, lp, &lpstat, objval, x, pi, NULL, NULL);
*matlpstat = lpstat;
if (status) {
printf(CPXgeterrorstring(env,status,errorMsg));
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
mexErrMsgTxt("\nFailure when retrieving solution.");
}
/* Get status of columns */
status = CPXgetbase(env, lp, istat, NULL);
if (status) {
printf(CPXgeterrorstring(env,status,errorMsg));
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
mexErrMsgTxt("\nUnable to get basis status.");
}
/* Copy int column values to double column values */
for (i=0; i < cols; i++)
cstat[i] = istat[i];
/* Get iteration count */
*itcnt = (double)CPXgetitcnt(env,lp);
/* Clean up problem */
//CPXfreeprob(env,&lp);
//CPXcloseCPLEX(&env);
}
