long GenModelCplex::Solve() { if(!bcreated) throw string("Solve() not available : Problem not created yet"); CplexData* d = static_cast<CplexData*>(solverdata); int status = 0; if(boolParam.count("qp") > 0 && boolParam["qp"]) status = CPXqpopt(d->env, d->lp); else if(boolParam.count("mip") > 0 && boolParam["mip"]) status = CPXmipopt(d->env, d->lp); else if(strParam.count("algo") > 0 && strParam["algo"] == "interior") status = CPXbaropt(d->env, d->lp); else if(strParam.count("algo") > 0 && strParam["algo"] == "dual") status = CPXdualopt(d->env, d->lp); else if(strParam.count("algo") > 0 && strParam["algo"] == "primal") status = CPXprimopt(d->env, d->lp); else if(strParam.count("algo") > 0 && strParam["algo"] == "concurrent") { //printf("choosing concurrent algo\n"); CPXsetintparam (d->env, CPX_PARAM_LPMETHOD, CPX_ALG_CONCURRENT); status = CPXlpopt(d->env, d->lp); } else if(strParam.count("algo") > 0 && strParam["algo"] == "sifting") { CPXsetintparam (d->env, CPX_PARAM_LPMETHOD, CPX_ALG_SIFTING); status = CPXlpopt(d->env, d->lp); } else status = CPXlpopt(d->env, d->lp); return 0; }
int CSolver:: Optimize(int Algorthim) { m_cbData.bMip = false; CPXsetlpcallbackfunc(m_env, lpcallback, &m_cbData); switch(Algorthim) { case SIMPLEX: m_status = CPXprimopt(m_env,m_lp); break; case DUAL_SIMPLEX: m_status = CPXdualopt(m_env,m_lp); break; case BARRIER: m_status = CPXbaropt(m_env,m_lp); break; default: Message("Undefined Algorthim specified in call to Optimize -- will use simplex!"); m_status = CPXoptimize(m_env,m_lp); }; char buff[100]; if (m_status) { CPXgeterrorstring(m_env, m_status, m_error ); sprintf(buff,"Error: %d",m_status); Message( buff ); Message( m_error ); return -1; } CPXsetlpcallbackfunc(m_env,NULL, NULL); CreateSolArrays(); // get solution and place into arrays m_status = CPXsolution(m_env, m_lp, &m_lpstat, &m_obj, m_x, m_pi, m_slack, m_dj); if (m_status) { CPXgeterrorstring(m_env, m_status, m_error ); Message("Getting solution IP_FAILED."); Message( m_error ); return -1; } // save the basis to arrays m_status = CPXgetbase(m_env, m_lp, m_pCstat, m_pRstat); if ( m_status ) { CPXgeterrorstring(m_env, m_status, m_error); Message("Getting basis failed!"); Message(m_error); return -1; } return m_status; }
static int CPXPUBLIC usersolve (CPXCENVptr env, void *cbdata, int wherefrom, void *cbhandle, int *useraction_p) { int status = 0; int nodecount; CPXLPptr nodelp; *useraction_p = CPX_CALLBACK_DEFAULT; /* Get pointer to LP subproblem */ status = CPXgetcallbacknodelp (env, cbdata, wherefrom, &nodelp); if ( status ) goto TERMINATE; /* Find out what node is being processed */ status = CPXgetcallbackinfo (env, cbdata, wherefrom, CPX_CALLBACK_INFO_NODE_COUNT, &nodecount); if ( status ) goto TERMINATE; /* Solve initial node with primal, others with dual */ if ( nodecount < 1 ) status = CPXprimopt (env, nodelp); else status = CPXdualopt (env, nodelp); /* If the solve was OK, set return to say optimization has been done in callback, otherwise return the CPLEX error code */ if ( !status ) *useraction_p = CPX_CALLBACK_SET; TERMINATE: return (status); } /* END usersolve */
static int CPXPUBLIC solvecallback (CPXCENVptr env, void *cbdata, int wherefrom, void *userinfo, int *useraction_p) { int status = 0; int lpstatus = 0; CPXLPptr nodelp = NULL; double *prex = NULL; MYCBptr mycbinfo = (MYCBptr) userinfo; CPXLPptr mip = mycbinfo->mip; double *relx = mycbinfo->relx; int cols; int prestat; *useraction_p = CPX_CALLBACK_DEFAULT; /* Only use callback for solving the root relaxation (node 0) */ if ( mycbinfo->count > 0 ) { goto TERMINATE; } mycbinfo->count++; /* Extract the LP to be solved */ status = CPXgetcallbacknodelp (env, cbdata, wherefrom, &nodelp); if ( status ) goto TERMINATE; cols = CPXgetnumcols (env, nodelp); prex = (double *) malloc (cols * sizeof (double)); if ( prex == NULL ) { status = CPXERR_NO_MEMORY; goto TERMINATE; } /* Use MIP presolve to crush the original solution. Note that MIP presolve can only crush primal solutions */ status = CPXgetprestat (env, mip, &prestat, NULL, NULL, NULL, NULL); if ( status ) goto TERMINATE; /* If a presolved model exists, then relx is crushed down to prex, the corresponding solution for the presolved model; otherwise, prex is just a copy of relx */ if ( prestat ) { status = CPXcrushx (env, mip, relx, prex); if ( status ) goto TERMINATE; } else { memcpy (prex, relx, cols * sizeof (double)); } /* Feed the crushed solution into 'nodelp' */ status = CPXcopystart (env, nodelp, NULL, NULL, prex, NULL, NULL, NULL); /* Use primal to reoptimize, since we only have a primal solution */ status = CPXprimopt (env, nodelp); if ( status ) goto TERMINATE; lpstatus = CPXgetstat (env, nodelp); if ( lpstatus == CPX_STAT_OPTIMAL || lpstatus == CPX_STAT_OPTIMAL_INFEAS || lpstatus == CPX_STAT_INFEASIBLE ) { *useraction_p = CPX_CALLBACK_SET; } TERMINATE: free_and_null ((char **) &prex); return (status); } /* END solvecallback */
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); }