// Function definitions.
// -----------------------------------------------------------------
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Input Args
user_function_data fun, grad;
iter_fun_data iterF;
double *x0, *lb, *ub;
//Options
int printLevel = 0, maxIter = 1000, nupdate = 5, maxFeval = 1500;
double ftol = 1e-7, pgtol = 1e-5, maxtime = 1000;
iterF.enabled = false;
//Outputs Args
double *x, *fval, *exitflag, *iter, *feval;
//Internal Vars
size_t ndec;
int iiter, nfeval;
if (nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(LBFGSB_VERSION);
return;
}
//Check user inputs
checkInputs(prhs,nrhs);
try
{
//Get Size
ndec = mxGetNumberOfElements(prhs[4]);
//Get Function Handles
if (mxIsChar(prhs[0])) {
CHECK(mxGetString(prhs[0], fun.f, FLEN) == 0,"error reading objective name string");
fun.nrhs = 1;
fun.xrhs = 0;
} else {
fun.prhs[0] = (mxArray*)prhs[0];
strcpy(fun.f, "feval");
fun.nrhs = 2;
fun.xrhs = 1;
}
if (mxIsChar(prhs[1])) {
CHECK(mxGetString(prhs[1], grad.f, FLEN) == 0,"error reading gradient name string");
grad.nrhs = 1;
grad.xrhs = 0;
} else {
grad.prhs[0] = (mxArray*)prhs[1];
strcpy(grad.f, "feval");
grad.nrhs = 2;
grad.xrhs = 1;
}
fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0
grad.prhs[grad.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL);
//Get Bounds + x0
lb = mxGetPr(prhs[2]);
ub = mxGetPr(prhs[3]);
x0 = mxGetPr(prhs[4]);
//Get Options if specified
if(nrhs > 5) {
GetIntegerOption(prhs[5], "display", &printLevel);
GetIntegerOption(prhs[5], "maxiter", &maxIter);
GetIntegerOption(prhs[5], "maxfeval", &maxFeval);
GetIntegerOption(prhs[5], "nupdate", &nupdate);
GetDoubleOption(prhs[5], "tolrfun", &ftol);
GetDoubleOption(prhs[5], "tolrfun", &ftol);
GetDoubleOption(prhs[5], "pgtol", &pgtol);
GetDoubleOption(prhs[5], "maxtime", &maxtime);
if(mxGetField(prhs[5],0,"iterfun") && !mxIsEmpty(mxGetField(prhs[5],0,"iterfun")))
{
iterF.prhs[0] = (mxArray*)mxGetField(prhs[5],0,"iterfun");
strcpy(iterF.f, "feval");
iterF.enabled = true;
iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL);
}
}
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
iter = mxGetPr(plhs[3]);
feval = mxGetPr(plhs[4]);
//Create Class for Peter's L-BFGS-B Interface
lbfgsb_program solver(&fun,&grad,&iterF,ndec,lb,ub,x0,x,fval,iter,printLevel,maxIter,maxFeval,maxtime,ftol,nupdate,pgtol);
//Run the Solver
int exitStatus = solver.runSolver(iiter,nfeval,*fval);
//Save Status & Iterations
*exitflag = (double)exitStatus;
*iter = (double)iiter;
*feval = (double)nfeval;
}
catch (std::exception& error)
{
mexErrMsgTxt(error.what());
}
}
//Main Function
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[])
{
//Input Args
double *f, *A = NULL, *b = NULL, *lb = NULL, *ub = NULL, *y0 = NULL;
double *sdpDIM = NULL, *SDP_pr = NULL;
//Return Args
double *x, *pval, *dval, *exitflag, *iter, *pdflag;
//Options (most get defaults written in)
int maxiter = 1500;
int reuse=4,rpos=0,drho=1,ndim,sdpnmax=1;
double penalty,rho,dbound,dlbound,zbar,r0,mu0,ylow,yhigh,gaptol,pnormtol,maxtrust,steptol,inftol,infptol;
double lpb=1.0, datanorm[3], *dreuse, *fixed = NULL;
//Internal Vars
size_t nlincon = 0, ndec = 0, ncones = 0, nfix = 0;
size_t lincon_nz = 0;
size_t i, j;
size_t nLB = 0, nUB = 0;
int *temp_ir = NULL, *temp_jc = NULL;
double *temp_pr = NULL;
const char *onames[2] = {"pval","dval"};
const char *fnames[11] = {"iter","pdflag","r","mu","pstep","dstep","pnorm","ynorm","tracex","reuse","rho"};
double evaltime, *X = NULL;
int iters = 0, status, indcell = 0;
//DSDP Vars
DSDP dsdp;
SDPCone sdpcone = NULL;
LPCone lpcone = NULL;
BCone bcone = NULL;
DSDPTerminationReason reason;
DSDPSolutionType pdfeasible;
//Sparse Indicing
mwIndex *A_ir, *A_jc;
//Version Return
if(nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(DSDP_VERSION);
return;
}
//Check Inputs
checkInputs(prhs,nrhs);
//Get pointers to Input variables
f = mxGetPr(pF); ndec = mxGetNumberOfElements(pF);
if(!mxIsEmpty(pA)) {
A = mxGetPr(pA);
A_ir = mxGetIr(pA);
A_jc = mxGetJc(pA);
b = mxGetPr(pB);
nlincon = mxGetM(pA);
lincon_nz = A_jc[mxGetN(pA)];
}
if(nrhs > eLB && !mxIsEmpty(pLB))
lb = mxGetPr(pLB);
if(nrhs > eUB && !mxIsEmpty(pUB))
ub = mxGetPr(pUB);
if(nrhs > eSDP && !mxIsEmpty(pSDP)) {
if(mxIsCell(pSDP))
ncones = mxGetNumberOfElements(pSDP);
else
ncones = 1;
}
if(nrhs > eY0 && !mxIsEmpty(pY0))
y0 = mxGetPr(pY0);
if(nrhs > eOPTS && !mxIsEmpty(pOPTS) && mxGetField(pOPTS,0,"fixed") && !mxIsEmpty(mxGetField(pOPTS,0,"fixed"))) {
fixed = mxGetPr(mxGetField(pOPTS,0,"fixed"));
nfix = mxGetM(mxGetField(pOPTS,0,"fixed"));
}
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateStructMatrix(1,1,2,onames);
mxSetField(plhs[1],0,onames[0],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[1],0,onames[1],mxCreateDoubleMatrix(1,1, mxREAL));
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
pval = mxGetPr(mxGetField(plhs[1],0,onames[0]));
dval = mxGetPr(mxGetField(plhs[1],0,onames[1]));
exitflag = mxGetPr(plhs[2]);
//Info Output
plhs[3] = mxCreateStructMatrix(1,1,11,fnames);
mxSetField(plhs[3],0,fnames[0],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[1],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[2],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[3],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[4],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[5],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[6],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[7],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[8],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[9],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[10],mxCreateDoubleMatrix(1,1, mxREAL));
iter = mxGetPr(mxGetField(plhs[3],0,fnames[0]));
pdflag = mxGetPr(mxGetField(plhs[3],0,fnames[1]));
dreuse = mxGetPr(mxGetField(plhs[3],0,"reuse"));
if(nlhs > 4)
plhs[4] = mxCreateCellMatrix(ncones+(int)(nlincon>0)+(int)(nfix>0),1);
//Set Defaults
maxtime = 1000;
printLevel = 0;
//Create DSDP Problem
DSDP_ERR( DSDPCreate((int)ndec,&dsdp), "Error Creating DSDP Problem");
//Set Monitor
DSDP_ERR( DSDPSetMonitor(dsdp,DSDPMonitor,0), "Error Setting DSDP Monitor");
//Set Dual Objective
for (i=0;i<ndec;i++){
DSDP_ERR( DSDPSetDualObjective(dsdp,(int)i+1,f[i]), "Error Adding Objective Coefficients"); }
//Check finite bounds for allocation
if(lb || ub)
for(i=0;i<ndec;i++) {
if(lb)
if(!mxIsInf(lb[i]))
nLB++;
if(ub)
if(!mxIsInf(ub[i]))
nUB++;
}
//Set Bounds as BCone
if(nLB || nUB) {
DSDP_ERR( DSDPCreateBCone(dsdp, &bcone), "Error creating BCone");
DSDP_ERR( BConeAllocateBounds(bcone, (int)(nLB+nUB)), "Error allocating bounds");
for(i=0;i<ndec;i++) {
if(nLB > 0 && !mxIsInf(lb[i]))
DSDP_ERR( BConeSetLowerBound(bcone, (int)i+1, lb[i]), "Error setting lower bound");
if(nUB > 0 && !mxIsInf(ub[i]))
DSDP_ERR( BConeSetUpperBound(bcone, (int)i+1, ub[i]), "Error setting upper bound");
}
}
//Set Linear Inequality Constraints as LPCone
if(nlincon) {
int M = (int)mxGetM(pA);
int N = (int)mxGetN(pA);
DSDP_ERR( DSDPCreateLPCone(dsdp, &lpcone), "Error creating LPCone (inequalities)");
//Create Memory to store A*x <= b in dsdp and integer format
temp_jc = mxCalloc(N+2,sizeof(int));
temp_ir = mxCalloc(lincon_nz+M,sizeof(int));
temp_pr = mxCalloc(lincon_nz+M,sizeof(double));
//Copy over linear A
for(i=0;i<=(size_t)N;i++)
temp_jc[i] = (int)A_jc[i];
for(i=0;i<lincon_nz;i++) {
temp_ir[i] = (int)A_ir[i];
temp_pr[i] = A[i];
}
//Append linear rhs (b)
temp_jc[N+1] = temp_jc[N] + M;
for(i=lincon_nz,j=0;j<(size_t)M;j++) {
if(b[j] != 0) {
temp_ir[i] = (int)j;
temp_pr[i++] = b[j];
}
else
temp_jc[N+1]--;
}
#ifdef DEBUG
mexPrintf("---- Inequality Constraints ----\n");
for(i=0;i<=(size_t)(N+1);i++)
mexPrintf("jc[%d] = %d\n",i,temp_jc[i]);
for(i=0;i<lincon_nz+M;i++)
mexPrintf("ir[%d] = %d, pr[%d] = %f\n",i,temp_ir[i],i,temp_pr[i]);
#endif
//Set LP Cone Data
DSDP_ERR( LPConeSetData2(lpcone, M, temp_jc, temp_ir, temp_pr), "Error setting LP Cone data (inequality)" );
//Optionally set X data
if(nlhs > 4) {
mxSetCell(plhs[4],indcell,mxCreateDoubleMatrix(M,1,mxREAL));
DSDP_ERR( LPConeSetXVec(lpcone,mxGetPr(mxGetCell(plhs[4],indcell++)),M), "Error setting LP Cone X data" );
}
}
//Set Semidefinite Constraints as SDPCone
if(ncones) {
//Create the cone structure, specifying each constraint as a block
DSDP_ERR( DSDPCreateSDPCone(dsdp,(int)ncones,&sdpcone), "Error creating SDPCone");
//Add each constraint cone
for(i=0;i<ncones;i++) {
if(ncones == 1 && !mxIsCell(pSDP)) {
if(nlhs > 4) {
mxSetCell(plhs[4],indcell,mxCreateDoubleMatrix(mxGetM(pSDP),1,mxREAL));
X = mxGetPr(mxGetCell(plhs[4],indcell++));
}
ndim = addSDPCone(sdpcone,pSDP,(int)i,X);
}
else {
if(nlhs > 4) {
mxSetCell(plhs[4],indcell,mxCreateDoubleMatrix(mxGetM(mxGetCell(pSDP,i)),1,mxREAL));
X = mxGetPr(mxGetCell(plhs[4],indcell++));
}
ndim = addSDPCone(sdpcone,mxGetCell(pSDP,i),(int)i,X);
}
//Update max dim
if(sdpnmax < ndim)
sdpnmax = ndim;
}
}
//Set y0
if (y0)
for (i=0;i<ndec;i++) {
DSDP_ERR( DSDPSetY0(dsdp,(int)i+1,y0[i]), "Error setting Y0");
}
//Determine whether to reuse schur complement matrix (dsdp authors' heuristic)
if(ndec == 1)
reuse = 1/sdpnmax;
else
reuse = ((int)ndec-2)/sdpnmax;
if (ndec<50 && reuse==0) reuse=1;
if (reuse>=1) reuse++;
reuse=reuse*reuse;
if (ndec<2000 && ndec>10) reuse=10;
if (ndec>12) reuse=12;
//Get DSDP Default Options
DSDP_ERR( DSDPGetR(dsdp,&r0), "Error Getting R");
DSDP_ERR( DSDPGetPenaltyParameter(dsdp,&penalty), "Error Getting Penalty Parameter");
DSDP_ERR( DSDPGetPotentialParameter(dsdp,&rho), "Error Getting Potential Parameter");
DSDP_ERR( DSDPGetDualBound(dsdp,&dbound), "Error Getting Dual Bound");
DSDP_ERR( DSDPGetGapTolerance(dsdp,&gaptol), "Error Getting Gap Tolerance");
DSDP_ERR( DSDPGetRTolerance(dsdp,&inftol), "Error Getting R Tolerance");
DSDP_ERR( DSDPGetBarrierParameter(dsdp,&mu0), "Error Getting Barrier Parameter");
DSDP_ERR( DSDPGetMaxTrustRadius(dsdp,&maxtrust), "Error Getting Max Trust Radius");
DSDP_ERR( DSDPGetStepTolerance(dsdp,&steptol), "Error Getting Step Tolerance");
DSDP_ERR( DSDPGetPTolerance(dsdp,&infptol), "Error Getting P Tolerance");
DSDP_ERR( DSDPGetPNormTolerance(dsdp,&pnormtol), "Error Getting PNorm Tolerance");
//Get Data Norms to establish y bounds
DSDP_ERR( DSDPGetDataNorms(dsdp, datanorm), "Error Getting Data Norms");
DSDP_ERR( DSDPGetYBounds(dsdp,&ylow,&yhigh), "Error Getting Y Bounds");
if (datanorm[0]==0){DSDP_ERR( DSDPSetYBounds(dsdp,-1.0,1.0), "Error Setting Y Bounds");}
//Get User Options (overwrites defaults above)
if(nrhs > eOPTS && !mxIsEmpty(pOPTS)) {
//OPTI Options
GetIntegerOption(pOPTS,"maxiter",&maxiter);
GetDoubleOption(pOPTS,"maxtime",&maxtime);
GetIntegerOption(pOPTS,"display",&printLevel);
//DSDP Options
GetDoubleOption(pOPTS,"r0",&r0);
GetDoubleOption(pOPTS,"penalty",&penalty);
GetDoubleOption(pOPTS,"rho",&rho);
GetDoubleOption(pOPTS,"dbound",&dbound);
GetDoubleOption(pOPTS,"gaptol",&gaptol);
GetDoubleOption(pOPTS,"rtol",&inftol);
GetDoubleOption(pOPTS,"mu0",&mu0);
GetDoubleOption(pOPTS,"maxtrust",&maxtrust);
GetDoubleOption(pOPTS,"steptol",&steptol);
GetDoubleOption(pOPTS,"ptol",&infptol);
GetDoubleOption(pOPTS,"pnormtol",&pnormtol);
GetIntegerOption(pOPTS,"reuse",&reuse);
GetIntegerOption(pOPTS,"rpos",&rpos);
GetIntegerOption(pOPTS,"drho",&drho);
//Check and set DSDP options without valid defaults
if(mxGetField(pOPTS,0,"zbar") && !mxIsEmpty(mxGetField(pOPTS,0,"zbar"))) {
GetDoubleOption(pOPTS,"zbar",&zbar);
DSDP_ERR( DSDPSetZBar(dsdp,zbar), "Error Setting Z Bar");
}
if(mxGetField(pOPTS,0,"dlbound") && !mxIsEmpty(mxGetField(pOPTS,0,"dlbound"))) {
GetDoubleOption(pOPTS,"dlbound",&dlbound);
DSDP_ERR( DSDPSetDualLowerBound(dsdp,dlbound), "Error Setting Dual Lower Bound");
}
if(mxGetField(pOPTS,0,"ybound") && !mxIsEmpty(mxGetField(pOPTS,0,"ybound"))) {
GetDoubleOption(pOPTS,"ybound",&yhigh); ylow = -yhigh;
DSDP_ERR( DSDPSetYBounds(dsdp,ylow,yhigh), "Error Setting Y Bounds");
}
}
//Set DSDP Options with Defaults
DSDP_ERR( DSDPSetMaxIts(dsdp,maxiter), "Error Setting Max Iterations");
DSDP_ERR( DSDPSetR0(dsdp,r0), "Error Setting Option R0 ");
DSDP_ERR( DSDPSetPenaltyParameter(dsdp,penalty), "Error Setting Penalty Parameter");
DSDP_ERR( DSDPSetPotentialParameter(dsdp,rho), "Error Setting Potential Parameter");
DSDP_ERR( DSDPSetDualBound(dsdp,dbound), "Error Setting Dual Bound");
DSDP_ERR( DSDPSetGapTolerance(dsdp,gaptol), "Error Setting Gap Tolerance");
DSDP_ERR( DSDPSetRTolerance(dsdp,inftol), "Error Setting R Tolerance");
DSDP_ERR( DSDPSetBarrierParameter(dsdp,mu0), "Error Setting Barrier Parameter");
DSDP_ERR( DSDPSetMaxTrustRadius(dsdp,maxtrust), "Error Setting Max Trust Radius");
DSDP_ERR( DSDPSetStepTolerance(dsdp,steptol), "Error Setting Step Tolerance")
DSDP_ERR( DSDPSetPTolerance(dsdp,infptol), "Error Setting P Tolerance");
DSDP_ERR( DSDPSetPNormTolerance(dsdp,pnormtol), "Error Setting PNorm Tolerance");
if(reuse < 0) reuse = 0; if(reuse > 15) reuse = 15;
DSDP_ERR( DSDPReuseMatrix(dsdp,reuse), "Error Setting Reuse Matrix");
//Set Other DSDP Options
DSDP_ERR( DSDPUsePenalty(dsdp,rpos), "Error Setting Use Penalty");
DSDP_ERR( DSDPUseDynamicRho(dsdp,drho), "Error Setting Dynamic Rho");
if (lpb<0.1) lpb=0.1;
if(lpcone) DSDP_ERR( LPConeScaleBarrier(lpcone,lpb), "Error Setting LPCone Scale Barrier");
//Set Fixed Variables
if(fixed != NULL) {
if(nlhs > 4) {
mxSetCell(plhs[4],indcell,mxCreateDoubleMatrix(nfix,1,mxREAL));
X = mxGetPr(mxGetCell(plhs[4],indcell++));
}
else
X = NULL;
DSDP_ERR( DSDPSetFixedVariables(dsdp, fixed, &fixed[nfix], X, (int)nfix), "Error Setting Fixed Variables");
}
//Print Header
if(printLevel) {
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is DSDP v%s\n",DSDP_VERSION);
mexPrintf(" Authors: Steve Benson, Yinyu Ye and Xiong Zhang\n\n");
mexPrintf(" Problem Properties:\n");
mexPrintf(" # Decision Variables: %4d\n",ndec);
mexPrintf(" # Linear Inequalities: %4d ",nlincon);
if(nlincon)
mexPrintf("[%d nz]\n",lincon_nz);
else
mexPrintf("\n");
mexPrintf(" # Semidefinite Cones: %4d\n",ncones);
mexPrintf("------------------------------------------------------------------\n");
}
//Start timer
start = clock();
//Call DSDP Setup to initialize problem
DSDP_ERR( DSDPSetup(dsdp), "Error setting up DSDP Problem, likely out of memory");
//Now Solve the Problem
status = DSDPSolve(dsdp);
//Stop Timer
end = clock();
evaltime = ((double)(end-start))/CLOCKS_PER_SEC;
//Determine Stop Reason
if(status == 0) {
DSDP_ERR( DSDPStopReason(dsdp,&reason), "Error retrieving post-solve stop reason"); }
else if(status == DSDP_MAX_TIME || status == DSDP_USER_TERMINATION)
reason = status;
else {
DSDP_ERR( status, "Error solving DSDP Problem!");}
//Computer X and Get Solution Type
if (reason!=DSDP_INFEASIBLE_START)
DSDP_ERR( DSDPComputeX(dsdp), "Error computing post-solve x");
DSDP_ERR( DSDPGetSolutionType(dsdp,&pdfeasible), "Error collecting post-solve solution type");
//Copy Dual Solution
DSDP_ERR( DSDPGetY(dsdp,x,(int)ndec), "Error returning Solution Vector");
//Collect Output Statistics
DSDPGetIts(dsdp,&iters);
DSDPGetDObjective(dsdp,dval);
DSDPGetPObjective(dsdp,pval);
DSDPGetR(dsdp,mxGetPr(mxGetField(plhs[3],0,"r")));
DSDPGetBarrierParameter(dsdp,mxGetPr(mxGetField(plhs[3],0,"mu")));
DSDPGetStepLengths(dsdp,mxGetPr(mxGetField(plhs[3],0,"pstep")),mxGetPr(mxGetField(plhs[3],0,"dstep")));
DSDPGetPnorm(dsdp,mxGetPr(mxGetField(plhs[3],0,"pnorm")));
DSDPGetYMaxNorm(dsdp,mxGetPr(mxGetField(plhs[3],0,"ynorm")));
DSDPGetTraceX(dsdp,mxGetPr(mxGetField(plhs[3],0,"tracex")));
DSDPGetPotentialParameter(dsdp,mxGetPr(mxGetField(plhs[3],0,"rho")));
*dreuse = (double)reuse;
//Assign to MATLAB
*iter = (double)iters;
*exitflag = (double)reason;
*pdflag = (double)pdfeasible;
//Print Header
if(printLevel){
//Detail termination reason
switch(reason)
{
//Success
case DSDP_CONVERGED:
mexPrintf("\n *** DSDP CONVERGED ***\n"); break;
case DSDP_UPPERBOUND:
mexPrintf("\n *** DSDP CONVERGED: Dual Objective exceeds its bound***\n"); break;
//Error
case DSDP_SMALL_STEPS:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Terminated due to Small Steps ***\n"); break;
case DSDP_MAX_IT:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Maximum Iterations Reached ***\n"); break;
case DSDP_MAX_TIME:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Maximum Time Reached ***\n"); break;
case DSDP_INFEASIBLE_START:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Infeasible Starting Point ***\n"); break;
case DSDP_USER_TERMINATION:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: User Exited ***\n"); break;
//Here is ok too?
default:
mexPrintf("\n *** DSDP FINISHED ***\n"); break;
}
//Detail solution status
if(reason == DSDP_CONVERGED || reason == DSDP_UPPERBOUND) {
switch(pdfeasible)
{
//Success
case DSDP_PDFEASIBLE:
mexPrintf(" Solution Status: Both Primal and Dual are Feasible and Bounded\n"); break;
//Error
case DSDP_UNBOUNDED:
mexPrintf(" Solution Status: Dual Unbounded, Primal Infeasible\n"); break;
case DSDP_INFEASIBLE:
mexPrintf(" Solution Status: Primal Unbounded, Dual Infeasible\n"); break;
case DSDP_PDUNKNOWN:
default:
mexPrintf(" Solution Status: Unknown - Check Dual Bounds\n"); break;
}
}
if(reason==DSDP_CONVERGED)
mexPrintf("\n Final Primal Objective: %2.5g\n Final Dual Objective: %2.5g\n In %5d iterations\n %5.2f seconds\n",*pval,*dval,iters,evaltime);
mexPrintf("------------------------------------------------------------------\n\n");
}
//Free DSDP Problem
DSDP_ERR( DSDPDestroy(dsdp), "Error Destroying DSDP Problem");
//Free Temporary memory
if(temp_jc) {mxFree(temp_jc); temp_jc = NULL;}
if(temp_ir) {mxFree(temp_ir); temp_ir = NULL;}
if(temp_pr) {mxFree(temp_pr); temp_pr = NULL;}
}
//Main Function
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[])
{
//Input Args
double *f, *blin = NULL, *lb = NULL, *ub = NULL, *y0 = NULL;
//Return Args
double *x, *pval, *dval, *exitflag, *iter, *pinf, *dinf, *realgap, *xzgap;
//Options (most get defaults written in)
int maxiter = 1500;
//Internal Vars
size_t ndec = 0, nlincon = 0, lincon_nz = 0, total_dim = 0, ncones = 0;
size_t i, j;
const char *onames[2] = {"pval","dval"};
const char *fnames[5] = {"iter","pinf","dinf","realgap","xzgap"};
double evaltime;
int status = -1, nb = 0, linoffset = 0, indlb = 1, indub = 1, nLB = 0, nUB = 0;
mwIndex *jc;
//CSDP Problem Data
struct blockmatrix C;
double *b, *y, *xx, objconstant = 0.0;
struct constraintmatrix *constraints;
struct blockmatrix X, Z;
struct sparseblock *blockptr;
struct paramstruc params;
//Version Return
if(nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(CSDP_VERSION);
return;
}
//Check Inputs
checkInputs(prhs,nrhs);
//Get pointers to Input variables
f = mxGetPr(pF); ndec = mxGetNumberOfElements(pF);
if(!mxIsEmpty(pA)) {
blin = mxGetPr(pB);
nlincon = mxGetM(pA);
jc = mxGetJc(pA);
lincon_nz = jc[ndec];
}
if(nrhs > eLB && !mxIsEmpty(pLB)) {
lb = mxGetPr(pLB);
//Ensure we have at least one finite bound
for(i=0,j=0;i<ndec;i++)
if(mxIsInf(lb[i]))
j++;
if(j==ndec)
lb = NULL;
}
if(nrhs > eUB && !mxIsEmpty(pUB)) {
ub = mxGetPr(pUB);
//Ensure we have at least one finite bound
for(i=0,j=0;i<ndec;i++)
if(mxIsInf(ub[i]))
j++;
if(j==ndec)
ub = NULL;
}
if(nrhs > eSDP && !mxIsEmpty(pSDP)) {
if(mxIsCell(pSDP))
ncones = mxGetNumberOfElements(pSDP);
else
ncones = 1;
}
if(nrhs > eY0 && !mxIsEmpty(pY0))
y0 = mxGetPr(pY0);
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateStructMatrix(1,1,2,onames);
mxSetField(plhs[1],0,onames[0],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[1],0,onames[1],mxCreateDoubleMatrix(1,1, mxREAL));
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
pval = mxGetPr(mxGetField(plhs[1],0,onames[0]));
dval = mxGetPr(mxGetField(plhs[1],0,onames[1]));
exitflag = mxGetPr(plhs[2]);
//Info Output
plhs[3] = mxCreateStructMatrix(1,1,5,fnames);
mxSetField(plhs[3],0,fnames[0],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[1],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[2],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[3],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[4],mxCreateDoubleMatrix(1,1, mxREAL));
iter = mxGetPr(mxGetField(plhs[3],0,fnames[0]));
pinf = mxGetPr(mxGetField(plhs[3],0,fnames[1]));
dinf = mxGetPr(mxGetField(plhs[3],0,fnames[2]));
realgap = mxGetPr(mxGetField(plhs[3],0,fnames[3]));
xzgap = mxGetPr(mxGetField(plhs[3],0,fnames[4]));
//Set Defaults
citer = 0;
maxtime = 1000;
printLevel = 0;
//Allocate Initial Storage for the Problem
b = (double*)malloc((ndec+1)*sizeof(double)); //objective vector
//C matrices [LB UB LIN SD]
nb = (int)ncones+(int)(nlincon>0)+(int)(lb!=NULL)+(int)(ub!=NULL);
#ifdef DEBUG
mexPrintf("Number of blocks (including bounds, linear and sdcones): %d\n",nb);
#endif
C.nblocks = nb;
C.blocks = (struct blockrec*)malloc((nb+1)*sizeof(struct blockrec)); //+1 due to fortran index
if(C.blocks == NULL)
mexErrMsgTxt("Error allocating memory for C matrices");
//Constraints (i.e. 1 per decision variable)
constraints = (struct constraintmatrix*)malloc((ndec+1)*sizeof(struct constraintmatrix)); //+1 due to fortran index
if(constraints == NULL) {
free(C.blocks);
mexErrMsgTxt("Error allocating memory for A matrices");
}
for(i=1;i<=ndec;i++)
constraints[i].blocks=NULL; //initially set as NULL
//Copy in and negate objective vector
for(i=0;i<ndec;i++)
b[i+1] = -f[i];
//Create Bounds if Present
if(lb || ub)
linoffset += addBounds(C,lb,ub,ndec,&nLB,&nUB);
//Create Linear Cone (diagonal) if present
if(nlincon) {
//Initialize C
C.blocks[linoffset+1].blockcategory = DIAG;
C.blocks[linoffset+1].blocksize = (int)nlincon;
C.blocks[linoffset+1].data.vec = (double*)malloc((nlincon+1)*sizeof(double));
if(C.blocks[linoffset+1].data.vec == NULL)
mexErrMsgTxt("Error allocating memory for LP C diagonal");
#ifdef DEBUG
mexPrintf("LP C[%d] Vector size: %d\n",linoffset+1,nlincon);
#endif
//Copy Elements
for(i=0;i<nlincon;i++) {
C.blocks[linoffset+1].data.vec[i+1] = -blin[i];
#ifdef DEBUG
mexPrintf(" C vec[%d] = %f\n",i+1,-blin[i]);
#endif
}
linoffset++;
}
#ifdef DEBUG
mexPrintf("\nBlock offset after bounds + linear con: %d\n\n",linoffset);
#endif
//Setup Semidefinite C matrices (note all full matrices, dense, in order from 1)
for(i=1;i<=ncones;i++) {
//Single Cone
if(ncones == 1 && !mxIsCell(pSDP))
total_dim += addCMatrix(C,pSDP,(int)i+linoffset);
//Multiple Cones
else
total_dim += addCMatrix(C,mxGetCell(pSDP,i-1),(int)i+linoffset);
}
//Add Linear Dims
total_dim += nLB+nUB+nlincon;
#ifdef DEBUG
mexPrintf("\nTotal dimension of all cones: %d\n\n",total_dim);
#endif
//Setup Each Constraint (for each decision var) (in order from 1)
indlb = 1; indub = 1;
for(i=1;i<=ndec;i++) {
//For each Semidefinte A matrix (sparse triu, in reverse order, i.e. [SD, LP, UB, LB])
for(j=ncones;j>0;j--) {
//Create an A matrix
blockptr=(struct sparseblock*)malloc(sizeof(struct sparseblock));
if(blockptr==NULL) {
sprintf(msgbuf,"Error allocating memory for Semidefinite A[%d,%d]",i,j+linoffset);
mexErrMsgTxt(msgbuf);
}
//Single Cone
if(ncones == 1 && !mxIsCell(pSDP))
addAMatrix(blockptr,pSDP,(int)i,(int)j+linoffset);
//Multiple Cones
else
addAMatrix(blockptr,mxGetCell(pSDP,j-1),(int)i,(int)j+linoffset);
//Insert A matrix into constraint list
blockptr->next=constraints[i].blocks;
constraints[i].blocks=blockptr;
}
//Linear Inequality Constraints
if(nlincon) {
//Create an A matrix
blockptr=(struct sparseblock*)malloc(sizeof(struct sparseblock));
if(blockptr==NULL) {
sprintf(msgbuf,"Error allocating memory for LP A[%d]",i);
mexErrMsgTxt(msgbuf);
}
//Insert LP A entries
j = 1 + (int)(nUB > 0) + (int)(nLB > 0);
insertLPVector(blockptr, pA, (int)i, (int)j);
//Insert A matrix into constraint list
blockptr->next=constraints[i].blocks;
constraints[i].blocks=blockptr;
}
//Upper Bounds
if(nUB) {
//Create an A matrix
blockptr=(struct sparseblock*)malloc(sizeof(struct sparseblock));
if(blockptr==NULL) {
sprintf(msgbuf,"Error allocating memory for UB A[%d]",i);
mexErrMsgTxt(msgbuf);
}
//Insert Bound A matrix entries
if(nLB > 0)
indub += insertBound(blockptr,ub,nUB,(int)i,2,indub,1.0); //block 2 ([LB,UB,..] 1.0 for ub)
else
indub += insertBound(blockptr,ub,nUB,(int)i,1,indub,1.0); //block 1 (first block, 1.0 for ub)
//Insert A matrix into constraint list
blockptr->next=constraints[i].blocks;
constraints[i].blocks=blockptr;
}
//Lower Bounds
if(nLB) {
//Create an A matrix
blockptr=(struct sparseblock*)malloc(sizeof(struct sparseblock));
if(blockptr==NULL) {
sprintf(msgbuf,"Error allocating memory for LB A[%d]",i);
mexErrMsgTxt(msgbuf);
}
//Insert Bound A matrix entries
indlb += insertBound(blockptr,lb,nLB,(int)i,1,indlb,-1.0); //block 1 (always first block, -1.0 for lb)
//Insert A matrix into constraint list
blockptr->next=constraints[i].blocks;
constraints[i].blocks=blockptr;
}
}
// //Set y0
// if (y0)
// for (i=0;i<ndec;i++) {
// DSDP_ERR( DSDPSetY0(dsdp,(int)i+1,y0[i]), "Error setting Y0");
// }
//
//Get CSDP Default Options
initparams(¶ms,&printLevel);
//Set OPTI default printLevel (none)
printLevel = 0;
//Get User Options (overwrites defaults above)
if(nrhs > eOPTS && !mxIsEmpty(pOPTS)) {
//OPTI Options
GetIntegerOption(pOPTS,"maxiter",¶ms.maxiter);
GetDoubleOption(pOPTS,"maxtime",&maxtime);
GetIntegerOption(pOPTS,"display",&printLevel);
GetDoubleOption(pOPTS,"objconstant",&objconstant);
//CSDP Options
GetDoubleOption(pOPTS,"axtol",¶ms.axtol);
GetDoubleOption(pOPTS,"atytol",¶ms.atytol);
GetDoubleOption(pOPTS,"objtol",¶ms.objtol);
GetDoubleOption(pOPTS,"pinftol",¶ms.pinftol);
GetDoubleOption(pOPTS,"dinftol",¶ms.dinftol);
GetDoubleOption(pOPTS,"minstepfrac",¶ms.minstepfrac);
GetDoubleOption(pOPTS,"maxstepfrac",¶ms.maxstepfrac);
GetDoubleOption(pOPTS,"minstepp",¶ms.minstepp);
GetDoubleOption(pOPTS,"minstepd",¶ms.minstepd);
GetIntegerOption(pOPTS,"usexzgap",¶ms.usexzgap);
GetIntegerOption(pOPTS,"tweakgap",¶ms.tweakgap);
GetIntegerOption(pOPTS,"affine",¶ms.affine);
GetDoubleOption(pOPTS,"perturbobj",¶ms.perturbobj);
//Optionally write problem to a SDPA sparse file
if(mxGetField(pOPTS,0,"writeprob") && !mxIsEmpty(mxGetField(pOPTS,0,"writeprob")) && mxIsChar(mxGetField(pOPTS,0,"writeprob"))) {
mxGetString(mxGetField(pOPTS,0,"writeprob"),msgbuf,1024);
write_prob(msgbuf,(int)total_dim,(int)ndec,C,b,constraints);
}
}
//Print Header
if(printLevel) {
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is CSDP v%s\n",CSDP_VERSION);
mexPrintf(" Author: Brian Borchers\n MEX Interface J. Currie 2013\n\n");
mexPrintf(" Problem Properties:\n");
mexPrintf(" # Decision Variables: %4d\n",ndec);
mexPrintf(" # Linear Inequalities: %4d ",nlincon);
if(nlincon)
mexPrintf("[%d nz]\n",lincon_nz);
else
mexPrintf("\n");
mexPrintf(" # Semidefinite Cones: %4d\n",ncones);
mexPrintf("------------------------------------------------------------------\n");
}
//Start timer
start = clock();
//Find Initial Solution
initsoln((int)total_dim,(int)ndec,C,b,constraints,&X,&y,&Z);
//Solve the problem
status=easy_sdp((int)total_dim,(int)ndec,C,b,constraints,objconstant,params,&X,&y,&Z,pval,dval,pinf,dinf,realgap,xzgap);
//Stop Timer
end = clock();
evaltime = ((double)(end-start))/CLOCKS_PER_SEC;
//Copy and negate solution
for(i=0;i<ndec;i++)
x[i] = -y[i+1];
//Assign other MATLAB outputs
*iter = (double)citer-1;
*exitflag = (double)status;
//Print Header
if(printLevel){
//Detail termination reason
switch(status)
{
//Success
case 0:
mexPrintf("\n *** CSDP CONVERGED ***\n"); break;
//Infeasible
case 1:
mexPrintf("\n *** TERMINATION: Primal Infeasible ***\n"); break;
case 2:
mexPrintf("\n *** TERMINATION: Dual Infeasible ***\n"); break;
//Partial Success
case 3:
mexPrintf("\n *** TERMINATION: PARTIAL SUCESS ***\n *** A Solution is found but full accuracy was not achieved ***\n"); break;
//Error
case 4:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Maximum Iterations Reached ***\n"); break;
case CSDP_MAX_TIME:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Maximum Time Reached ***\n"); break;
case 5:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Stuck at edge of primal feasibility ***\n"); break;
case 6:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Stuck at edge of dual infeasibility ***\n"); break;
case 7:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Lack of progress ***\n"); break;
case 8:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: X, Z, or O was singular ***\n"); break;
case 9:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Detected NaN or Inf values ***\n"); break;
case 10:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Easy-SDP General Failure ***\n"); break;
case 11:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Failed C Check - Check Symmetry! ***\n"); break;
case 12:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Failed Constraints Check ***\n"); break;
case CSDP_USER_TERMINATION:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: User Exited ***\n"); break;
//Here is ok too?
default:
mexPrintf("\n *** CSDP FINISHED ***\n"); break;
}
if(status==0 || status==3)
mexPrintf("\n Final Primal Objective: %2.5g\n Final Dual Objective: %2.5g\n In %5d iterations\n %5.2f seconds\n",*pval,*dval,citer-1,evaltime);
mexPrintf("------------------------------------------------------------------\n\n");
}
//Optionally write solution to a SDPA sparse file
if(nrhs > eOPTS && !mxIsEmpty(pOPTS) && mxGetField(pOPTS,0,"writesol") && !mxIsEmpty(mxGetField(pOPTS,0,"writesol")) && mxIsChar(mxGetField(pOPTS,0,"writesol"))) {
mxGetString(mxGetField(pOPTS,0,"writesol"),msgbuf,1024);
write_sol(msgbuf,(int)total_dim,(int)ndec,X,y,Z);
}
//Optionally retrieve X
if(nlhs > 4) {
plhs[4] = mxCreateCellMatrix(X.nblocks,1);
for(i=0;i<X.nblocks;i++) {
//Set Block Values
if(X.blocks[i+1].blockcategory == DIAG) {
mxSetCell(plhs[4],i,mxCreateDoubleMatrix(X.blocks[i+1].blocksize,1,mxREAL)); //create vector
xx = mxGetPr(mxGetCell(plhs[4],i));
for(j=0;j<X.blocks[i+1].blocksize;j++)
xx[j] = X.blocks[i+1].data.vec[j+1];
}
else {
mxSetCell(plhs[4],i,mxCreateDoubleMatrix(X.blocks[i+1].blocksize,X.blocks[i+1].blocksize,mxREAL)); //create matrix
xx = mxGetPr(mxGetCell(plhs[4],i));
for(j=0;j<(X.blocks[i+1].blocksize*X.blocks[i+1].blocksize);j++)
xx[j] = X.blocks[i+1].data.mat[j];
}
}
}
//Free CSDP Problem (including all allocated memory)
free_prob((int)total_dim,(int)ndec,C,b,constraints,X,y,Z);
}
