/*
* s o l v e O Q P b e n c h m a r k
*/
returnValue solveOQPbenchmark( int nQP, int nV,
const real_t* const _H, const real_t* const g,
const real_t* const lb, const real_t* const ub,
BooleanType isSparse,
const Options& options, int& nWSR, real_t& maxCPUtime,
real_t& maxStationarity, real_t& maxFeasibility, real_t& maxComplementarity
)
{
real_t maxNWSR = 0.0;
real_t avgNWSR = 0.0;
real_t avgCPUtime = 0.0;
returnValue returnvalue = solveOQPbenchmark( nQP,nV,
_H,g,lb,ub,
isSparse,BT_TRUE,
options,nWSR,
maxNWSR,avgNWSR,maxCPUtime,avgCPUtime,
maxStationarity,maxFeasibility,maxComplementarity
);
nWSR = (int)maxNWSR;
return returnvalue;
}
/*
* 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;
}
/*
* 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;
}
