/*
* r u n O Q P b e n c h m a r k
*/
returnValue runOQPbenchmark( const char* path, BooleanType isSparse, const Options& options,
int& nWSR, real_t& maxCPUtime,
real_t& maxStationarity, real_t& maxFeasibility, real_t& maxComplementarity
)
{
int nQP=0, nV=0, nC=0, nEC=0;
real_t *H=0, *g=0, *A=0, *lb=0, *ub=0, *lbA=0, *ubA=0;
returnValue returnvalue;
/* I) SETUP BENCHMARK: */
/* 1) Obtain QP sequence dimensions. */
if ( readOQPdimensions( path, nQP,nV,nC,nEC ) != SUCCESSFUL_RETURN )
return THROWERROR( RET_BENCHMARK_ABORTED );
/* 2) Read OQP benchmark data. */
if ( readOQPdata( path,
nQP,nV,nC,nEC,
&H,&g,&A,&lb,&ub,&lbA,&ubA,
0,0,0
) != SUCCESSFUL_RETURN )
{
return THROWERROR( RET_UNABLE_TO_READ_BENCHMARK );
}
/* II) SOLVE BENCHMARK */
if ( nC > 0 )
{
returnvalue = solveOQPbenchmark( nQP,nV,nC,nEC,
H,g,A,lb,ub,lbA,ubA,
isSparse,options,
nWSR,maxCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
{
delete[] H; delete[] A;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] g;
return THROWERROR( returnvalue );
}
}
else
{
returnvalue = solveOQPbenchmark( nQP,nV,
H,g,lb,ub,
isSparse,options,
nWSR,maxCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
{
delete[] H; delete[] A;
delete[] ub; delete[] lb; delete[] g;
return THROWERROR( returnvalue );
}
}
delete[] H; delete[] A;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] g;
return SUCCESSFUL_RETURN;
}
/*
* r u n O Q P b e n c h m a r k
*/
returnValue runOQPbenchmark( const char* path, BooleanType isSparse, BooleanType useHotstarts,
const Options& options, int maxAllowedNWSR,
real_t& maxNWSR, real_t& avgNWSR, real_t& maxCPUtime, real_t& avgCPUtime,
real_t& maxStationarity, real_t& maxFeasibility, real_t& maxComplementarity
)
{
int nQP=0, nV=0, nC=0, nEC=0;
real_t *H, *g, *A, *lb, *ub, *lbA, *ubA;
returnValue returnvalue;
/* I) SETUP BENCHMARK: */
/* 1) Obtain QP sequence dimensions. */
if ( readOQPdimensions( path, nQP,nV,nC,nEC ) != SUCCESSFUL_RETURN )
return THROWERROR( RET_BENCHMARK_ABORTED );
/* 2) Read OQP benchmark data. */
if ( readOQPdata( path,
nQP,nV,nC,nEC,
&H,&g,&A,&lb,&ub,&lbA,&ubA,
0,0,0
) != SUCCESSFUL_RETURN )
{
return THROWERROR( RET_UNABLE_TO_READ_BENCHMARK );
}
// normaliseConstraints( nV,nC,A,lbA,ubA ); //only works when nP==1
/* II) SOLVE BENCHMARK */
if ( nC > 0 )
{
returnvalue = solveOQPbenchmark( nQP,nV,nC,nEC,
H,g,A,lb,ub,lbA,ubA,
isSparse,useHotstarts,
options,maxAllowedNWSR,
maxNWSR,avgNWSR,maxCPUtime,avgCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
{
delete[] H; delete[] A;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] g;
return THROWERROR( returnvalue );
}
}
else
{
returnvalue = solveOQPbenchmark( nQP,nV,
H,g,lb,ub,
isSparse,useHotstarts,
options,maxAllowedNWSR,
maxNWSR,avgNWSR,maxCPUtime,avgCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
{
delete[] H; delete[] A;
delete[] ub; delete[] lb; delete[] g;
return THROWERROR( returnvalue );
}
}
delete[] H; delete[] A;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] g;
return SUCCESSFUL_RETURN;
}
/** Example for qpOASES main function using the possibility to specify
* user-defined constraint product function. */
int main( )
{
int nQP, nV, nC, nEC;
real_t *H, *g, *A, *lb, *ub, *lbA, *ubA;
real_t cputime;
real_t xOpt[1000];
real_t yOpt[1000];
real_t xOptCP[1000+1000];
real_t yOptCP[1000+1000];
const char* path = "./cpp/data/oqp/chain80w/";
int k = 10; //th problem
if ( readOQPdimensions( path, nQP,nV,nC,nEC ) != SUCCESSFUL_RETURN )
return TEST_DATA_NOT_FOUND;
readOQPdata( path, nQP,nV,nC,nEC,
&H,&g,&A,&lb,&ub,&lbA,&ubA,
0,0,0
);
Options myOptions;
//myOptions.setToMPC();
myOptions.printLevel = PL_LOW;
int nWSR = 500;
cputime = 20.0;
QProblem qp( nV,nC );
qp.setOptions( myOptions );
qp.init( H,&(g[k*nV]),A,&(lb[k*nV]),&(ub[k*nV]),&(lbA[k*nC]),&(ubA[k*nC]),nWSR,&cputime );
qp.getPrimalSolution( xOpt );
qp.getDualSolution( yOpt );
printf( "cputime without constraintProduct: %.3ems\n", cputime*1000.0 );
nWSR = 500;
cputime = 20.0;
MpcConstraintProduct myCP( nV,nC,2,A );
QProblem qpCP( nV,nC );
qpCP.setOptions( myOptions );
qpCP.setConstraintProduct( &myCP );
qpCP.init( H,&(g[k*nV]),A,&(lb[k*nV]),&(ub[k*nV]),&(lbA[k*nC]),&(ubA[k*nC]),nWSR,&cputime );
qpCP.getPrimalSolution( xOptCP );
qpCP.getDualSolution( yOptCP );
printf( "cputime with constraintProduct: %.3ems\n", cputime*1000.0 );
delete[] ubA;
delete[] lbA;
delete[] ub;
delete[] lb;
delete[] A;
delete[] g;
delete[] H;
for( int ii=0; ii<nV; ++ii )
QPOASES_TEST_FOR_NEAR( xOptCP[ii],xOpt[ii] );
for( int ii=0; ii<nV+nC; ++ii )
QPOASES_TEST_FOR_NEAR( yOptCP[ii],yOpt[ii] );
return 0;
}
/*
* r u n O Q P b e n c h m a r k
*/
returnValue runOQPbenchmark( const char* path,
int& nWSR, double& maxCPUtime,
double& maxPrimalDeviation, double& maxDualDeviation, double& maxObjDeviation
)
{
int nQP, nV, nC, nEC;
double *H, *g, *A, *lb, *ub, *lbA, *ubA;
double *xOpt, *yOpt, *objOpt;
/* I) SETUP BENCHMARK: */
/* 1) Obtain QP sequence dimensions. */
if ( readOQPdimensions( path, nQP,nV,nC,nEC ) != SUCCESSFUL_RETURN )
return THROWERROR( RET_BENCHMARK_ABORTED );
/* 2) Read OQP benchmark data. */
if ( readOQPdata( path,
nQP,nV,nC,nEC,
&H,&g,&A,&lb,&ub,&lbA,&ubA,
&xOpt,&yOpt,&objOpt
) != SUCCESSFUL_RETURN )
{
return THROWERROR( RET_UNABLE_TO_READ_BENCHMARK );
}
/* II) SOLVE BENCHMARK */
if ( nC > 0 )
{
if ( solveOQPbenchmark( nQP,nV,nC,nEC,
H,g,A,lb,ub,lbA,ubA,
xOpt,yOpt,objOpt,
nWSR,maxCPUtime,
maxPrimalDeviation,maxDualDeviation,maxObjDeviation
) != SUCCESSFUL_RETURN )
{
delete[] objOpt; delete[] yOpt; delete[] xOpt;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] A; delete[] g; delete[] H;
return THROWERROR( RET_BENCHMARK_ABORTED );
}
}
else
{
if ( solveOQPbenchmark( nQP,nV,
H,g,lb,ub,
xOpt,yOpt,objOpt,
nWSR,maxCPUtime,
maxPrimalDeviation,maxDualDeviation,maxObjDeviation
) != SUCCESSFUL_RETURN )
{
delete[] objOpt; delete[] yOpt; delete[] xOpt;
delete[] ub; delete[] lb; delete[] g; delete[] H;
return THROWERROR( RET_BENCHMARK_ABORTED );
}
}
delete[] objOpt; delete[] yOpt; delete[] xOpt;
delete[] ubA; delete[] lbA; delete[] ub; delete[] lb; delete[] A; delete[] g; delete[] H;
return SUCCESSFUL_RETURN;
}
/*
* r u n O Q P b e n c h m a r k
*/
returnValue runOQPbenchmark( const char* path, BooleanType isSparse, BooleanType useHotstarts,
const Options* options, int maxAllowedNWSR,
real_t* maxNWSR, real_t* avgNWSR, real_t* maxCPUtime, real_t* avgCPUtime,
real_t* maxStationarity, real_t* maxFeasibility, real_t* maxComplementarity
)
{
int nQP=0, nV=0, nC=0, nEC=0;
myStatic real_t H[NVMAX*NVMAX];
myStatic real_t g[NQPMAX*NVMAX];
myStatic real_t A[NCMAX*NVMAX];
myStatic real_t lb[NQPMAX*NVMAX];
myStatic real_t ub[NQPMAX*NVMAX];
myStatic real_t lbA[NQPMAX*NCMAX];
myStatic real_t ubA[NQPMAX*NCMAX];
returnValue returnvalue;
/* I) SETUP BENCHMARK: */
/* 1) Obtain QP sequence dimensions. */
/*if ( readOQPdimensions( path, &nQP,&nV,&nC,&nEC ) != SUCCESSFUL_RETURN )
return THROWERROR( RET_BENCHMARK_ABORTED );*/
/* 2) Read OQP benchmark data. */
if ( readOQPdata( path,
&nQP,&nV,&nC,&nEC,
H,g,A,lb,ub,lbA,ubA,
0,0,0
) != SUCCESSFUL_RETURN )
{
return THROWERROR( RET_UNABLE_TO_READ_BENCHMARK );
}
/* II) SOLVE BENCHMARK */
if ( nC > 0 )
{
returnvalue = solveOQPbenchmark( nQP,nV,nC,nEC,
H,g,A,lb,ub,lbA,ubA,
isSparse,useHotstarts,
options,maxAllowedNWSR,
maxNWSR,avgNWSR,maxCPUtime,avgCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
return THROWERROR( returnvalue );
}
else
{
returnvalue = solveOQPbenchmarkB( nQP,nV,
H,g,lb,ub,
isSparse,useHotstarts,
options,maxAllowedNWSR,
maxNWSR,avgNWSR,maxCPUtime,avgCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
if ( returnvalue != SUCCESSFUL_RETURN )
return THROWERROR( returnvalue );
}
return SUCCESSFUL_RETURN;
}
