/* n: size of b and coords, may be smaller than mskEnv->num_variables if we have dummy vars b: coefficients of linear part of optimisation function coords: optimal y* vector, coord[i] is coordinate of node[i] */ void mosek_quad_solve_sep(MosekEnv * mskEnv, int n, float *b, float *coords) { int i, j; assert(n <= mskEnv->num_variables + 1); for (i = 0; i < n - 1 && mskEnv->r == MSK_RES_OK; i++) { mskEnv->r = MSK_putcj(mskEnv->task, i, -2 * b[i + 1]); } if (mskEnv->r == MSK_RES_OK) mskEnv->r = MSK_optimize(mskEnv->task); if (mskEnv->r == MSK_RES_OK) { MSK_getsolutionslice(mskEnv->task, MSK_SOL_ITR, MSK_SOL_ITEM_XX, 0, mskEnv->num_variables, mskEnv->xx); #ifdef DUMP_CONSTRAINTS fprintf(logfile, "Primal solution\n"); #endif coords[0] = 0; for (j = 1; j <= n; j++) { #ifdef DUMP_CONSTRAINTS fprintf(logfile, "x[%d]: %.2f\n", j, mskEnv->xx[j - 1]); #endif coords[j] = -mskEnv->xx[j - 1]; } } fprintf(logfile, "Return code: %d\n", mskEnv->r); }
/* b: coefficients of linear part of optimisation function n: number of nodes coords: optimal y* vector, coord[i] is coordinate of node[i] hierarchy_boundaries: y coord of boundaries between levels (ie, solution values for the dummy variables used in constraints) */ void mosek_quad_solve_hier(MosekEnv * mskEnv, float *b, int n, float *coords, float *hierarchy_boundaries) { int i, j; for (i = 1; i < n && mskEnv->r == MSK_RES_OK; i++) { mskEnv->r = MSK_putcj(mskEnv->task, i - 1, -2 * b[i]); } #ifdef DUMP_CONSTRAINTS fprintf(logfile, "x0=["); for (j = 0; j < mskEnv->num_variables; j++) { fprintf(logfile, "%f ", j < n ? b[j] : 0); } fprintf(logfile, "]\n"); fprintf(logfile, "f=["); double *c = N_GNEW(mskEnv->num_variables, double); MSK_getc(mskEnv->task, c); for (j = 0; j < mskEnv->num_variables; j++) { fprintf(logfile, "%f ", c[j]); } free(c); fprintf(logfile, "]\n"); #endif if (mskEnv->r == MSK_RES_OK) mskEnv->r = MSK_optimize(mskEnv->task); if (mskEnv->r == MSK_RES_OK) { MSK_getsolutionslice(mskEnv->task, MSK_SOL_ITR, MSK_SOL_ITEM_XX, 0, mskEnv->num_variables, mskEnv->xx); #ifdef DUMP_CONSTRAINTS fprintf(logfile, "Primal solution\n"); #endif coords[0] = 0; for (j = 0; j < mskEnv->num_variables; ++j) { #ifdef DUMP_CONSTRAINTS fprintf(logfile, "x[%d]: %.2f\n", j, mskEnv->xx[j]); #endif if (j < n - 1) { coords[j + 1] = -mskEnv->xx[j]; } else if (j >= n && j < mskEnv->num_variables - 1) { hierarchy_boundaries[j - n] = -mskEnv->xx[j]; } } } fprintf(logfile, "Return code: %d\n", mskEnv->r); }
bool ConicSolver::Solve(VectorXd& sol) { bool ret = false; #ifdef _WIN32 VectorXd solution; convertMatrixVectorFormat(); MSKenv_t env; MSKtask_t task; MSKrescodee r; r = MSK_makeenv(&env, NULL, NULL, NULL, NULL); if (r == MSK_RES_OK) { r = MSK_linkfunctoenvstream(env, MSK_STREAM_LOG, NULL, printstr); } r = MSK_initenv(env); if (r == MSK_RES_OK) { r = MSK_maketask(env, mNumCon, mNumVar, &task); if (r == MSK_RES_OK) { r = MSK_linkfunctotaskstream(task, MSK_STREAM_LOG, NULL, printstr); } if (r == MSK_RES_OK) r = MSK_putmaxnumvar(task, mNumVar); if (r == MSK_RES_OK) r = MSK_putmaxnumcon(task, mNumCon); /* Append ¡¯NUMCON ¡¯ empty constraints . The constraints will initially have no bounds . */ if (r == MSK_RES_OK) r = MSK_append(task, MSK_ACC_CON, mNumCon); /* Append ¡¯NUMVAR ¡¯ variables . The variables will initially be fixed at zero (x =0). */ if (r == MSK_RES_OK) r = MSK_append(task, MSK_ACC_VAR, mNumVar); /* Optionally add a constant term to the objective . */ if (r == MSK_RES_OK) r = MSK_putcfix(task, mConstant); for (int j = 0; j < mNumVar && r == MSK_RES_OK; ++j) { /* Set the linear term c_j in the objective .*/ if (r == MSK_RES_OK) r = MSK_putcj(task, j, mc[j]); /* Set the bounds on variable j.*/ if (r == MSK_RES_OK) { if (mbLowerBounded[j] && mbUpperBounded[j]) { if (mlb[j] == mub[j]) r = MSK_putbound(task, MSK_ACC_VAR, j, MSK_BK_FX, mlb[j], mub[j]); else { CHECK(mlb[j] < mub[j]); r = MSK_putbound(task, MSK_ACC_VAR, j, MSK_BK_RA, mlb[j], mub[j]); } } else if (mbLowerBounded[j]) { r = MSK_putbound(task, MSK_ACC_VAR, j , MSK_BK_LO, mlb[j], +MSK_INFINITY); } else if (mbUpperBounded[j]) { r = MSK_putbound(task, MSK_ACC_VAR, j, MSK_BK_UP, -MSK_INFINITY, mub[j]); } else { r = MSK_putbound(task, MSK_ACC_VAR, j, MSK_BK_FR, -MSK_INFINITY, +MSK_INFINITY); } } /* Input column j of A */ if (r == MSK_RES_OK && mNumCon) { int currentColumnIdx = mAColumnStartIdx[j]; int nextColumnIdx = mAColumnStartIdx[j + 1]; if (nextColumnIdx - currentColumnIdx > 0) r = MSK_putavec(task, MSK_ACC_VAR, j, nextColumnIdx - currentColumnIdx, &(mARowIdx[currentColumnIdx]), &(mAValues[currentColumnIdx])); } } /* Set the bounds on constraints . for i=1, ... , NUMCON : blc [i] <= constraint i <= buc [i] */ for (int i = 0; i < mNumCon && r == MSK_RES_OK; ++i) { if (mbConstraintLowerBounded[i] && mbConstraintUpperBounded[i]) { if (mlbc[i] == mubc[i]) { r = MSK_putbound(task, MSK_ACC_CON, i, MSK_BK_FX, mlbc[i], mubc[i]); } else { r = MSK_putbound(task, MSK_ACC_CON, i, MSK_BK_RA, mlbc[i], mubc[i]); } } else if (mbConstraintLowerBounded[i]) { r = MSK_putbound(task, MSK_ACC_CON, i, MSK_BK_LO, mlbc[i], +MSK_INFINITY); } else if (mbConstraintUpperBounded[i]) { r = MSK_putbound(task, MSK_ACC_CON, i, MSK_BK_UP, -MSK_INFINITY, mubc[i]); } else { LOG(WARNING) << "Every constraint should not be free."; } } for (int i = 0; i < mNumCone; ++i) { Cone& cone = mCones[i]; r = MSK_appendcone(task, MSK_CT_RQUAD, 0.0, cone.mSubscripts.size(), cone.GetMosekConeSubId()); //r = MSK_appendcone(task, MSK_CT_QUAD, 0.0, cone.mSubscripts.size(), cone.GetMosekConeSubId()); } if (r == MSK_RES_OK) { MSKrescodee trmcode; r = MSK_optimizetrm(task, &trmcode); MSK_solutionsummary(task, MSK_STREAM_LOG); if (r == MSK_RES_OK) { MSKsolstae solsta; MSK_getsolutionstatus(task, MSK_SOL_ITR, NULL, &solsta); double* result = new double[mNumVar]; switch (solsta) { case MSK_SOL_STA_OPTIMAL: case MSK_SOL_STA_NEAR_OPTIMAL: MSK_getsolutionslice(task, MSK_SOL_ITR, MSK_SOL_ITEM_XX, 0, mNumVar, result); LOG(INFO) << "Optimal primal solution"; ret = true; solution = VectorXd::Zero(mNumVar); sol = VectorXd::Zero(mNumVar); for (int k = 0; k < mNumVar; ++k) { solution[k] = result[k]; sol[k] = result[k]; } break; case MSK_SOL_STA_DUAL_INFEAS_CER: case MSK_SOL_STA_PRIM_INFEAS_CER: case MSK_SOL_STA_NEAR_DUAL_INFEAS_CER: case MSK_SOL_STA_NEAR_PRIM_INFEAS_CER: LOG(WARNING) << "Primal or dual infeasibility certificate found."; break; case MSK_SOL_STA_UNKNOWN: LOG(WARNING) << "The status of the solution could not be determined."; break; default: LOG(WARNING) << "Other solution status."; break; } delete[] result; } } else { LOG(WARNING) << "Error while optimizing."; } if (r != MSK_RES_OK) { char symname[MSK_MAX_STR_LEN]; char desc[MSK_MAX_STR_LEN]; LOG(WARNING) << "An error occurred while optimizing."; MSK_getcodedesc(r, symname, desc); LOG(WARNING) << "Error " << symname << " - " << desc; } } MSK_deletetask(&task); MSK_deleteenv(&env); #endif return ret; }
int main(int argc,char *argv[]) { MSKrescodee r; MSKidxt i,j; double c[] = {3.0, 1.0, 5.0, 1.0}; /* Below is the sparse representation of the A matrix stored by column. */ MSKlidxt aptrb[] = {0, 2, 5, 7}; MSKlidxt aptre[] = {2, 5, 7, 9}; MSKidxt asub[] = { 0, 1, 0, 1, 2, 0, 1, 1, 2}; double aval[] = { 3.0, 2.0, 1.0, 1.0, 2.0, 2.0, 3.0, 1.0, 3.0}; /* Bounds on constraints. */ MSKboundkeye bkc[] = {MSK_BK_FX, MSK_BK_LO, MSK_BK_UP }; double blc[] = {30.0, 15.0, -MSK_INFINITY}; double buc[] = {30.0, +MSK_INFINITY, 25.0 }; /* Bounds on variables. */ MSKboundkeye bkx[] = {MSK_BK_LO, MSK_BK_RA, MSK_BK_LO, MSK_BK_LO }; double blx[] = {0.0, 0.0, 0.0, 0.0 }; double bux[] = {+MSK_INFINITY, 10.0, +MSK_INFINITY, +MSK_INFINITY }; double xx[NUMVAR]; MSKenv_t env = NULL; MSKtask_t task = NULL; /* Create the mosek environment. */ r = MSK_makeenv(&env,NULL,NULL,NULL,NULL); /* Directs the env log stream to the 'printstr' function. */ if ( r==MSK_RES_OK ) MSK_linkfunctoenvstream(env,MSK_STREAM_LOG,NULL,printstr); /* Initialize the environment. */ if ( r==MSK_RES_OK ) r = MSK_initenv(env); if ( r==MSK_RES_OK ) { /* Create the optimization task. */ r = MSK_maketask(env,NUMCON,NUMVAR,&task); /* Directs the log task stream to the 'printstr' function. */ if ( r==MSK_RES_OK ) MSK_linkfunctotaskstream(task,MSK_STREAM_LOG,NULL,printstr); /* Give MOSEK an estimate of the size of the input data. This is done to increase the speed of inputting data. However, it is optional. */ if (r == MSK_RES_OK) r = MSK_putmaxnumvar(task,NUMVAR); if (r == MSK_RES_OK) r = MSK_putmaxnumcon(task,NUMCON); if (r == MSK_RES_OK) r = MSK_putmaxnumanz(task,NUMANZ); /* Append 'NUMCON' empty constraints. The constraints will initially have no bounds. */ if ( r == MSK_RES_OK ) r = MSK_append(task,MSK_ACC_CON,NUMCON); /* Append 'NUMVAR' variables. The variables will initially be fixed at zero (x=0). */ if ( r == MSK_RES_OK ) r = MSK_append(task,MSK_ACC_VAR,NUMVAR); /* Optionally add a constant term to the objective. */ if ( r ==MSK_RES_OK ) r = MSK_putcfix(task,0.0); for(j=0; j<NUMVAR && r == MSK_RES_OK; ++j) { /* Set the linear term c_j in the objective.*/ if(r == MSK_RES_OK) r = MSK_putcj(task,j,c[j]); /* Set the bounds on variable j. blx[j] <= x_j <= bux[j] */ if(r == MSK_RES_OK) r = MSK_putbound(task, MSK_ACC_VAR, /* Put bounds on variables.*/ j, /* Index of variable.*/ bkx[j], /* Bound key.*/ blx[j], /* Numerical value of lower bound.*/ bux[j]); /* Numerical value of upper bound.*/ /* Input column j of A */ if(r == MSK_RES_OK) r = MSK_putavec(task, MSK_ACC_VAR, /* Input columns of A.*/ j, /* Variable (column) index.*/ aptre[j]-aptrb[j], /* Number of non-zeros in column j.*/ asub+aptrb[j], /* Pointer to row indexes of column j.*/ aval+aptrb[j]); /* Pointer to Values of column j.*/ } /* Set the bounds on constraints. for i=1, ...,NUMCON : blc[i] <= constraint i <= buc[i] */ for(i=0; i<NUMCON && r==MSK_RES_OK; ++i) r = MSK_putbound(task, MSK_ACC_CON, /* Put bounds on constraints.*/ i, /* Index of constraint.*/ bkc[i], /* Bound key.*/ blc[i], /* Numerical value of lower bound.*/ buc[i]); /* Numerical value of upper bound.*/ /* Maximize objective function. */ if (r == MSK_RES_OK) r = MSK_putobjsense(task, MSK_OBJECTIVE_SENSE_MAXIMIZE); if ( r==MSK_RES_OK ) { MSKrescodee trmcode; /* Run optimizer */ r = MSK_optimizetrm(task,&trmcode); /* Print a summary containing information about the solution for debugging purposes. */ MSK_solutionsummary (task,MSK_STREAM_LOG); if ( r==MSK_RES_OK ) { MSKsolstae solsta; int j; MSK_getsolutionstatus (task, MSK_SOL_BAS, NULL, &solsta); switch(solsta) { case MSK_SOL_STA_OPTIMAL: case MSK_SOL_STA_NEAR_OPTIMAL: MSK_getsolutionslice(task, MSK_SOL_BAS, /* Request the basic solution. */ MSK_SOL_ITEM_XX,/* Which part of solution. */ 0, /* Index of first variable. */ NUMVAR, /* Index of last variable+1. */ xx); printf("Optimal primal solution\n"); for(j=0; j<NUMVAR; ++j) printf("x[%d]: %e\n",j,xx[j]); break; case MSK_SOL_STA_DUAL_INFEAS_CER: case MSK_SOL_STA_PRIM_INFEAS_CER: case MSK_SOL_STA_NEAR_DUAL_INFEAS_CER: case MSK_SOL_STA_NEAR_PRIM_INFEAS_CER: printf("Primal or dual infeasibility certificate found.\n"); break; case MSK_SOL_STA_UNKNOWN: printf("The status of the solution could not be determined.\n"); break; default: printf("Other solution status."); break; } } else { printf("Error while optimizing.\n"); } } if (r != MSK_RES_OK) { /* In case of an error print error code and description. */ char symname[MSK_MAX_STR_LEN]; char desc[MSK_MAX_STR_LEN]; printf("An error occurred while optimizing.\n"); MSK_getcodedesc (r, symname, desc); printf("Error %s - '%s'\n",symname,desc); } MSK_deletetask(&task); MSK_deleteenv(&env); } return r; }
void MyQCQP::optimize() { // resize alpha if(alpha != NULL) delete []alpha; alpha = new double[numvar]; double *c_ = new double[numvar]; for(int i = 0;i<numvar;i++) c_[i] = c[i]; MSKboundkeye *bkc_ = new MSKboundkeye[numcon]; double * blc_ = new double[numcon]; double * buc_ = new double[numcon]; for(int i = 0;i<numcon;i++) { bkc_[i] = bkc[i]; blc_[i] = blc[i]; buc_[i] = buc[i]; } MSKboundkeye *bkx_ = new MSKboundkeye[numvar]; double * blx_ = new double[numvar]; double * bux_ = new double[numvar]; for(int i = 0;i<numvar;i++) { bkx_[i] = bkx[i]; blx_[i] = blx[i]; bux_[i] = bux[i]; } MSKlidxt *aptrb_ = new MSKlidxt[aptrb.size()]; for(size_t i = 0;i<aptrb.size();i++) aptrb_[i] = aptrb[i]; MSKlidxt * aptre_ = new MSKlidxt[aptre.size()]; for(size_t i = 0;i<aptre.size();i++) aptre_[i] = aptre[i]; MSKidxt * asub_ = new MSKidxt[asub.size()]; for(size_t i = 0;i<asub.size();i++) asub_[i] = asub[i]; double *aval_ = new double[aval.size()]; for(size_t i = 0;i<aval.size();i++) aval_[i] = aval[i]; MSKrescodee r; MSKenv_t env; MSKtask_t task; r = MSK_makeenv(&env,NULL,NULL,NULL,NULL); r = MSK_initenv(env); if(r == MSK_RES_OK) { r = MSK_maketask(env,numcon,numvar,&task); if(r == MSK_RES_OK) r = MSK_append(task,MSK_ACC_CON,numcon); if(r == MSK_RES_OK) r = MSK_append(task,MSK_ACC_VAR, numvar); for(int j = 0;j<numvar && r== MSK_RES_OK;j++) { if(r == MSK_RES_OK) r = MSK_putcj(task,j,c_[j]); if(r == MSK_RES_OK) r = MSK_putbound(task,MSK_ACC_VAR,j,bkx_[j],blx_[j],bux_[j]); if(r == MSK_RES_OK) r = MSK_putavec(task,MSK_ACC_VAR,j,aptre_[j] - aptrb_[j], asub_ + aptrb_[j],aval_+aptrb_[j]); } for(int i=0;i<numcon && r== MSK_RES_OK;i++) { r = MSK_putbound(task,MSK_ACC_CON,i,bkc_[i],blc_[i],buc_[i]); } delete []c_; delete []bkx_; delete []blx_; delete []bux_; delete []aptrb_; delete []aptre_; delete []asub_; delete []aval_; delete []bkc_; delete []blc_; delete []buc_; for(int i=0;i<numcon-1 && r== MSK_RES_OK;i++) // numcon-1 quadratic constraints { int nzero = qsubi[i].size(); MSKidxt * qsubi_ = new MSKidxt[nzero]; MSKidxt * qsubj_ = new MSKidxt[nzero]; double * qval_ = new double[nzero]; for(int m = 0;m<nzero;m++) { qsubi_[m] = qsubi[i][m]; qsubj_[m] = qsubj[i][m]; qval_[m] = qval[i][m]; } if(r == MSK_RES_OK) r = MSK_putqconk(task,i,nzero,qsubi_,qsubj_,qval_); delete []qsubi_; delete []qsubj_; delete []qval_; } if(r == MSK_RES_OK) r = MSK_putobjsense(task,MSK_OBJECTIVE_SENSE_MINIMIZE); if(r == MSK_RES_OK) { MSKrescodee trmcode; r = MSK_optimizetrm(task,&trmcode); MSK_getsolutionslice(task,MSK_SOL_ITR, MSK_SOL_ITEM_XX,0,numvar,alpha); MSK_getsolutionslice(task,MSK_SOL_ITR,MSK_SOL_ITEM_SUC,0,numcon,mu); } MSK_deletetask(&task); } MSK_deleteenv(&env); }
int mosekNNSolverWrapper(const Matrix &Q, const Matrix &Eq, const Matrix &b, const Matrix &InEq, const Matrix &ib, const Matrix &lowerBounds, const Matrix &upperBounds, Matrix &sol, double *objVal, MosekObjectiveType objType) { DBGP("Mosek QP Wrapper started"); MSKrescodee r; MSKtask_t task = NULL; // Get the only instance of the mosek environment. MSKenv_t env = getMosekEnv(); // Create the optimization task. r = MSK_maketask(env, 0, 0, &task); if (r != MSK_RES_OK) { DBGA("Failed to create optimization task"); return -1; } MSK_linkfunctotaskstream(task, MSK_STREAM_LOG, NULL, printstr); //--------------------------------------- //start inputing the problem //prespecify number of variables to make inputting faster r = MSK_putmaxnumvar(task, sol.rows()); //number of constraints (both equality and inequality) if (r == MSK_RES_OK) { r = MSK_putmaxnumcon(task, Eq.rows() + InEq.rows()); } //make sure default value is 0 for sparse matrices assert(Q.getDefault() == 0.0); assert(Eq.getDefault() == 0.0); assert(InEq.getDefault() == 0.0); //number of non-zero entries in A if (r == MSK_RES_OK) { r = MSK_putmaxnumanz(task, Eq.numElements() + InEq.numElements()); } if (r != MSK_RES_OK) { DBGA("Failed to input variables"); MSK_deletetask(&task); return -1; } //solver is sensitive to numerical problems. Scale the problem down //we will use this value to scale down the right hand side of equality //and inequality constraints and lower and upper bounds //after solving, we must scale back up the solution and the value of the //objective double scale = b.absMax(); if (scale < 1.0e2) { scale = 1.0; } else { DBGP("Mosek solver: scaling problem down by " << scale); } //--------------------------------------- //insert the actual variables and constraints //append the variables MSK_append(task, MSK_ACC_VAR, sol.rows()); //append the constraints. MSK_append(task, MSK_ACC_CON, Eq.rows() + InEq.rows()); int i, j; double value; if (objType == MOSEK_OBJ_QP) { //quadratic optimization objective //the quadratic term Q.sequentialReset(); while (Q.nextSequentialElement(i, j, value)) { MSK_putqobjij(task, i, j, 2.0 * value); } } else if (objType == MOSEK_OBJ_LP) { //linear objective for (j = 0; j < Q.cols(); j++) { if (fabs(Q.elem(0, j)) > 1.0e-5) { MSK_putcj(task, j, Q.elem(0, j)); } } } else { assert(0); } //variable bounds assert(sol.rows() == lowerBounds.rows()); assert(sol.rows() == upperBounds.rows()); for (i = 0; i < sol.rows(); i++) { if (lowerBounds.elem(i, 0) >= upperBounds.elem(i, 0)) { if (lowerBounds.elem(i, 0) > upperBounds.elem(i, 0)) { assert(0); } if (lowerBounds.elem(i, 0) == -std::numeric_limits<double>::max()) { assert(0); } if (upperBounds.elem(i, 0) == std::numeric_limits<double>::max()) { assert(0); } //fixed variable DBGP(i << ": fixed " << lowerBounds.elem(i, 0) / scale); MSK_putbound(task, MSK_ACC_VAR, i, MSK_BK_FX, lowerBounds.elem(i, 0) / scale, upperBounds.elem(i, 0) / scale); } else if (lowerBounds.elem(i, 0) != -std::numeric_limits<double>::max()) { //finite lower bound if (upperBounds.elem(i, 0) != std::numeric_limits<double>::max()) { //two finite bounds DBGP(i << ": finite bounds " << lowerBounds.elem(i, 0) / scale << " " << upperBounds.elem(i, 0) / scale); MSK_putbound(task, MSK_ACC_VAR, i, MSK_BK_RA, lowerBounds.elem(i, 0) / scale, upperBounds.elem(i, 0) / scale); } else { //lower bound DBGP(i << ": lower bound " << lowerBounds.elem(i, 0) / scale); MSK_putbound(task, MSK_ACC_VAR, i, MSK_BK_LO, lowerBounds.elem(i, 0) / scale, +MSK_INFINITY); } } else { //infinite lower bound if (upperBounds.elem(i, 0) != std::numeric_limits<double>::max()) { //upper bound DBGP(i << ": upper bound " << upperBounds.elem(i, 0) / scale); MSK_putbound(task, MSK_ACC_VAR, i, MSK_BK_UP, -MSK_INFINITY, upperBounds.elem(i, 0) / scale); } else { //unbounded DBGP(i << ": unbounded"); MSK_putbound(task, MSK_ACC_VAR, i, MSK_BK_FR, -MSK_INFINITY, +MSK_INFINITY); } } } //constraints and constraint bounds //equality constraints Eq.sequentialReset(); while (Eq.nextSequentialElement(i, j, value)) { MSK_putaij(task, i, j, value); } for (i = 0; i < Eq.rows(); i++) { MSK_putbound(task, MSK_ACC_CON, i, MSK_BK_FX, b.elem(i, 0) / scale, b.elem(i, 0) / scale); } //inequality constraints, <= InEq.sequentialReset(); while (InEq.nextSequentialElement(i, j, value)) { int eqi = i + Eq.rows(); MSK_putaij(task, eqi, j, value); } for (i = 0; i < InEq.rows(); i++) { int eqi = i + Eq.rows(); MSK_putbound(task, MSK_ACC_CON, eqi, MSK_BK_UP, -MSK_INFINITY, ib.elem(i, 0) / scale); } //specify objective: minimize MSK_putobjsense(task, MSK_OBJECTIVE_SENSE_MINIMIZE); //give it 800 iterations, twice the default. MSK_putintparam(task, MSK_IPAR_INTPNT_MAX_ITERATIONS, 800); //---------------------------------- //solve the thing DBGP("Optimization started"); r = MSK_optimize(task); DBGP("Optimization returns"); //write problem to file /* static int fileNum = 0; if (r != MSK_RES_OK) { char filename[50]; sprintf(filename,"mosek_error_%d_%d.opf",fileNum++, r); MSK_writedata(task, filename); FILE *fp = fopen(filename,"a"); fprintf(fp,"\n\nEquality matrix:\n"); Eq.print(fp); fclose(fp); } */ if (r != MSK_RES_OK) { DBGA("Mosek optimization call failed, error code " << r); MSK_deletetask(&task); return -1; } DBGP("Optimization complete"); //debug code, find out number of iterations used //int iter; //MSK_getintinf(task, MSK_IINF_INTPNT_ITER, &iter); //DBGA("Iterations used: " << iter); //find out what kind of solution we have MSKprostae pst; MSKsolstae sst; MSK_getsolutionstatus(task, MSK_SOL_ITR, &pst, &sst); int result; if (sst == MSK_SOL_STA_OPTIMAL || sst == MSK_SOL_STA_NEAR_OPTIMAL) { //success, we have an optimal problem if (sst == MSK_SOL_STA_OPTIMAL) {DBGP("QP solution is optimal");} else {DBGA("QP solution is *nearly* optimal");} result = 0; } else if (sst == MSK_SOL_STA_PRIM_INFEAS_CER) { //unfeasible problem DBGP("Mosek optimization: primal infeasible"); result = 1; } else if (sst == MSK_SOL_STA_DUAL_INFEAS_CER) { //unfeasible problem DBGA("Mosek optimization: dual infeasible (primal unbounded?)"); result = 1; } else if (sst == MSK_SOL_STA_PRIM_AND_DUAL_FEAS) { //i think this means feasible problem, but unbounded solution //this shouldn't happen as our Q is positive semidefinite DBGA("QP solution is prim and dual feasible, but not optimal"); DBGA("Is Q positive semidefinite?"); result = -1; } else { //unknown return status DBGA("QP fails with solution status " << sst << " and problem status " << pst); result = -1; } //MSK_SOL_STA_DUAL_FEAS; //retrieve the solutions if (!result) { //get the value of the objective function MSKrealt obj, foo; MSK_getsolutioninf(task, MSK_SOL_ITR, &pst, &sst, &obj, &foo, &foo, &foo, &foo, &foo, &foo, &foo, &foo); if (objType == MOSEK_OBJ_QP) { *objVal = obj * scale * scale; } else if (objType == MOSEK_OBJ_LP) { *objVal = obj * scale; } else { assert(0); } double *xx = new double[sol.rows()]; MSK_getsolutionslice(task, MSK_SOL_ITR, MSK_SOL_ITEM_XX, 0, sol.rows(), xx); for (i = 0; i < sol.rows(); i++) { sol.elem(i, 0) = scale * xx[i]; DBGP("x" << i << ": " << xx[i]); } delete [] xx; } MSK_deletetask(&task); return result; }
int main (int argc, char * argv[]) { MSKtask_t task = NULL; MSKenv_t env = NULL; MSKrescodee r = MSK_RES_OK; if (argc <= 1) { printf ("Missing argument. The syntax is:\n"); printf (" simple inputfile [ solutionfile ]\n"); } else { /* Create the mosek environment. The `NULL' arguments here, are used to specify customized memory allocators and a memory debug file. These can safely be ignored for now. */ r = MSK_makeenv(&env, NULL, NULL, NULL, NULL); /* Initialize the environment */ if ( r==MSK_RES_OK ) MSK_initenv (env); /* Create a task object linked to the environment env. Initially we create it with 0 variables and 0 columns, since we do not know the size of the problem. */ if ( r==MSK_RES_OK ) r = MSK_maketask (env, 0,0, &task); if (r == MSK_RES_OK) MSK_linkfunctotaskstream(task,MSK_STREAM_LOG,NULL,printstr); /* We assume that a problem file was given as the first command line argument (received in `argv'). */ if ( r==MSK_RES_OK ) r = MSK_readdata (task, argv[1]); /* Solve the problem */ if ( r==MSK_RES_OK ) { MSKrescodee trmcode; MSK_optimizetrm(task,&trmcode); } /* Print a summary of the solution. */ MSK_solutionsummary(task, MSK_STREAM_MSG); if (r == MSK_RES_OK) { MSKprostae prosta; MSKsolstae solsta; MSKrealt primalobj,maxpbi,maxpcni,maxpeqi,maxinti, dualobj, maxdbi, maxdcni, maxdeqi; MSKintt isdef; MSKsoltypee whichsol = MSK_SOL_BAS; int accepted = 1; MSK_getsolutioninf ( task, whichsol, &prosta, &solsta, &primalobj, &maxpbi, &maxpcni, &maxpeqi, &maxinti, &dualobj, &maxdbi, &maxdcni, &maxdeqi); switch(solsta) { case MSK_SOL_STA_OPTIMAL: case MSK_SOL_STA_NEAR_OPTIMAL: { double max_primal_infeas = 0.0; /* maximal primal infeasibility */ double max_dual_infeas = 0.0; /* maximal dual infeasibility */ double obj_gap = fabs(dualobj-primalobj); max_primal_infeas = double_max(max_primal_infeas,maxpbi); max_primal_infeas = double_max(max_primal_infeas,maxpcni); max_primal_infeas = double_max(max_primal_infeas,maxpeqi); max_dual_infeas = double_max(max_dual_infeas,maxdbi); max_dual_infeas = double_max(max_dual_infeas,maxdcni); max_dual_infeas = double_max(max_dual_infeas,maxdeqi); /* Assume the application needs the solution to be within 1e-6 ofoptimality in an absolute sense. Another approach would be looking at the relative objective gap */ printf("Objective gap: %e\n",obj_gap); if (obj_gap > 1e-6) { printf("Warning: The objective gap is too large."); accepted = 0; } printf("Max primal infeasibility: %e\n", max_primal_infeas); printf("Max dual infeasibility: %e\n" , max_dual_infeas); /* We will accept a primal infeasibility of 1e-8 and dual infeasibility of 1e-6 */ if (max_primal_infeas > 1e-8) { printf("Warning: Primal infeasibility is too large"); accepted = 0; } if (max_dual_infeas > 1e-6) { printf("Warning: Dual infeasibility is too large"); accepted = 0; } } if (accepted && r == MSK_RES_OK) { MSKintt numvar,j; MSKrealt *xx = NULL; MSK_getnumvar(task,&numvar); xx = (double *) malloc(numvar*sizeof(MSKrealt)); MSK_getsolutionslice(task, MSK_SOL_BAS, /* Request the basic solution. */ MSK_SOL_ITEM_XX,/* Which part of solution. */ 0, /* Index of first variable. */ numvar, /* Index of last variable+1. */ xx); printf("Optimal primal solution\n"); for(j=0; j<numvar; ++j) printf("x[%d]: %e\n",j,xx[j]); free(xx); } else { /* Print detailed information about the solution */ if (r == MSK_RES_OK) r = MSK_analyzesolution(task,MSK_STREAM_LOG,whichsol); } break; case MSK_SOL_STA_DUAL_INFEAS_CER: case MSK_SOL_STA_PRIM_INFEAS_CER: case MSK_SOL_STA_NEAR_DUAL_INFEAS_CER: case MSK_SOL_STA_NEAR_PRIM_INFEAS_CER: printf("Primal or dual infeasibility certificate found.\n"); break; case MSK_SOL_STA_UNKNOWN: printf("The status of the solution could not be determined.\n"); break; default: printf("Other solution status"); break; } } else { printf("Error while optimizing.\n"); } MSK_deletetask(&task); MSK_deleteenv(&env); } return r; }
int mosek_qp_optimize(double** G, double* delta, double* alpha, long k, double C, double *dual_obj) { long i,j,t; double *c; MSKlidxt *aptrb; MSKlidxt *aptre; MSKidxt *asub; double *aval; MSKboundkeye bkc[1]; double blc[1]; double buc[1]; MSKboundkeye *bkx; double *blx; double *bux; MSKidxt *qsubi,*qsubj; double *qval; MSKenv_t env; MSKtask_t task; MSKrescodee r; /*double dual_obj;*/ c = (double*) malloc(sizeof(double)*k); assert(c!=NULL); aptrb = (MSKlidxt*) malloc(sizeof(MSKlidxt)*k); assert(aptrb!=NULL); aptre = (MSKlidxt*) malloc(sizeof(MSKlidxt)*k); assert(aptre!=NULL); asub = (MSKidxt*) malloc(sizeof(MSKidxt)*k); assert(asub!=NULL); aval = (double*) malloc(sizeof(double)*k); assert(aval!=NULL); bkx = (MSKboundkeye*) malloc(sizeof(MSKboundkeye)*k); assert(bkx!=NULL); blx = (double*) malloc(sizeof(double)*k); assert(blx!=NULL); bux = (double*) malloc(sizeof(double)*k); assert(bux!=NULL); qsubi = (MSKidxt*) malloc(sizeof(MSKidxt)*(k*(k+1)/2)); assert(qsubi!=NULL); qsubj = (MSKidxt*) malloc(sizeof(MSKidxt)*(k*(k+1)/2)); assert(qsubj!=NULL); qval = (double*) malloc(sizeof(double)*(k*(k+1)/2)); assert(qval!=NULL); /* DEBUG */ /* for (i=0;i<k;i++) { printf("delta: %.4f\n", delta[i]); } printf("G:\n"); for (i=0;i<k;i++) { for (j=0;j<k;j++) { printf("%.4f ", G[i][j]); } printf("\n"); } fflush(stdout); */ /* DEBUG */ for (i=0;i<k;i++) { c[i] = -delta[i]; aptrb[i] = i; aptre[i] = i+1; asub[i] = 0; aval[i] = 1.0; bkx[i] = MSK_BK_LO; blx[i] = 0.0; bux[i] = MSK_INFINITY; } bkc[0] = MSK_BK_UP; blc[0] = -MSK_INFINITY; buc[0] = C; /* bkc[0] = MSK_BK_FX; blc[0] = C; buc[0] = C; */ /* create mosek environment */ r = MSK_makeenv(&env, NULL, NULL, NULL, NULL); /* check return code */ if (r==MSK_RES_OK) { /* directs output to printstr function */ MSK_linkfunctoenvstream(env, MSK_STREAM_LOG, NULL, printstr); } /* initialize the environment */ r = MSK_initenv(env); if (r==MSK_RES_OK) { /* create the optimization task */ r = MSK_maketask(env,1,k,&task); if (r==MSK_RES_OK) { r = MSK_linkfunctotaskstream(task, MSK_STREAM_LOG,NULL,printstr); if (r==MSK_RES_OK) { r = MSK_inputdata(task, 1,k, 1,k, c,0.0, aptrb,aptre, asub,aval, bkc,blc,buc, bkx,blx,bux); } if (r==MSK_RES_OK) { /* coefficients for the Gram matrix */ t = 0; for (i=0;i<k;i++) { for (j=0;j<=i;j++) { qsubi[t] = i; qsubj[t] = j; qval[t] = G[i][j]; t++; } } r = MSK_putqobj(task, k*(k+1)/2, qsubi,qsubj,qval); } /* DEBUG */ /* printf("t: %ld\n", t); for (i=0;i<t;i++) { printf("qsubi: %d, qsubj: %d, qval: %.4f\n", qsubi[i], qsubj[i], qval[i]); } fflush(stdout); */ /* DEBUG */ /* set relative tolerance gap (DEFAULT = 1E-8)*/ //MSK_putdouparam(task, MSK_DPAR_INTPNT_TOL_REL_GAP, 1E-10); MSK_putdouparam(task, MSK_DPAR_INTPNT_TOL_REL_GAP, 1E-14); if (r==MSK_RES_OK) { r = MSK_optimize(task); } if (r==MSK_RES_OK) { MSK_getsolutionslice(task, MSK_SOL_ITR, MSK_SOL_ITEM_XX, 0, k, alpha); /* print out alphas */ /* for (i=0;i<k;i++) { printf("alpha[%ld]: %.8f\n", i, alpha[i]); fflush(stdout); } */ /* output the objective value */ MSK_getprimalobj(task, MSK_SOL_ITR, dual_obj); //printf("ITER DUAL_OBJ %.8g\n", -(*dual_obj)); fflush(stdout); } MSK_deletetask(&task); } MSK_deleteenv(&env); } /* free the memory */ free(c); free(aptrb); free(aptre); free(asub); free(aval); free(bkx); free(blx); free(bux); free(qsubi); free(qsubj); free(qval); if(r == MSK_RES_OK) return(0); else return(r); }