/* * 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_t& 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 = runOqpBenchmark( path,isSparse,BT_TRUE, options,nWSR, maxNWSR,avgNWSR,maxCPUtime,avgCPUtime, maxStationarity,maxFeasibility,maxComplementarity ); nWSR = (int_t)maxNWSR; return returnvalue; }
/** Example for qpOASES main function using the OQP interface. */ int main( ) { USING_NAMESPACE_QPOASES /* 1) Define benchmark arguments. */ BooleanType isSparse = BT_FALSE; Options options; options.setToMPC(); options.printLevel = PL_NONE; int_t nWSR = 600; real_t maxCPUtime = 10.0; /* seconds */ real_t maxStationarity, maxFeasibility, maxComplementarity; /* 2) Run benchmark. */ if ( runOqpBenchmark( "./chain80w/", isSparse, options, nWSR, maxCPUtime, maxStationarity, maxFeasibility, maxComplementarity ) != SUCCESSFUL_RETURN ) { myPrintf( "In order to run this example, you need to download example no. 02\nfrom the Online QP Benchmark Collection website first!\n" ); return -1; } /* 3) Print results. */ printf( "\n\n" ); printf( "OQP Benchmark Results:\n" ); printf( "======================\n\n" ); printf( "maximum violation stationarity: %.3e\n",maxStationarity ); printf( "maximum violation feasibility: %.3e\n",maxFeasibility ); printf( "maximum violation complementarity: %.3e\n",maxComplementarity ); printf( "\n" ); printf( "maximum CPU time: %.3f milliseconds\n\n",1000.0*maxCPUtime ); return 0; }
/** Run benchmark examples. */ int main( int argc, char *argv[] ) { USING_NAMESPACE_QPOASES #ifdef __USE_SINGLE_PRECISION__ const real_t TOL = 5e-2; #else const real_t TOL = 1e-5; #endif /* 1) Define benchmark arguments. */ BooleanType isSparse = BT_FALSE; //BooleanType isSparse = BT_TRUE; Options options; options.setToDefault(); //options.setToMPC(); //options.setToReliable(); options.printLevel = PL_LOW; //options.printLevel = PL_MEDIUM; //options.printLevel = PL_TABULAR; //options.enableFarBounds = BT_FALSE; // options.initialStatusBounds = ST_LOWER; //options.numRegularisationSteps = 1; //options.epsRegularisation = 1.0e3 * EPS; //options.enableFlippingBounds = BT_FALSE; //options.enableFlippingBounds = BT_FALSE; //options.enableRamping = BT_TRUE; //options.enableFarBounds = BT_FALSE; //options.enableNZCTests = BT_FALSE; //options.epsNZCTests = 1.0e4 * EPS; //options.epsFlipping = 1.0e5 * EPS; //options.enableFullLITests = BT_TRUE; //options.enableDriftCorrection = 1; //options.enableEqualities = BT_TRUE; //options.enableEqualities = BT_FALSE; //options.epsNum = -1.0e3 * EPS; //options.epsDen = 1.0e3 * EPS; int_t nWSR; real_t maxCPUtime; /* seconds */ real_t maxStationarity = 0.0, maxFeasibility = 0.0, maxComplementarity = 0.0; real_t avgStationarity = 0.0, avgFeasibility = 0.0, avgComplementarity = 0.0; int_t scannedDir = 0; int_t nfail = 0, npass = 0; int_t nproblems, i; struct dirent **namelist; char resstr[MAX_STRING_LENGTH], oqpProblem[MAX_STRING_LENGTH]; char *problem; returnValue returnvalue; int_t expectedNumSolvedProblems = 44; real_t expectedAvgStationarity = TOL; real_t expectedAvgFeasibility = TOL; real_t expectedAvgComplementarity = TOL; if ( argv[argc-1][0] == 'O' ) { if ( strlen(argv[argc-1]) != 3 ) { fprintf( stdout,"ERROR (testbench): Invalid options passed!\n" ); return TEST_DATA_NOT_FOUND; } fprintf( stdout,"Analysing passed options: " ); switch ( argv[argc-1][1] ) { case 'd': fprintf( stdout,"default options, " ); options.setToDefault(); if ( argv[argc-1][2] == 's' ) { expectedNumSolvedProblems = 44; expectedAvgStationarity = 1e-9; expectedAvgFeasibility = 1e-9; expectedAvgComplementarity = 5e-7; } else { expectedNumSolvedProblems = 44; expectedAvgStationarity = 5e-10; expectedAvgFeasibility = 5e-10; expectedAvgComplementarity = 5e-8; } break; case 'r': fprintf( stdout,"reliable options, " ); options.setToReliable(); if ( argv[argc-1][2] == 's' ) { expectedNumSolvedProblems = 44; expectedAvgStationarity = 2e-9; expectedAvgFeasibility = 2e-11; expectedAvgComplementarity = 3e-9; } else { expectedNumSolvedProblems = 44; expectedAvgStationarity = 2e-9; expectedAvgFeasibility = 2e-9; expectedAvgComplementarity = 3e-7; } break; case 'm': fprintf( stdout,"MPC options, " ); options.setToMPC(); if ( argv[argc-1][2] == 's' ) { expectedNumSolvedProblems = 42; expectedAvgStationarity = 2e-8; expectedAvgFeasibility = 1e-8; expectedAvgComplementarity = 2e-7; } else { expectedNumSolvedProblems = 42; expectedAvgStationarity = 3e-8; expectedAvgFeasibility = 1e-8; expectedAvgComplementarity = 5e-8; } break; default: fprintf( stdout,"ERROR (testbench): Invalid options passed!\n" ); return TEST_DATA_NOT_FOUND; } switch ( argv[argc-1][2] ) { case 's': fprintf( stdout,"sparse QP data\n" ); isSparse = BT_TRUE; break; case 'd': fprintf( stdout,"dense QP data\n" ); isSparse = BT_FALSE; break; default: fprintf( stdout,"ERROR (testbench): Invalid options passed!\n" ); return TEST_DATA_NOT_FOUND; } options.printLevel = PL_NONE; //options.enableFlippingBounds = BT_FALSE; nproblems = argc-2; } else { nproblems = argc-1; } if (nproblems == 0) { /* 2a) Scan problem directory */ nproblems = scandir("../testing/cpp/data/problems", &namelist, NULL, alphasort); if (nproblems <= 0) { myPrintf( "No test problems found!\n" ); return TEST_DATA_NOT_FOUND; } scannedDir = 1; } else { /* 2b) Use problem list given by arguments */ scannedDir = 0; } /* 3) Run benchmark. */ printf("%10s %9s %9s %9s %6s %-12s\n", "problem", "stat", "feas", "compl", "nWSR", "result"); for (i = 0; i < nproblems; i++) { if (scannedDir) { /* skip special directories and zip file cuter.*bz2 */ if (namelist[i]->d_name[0] == '.' || namelist[i]->d_name[0] == 'c') { free(namelist[i]); continue; } problem = namelist[i]->d_name; } else { problem = argv[i+1]; } fprintf(stdFile, "%-10s ", problem); fflush(stdFile); snprintf(oqpProblem, MAX_STRING_LENGTH, "../testing/cpp/data/problems/%s/", problem); maxCPUtime = 300.0; nWSR = 2500; returnvalue = runOqpBenchmark( oqpProblem, isSparse, options, nWSR, maxCPUtime, maxStationarity, maxFeasibility, maxComplementarity ); if (returnvalue == SUCCESSFUL_RETURN && maxStationarity < TOL && maxFeasibility < TOL && maxComplementarity < TOL) { npass++; avgStationarity += maxStationarity; avgFeasibility += maxFeasibility; avgComplementarity += maxComplementarity; strncpy(resstr, "pass", MAX_STRING_LENGTH); } else { if ( returnvalue == RET_BENCHMARK_ABORTED ) return TEST_DATA_NOT_FOUND; nfail++; snprintf (resstr, MAX_STRING_LENGTH, "fail (%d)",(int)returnvalue); } fprintf(stdFile, "%9.2e %9.2e %9.2e %6d %-12s\n", maxStationarity, maxFeasibility, maxComplementarity, (int)nWSR, resstr); if (scannedDir) free(namelist[i]); } if (scannedDir) free(namelist); avgStationarity /= (real_t)npass; avgFeasibility /= (real_t)npass; avgComplementarity /= (real_t)npass; /* 4) Print results. */ printf( "\n\n" ); printf( "Testbench results:\n" ); printf( "======================\n\n" ); printf( "Pass: %3d\n",(int)npass ); printf( "Fail: %3d\n",(int)nfail ); printf( "Ratio: %5.1f%%\n", 100.0 * (real_t)npass / (real_t)(npass+nfail) ); printf( "\n" ); QPOASES_TEST_FOR_TRUE( npass >= expectedNumSolvedProblems ); printf( "avg. stat: %e\n", avgStationarity ); printf( "avg. feas: %e\n", avgFeasibility ); printf( "avg. cmpl: %e\n", avgComplementarity ); QPOASES_TEST_FOR_TOL( avgStationarity, expectedAvgStationarity ); QPOASES_TEST_FOR_TOL( avgFeasibility, expectedAvgFeasibility ); QPOASES_TEST_FOR_TOL( avgComplementarity, expectedAvgComplementarity ); return 0; }
/** Example for qpOASES main function using the OQP interface. */ int main( ) { USING_NAMESPACE_QPOASES /* 1) Define benchmark arguments. */ BooleanType isSparse = BT_FALSE; BooleanType useHotstarts; Options options; options.setToMPC(); options.printLevel = PL_LOW; int_t maxAllowedNWSR; real_t maxNWSR, avgNWSR, maxCPUtime, avgCPUtime; real_t maxStationarity, maxFeasibility, maxComplementarity; const int_t numBenchmarks = 4; //5 const char *benchmarkPath[numBenchmarks]; benchmarkPath[0] = "../testing/cpp/data/oqp/chain80/"; benchmarkPath[1] = "../testing/cpp/data/oqp/chain80w/"; benchmarkPath[2] = "../testing/cpp/data/oqp/diesel/"; benchmarkPath[3] = "../testing/cpp/data/oqp/crane/"; //benchmarkPath[4] = "../testing/cpp/data/oqp/CDU/"; /* 2) Run all benchmarks in a loop */ for ( int_t ii=0; ii<2*numBenchmarks; ++ii ) { if ( ii%2 == 0 ) useHotstarts = BT_FALSE; else useHotstarts = BT_TRUE; maxAllowedNWSR = 1000; maxNWSR = 0.0; avgNWSR = 0.0; maxCPUtime = 1000.0; /* seconds */ avgCPUtime = 0.0; /* seconds */ maxStationarity = 0.0; maxFeasibility = 0.0; maxComplementarity = 0.0; if ( runOqpBenchmark( benchmarkPath[ii/2], isSparse,useHotstarts, options,maxAllowedNWSR, maxNWSR,avgNWSR,maxCPUtime,avgCPUtime, maxStationarity,maxFeasibility,maxComplementarity ) != SUCCESSFUL_RETURN ) { myPrintf( "Something went wrong when running benchmark!\n" ); return TEST_DATA_NOT_FOUND; } /* 3) Print results. */ printf( "\n\n" ); if ( useHotstarts == BT_FALSE ) printf( "OQP Benchmark Results for %s (cold-starts):\n", benchmarkPath[ii/2] ); else printf( "OQP Benchmark Results for %s (hot-starts):\n", benchmarkPath[ii/2] ); printf( "===========================================================================\n\n" ); printf( "maximum CPU time: %.2f milliseconds\n",1000.0*maxCPUtime ); printf( "average CPU time: %.2f milliseconds\n",1000.0*avgCPUtime ); printf( "\n" ); printf( "maximum iterations: %.1f\n",maxNWSR ); printf( "average iterations: %.1f\n",avgNWSR ); printf( "\n" ); printf( "maximum violation stationarity: %.3e\n",maxStationarity ); printf( "maximum violation feasibility: %.3e\n",maxFeasibility ); printf( "maximum violation complementarity: %.3e\n",maxComplementarity ); printf( "\n" ); QPOASES_TEST_FOR_TOL( maxStationarity, 1e-9 ); QPOASES_TEST_FOR_TOL( maxFeasibility, 2e-11 ); QPOASES_TEST_FOR_TOL( maxComplementarity, 2e-10 ); switch( ii ) { case 0: /* chain80 (cold) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 62.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 7.5 ); break; case 1: /* chain80 (hot) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 19.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 2.4 ); break; case 2: /* chain80w (cold) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 84.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 10.1 ); break; case 3: /* chain80w (hot) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 16.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 2.7 ); break; case 4: /* diesel (cold) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 26.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 0.5 ); break; case 5: /* diesel (hot) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 22.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 0.3 ); break; case 6: /* crane (cold) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 64.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 44.0 ); break; case 7: /* crane (hot) */ QPOASES_TEST_FOR_TRUE( maxNWSR <= 42.5 ); QPOASES_TEST_FOR_TRUE( avgNWSR <= 0.4 ); break; } } return TEST_PASSED; }