Ignore:
Timestamp:
Aug 30, 2012 11:43:19 AM (7 years ago)
Author:
forrest
Message:

minor changes to implement Aboca

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/unitTest.cpp

    r1726 r1878  
    2626#include "CoinFloatEqual.hpp"
    2727
     28#if CLP_HAS_ABC
     29#include "CoinAbcCommon.hpp"
     30#endif
     31#ifdef ABC_INHERIT
     32#include "CoinAbcFactorization.hpp"
     33#endif
    2834#include "ClpFactorization.hpp"
    2935#include "ClpSimplex.hpp"
     
    4450#include "ClpPresolve.hpp"
    4551#include "Idiot.hpp"
    46 
     52#if FACTORIZATION_STATISTICS
     53extern double ftranTwiddleFactor1X;
     54extern double ftranTwiddleFactor2X;
     55extern double ftranFTTwiddleFactor1X;
     56extern double ftranFTTwiddleFactor2X;
     57extern double btranTwiddleFactor1X;
     58extern double btranTwiddleFactor2X;
     59extern double ftranFullTwiddleFactor1X;
     60extern double ftranFullTwiddleFactor2X;
     61extern double btranFullTwiddleFactor1X;
     62extern double btranFullTwiddleFactor2X;
     63extern double denseThresholdX;
     64extern double twoThresholdX;
     65extern double minRowsSparse;
     66extern double largeRowsSparse;
     67extern double mediumRowsDivider;
     68extern double mediumRowsMinCount;
     69extern double largeRowsCount;
     70#endif
    4771
    4872//#############################################################################
     
    251275               << "        If specified, then netlib testset run as well as the nitTest.\n";
    252276}
    253 
     277#if FACTORIZATION_STATISTICS
     278int loSizeX=-1;
     279int hiSizeX=1000000;
     280#endif
    254281//----------------------------------------------------------------
     282#ifndef ABC_INHERIT
     283#define AnySimplex ClpSimplex
     284#else
     285#include "AbcSimplex.hpp"
     286#define AnySimplex AbcSimplex
     287#endif
    255288int mainTest (int argc, const char *argv[], int algorithm,
    256               ClpSimplex empty, ClpSolve solveOptionsIn,
     289              AnySimplex empty, ClpSolve solveOptionsIn,
    257290              int switchOffValue, bool doVector)
    258291{
     
    271304          }
    272305     }
    273 
     306     int numberFailures=0;
    274307     // define valid parameter keywords
    275308     std::set<std::string> definedKeyWords;
     
    318351     else
    319352          dirNetlib = dirsep == '/' ? "../../Data/Netlib/" : "..\\..\\Data\\Netlib\\";
     353#if 0 //FACTORIZATION_STATISTICS==0
    320354     if (!empty.numberRows()) {
    321355          testingMessage( "Testing ClpSimplex\n" );
    322356          ClpSimplexUnitTest(dirSample);
    323357     }
     358#endif
    324359     if (parms.find("-netlib") != parms.end() || empty.numberRows()) {
    325360          unsigned int m;
    326 
     361          std::string sizeLoHi;
     362#if FACTORIZATION_STATISTICS
     363          double ftranTwiddleFactor1XChoice[3]={0.9,1.0,1.1};
     364          double ftranTwiddleFactor2XChoice[3]={0.9,1.0,1.1};
     365          double ftranFTTwiddleFactor1XChoice[3]={0.9,1.0,1.1};
     366          double ftranFTTwiddleFactor2XChoice[3]={0.9,1.0,1.1};
     367          double btranTwiddleFactor1XChoice[3]={0.9,1.0,1.1};
     368          double btranTwiddleFactor2XChoice[3]={0.9,1.0,1.1};
     369          double ftranFullTwiddleFactor1XChoice[3]={0.9,1.0,1.1};
     370          double ftranFullTwiddleFactor2XChoice[3]={0.9,1.0,1.1};
     371          double btranFullTwiddleFactor1XChoice[3]={0.9,1.0,1.1};
     372          double btranFullTwiddleFactor2XChoice[3]={0.9,1.0,1.1};
     373          double denseThresholdXChoice[3]={2,20,40};
     374          double twoThresholdXChoice[3]={800,1000,1200};
     375          double minRowsSparseChoice[3]={250,300,350};
     376          double largeRowsSparseChoice[3]={8000,10000,12000};
     377          double mediumRowsDividerChoice[3]={5,6,7};
     378          double mediumRowsMinCountChoice[3]={300,500,600};
     379          double largeRowsCountChoice[3]={700,1000,1300};
     380          double times[3*3*3*3*3];
     381          memset(times,0,sizeof(times));
     382#define whichParam(za,zname) const char * choice##za=#zname; \
     383       const double * use##za=zname##Choice;                 \
     384       double * external##za=&zname
     385          whichParam(A,denseThresholdX);
     386          whichParam(B,twoThresholdX);
     387          whichParam(C,minRowsSparse);
     388          whichParam(D,mediumRowsDivider);
     389          whichParam(E,mediumRowsMinCount);
     390#endif
    327391          // Define test problems:
    328392          //   mps names,
     
    352416          }
    353417          if (!empty.numberRows()) {
     418#if 1
    354419               mpsName.push_back("25fv47");
    355420               min.push_back(true);
     
    363428               nRows.push_back(2263);
    364429               nCols.push_back(9799);
    365                objValueTol.push_back(1.e-10);
     430               objValueTol.push_back(1.e-8);
    366431               objValue.push_back(9.8722419241E+05);
    367432               bestStrategy.push_back(3);
     
    370435               nRows.push_back(75);
    371436               nCols.push_back(83);
    372                objValueTol.push_back(1.e-10);
     437               objValueTol.push_back(1.e-8);
    373438               objValue.push_back(-3.0812149846e+01);
    374439               bestStrategy.push_back(3);
     
    401466               objValue.push_back(-2.5811392641e+03);
    402467               bestStrategy.push_back(3);
     468#endif
    403469               mpsName.push_back("pilot87");
    404470               min.push_back(true);
     
    408474               objValue.push_back(3.0171072827e+02);
    409475               bestStrategy.push_back(0);
     476#if 1
    410477               mpsName.push_back("adlittle");
    411478               min.push_back(true);
     
    9871054               objValue.push_back(1.3044763331E+00);
    9881055               bestStrategy.push_back(3);
     1056#endif
    9891057          } else {
    9901058               // Just testing one
     
    10151083          // Loop once for each Mps File
    10161084          for (m = 0; m < mpsName.size(); m++ ) {
     1085#if FACTORIZATION_STATISTICS
     1086               if (nRows[m]<loSizeX||nRows[m]>=hiSizeX) {
     1087                 std::cerr << "  skipping mps file: " << mpsName[m]
     1088                           <<" as "<<nRows[m]
     1089                         << " (" << m + 1 << " out of " << mpsName.size() << ")" << std::endl;
     1090                 continue;
     1091               }
     1092#endif
    10171093               std::cerr << "  processing mps file: " << mpsName[m]
    10181094                         << " (" << m + 1 << " out of " << mpsName.size() << ")" << std::endl;
    1019 
    1020                ClpSimplex solutionBase = empty;
     1095               AnySimplex solutionBase = empty;
    10211096               std::string fn = dirNetlib + mpsName[m];
    10221097               if (!empty.numberRows() || algorithm < 6) {
     
    10601135                              double time2 = CoinCpuTime() - time1;
    10611136                              testTime[iTest] = time2;
    1062                               printf("Took %g seconds - status %d\n", time2, solution.problemStatus());
     1137                              printf("Finished %s Took %g seconds (%d iterations) - status %d\n",
     1138                                     mpsName[m].c_str(),time2, solution.problemStatus(),solution.numberIterations());
    10631139                              if (solution.problemStatus())
    10641140                                   testTime[iTest] = 1.0e20;
     
    10891165               }
    10901166               double time1 = CoinCpuTime();
    1091                ClpSimplex solution = solutionBase;
     1167               AnySimplex solution = solutionBase;
    10921168#if 0
    10931169               solution.setOptimizationDirection(-1);
     
    11511227                    }
    11521228               }
     1229#if FACTORIZATION_STATISTICS
     1230               double timesOne[3*3*3*3*3];
     1231               memset(timesOne,0,sizeof(timesOne));
     1232               int iterationsOne[3*3*3*3*3];
     1233               memset(iterationsOne,0,sizeof(iterationsOne));
     1234               AnySimplex saveModel(solution);
     1235               double time2;
     1236#if 0
     1237               solution.initialSolve(solveOptions);
     1238               time2 = CoinCpuTime() - time1;
     1239               timeTaken += time2;
     1240               printf("%s took %g seconds using algorithm %s\n", fn.c_str(), time2, nameAlgorithm.c_str());
     1241#endif
     1242#define loA 1
     1243#define loB 0
     1244#define loC 0
     1245#define loD 1
     1246#define loE 1
     1247#define hiA 2
     1248#define hiB 1
     1249#define hiC 1
     1250#define hiD 2
     1251#define hiE 2
     1252               time2 = CoinCpuTime();
     1253               for (int iA=loA;iA<hiA;iA++) {
     1254                 *externalA=useA[iA];
     1255                 for (int iB=loB;iB<hiB;iB++) {
     1256                   *externalB=useB[iB];
     1257                   for (int iC=loC;iC<hiC;iC++) {
     1258                     *externalC=useC[iC];
     1259                     for (int iD=loD;iD<hiD;iD++) {
     1260                       *externalD=useD[iD];
     1261                       for (int iE=loE;iE<hiE;iE++) {
     1262                         *externalE=useE[iE];
     1263                         solution=saveModel;
     1264                         solution.initialSolve(solveOptions);
     1265                         double time3=CoinCpuTime();
     1266                         printf("Finished %s Took %g seconds (%d iterations) - status %d\n",
     1267                                mpsName[m].c_str(),time3-time2,solution.numberIterations(), solution.problemStatus());
     1268                         iterationsOne[iA+3*iB+9*iC+27*iD+81*iE]=solution.numberIterations();
     1269                         timesOne[iA+3*iB+9*iC+27*iD+81*iE]=time3-time2;
     1270                         times[iA+3*iB+9*iC+27*iD+81*iE]+=time3-time2;
     1271                         time2=time3;
     1272                       }
     1273                     }
     1274                   }
     1275                 }
     1276               }
     1277               double bestTime=1.0e100;
     1278               int iBestTime=-1;
     1279               double bestTimePer=1.0e100;
     1280               int iBestTimePer=-1;
     1281               int bestIterations=1000000;
     1282               int iBestIterations=-1;
     1283               printf("TTimes ");
     1284               for (int i=0;i<3*3*3*3*3;i++) {
     1285                 // skip if not done
     1286                 if (!iterationsOne[i])
     1287                   continue;
     1288                 double average=timesOne[i]/static_cast<double>(iterationsOne[i]);
     1289                 if (timesOne[i]<bestTime) {
     1290                   bestTime=timesOne[i];
     1291                   iBestTime=i;
     1292                 }
     1293                 if (average<bestTimePer) {
     1294                   bestTimePer=average;
     1295                   iBestTimePer=i;
     1296                 }
     1297                 if (iterationsOne[i]<bestIterations) {
     1298                   bestIterations=iterationsOne[i];
     1299                   iBestIterations=i;
     1300                 }
     1301                 printf("%.2f ",timesOne[i]);
     1302               }
     1303               printf("\n");
     1304               int iA,iB,iC,iD,iE;
     1305               iA=iBestTime;
     1306               iE=iA/81;
     1307               iA-=81*iE;
     1308               iD=iA/27;
     1309               iA-=27*iD;
     1310               iC=iA/9;
     1311               iA-=9*iC;
     1312               iB=iA/3;
     1313               iA-=3*iB;
     1314               printf("Best time %.2f %s=%g %s=%g %s=%g %s=%g %s=%g\n",bestTime,choiceA,useA[iA],
     1315                      choiceB,useB[iB],choiceC,useC[iC],choiceD,useD[iD],choiceE,useE[iE]);
     1316               iA=iBestTimePer;
     1317               iE=iA/81;
     1318               iA-=81*iE;
     1319               iD=iA/27;
     1320               iA-=27*iD;
     1321               iC=iA/9;
     1322               iA-=9*iC;
     1323               iB=iA/3;
     1324               iA-=3*iB;
     1325               printf("Best time per iteration %g %s=%g %s=%g %s=%g %s=%g %s=%g\n",bestTimePer,choiceA,useA[iA],
     1326                      choiceB,useB[iB],choiceC,useC[iC],choiceD,useD[iD],choiceE,useE[iE]);
     1327               iA=iBestIterations;
     1328               iE=iA/81;
     1329               iA-=81*iE;
     1330               iD=iA/27;
     1331               iA-=27*iD;
     1332               iC=iA/9;
     1333               iA-=9*iC;
     1334               iB=iA/3;
     1335               iA-=3*iB;
     1336               printf("Best iterations %d %s=%g %s=%g %s=%g %s=%g %s=%g\n",bestIterations,choiceA,useA[iA],
     1337                      choiceB,useB[iB],choiceC,useC[iC],choiceD,useD[iD],choiceE,useE[iE]);
     1338#else
    11531339               solution.initialSolve(solveOptions);
    11541340               double time2 = CoinCpuTime() - time1;
    11551341               timeTaken += time2;
    11561342               printf("%s took %g seconds using algorithm %s\n", fn.c_str(), time2, nameAlgorithm.c_str());
     1343#endif
    11571344               // Test objective solution value
    11581345               {
     1346                    if (!solution.isProvenOptimal()) {
     1347                      std::cerr <<"** NOT OPTIMAL ";
     1348                      numberFailures++;
     1349                    }
    11591350                    double soln = solution.objectiveValue();
    11601351                    CoinRelFltEq eq(objValueTol[m]);
    11611352                    std::cerr << soln << ",  " << objValue[m] << " diff " <<
    11621353                              soln - objValue[m] << std::endl;
    1163                     if(!eq(soln, objValue[m]))
     1354                    if(!eq(soln, objValue[m])) {
    11641355                         printf("** difference fails\n");
     1356                         numberFailures++;
     1357                    }
    11651358               }
    11661359          }
    11671360          printf("Total time %g seconds\n", timeTaken);
     1361#if FACTORIZATION_STATISTICS
     1362          double bestTime=1.0e100;
     1363          int iBestTime=-1;
     1364          for (int i=0;i<3*3*3*3*3;i++) {
     1365            if (times[i]&&times[i]<bestTime) {
     1366              bestTime=times[i];
     1367              iBestTime=i;
     1368            }
     1369          }
     1370          for (int iA=0;iA<hiA;iA++) {
     1371            for (int iB=0;iB<hiB;iB++) {
     1372              for (int iC=0;iC<hiC;iC++) {
     1373                for (int iD=loD;iD<hiD;iD++) {
     1374                  for (int iE=loE;iE<hiE;iE++) {
     1375                    int k=iA+3*iB+9*iC+27*iD+81*iE;
     1376                    double thisTime=times[k];
     1377                    if (thisTime) {
     1378                      if (k==iBestTime)
     1379                        printf("** ");
     1380                      printf("%s=%g %s=%g %s=%g %s=%g %s=%g - time %.2f\n",
     1381                             choiceA,useA[iA],
     1382                             choiceB,useB[iB],choiceC,useC[iC],
     1383                             choiceD,useD[iD],choiceE,useE[iE],thisTime);
     1384                    }
     1385                  }
     1386                }
     1387              }
     1388            }
     1389          }
     1390          //exit(0);
     1391#endif
    11681392     } else {
    11691393          testingMessage( "***Skipped Testing on netlib    ***\n" );
    11701394          testingMessage( "***use -netlib to test class***\n" );
    11711395     }
    1172 
    1173      testingMessage( "All tests completed successfully\n" );
     1396     if (!numberFailures)
     1397       testingMessage( "All tests completed successfully\n" );
     1398     else
     1399       testingMessage( "Some tests failed\n" );
    11741400     return 0;
    11751401}
Note: See TracChangeset for help on using the changeset viewer.