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);
}
template <typename _Scalar> typename MosekOpt<_Scalar>::ReturnType
MosekOpt<_Scalar>::optimize( std::vector<_Scalar> *x_out, OBJ_SENSE objective_sense )
{
if ( !this->_updated )
{
std::cerr << "[" << __func__ << "]: " << "Please call update() first!" << std::endl;
return MSK_RES_ERR_UNKNOWN;
}
// cache problem size
const int numvar = this->getVarCount();
// determine problem type
MSKobjsense_enum objsense = (objective_sense == OBJ_SENSE::MINIMIZE) ? MSK_OBJECTIVE_SENSE_MINIMIZE
: MSK_OBJECTIVE_SENSE_MAXIMIZE;
if ( MSK_RES_OK == _r )
_r = MSK_putobjsense( _task, objsense );
if ( MSK_RES_OK == _r )
{
// set termination sensitivity
MSKrescodee trmcode;
if ( (_r == MSK_RES_OK) && (this->getTolRelGap() > Scalar(0)) )
{
_r = MSK_putdouparam( _task, MSK_DPAR_MIO_TOL_REL_GAP, this->getTolRelGap() /*1e-10f*/ );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_DPAR_MIO_DISABLE_TERM_TIME to " << this->getTimeLimit() << " did NOT work!" << std::endl;
}
}
if ( (_r == MSK_RES_OK) && (this->getTimeLimit() > Scalar(0)) )
{
_r = MSK_putdouparam(_task, MSK_DPAR_MIO_DISABLE_TERM_TIME, this->getTimeLimit() );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_DPAR_MIO_DISABLE_TERM_TIME to " << this->getTimeLimit() << " did NOT work!" << std::endl;
}
_r = MSK_putdouparam(_task, MSK_DPAR_MIO_MAX_TIME, this->getTimeLimit()+Scalar(5) );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_DPAR_MIO_MAX_TIME to " << this->getTimeLimit()+Scalar(5) << " did NOT work!" << std::endl;
}
}
if (_r == MSK_RES_OK)
{
//_r = MSK_putintparam(_task, MSK_IPAR_OPTIMIZER, MSK_OPTIMIZER_MIXED_INT_CONIC );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_OPTIMIZER_MIXED_INT_CONIC did not work!" << std::endl;
}
}
if ( _r == MSK_RES_OK )
{
_r = MSK_putintparam( _task, MSK_IPAR_MIO_PRESOLVE_USE, MSK_ON );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_IPAR_MIO_PRESOLVE_USE did not work!" << std::endl;
}
}
if ( _r == MSK_RES_OK )
{
_r = MSK_putintparam( _task, MSK_IPAR_MIO_HEURISTIC_LEVEL, 5 );
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "setting MSK_IPAR_MIO_HEURISTIC_LEVEL did not work!" << std::endl;
}
}
// Run optimizer
_r = MSK_optimizetrm( _task, &trmcode );
// Print a summary containing information about the solution for debugging purposes.
MSK_solutionsummary( _task, MSK_STREAM_LOG );
// save solution
double *xx = (double*) calloc(numvar,sizeof(double));
if ( _r == MSK_RES_OK )
{
MSKsolstae solsta;
if ( _r == MSK_RES_OK )
{
_r = MSK_getsolsta( _task, MSK_SOL_ITR, &solsta );
if ( _r != MSK_RES_OK )
{
_r = MSK_getsolsta( _task, MSK_SOL_ITG, &solsta );
}
if ( _r != MSK_RES_OK )
{
std::cerr << "[" << __func__ << "]: " << "neithter MSK_SOL_ITR, nor MSK_SOL_ITR worked" << std::endl;
}
}
switch ( solsta )
{
case MSK_SOL_STA_OPTIMAL:
case MSK_SOL_STA_NEAR_OPTIMAL:
{
if ( xx )
{
MSK_getxx(_task,
MSK_SOL_ITR, /* Request the basic solution. */
xx);
_storeSolution( xx, numvar );
printf("Optimal primal solution\n");
}
else
{
_r = MSK_RES_ERR_SPACE;
}
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:
{
MSKprostae prosta;
MSK_getprosta(_task,MSK_SOL_ITG,&prosta);
switch (prosta)
{
case MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED:
printf("Problem status Infeasible or unbounded\n");
break;
case MSK_PRO_STA_PRIM_INFEAS:
printf("Problem status Infeasible.\n");
break;
case MSK_PRO_STA_UNKNOWN:
printf("Problem status unknown.\n");
break;
default:
printf("Other problem status.");
break;
}
char symname[MSK_MAX_STR_LEN];
char desc[MSK_MAX_STR_LEN];
/* If the solutions status is unknown, print the termination code
indicating why the optimizer terminated prematurely. */
MSK_getcodedesc(trmcode,
symname,
desc);
printf("The solutuion status is unknown.\n");
printf("The optimizer terminitated with code: %s\n",symname);
break;
}
// ITG
//asdf todo: consolidate this last part:
case MSK_SOL_STA_INTEGER_OPTIMAL:
case MSK_SOL_STA_NEAR_INTEGER_OPTIMAL :
MSK_getxx(_task,
MSK_SOL_ITG, /* Request the integer solution. */
xx);
_storeSolution( xx, numvar );
printf("Optimal integer solution.\n");
break;
case MSK_SOL_STA_PRIM_FEAS:
/* A feasible but not necessarily optimal solution was located. */
MSK_getxx(_task,MSK_SOL_ITG,xx);
_storeSolution( xx, numvar );
printf("Feasible solution.\n");
break;
default:
std::cerr << "[" << __func__ << "]: " << "unknown code " << (int)solsta << std::endl;
break;
}
if ( xx ) { free(xx); xx = NULL; }
}
}
if ( MSK_RES_OK != _r )
{
/* 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);
}
else
{
// output
if ( x_out )
{
x_out->clear();
x_out->reserve( this->_x.size() );
for ( int j=0; j < this->_x.size(); ++j )
{
x_out->push_back( this->_x[j] );
}
}
}
return _r;
} // ...MosekOpt::optimize()
