/home/coin/SVN-release/OS-2.1.0/OS/v2.0/unitTest.cpp

Go to the documentation of this file.
00001 
00104 #define DEBUG       
00105 //#define INSTALLATION_TEST   // minimal functionality test
00106 //#define THOROUGH            // multiple problems for some solvers
00107 #define COMPONENT_DEBUG     // program logic, especially parser testing
00108 
00109 
00110 #include <cppad/cppad.hpp> 
00111 //#include "CoinUtilsConfig.h"
00112 #include "OSCoinSolver.h"
00113 #include "OSConfig.h"
00114 #include "OSmps2osil.h" 
00115 #include "OSResult.h" 
00116 #include "OSOption.h"
00117 #include "OSiLReader.h"        
00118 #include "OSiLWriter.h" 
00119 #include "OSoLReader.h"        
00120 #include "OSoLWriter.h" 
00121 #include "OSrLReader.h"          
00122 #include "OSrLWriter.h"      
00123 #include "OSInstance.h"  
00124 #include "OSFileUtil.h"  
00125 #include "CoinError.hpp"
00126 
00127 #include "OSDefaultSolver.h"  
00128 #include "OSWSUtil.h" 
00129 #include "OSSolverAgent.h"   
00130 #include "OShL.h"     
00131 #include "OSErrorClass.h"
00132 #include "OSBase64.h"
00133 #include "OSCommonUtil.h"
00134 #include "OSMathUtil.h"
00135 
00136 
00137 #include <CoinMpsIO.hpp>
00138 #include <CoinPackedMatrix.hpp>
00139     
00140 
00141 
00142 
00143 #ifdef COIN_HAS_GLPK
00144 #include <OsiGlpkSolverInterface.hpp>
00145 #endif
00146 
00147 #ifdef COIN_HAS_COUENNE    
00148 #include "OSCouenneSolver.h"
00149 #endif
00150 
00151 #ifdef COIN_HAS_ASL
00152 #include "OSnl2osil.h"
00153 #endif
00154 
00155 #ifdef COIN_HAS_LINDO    
00156 #include "OSLindoSolver.h"
00157 #endif  
00158 
00159 #ifdef COIN_HAS_IPOPT    
00160 #include "OSIpoptSolver.h"
00161 #endif 
00162 
00163 #ifdef COIN_HAS_BONMIN    
00164 #include "OSBonminSolver.h"
00165 #endif 
00166 
00167 
00168 
00169 
00170 #ifdef HAVE_CTIME
00171 # include <ctime>
00172 #else
00173 # ifdef HAVE_TIME_H
00174 #  include <time.h>
00175 # else
00176 #  error "don't have header file for time"
00177 # endif
00178 #endif
00179 
00180 
00181 #ifdef HAVE_CMATH
00182 # include <cmath>
00183 #else
00184 # ifdef HAVE_CMATH_H
00185 #  include <cmath.h>
00186 # endif
00187 #endif
00188 
00189 
00190 
00191 #ifdef HAVE_CSTDIO
00192 # include <cstdio>
00193 #else
00194 # ifdef HAVE_STDIO_H
00195 #  include <stdio.h>
00196 # else
00197 #  error "don't have header file for stdio"
00198 # endif
00199 #endif
00200 
00201 //#ifdef HAVE_WINDOWS_H
00202 //#include <windows.h>
00203 //#endif
00204 
00205 using std::cout;   
00206 using std::endl;
00207 using std::ostringstream; 
00208 
00209 
00210 
00211 
00212 int main(int argC, char* argV[])
00213 {
00214 //#ifdef HAVE_WINDOWS_H
00215 //   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
00216 //#endif 
00217         WindowsErrorPopupBlocker();
00218         double getObjVal(std::string osrl);
00219         //using CppAD::NearEqual;
00220         bool ok;
00221         double check;
00222         
00223         //return 0;
00224         cout << "START UNIT TEST" << endl;
00225         int nOfTest = 0;
00226         // define the classes
00227         FileUtil *fileUtil = NULL;  
00228         #ifdef COIN_HAS_ASL
00229         OSnl2osil *nl2osil = NULL;
00230         #endif 
00231         OSmps2osil *mps2osil = NULL;
00232         DefaultSolver *solver  = NULL;
00233         OSiLReader *osilreader = NULL;
00234         OSoLReader *osolreader = NULL;
00235         OSrLReader *osrlreader = NULL;
00236         OSrLWriter *osrlwriter = NULL;
00237         OSrLWriter *tmp_writer = NULL;
00238         // end classes    
00239         std::string osilFileName;
00240         std::string osolFileName;
00241         std::string osrlFileName;
00242         std::string nlFileName; 
00243         std::string mpsFileName;     
00244         std::string osil;
00245         std::string osol; 
00246         ostringstream unitTestResult;
00247         ostringstream unitTestResultFailure;
00248         // get the input files
00249          const char dirsep =  CoinFindDirSeparator();
00250         // Set directory containing mps data files.
00251         std::string dataDir;
00252     dataDir = dirsep == '/' ? "../data/" : "..\\data\\";
00253         nlFileName =  dataDir  + "amplFiles" + dirsep + "parinc.nl";
00254         mpsFileName =  dataDir + "mpsFiles" + dirsep + "parinc.mps";
00255         fileUtil = new FileUtil();
00256         // 
00257 
00258 #ifdef INSTALLATION_TEST
00259 
00260         //first make sure we can read files
00261         try{
00262                 std::cout << endl << "TEST " << ++nOfTest << ": Try to read a sample file" << endl << endl;
00263                 osilFileName =  dataDir  + "osilFiles" + dirsep +  "parincLinearByRow.osil";
00264                 //osilFileName =  dataDir  + "osilFiles" + dirsep +  "parincLinear.osil";
00265                 std::cout << "The file is: " ;
00266                 std::cout <<  osilFileName << std::endl;
00267                 osil = fileUtil->getFileAsString( osilFileName.c_str() );
00268                 std::cout << "Done reading the test file" << std::endl;
00269                 osilreader = new OSiLReader(); 
00270                 //OSInstance *osinstance = osilreader->readOSiL( osil);
00271                 //osinstance->initForAlgDiff();
00272                 unitTestResult << "Reading files successfully" << std::endl;
00273                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00274                 OSiLWriter osilwriter;
00275                 osilwriter.m_bWhiteSpace = true;
00276                 //std::cout << osilwriter.writeOSiL( osinstance) << std::endl;
00277                 delete osilreader;
00278                 osilreader = NULL;
00279                 //cout << "The unitTest passed the following" << endl << endl;
00280                 //cout << unitTestResult.str() << endl << endl;
00281                 /*
00282                 // below is just a bunch of misc. stuff kipp is testing
00283                 //
00284                 // Create a problem pointer.  We use the base class here.
00285                 OsiSolverInterface *si, *si2;
00286                 // When we instantiate the object, we need a specific derived class.
00287                 si = new OsiCbcSolverInterface;
00288                 // Read in an mps file.  This one's from the MIPLIB library.
00289                 si->readMps( mpsFileName.c_str());
00290                 // get the problem
00291                 // variable upper and lower bounds
00292                  const double *collb = si->getColLower();
00293                  const double *colub = si->getColUpper();               
00294                 // constraint upper and lower bound     
00295                 const  double *rowlb = si->getRowLower();
00296                 const  double *rowub = si->getRowUpper();               
00297                 //the Coin packed matrix
00298                 const CoinPackedMatrix *m_CoinPackedMatrix =  si->getMatrixByCol();             
00299                 //finally the objective function coefficieCnts          
00300                 const double *objcoef = si->getObjCoefficients();
00301                 //delete si;
00302                 si2 = new OsiCbcSolverInterface;
00303                 std::cout << objcoef[ 0] << std::endl;
00304                 // now load the problem
00305                 si2->loadProblem(*m_CoinPackedMatrix, collb, colub,  objcoef, rowlb, rowub);            
00306                 // Solve the (relaxation of the) problem
00307                 //si2->branchAndBound();        
00308                 delete si;
00309                 delete si2;
00310                 */
00311                 
00312                 
00313                 cout << endl << "TEST " << ++nOfTest << ": Lossless I/O" << endl << endl;
00314                 //mpsFileName =  dataDir + "mpsFiles" + dirsep + "testfile2.mps";
00315                 mpsFileName =  dataDir + "mpsFiles" + dirsep + "parinc.mps";
00316                 mps2osil = new OSmps2osil( mpsFileName);
00317                 // create the first in-memory OSInstance
00318                 mps2osil->createOSInstance() ;
00319                 // write the instance to a string
00320                 OSInstance *osinstance1 = mps2osil->osinstance;
00321                 std::string sOSiL = osilwriter.writeOSiL( osinstance1  );
00322                 //cout << sOSiL << endl;
00324                 // now create a second object
00325                 osilreader = new OSiLReader();
00326                 OSInstance *osinstance2 = osilreader->readOSiL( sOSiL);
00327                 // now compare the elements in the A matrix for the two intances
00328                 int nvals = osinstance1->instanceData->linearConstraintCoefficients->numberOfValues;
00329                 double theDiff, theMax;
00330                 int theIndex = -1;
00331                 theMax = 0;
00332                 for(int i = 0; i < nvals; i++){
00333                         theDiff = fabs(osinstance1->instanceData->linearConstraintCoefficients->value->el[ i] -
00334                                 osinstance2->instanceData->linearConstraintCoefficients->value->el[ i])/ fabs(osinstance1->instanceData->linearConstraintCoefficients->value->el[ i]);
00335                         if(theDiff > theMax){
00336                                 theMax = theDiff;
00337                                 theIndex = i;
00338                         }
00339                         //std::cout << theDiff << std::endl;
00340                 }
00341                 std::cout << "MAXIMUM DIFF = " << theMax << std::endl;
00342                 std::cout << "MAXIMUM DIFF INDEX  = " << theIndex << std::endl;
00343                 if(theMax > 0) unitTestResult << "WARNING:  you do not have lossless IO" << std::endl;
00344                 else 
00345                 {       unitTestResult << "Passed lossless IO test" << std::endl;
00346                         cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00347                 }
00348                 delete mps2osil;
00349                 delete osilreader;
00350                 osilreader = NULL;
00351 
00352 
00353                 //nl2osil = new OSnl2osil( nlFileName);
00354             //return 0; 
00355                 /*
00356                 //using os_dtoa_format
00357                 MathUtil *mathUtil = new MathUtil();
00358             int decimalPoint; // where the decimal point goes
00359             int sign; // 1 if negative, 0 if positive
00360             double d ;
00361             d = -2./3.;
00362             //d = 123.4567;
00363             d = 1.23456589e-2;
00364             d = .00001123;
00365             char *result = os_dtoa(d, 0, 0, &decimalPoint, &sign, NULL);
00366             for(int kj = 5; kj < 9; kj++){
00367                 d = pow(10. ,kj) + pow(10., (kj-1));
00368                 //d = 57.7;
00369                 result =os_dtoa(d, 0, 0, &decimalPoint, &sign, NULL);
00370                 printf("HERE IS THE RESULT  %s\n\n", result);
00371                 printf("HERE IS THE RESULT of sign  %d\n\n", sign);
00372                 printf("HERE IS THE RESULT decimal point  %i\n\n", decimalPoint);
00373                 printf("HERE IS THE LENGTH OF THE RESULT  %d\n\n",  strlen(result));
00374                 std::cout << "HERE IS THE RESULT OF OS os_dtoa_format: " << os_dtoa_format( d) << std::endl;
00375             }
00376             d = .00001123;
00377             d = -2./3.;
00378             d = 100;
00379             result = os_dtoa(DBL_MAX, 0, 0, &decimalPoint, &sign, NULL);
00380         printf("HERE IS THE RESULT  %s\n\n", result);
00381         printf("HERE IS THE RESULT of sign  %d\n\n", sign);
00382         printf("HERE IS THE RESULT decimal point  %i\n\n", decimalPoint);
00383         printf("HERE IS THE LENGTH OF THE RESULT  %d\n\n",  strlen(result));
00384         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format: " << os_dtoa_format( OSDBL_MAX) << std::endl;    
00385         d = .000234;
00386             result = os_dtoa(d, 0, 0, &decimalPoint, &sign, NULL);
00387         printf("HERE IS THE RESULT  %s\n\n", result);
00388         printf("HERE IS THE RESULT of sign  %d\n\n", sign);
00389         printf("HERE IS THE RESULT decimal point  %i\n\n", decimalPoint);
00390         printf("HERE IS THE LENGTH OF THE RESULT  %d\n\n",  strlen(result));
00391         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format: " << os_dtoa_format( d) << std::endl;
00392         //
00393         char sInput[] = "77.77 99.99";
00394         char *pEnd;
00395         double d1, d2;
00396         d1 = os_strtod (sInput,  &pEnd);
00397         d2 = os_strtod (pEnd,NULL);
00398         std::cout << d1 << std::endl;
00399         std::cout << d2 << std::endl;
00400         
00401         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format OSDBL_MAX: " << os_dtoa_format( OSDBL_MAX) << std::endl;
00402         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format OSDBL_MAX: " << OSDBL_MAX << std::endl;
00403         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format DBL_MAX: " << os_dtoa_format( DBL_MAX) << std::endl;
00404         std::cout << "HERE IS THE RESULT OF OS os_dtoa_format DBL_MAX: " <<  DBL_MAX << std::endl;
00405         d1 = os_strtod(os_dtoa_format( OSDBL_MAX).c_str(),     NULL);
00406         if(d1 == DBL_MAX )std::cout <<  "SUCCESS" << endl;
00407         else std::cout <<  "FAILURE" << endl;
00408         */
00409         }
00410         catch(const ErrorClass& eclass){
00411                 unitTestResultFailure << "Sorry Unit Test Failed Reading a file: "  + eclass.errormsg<< endl; 
00412                 //no point continuing we can't even read a file
00413                 unitTestResultFailure << "Since we can't read files we are terminating"  << endl; 
00414                 cout << unitTestResultFailure.str() << endl << endl;
00415                 cout << "Conclusion: FAILURE" << endl;
00416                 return 1;
00417         }       
00418 
00419         try{
00420                 cout << endl << "TEST " << ++nOfTest << ": Clp solver on parincLinearByRow.osil" << endl << endl;
00421                 ok = true; 
00422                 std::cout << "create a new COIN Clp for OSiL string solution" << std::endl;
00423                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincLinearByRow.osil";
00424                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincLinearByRow_clp.osol";
00425                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00426                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00427 
00428                 std::cout << "create a new Solver object" << std::endl;
00429                 osilreader = new OSiLReader(); 
00430                 osolreader = new OSoLReader(); 
00431                 solver = new CoinSolver();
00432                 solver->sSolverName = "clp";
00433                 solver->osinstance = osilreader->readOSiL( osil);
00434                 std::cout << " Done reading the OSiL" << std::endl;
00435                 // now write it again as a string
00436                 OSiLWriter *osilwriter;
00437                 osilwriter = new OSiLWriter();
00438                 osilwriter->m_bWhiteSpace = true;
00439                 std::cout << " Write the OSiL" << std::endl;
00440                 osil = osilwriter->writeOSiL( solver->osinstance) ;
00441                 //std::cout <<  osil  << std::endl;
00442                 std::cout << " Done writing the OSiL" << std::endl;
00443                 solver->osoption   = osolreader->readOSoL( osol);
00444                 cout << "call the COIN - clp Solver for parincLinearbyRow" << endl;
00445                 //solver->buildSolverInstance();
00446                 solver->solve();
00447                 cout << "Here is the COIN clp solver solution for parincLinearByRow" << endl;
00448                 cout << solver->osrl << endl;
00449                 check = 7668;
00450                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00451                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
00452                 if(ok == false) throw ErrorClass(" Fail unit test with clp on parincLinearByRow.osil");
00453                 // parse the osrl file
00454                 osrlreader =  new OSrLReader();
00455                 cout << "First osrl file\n" << solver->osrl << endl;
00456                 osrlreader->readOSrL( solver->osrl);
00457                 cout << "read successfully" << endl;
00458                 delete osilreader;
00459                 cout << "osilreader successfully deleted" << endl;
00460                 osilreader = NULL;      
00461                 delete osolreader;
00462                 cout << "osolreader successfully deleted" << endl;
00463                 osolreader = NULL;      
00464                 delete solver;
00465                 cout << "solver successfully deleted" << endl;
00466                 solver = NULL;
00467                 delete osilwriter;
00468                 cout << "osilwriter successfully deleted" << endl;
00469                 osilwriter = NULL;
00470                 delete osrlreader;
00471                 cout << "osrlreader successfully deleted" << endl;
00472                 osrlreader = NULL;
00473                 unitTestResult << "Solved problem parincLinearByRow.osil with Clp" << std::endl;
00474                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00475         }
00476         catch(const ErrorClass& eclass){
00477                 unitTestResultFailure << "Sorry Unit Test Failed Testing Clp Solver:"  + eclass.errormsg<< endl;
00478         }
00479 
00480         // now solve another problem -- try an integer program
00481         try{
00482                 cout << endl << "TEST " << ++nOfTest << ": Cbc solver on p0033.osil" << endl << endl;
00483                 std::cout << "create a new COIN Cbc for OSiL string solution" << std::endl;
00484                 ok = true;
00485                 osilFileName = dataDir  + "osilFiles" + dirsep + "p0033.osil";
00486                 osolFileName = dataDir  + "osolFiles" + dirsep + "p0033_cbc.osol";
00487                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00488                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00489                 osilreader = new OSiLReader(); 
00490                 osolreader = new OSoLReader(); 
00491                 solver = new CoinSolver();
00492                 solver->sSolverName ="cbc";
00493                 solver->osil = osil;
00494                 solver->osol = osol;  
00495                 solver->osinstance = NULL; 
00496                 solver->osoption   = NULL;
00497                 cout << "call the COIN - Cbc Solver for p0033" << endl;
00498                 solver->buildSolverInstance();
00499                 solver->solve();
00500                 cout << "Here is the COIN Cbc solver solution for p0033" << endl;
00501                 //cout << solver->osrl << endl;
00502                 check = 3089;
00503                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
00504                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00505                 if(ok == false) throw ErrorClass(" Fail unit test with Cbc on p0033.osil");
00506                 delete solver;
00507                 solver = NULL;
00508                 delete osilreader;
00509                 osilreader = NULL;
00510                 delete osolreader;
00511                 osolreader = NULL;
00512                 unitTestResult << "Solved problem p0033.osil with Cbc" << std::endl;
00513                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00514         }
00515         catch(const ErrorClass& eclass){
00516                 unitTestResultFailure << "Sorry Unit Test Failed Testing Cbc Solver:"  + eclass.errormsg<< endl;
00517         }
00518 
00519 #ifdef THOROUGH
00520         // now test p0201.osil
00521         try{
00522                 cout << endl << "TEST " << ++nOfTest << ": Cbc solver on p0201.osil" << endl << endl;
00523                 ok = true;
00524                 osilFileName = dataDir  + "osilFiles" + dirsep + "p0201.osil";
00525                 osolFileName = dataDir  + "osolFiles" + dirsep + "p0201_cbc.osol";
00526                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00527                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00528                 solver = new CoinSolver();
00529                 solver->sSolverName ="cbc";
00530                 solver->osil = osil;
00531                 osilreader = new OSiLReader(); 
00532                 osolreader = new OSoLReader(); 
00533                 solver->osol = "";  
00534                 solver->osinstance = NULL; 
00535                 solver->osoption   = NULL;
00536                 cout << "call the COIN - Cbc Solver for p0201" << endl;
00537                 solver->solve();
00538                 cout << "Here is the COIN Cbc solver solution for p0201" << endl;
00539                 check = 7615;
00540                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
00541                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00542                 if(ok == false) throw ErrorClass(" Fail unit test with Cbc on p0201.osil");
00543                 delete solver;
00544                 solver = NULL;
00545                 delete osilreader;
00546                 osilreader = NULL;
00547                 delete osolreader;
00548                 osolreader = NULL;
00549                 unitTestResult << "Solved problem p0201.osil with Cbc" << std::endl;
00550                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00551         }
00552         catch(const ErrorClass& eclass){
00553                 unitTestResultFailure << "Sorry Unit Test Failed Testing Cbc Solver:"  + eclass.errormsg<< endl;
00554         }
00555 
00556                 cout << endl << "TEST " << ++nOfTest << ": Cbc solver on parincInteger.osil" << endl << endl;
00557                 ok = true;
00558                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincInteger.osil";
00559                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincInteger_cbc.osol";
00560                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00561                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00562                 osilreader = new OSiLReader(); 
00563                 osolreader = new OSoLReader(); 
00564 
00565                 solver = new CoinSolver();
00566                 solver->sSolverName ="cbc";
00567                 solver->osinstance = osilreader->readOSiL( osil);
00568                 solver->osol = osol; 
00569                 cout << "call the COIN - Cbc Solver for parincInteger" << endl;
00570 //              solver->buildSolverInstance();
00571                 solver->solve();
00572                 cout << "Here is the Cbc solver solution for parincInteger" << endl;
00573                 check = 7668;
00574                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
00575                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00576                 if(ok == false) throw ErrorClass(" Fail unit test with Cbc on parincInteger.osil");
00577                 unitTestResult << "Solved problem parincInteger.osil with Cbc" << std::endl;
00578                 delete osilreader;
00579                 osilreader = NULL;      
00580                 delete osolreader;
00581                 osolreader = NULL;      
00582                 delete solver;
00583                 solver = NULL;
00584                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00585 
00586 
00587 #endif  
00588 
00589 #ifdef COIN_HAS_IPOPT
00590         IpoptSolver *ipoptSolver  =  NULL;      
00591         try{
00592                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver with avion2.osil" << endl << endl;
00593             ipoptSolver  = new IpoptSolver();
00594                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00595                 ok = true;
00596 //              OSiLReader *osilreader = NULL;
00597 //              OSoLReader *osolreader = NULL;
00598                 // avion does not work with Mumps on AIX xlC compiler
00599 #ifndef XLC_
00600                 osilFileName =  dataDir  + "osilFiles" + dirsep +  "avion2.osil";
00601                 osolFileName = dataDir  + "osolFiles" + dirsep + "avion2_ipopt.osol";
00602                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00603                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00604                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00605                 ipoptSolver->osol = osol;
00606                 osilreader = new OSiLReader(); 
00607                 osolreader = new OSoLReader(); 
00608                 ipoptSolver->osinstance = osilreader->readOSiL( osil);
00609                 ipoptSolver->osol = osol;
00610                 cout << "call the IPOPT Solver" << endl;        
00611                 ipoptSolver->buildSolverInstance();
00612                 ipoptSolver->solve();
00613                 cout << "Here is the IPOPT solver solution for avion2" << endl;
00614                 check = 9.46801e+07;
00615                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00616                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00617                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on avion2.osil");
00618                 delete osilreader;
00619                 osilreader = NULL;
00620                 delete osolreader;
00621                 osolreader = NULL;
00622                 delete ipoptSolver;
00623                 ipoptSolver = NULL;
00624                 unitTestResult << "Solved problem avion2.osil with Ipopt" << std::endl;
00625                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00626 #endif
00627 
00628 #ifdef THOROUGH
00629                 // solve another problem
00630                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver with HS071_NLPMod.osil" << endl << endl;
00631                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00632                 ipoptSolver  = new IpoptSolver();
00633                 // a problem with all nonlinear terms no linear terms
00634                 osilFileName = dataDir  + "osilFiles" + dirsep + "HS071_NLPMod.osil";
00635                 osolFileName = dataDir  + "osolFiles" + dirsep + "HS071_NLPMod_ipopt.osol";
00636                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00637                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00638                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00639 //              osol = "<osol></osol>";
00640                 osilreader = new OSiLReader(); 
00641                 osolreader = new OSoLReader(); 
00642                 ipoptSolver->osinstance = osilreader->readOSiL( osil);
00643                 ipoptSolver->osoption   = osolreader->readOSoL( osol);
00644                 ipoptSolver->osol = osol;
00645                 ipoptSolver->buildSolverInstance();
00646                 ipoptSolver->solve();
00647                 cout << "Here is the IPOPT solver solution for HS071_NLP" << endl;
00648                 check = 17.014;
00649                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00650                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00651                 delete osilreader;
00652                 osilreader = NULL;
00653                 delete osolreader;
00654                 osolreader = NULL;
00655                 delete ipoptSolver;
00656                 ipoptSolver = NULL;
00657                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on HS071_NLP.osil");
00658                 unitTestResult << "Solved problem HS071.osil with Ipopt" << std::endl;
00659                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00660 
00661                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on rosenbrockmod.osil" << endl << endl;
00662                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00663                 ipoptSolver  = new IpoptSolver();
00664                 // solve another problem
00665                 // a problem with both quadratic terms and general nonlinear terms
00666                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockmod.osil";
00667                 osolFileName = dataDir  + "osolFiles" + dirsep + "rosenbrockmod_ipopt.osol";
00668                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00669                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00670                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00671                 osilreader = new OSiLReader(); 
00672                 osolreader = new OSoLReader(); 
00673                 ipoptSolver->osil     = osil;
00674                 ipoptSolver->osoption = osolreader->readOSoL( osol);
00675                 cout << "call the IPOPT Solver" << endl;
00676                 ipoptSolver->buildSolverInstance();
00677                 ipoptSolver->solve();
00678                 check = 6.7279;
00679                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00680                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00681                 if(ok == false) 
00682                         throw ErrorClass(" Fail unit test with Ipopt on rosenbrockmod.osil");
00683                 delete osilreader;
00684                 osilreader = NULL;
00685                 delete osolreader;
00686                 osolreader = NULL;
00687                 unitTestResult << "Solved problem rosenbrockmod.osil with Ipopt" << std::endl;
00688                 delete ipoptSolver;
00689                 ipoptSolver = NULL;
00690                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00691 
00692                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on parincQuadratic.osil" << endl << endl;
00693                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00694                 ipoptSolver  = new IpoptSolver();
00695                 // solve another problem
00696                 // a problem that is a pure quadratic
00697                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincQuadratic.osil";
00698                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincQuadratic_ipopt.osol";
00699                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00700                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00701                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00702                 osilreader = new OSiLReader(); 
00703                 osolreader = new OSoLReader(); 
00704                 ipoptSolver->osinstance = osilreader->readOSiL( osil);
00705                 ipoptSolver->osil = osil;
00706                 ipoptSolver->osol = osol;
00707                 cout << "call the IPOPT Solver" << endl;
00708                 ipoptSolver->buildSolverInstance();
00709                 ipoptSolver->solve();
00710                 cout << "Here is the IPOPT solver solution for parincQuadratic" << endl;
00711                 check = 49920.5;
00712                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00713                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00714                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on parincQuadradic.osil");
00715                 delete osilreader;
00716                 osilreader = NULL;      
00717                 delete osolreader;
00718                 osolreader = NULL;      
00719                 unitTestResult << "Solved problem parincQuadratic.osil with Ipopt" << std::endl;
00720                 delete ipoptSolver;
00721                 ipoptSolver = NULL;
00722                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00723 
00724                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on parincLinear.osil" << endl << endl;
00725                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00726                 ipoptSolver  = new IpoptSolver();
00727                 // solve another problem
00728                 // try a pure linear program
00729                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincLinear.osil";
00730                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincLinear_ipopt.osol";
00731                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00732                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00733                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00734                 osilreader = new OSiLReader(); 
00735                 osolreader = new OSoLReader(); 
00736                 ipoptSolver->osinstance = osilreader->readOSiL( osil);
00737                 ipoptSolver->osoption   = NULL;
00738                 ipoptSolver->osol = ""; 
00739                 cout << "call the IPOPT Solver" << endl;
00740                 ipoptSolver->buildSolverInstance();
00741                 ipoptSolver->solve();
00742                 cout << "Here is the IPOPT solver solution for parincLinear" << endl;
00743                 check = 7668;
00744                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-1 , 1e-1);
00745                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00746                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on parincLinear.osil");
00747                 unitTestResult << "Solved problem parincLinear.osil with Ipopt" << std::endl;
00748                 delete osilreader;
00749                 osilreader = NULL;      
00750                 delete osolreader;
00751                 osolreader = NULL;      
00752                 delete ipoptSolver;
00753                 ipoptSolver = NULL;
00754                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00755 
00756                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on callBackTest.osil" << endl << endl;
00757                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00758                 ipoptSolver  = new IpoptSolver();
00759                 // solve another problem
00760                 // callBackTest.osil
00761                 osilFileName = dataDir  + "osilFiles" + dirsep + "callBackTest.osil";
00762                 osolFileName = dataDir  + "osolFiles" + dirsep + "callBackTest_ipopt.osol";
00763                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00764                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00765                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00766                 osilreader = new OSiLReader(); 
00767                 osolreader = new OSoLReader(); 
00768                 ipoptSolver->osinstance = osilreader->readOSiL( osil);
00769                 ipoptSolver->osoption   = osolreader->readOSoL( osol);
00770                 ipoptSolver->osol = osol;
00771                 cout << "call the IPOPT Solver" << endl;
00772                 ipoptSolver->buildSolverInstance();
00773                 ipoptSolver->solve();
00774                 cout << "Here is the IPOPT solver solution for callBackTest" << endl;
00775                 check = 1.00045e+06;
00776                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00777                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00778                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on callBackTest.osil");
00779                 unitTestResult << "Solved problem callBackTest.osil with Ipopt" << std::endl;   
00780                 delete osilreader;
00781                 osilreader = NULL;      
00782                 delete osolreader;
00783                 osolreader = NULL;      
00784                 delete ipoptSolver;
00785                 ipoptSolver = NULL;
00786                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00787 
00788                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on callBackTestRowMajor.osil" << endl << endl;
00789                 cout << "create a new IPOPT Solver for OSiL string solution" << endl;
00790                 ipoptSolver  = new IpoptSolver();
00791                 // solve another problem
00792                 // callBackTest.osil
00793                 osilFileName =  dataDir  + "osilFiles" + dirsep + "callBackTestRowMajor.osil";
00794                 osolFileName = dataDir  + "osolFiles" + dirsep + "callBackTestRowMajor_ipopt.osol";
00795                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00796                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00797                 cout << "IPOPT Solver created for OSiL string solution" << endl;
00798                 osilreader = new OSiLReader(); 
00799                 osolreader = new OSoLReader(); 
00800                 ipoptSolver->osinstance = NULL;
00801                 ipoptSolver->osoption   = NULL;
00802                 ipoptSolver->osil = osil;
00803                 ipoptSolver->osol = osol;
00804                 cout << "call the IPOPT Solver" << endl;
00805 //              ipoptSolver->buildSolverInstance();
00806                 ipoptSolver->solve();
00807                 cout << "Here is the IPOPT solver solution for callBackTestRowMajor" << endl;
00808                 check = 1.00045e+06;
00809                 //ok &= NearEqual(getObjVal( ipoptSolver->osrl) , check,  1e-10 , 1e-10);
00810                 ok = ( fabs(check - getObjVal( ipoptSolver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00811                 if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on callBackTestRowMajor.osil");
00812                 delete osilreader;
00813                 osilreader = NULL;      
00814                 delete osolreader;
00815                 osolreader = NULL;      
00816                 delete ipoptSolver;
00817                 ipoptSolver = NULL;     
00818                 unitTestResult << "Solved problem callBackRowMajor.osil with Ipopt" << std::endl;
00819                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00820 
00821                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on nonconvex.osil" << endl << endl;
00822 //              OSiLReader *osilreader = NULL;
00823                 osilreader = new OSiLReader(); 
00824                 osolreader = new OSoLReader(); 
00825                 ok = true; 
00826                 osilFileName = dataDir  + "osilFiles" + dirsep + "nonconvex.osil";
00827 //              osolFileName = dataDir  + "osolFiles" + dirsep + "bonminEx1_Couenne.osol";
00828                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00829 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
00830                 osol = "";
00831                 solver = new IpoptSolver();
00832                 solver->sSolverName = "ipopt";
00833                 solver->osil = osil;
00834                 solver->osol = osol; 
00835 //              solver->osinstance = osilreader->readOSiL( osil);
00836 //              solver->osoption   = osolreader->readOSoL( osol);
00837                 cout << "call the COIN - Ipopt Solver for nonconvex.osil" << endl;
00838                 solver->buildSolverInstance();
00839         
00840                 std::cout << " CALL SOLVE " << std::endl;
00841                 solver->solve();
00842         
00843                 cout << "Here is the Ipopt solver solution for nonconvex.osil" << endl;
00844 
00845 //              OSrLWriter *tmp_writer;
00846                 tmp_writer = new OSrLWriter();
00847                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
00848                 delete tmp_writer;
00849                 tmp_writer = NULL;
00850 
00851                 cout << solver->osrl << endl << endl;
00852 
00853 //              check = -1.70711;
00854 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
00855 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00856 //              if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on nonconvex.osil");
00857 
00858                 delete solver;
00859                 solver = NULL;
00860                 unitTestResult << "Solved problem nonconvex.osil with Ipopt" << std::endl;
00861         
00862         
00863                 delete osilreader;
00864                 osilreader = NULL;
00865                 delete osolreader;
00866                 osolreader = NULL;
00867                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00868 
00869                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on rosenbrockorig.osil" << endl << endl;
00870 //              OSiLReader *osilreader = NULL;
00871                 osilreader = new OSiLReader(); 
00872                 osolreader = new OSoLReader(); 
00873                 ok = true; 
00874                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockorig.osil";
00875 //              osolFileName = dataDir  + "osolFiles" + dirsep + "rosenbrockorig_Ipopt.osol";
00876                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00877 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
00878                 osol = "";
00879                 solver = new IpoptSolver();
00880                 solver->sSolverName = "ipopt";
00881                 solver->osil = osil;
00882                 solver->osol = osol; 
00883 //              solver->osinstance = osilreader->readOSiL( osil);
00884 //              solver->osoption   = osolreader->readOSoL( osol);
00885                 cout << "call the COIN - Ipopt Solver for rosenbrockorig" << endl;
00886                 solver->buildSolverInstance();
00887         
00888                 std::cout << " CALL SOLVE " << std::endl;
00889                 solver->solve();
00890         
00891                 cout << "Here is the Ipopt solver solution for rosenbrockorig" << endl;
00892 
00893 //              OSrLWriter *tmp_writer;
00894                 tmp_writer = new OSrLWriter();
00895                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
00896                 delete tmp_writer;
00897                 tmp_writer = NULL;
00898 
00899                 cout << solver->osrl << endl << endl;
00900 
00901 //              check = -1.70711;
00902 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
00903 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00904 //              if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on rosenbrockorig.osil");
00905 
00906                 delete solver;
00907                 solver = NULL;
00908                 unitTestResult << "Solved problem rosenbrockorig.osil with Ipopt" << std::endl;
00909         
00910         
00911                 delete osilreader;
00912                 osilreader = NULL;
00913                 delete osolreader;
00914                 osolreader = NULL;
00915                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00916 
00917                 cout << endl << "TEST " << ++nOfTest << ": Ipopt solver on HS071_feas.osil" << endl << endl;
00918                 try {
00919                         osilreader = new OSiLReader(); 
00920                         osolreader = new OSoLReader(); 
00921                         ok = true; 
00922                         osilFileName = dataDir  + "osilFiles" + dirsep + "HS071_feas.osil";
00923 //                      osolFileName = dataDir  + "osolFiles" + dirsep + "HS071_feas_Ipopt.osol";
00924                         osil = fileUtil->getFileAsString( osilFileName.c_str());
00925 //                      osol = fileUtil->getFileAsString( osolFileName.c_str());
00926                         osol = "";
00927                         solver = new IpoptSolver();
00928                         solver->sSolverName = "ipopt";
00929                         solver->osil = osil;
00930                         solver->osol = osol; 
00931 //                      solver->osinstance = osilreader->readOSiL( osil);
00932 //                      solver->osoption   = osolreader->readOSoL( osol);
00933                         cout << "call the COIN - Ipopt Solver for HS071_feas.osil" << endl;
00934                         solver->buildSolverInstance();
00935         
00936                         std::cout << " CALL SOLVE " << std::endl;
00937                         solver->solve();
00938                 }
00939                 catch(const ErrorClass& eclass)
00940                 {
00941                         ok = (solver->osresult->getGeneralMessage() == "Ipopt NEEDS AN OBJECTIVE FUNCTION");
00942                         if(ok == false) throw ErrorClass(" Fail unit test with Ipopt on HS071_feas.osil");
00943                 }
00944         
00945                 cout << "Received error message from Ipopt: \"Ipopt NEEDS AN OBJECTIVE FUNCTION\"" << endl;
00946                 unitTestResult << "Correctly diagnosed problem HS071_feas with Ipopt" << std::endl;
00947         
00948                 delete solver;
00949                 solver = NULL;
00950                 delete osilreader;
00951                 osilreader = NULL;
00952                 delete osolreader;
00953                 osolreader = NULL;
00954 
00955                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00956 
00957 #endif // end of #ifdef THOROUGH
00958         }
00959         catch(const ErrorClass& eclass){
00960                 unitTestResultFailure << "Sorry Unit Test Failed Testing the Ipopt Solver:"  + eclass.errormsg<< endl; 
00961         }
00962 #endif // end of #ifdef COIN_HAS_IPOPT
00963 
00964 
00965 #ifdef COIN_HAS_BONMIN
00966         try{
00967                 cout << endl << "TEST " << ++nOfTest << ": Bonmin solver on bonminEx1.osil" << endl << endl;
00968 //              OSiLReader *osilreader = NULL;
00969                 osilreader = new OSiLReader(); 
00970                 osolreader = new OSoLReader(); 
00971                 ok = true; 
00972                 osilFileName = dataDir  + "osilFiles" + dirsep + "bonminEx1.osil";
00973                 osolFileName = dataDir  + "osolFiles" + dirsep + "bonminEx1_Bonmin.osol";
00974                 osil = fileUtil->getFileAsString( osilFileName.c_str());
00975                 osol = fileUtil->getFileAsString( osolFileName.c_str());
00976                 solver = new BonminSolver();
00977                 //solver->sSolverName = "bonmin";
00978 //              solver->osinstance = osilreader->readOSiL( osil);
00979                 solver->osil = osil;
00980                 solver->osoption = osolreader->readOSoL( osol);
00981                 cout << "call the COIN - Bonmin Solver for bonminEx1" << endl;
00982 //              solver->buildSolverInstance();
00983                 solver->solve();
00984                 cout << "Here is the Bonmin solver solution for bonminEx1" << endl;
00985                 cout << solver->osrl << endl;
00986                 check = -1.70711;
00987                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
00988                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
00989                 if(ok == false) throw ErrorClass(" Fail unit test with Bonmin on bonminEx1.osil");
00990                 delete solver;
00991                 solver = NULL;
00992                 unitTestResult << "Solved problem bonminEx1.osil with Bonmin" << std::endl;
00993                 delete osilreader;
00994                 osilreader = NULL;
00995                 delete osolreader;
00996                 osolreader = NULL;
00997                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
00998 
00999 #ifdef THOROUGH
01000                 cout << endl << "TEST " << ++nOfTest << ": Bonmin solver on wayneQuadratic.osil" << endl << endl;
01001                 ok = true;
01002                 osilFileName = dataDir  + "osilFiles" + dirsep + "wayneQuadratic.osil";
01003                 osolFileName = dataDir  + "osolFiles" + dirsep + "wayneQuadratic_Bonmin1.osol";
01004                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01005                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01006                 osilreader = new OSiLReader(); 
01007                 solver = new BonminSolver();    
01008                 solver->osol = osol;
01009                 solver->osinstance = osilreader->readOSiL( osil);
01010                 cout << "call the Bonmin Solver for wayneQuadratic" << endl;
01011                 solver->buildSolverInstance();
01012                 // Do this one with two different osol files!!!
01013                 solver->solve();
01014                 cout << "Here is the Bonmin solver solution" << endl;
01015                 cout << solver->osrl << endl;
01016                 check = 2.925;
01017                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01018                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01019                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01020                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01021                 if(ok == false) throw ErrorClass(" Fail unit test with Bonmin on wayneQuadratic.osil");
01022                 delete solver;
01023                 solver = NULL;
01024                 delete osilreader;
01025                 osilreader = NULL;
01026                 unitTestResult << "Solved problem wayneQuadratic.osil with Bonmin" << std::endl;
01027                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01028 
01029                 cout << endl << "TEST " << ++nOfTest << ": Bonmin solver on wayneQuadratic.osil" << endl << endl;
01030                 ok = true;
01031                 osilFileName = dataDir  + "osilFiles" + dirsep + "wayneQuadratic.osil";
01032                 osolFileName = dataDir  + "osolFiles" + dirsep + "wayneQuadratic_Bonmin2.osol";
01033                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01034                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01035                 osilreader = new OSiLReader(); 
01036                 osolreader = new OSoLReader(); 
01037                 solver = new BonminSolver();    
01038                 solver->osol = osol;
01039                 solver->osinstance = osilreader->readOSiL( osil);
01040                 solver->osoption   = osolreader->readOSoL( osol);
01041                 cout << "call the Bonmin Solver for wayneQuadratic" << endl;
01042                 solver->buildSolverInstance();
01043                 // Do this one with two different osol files!!!
01044                 solver->solve();
01045                 cout << "Here is the Bonmin solver solution" << endl;
01046                 cout << solver->osrl << endl;
01047                 check = 2.925;
01048                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01049                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01050                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01051                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01052                 if(ok == false) throw ErrorClass(" Fail unit test with Bonmin on wayneQuadratic.osil");
01053                 delete solver;
01054                 solver = NULL;
01055                 delete osilreader;
01056                 osilreader = NULL;      
01057                 delete osolreader;
01058                 osolreader = NULL;      
01059                 unitTestResult << "Solved problem wayneQuadratic.osil with Bonmin" << std::endl;
01060                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01061 
01062 
01063 
01064 
01065                 cout << endl << "TEST " << ++nOfTest << ": Bonmin solver on rosenbrockorig.osil" << endl << endl;
01066                 ok = true;
01067                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockorig.osil";
01068 //              osolFileName = dataDir  + "osolFiles" + dirsep + "wayneQuadratic_Bonmin2.osol";
01069                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01070 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01071                 osilreader = new OSiLReader(); 
01072 //              osolreader = new OSoLReader(); 
01073                 solver = new BonminSolver();    
01074                 solver->osol = "";
01075                 solver->osinstance = osilreader->readOSiL( osil);
01076 //              solver->osoption   = osolreader->readOSoL( osol);
01077                 cout << "call the Bonmin Solver for rosenbrockorig" << endl;
01078                 solver->buildSolverInstance();
01079                 solver->solve();
01080                 cout << "Here is the Bonmin solver solution" << endl;
01081                 cout << solver->osrl << endl;
01082                 check = 2.925;
01083                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01084                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01085                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01086                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01087                 if(ok == false) throw ErrorClass(" Fail unit test with Bonmin on rosenbrockorig.osil");
01088                 delete solver;
01089                 solver = NULL;
01090                 delete osilreader;
01091                 osilreader = NULL;      
01092                 delete osolreader;
01093                 osolreader = NULL;      
01094                 unitTestResult << "Solved problem rosenbrockorig.osil with Bonmin" << std::endl;
01095                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01096 
01097 
01098 
01099                 cout << endl << "TEST " << ++nOfTest << ": Bonmin solver on rosenbrockinteger.osil" << endl << endl;
01100                 ok = true;
01101                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockinteger.osil";
01102 //              osolFileName = dataDir  + "osolFiles" + dirsep + "wayneQuadratic_Bonmin2.osol";
01103                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01104 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01105                 osilreader = new OSiLReader(); 
01106 //              osolreader = new OSoLReader(); 
01107                 solver = new BonminSolver();    
01108                 solver->osol = "";
01109                 solver->osinstance = osilreader->readOSiL( osil);
01110 //              solver->osoption   = osolreader->readOSoL( osol);
01111                 cout << "call the Bonmin Solver for rosenbrockinteger" << endl;
01112                 solver->buildSolverInstance();
01113                 solver->solve();
01114                 cout << "Here is the Bonmin solver solution" << endl;
01115                 cout << solver->osrl << endl;
01116                 check = 2.925;
01117                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01118                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01119                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01120                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01121                 if(ok == false) throw ErrorClass(" Fail unit test with Bonmin on rosenbrockinteger.osil");
01122                 delete solver;
01123                 solver = NULL;
01124                 delete osilreader;
01125                 osilreader = NULL;      
01126                 delete osolreader;
01127                 osolreader = NULL;      
01128                 unitTestResult << "Solved problem rosenbrockinteger.osil with Bonmin" << std::endl;
01129                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01130 
01131 #endif   // end of #ifdef THOROUGH
01132         }
01133         catch(const ErrorClass& eclass){
01134                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01135                 cout << endl << endl << endl;
01136                 unitTestResultFailure  << "Sorry Unit Test Failed Testing the Bonmin Solver:"  + eclass.errormsg << endl;
01137         }       
01138 #endif   // end of #ifdef COIN_HAS_BONMIN
01139 
01140 
01141 #ifdef COIN_HAS_COUENNE
01142         try{
01143                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on bonminEx1.osil" << endl << endl;
01144                 CouenneSolver *solver = NULL;
01145 
01146 //              OSiLReader *osilreader = NULL;
01147                 osilreader = new OSiLReader(); 
01148                 osolreader = new OSoLReader(); 
01149                 ok = true; 
01150                 osilFileName = dataDir  + "osilFiles" + dirsep + "bonminEx1.osil";
01151                 osolFileName = dataDir  + "osolFiles" + dirsep + "bonminEx1_Couenne.osol";
01152                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01153                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01154                 solver = new CouenneSolver();
01155                 solver->sSolverName = "bonmin";
01156                 solver->osil = osil;
01157                 solver->osol = osol; 
01158 //              solver->osinstance = osilreader->readOSiL( osil);
01159 //              solver->osoption   = osolreader->readOSoL( osol);
01160                 cout << "call the COIN - Couenne Solver for bonminEx1" << endl;
01161                 solver->buildSolverInstance();
01162         
01163                 std::cout << " CALL SOLVE " << std::endl;
01164                 solver->solve();
01165         
01166                 cout << "Here is the Couenne solver solution for bonminEx1" << endl;
01167 
01168                 tmp_writer = new OSrLWriter();
01169                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01170                 delete tmp_writer;
01171                 tmp_writer = NULL;
01172 
01173                 check = -1.70711;
01174                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01175                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01176                 if(ok == false) throw ErrorClass(" Fail unit test with Couenne on bonminEx1.osil");
01177 
01178                 delete solver;
01179                 solver = NULL;
01180                 unitTestResult << "Solved problem bonminEx1.osil with Couenne" << std::endl;
01181         
01182         
01183                 delete osilreader;
01184                 osilreader = NULL;
01185                 delete osolreader;
01186                 osolreader = NULL;
01187                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01188 
01189 #ifdef THOROUGH   
01190                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on bonminEx1_Nonlinear.osil" << endl << endl;
01191 //              OSiLReader *osilreader = NULL;
01192                 osilreader = new OSiLReader(); 
01193                 osolreader = new OSoLReader(); 
01194                 ok = true; 
01195                 osilFileName = dataDir  + "osilFiles" + dirsep + "bonminEx1_Nonlinear.osil";
01196 //              osolFileName = dataDir  + "osolFiles" + dirsep + "bonminEx1_Couenne.osol";
01197                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01198 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01199                 osol = "";
01200                 solver = new CouenneSolver();
01201                 solver->sSolverName = "bonmin";
01202                 solver->osil = osil;
01203                 solver->osol = osol; 
01204 //              solver->osinstance = osilreader->readOSiL( osil);
01205 //              solver->osoption   = osolreader->readOSoL( osol);
01206                 cout << "call the COIN - Couenne Solver for bonminEx1_Nonlinear" << endl;
01207                 solver->buildSolverInstance();
01208         
01209                 std::cout << " CALL SOLVE " << std::endl;
01210                 solver->solve();
01211         
01212                 cout << "Here is the Couenne solver solution for bonminEx1_Nonlinear.osil" << endl;
01213 
01214 //              OSrLWriter *tmp_writer;
01215                 tmp_writer = new OSrLWriter();
01216                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01217                 delete tmp_writer;
01218                 tmp_writer = NULL;
01219 
01220                 cout << solver->osrl << endl << endl;
01221 
01222 //              check = -1.70711;
01223 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01224 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01225 //              if(ok == false) throw ErrorClass(" Fail unit test with Couenne on bonminEx1_Nonlinear.osil");
01226 
01227                 delete solver;
01228                 solver = NULL;
01229                 unitTestResult << "Solved problem bonminEx1_Nonlinear with Couenne" << std::endl;
01230         
01231         
01232                 delete osilreader;
01233                 osilreader = NULL;
01234                 delete osolreader;
01235                 osolreader = NULL;
01236                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01237 
01238 
01239                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on nonconvex.osil" << endl << endl;
01240 //              OSiLReader *osilreader = NULL;
01241                 osilreader = new OSiLReader(); 
01242                 osolreader = new OSoLReader(); 
01243                 ok = true; 
01244                 osilFileName = dataDir  + "osilFiles" + dirsep + "nonconvex.osil";
01245 //              osolFileName = dataDir  + "osolFiles" + dirsep + "bonminEx1_Couenne.osol";
01246                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01247 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01248                 osol = "";
01249                 solver = new CouenneSolver();
01250                 solver->sSolverName = "bonmin";
01251                 solver->osil = osil;
01252                 solver->osol = osol; 
01253 //              solver->osinstance = osilreader->readOSiL( osil);
01254 //              solver->osoption   = osolreader->readOSoL( osol);
01255                 cout << "call the COIN - Couenne Solver for nonconvex.osil" << endl;
01256                 solver->buildSolverInstance();
01257         
01258                 std::cout << " CALL SOLVE " << std::endl;
01259                 solver->solve();
01260         
01261                 cout << "Here is the Couenne solver solution for nonconvex.osil" << endl;
01262 
01263 //              OSrLWriter *tmp_writer;
01264                 tmp_writer = new OSrLWriter();
01265                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01266                 delete tmp_writer;
01267                 tmp_writer = NULL;
01268 
01269                 cout << solver->osrl << endl << endl;
01270 
01271 //              check = -1.70711;
01272 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01273 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01274 //              if(ok == false) throw ErrorClass(" Fail unit test with Couenne on nonconvex.osil");
01275 
01276                 delete solver;
01277                 solver = NULL;
01278                 unitTestResult << "Solved problem nonconvex.osil with Couenne" << std::endl;
01279         
01280         
01281                 delete osilreader;
01282                 osilreader = NULL;
01283                 delete osolreader;
01284                 osolreader = NULL;
01285                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01286 
01287                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on rosenbrockorig.osil" << endl << endl;
01288 //              OSiLReader *osilreader = NULL;
01289                 osilreader = new OSiLReader(); 
01290                 osolreader = new OSoLReader(); 
01291                 ok = true; 
01292                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockorig.osil";
01293 //              osolFileName = dataDir  + "osolFiles" + dirsep + "rosenbrockorig_Couenne.osol";
01294                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01295 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01296                 osol = "";
01297                 solver = new CouenneSolver();
01298                 solver->sSolverName = "bonmin";
01299                 solver->osil = osil;
01300                 solver->osol = osol; 
01301 //              solver->osinstance = osilreader->readOSiL( osil);
01302 //              solver->osoption   = osolreader->readOSoL( osol);
01303                 cout << "call the COIN - Couenne Solver for rosenbrockorig" << endl;
01304                 solver->buildSolverInstance();
01305         
01306                 std::cout << " CALL SOLVE " << std::endl;
01307                 solver->solve();
01308         
01309                 cout << "Here is the Couenne solver solution for rosenbrockorig" << endl;
01310 
01311 //              OSrLWriter *tmp_writer;
01312                 tmp_writer = new OSrLWriter();
01313                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01314                 delete tmp_writer;
01315                 tmp_writer = NULL;
01316 
01317                 cout << solver->osrl << endl << endl;
01318 
01319 //              check = -1.70711;
01320 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01321 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01322 //              if(ok == false) throw ErrorClass(" Fail unit test with Couenne on rosenbrockorig.osil");
01323 
01324                 delete solver;
01325                 solver = NULL;
01326                 unitTestResult << "Solved problem rosenbrockorig.osil with Couenne" << std::endl;
01327         
01328         
01329                 delete osilreader;
01330                 osilreader = NULL;
01331                 delete osolreader;
01332                 osolreader = NULL;
01333                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01334 
01335 
01336 
01337                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on rosenbrockinteger.osil" << endl << endl;
01338 //              OSiLReader *osilreader = NULL;
01339                 osilreader = new OSiLReader(); 
01340                 osolreader = new OSoLReader(); 
01341                 ok = true; 
01342                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockinteger.osil";
01343 //              osolFileName = dataDir  + "osolFiles" + dirsep + "rosenbrockinteger_Couenne.osol";
01344                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01345 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01346                 osol = "";
01347                 solver = new CouenneSolver();
01348                 solver->sSolverName = "bonmin";
01349                 solver->osil = osil;
01350                 solver->osol = osol; 
01351 //              solver->osinstance = osilreader->readOSiL( osil);
01352 //              solver->osoption   = osolreader->readOSoL( osol);
01353                 cout << "call the COIN - Couenne Solver for rosenbrockinteger" << endl;
01354                 solver->buildSolverInstance();
01355         
01356                 std::cout << " CALL SOLVE " << std::endl;
01357                 solver->solve();
01358         
01359                 cout << "Here is the Couenne solver solution for rosenbrockinteger" << endl;
01360 
01361 //              OSrLWriter *tmp_writer;
01362                 tmp_writer = new OSrLWriter();
01363                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01364                 delete tmp_writer;
01365                 tmp_writer = NULL;
01366 
01367                 cout << solver->osrl << endl << endl;
01368 
01369 //              check = -1.70711;
01370 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01371 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01372 //              if(ok == false) throw ErrorClass(" Fail unit test with Couenne on rosenbrockinteger.osil");
01373 
01374                 delete solver;
01375                 solver = NULL;
01376                 unitTestResult << "Solved problem rosenbrockinteger.osil with Couenne" << std::endl;
01377         
01378         
01379                 delete osilreader;
01380                 osilreader = NULL;
01381                 delete osolreader;
01382                 osolreader = NULL;
01383                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01384 
01385 
01386                 cout << endl << "TEST " << ++nOfTest << ": Couenne solver on HS071_feas.osil" << endl << endl;
01387 //              OSiLReader *osilreader = NULL;
01388                 osilreader = new OSiLReader(); 
01389                 osolreader = new OSoLReader(); 
01390                 ok = true; 
01391                 osilFileName = dataDir  + "osilFiles" + dirsep + "HS071_feas.osil";
01392 //              osolFileName = dataDir  + "osolFiles" + dirsep + "HS071_feas_Couenne.osol";
01393                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01394 //              osol = fileUtil->getFileAsString( osolFileName.c_str());
01395                 osol = "";
01396                 solver = new CouenneSolver();
01397                 solver->sSolverName = "bonmin";
01398                 solver->osil = osil;
01399                 solver->osol = osol; 
01400 //              solver->osinstance = osilreader->readOSiL( osil);
01401 //              solver->osoption   = osolreader->readOSoL( osol);
01402                 cout << "call the COIN - Couenne Solver for HS071_feas.osil" << endl;
01403                 solver->buildSolverInstance();
01404         
01405                 std::cout << " CALL SOLVE " << std::endl;
01406                 solver->solve();
01407         
01408                 cout << "Here is the Couenne solver solution for HS071_feas" << endl;
01409 
01410 //              OSrLWriter *tmp_writer;
01411                 tmp_writer = new OSrLWriter();
01412                 solver->osrl = tmp_writer->writeOSrL(solver->osresult);
01413                 delete tmp_writer;
01414                 tmp_writer = NULL;
01415 
01416                 cout << solver->osrl << endl << endl;
01417 
01418 //              check = -1.70711;
01419 //              //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01420 //              ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01421 //              if(ok == false) throw ErrorClass(" Fail unit test with Couenne on HS071_feas.osil");
01422 
01423                 delete solver;
01424                 solver = NULL;
01425                 unitTestResult << "Solved problem HS071_feas with Couenne" << std::endl;
01426         
01427         
01428                 delete osilreader;
01429                 osilreader = NULL;
01430                 delete osolreader;
01431                 osolreader = NULL;
01432                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01433 
01434 #endif
01435 
01436         }
01437         catch(const ErrorClass& eclass){
01438                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01439                 cout << endl << endl << endl;
01440                 unitTestResultFailure  << "Sorry Unit Test Failed Testing the Couenne Solver:"  + eclass.errormsg << endl;
01441         
01442         }       
01443 #endif
01444 
01445 
01446 
01447 #ifdef COIN_HAS_SYMPHONY
01448         try{
01449                 cout << endl << "TEST " << ++nOfTest << ": SYMPHONY solver on p0033.osil" << endl << endl;
01450                 ok = true; 
01451                 osilFileName = dataDir  + "osilFiles" + dirsep + "p0033.osil";
01452                 osolFileName = dataDir  + "osolFiles" + dirsep + "p0033_sym.osol";
01453                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01454                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01455                 osolreader = new OSoLReader(); 
01456                 solver = new CoinSolver();
01457                 solver->sSolverName = "symphony";
01458                 solver->osil = osil;
01459                 solver->osinstance = NULL; 
01460                 solver->osoption   = osolreader->readOSoL( osol);
01461                 cout << "build the solver instance for COIN - SYMPHONY" << endl;
01462                 solver->buildSolverInstance();
01463 //              cout << "call the COIN - SYMPHONY Solver for p0033" << endl;
01464                 solver->solve();
01465                 cout << "Here is the COIN SYMPHONY solver solution for p0033" << endl;
01466                 cout << solver->osrl << endl;
01467                 check = 3089;
01468                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01469                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01470                 if(ok == false) throw ErrorClass(" Fail unit test with SYMPHONY on p0033.osil");
01471                 delete solver;
01472                 solver = NULL;
01473                 delete osolreader;
01474                 osolreader = NULL;      
01475                 unitTestResult << "Solved problem p0033.osil with SYMPHONY" << std::endl;
01476                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01477         }
01478         catch(const ErrorClass& eclass){
01479                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01480                 cout << endl << endl << endl;
01481                 unitTestResultFailure  << "Sorry Unit Test Failed Testing the SYMPHONY Solver:"  + eclass.errormsg << endl;
01482         }       
01483 #endif
01484         
01485 
01486 
01487 #ifdef COIN_HAS_DYLP
01488         try{
01489                 cout << endl << "TEST " << ++nOfTest << ": DyLP solver on parincLinear.osil" << endl << endl;
01490                 ok = true; 
01491                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincLinear.osil";
01492                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincLinear_dylp.osol";
01493                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01494                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01495                 osilreader = new OSiLReader(); 
01496                 solver = new CoinSolver();
01497                 solver->sSolverName = "dylp";
01498                 solver->osol = osol;   
01499                 solver->osinstance = osilreader->readOSiL( osil);
01500                 cout << "call the COIN - DyLP solver for parincLinear" << endl;
01501                 solver->buildSolverInstance();
01502                 solver->solve();
01503                 cout << "Here is the COIN - DyLP solver solution for parincLinear" << endl;
01504                 cout << solver->osrl << endl;
01505                 check = 7668;
01506                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
01507                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01508                 if(ok == false) throw ErrorClass(" Fail unit test with DyLP on parincLinear.osil");
01509                 delete solver;
01510                 solver = NULL;
01511                 delete osilreader;
01512                 osilreader = NULL;      
01513                 unitTestResult << "Solved problem parincLinear.osil with DyLP" << std::endl;
01514                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01515         }
01516         catch(const ErrorClass& eclass){
01517                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01518                 cout << endl << endl << endl;
01519                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the DyLP Solver:"  + eclass.errormsg << endl;
01520         }       
01521         #endif
01522         
01523 
01524 #ifdef COIN_HAS_VOL
01525         try{
01526                 cout << endl << "TEST " << ++nOfTest << ": Vol solver on volumeTest.osil" << endl << endl;
01527                 ok = true; 
01528                 osilFileName = dataDir  + "osilFiles" + dirsep + "volumeTest.osil";
01529                 osolFileName = dataDir  + "osolFiles" + dirsep + "volumeTest_vol.osol";
01530                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01531                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01532                 osolreader = new OSoLReader(); 
01533                 solver = new CoinSolver();
01534                 solver->sSolverName = "vol";
01535                 solver->osil = osil;
01536                 solver->osinstance = NULL; 
01537                 solver->osoption = osolreader->readOSoL( osol);
01538                 cout << "call the COIN - Vol solver for volumeTest" << endl;
01539                 solver->buildSolverInstance();
01540                 solver->solve();
01541                 cout << "Here is the COIN - Vol solver solution for parincLinear" << endl;
01542                 cout << solver->osrl << endl;
01543                 check = 7;
01544                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
01545                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01546                 if(ok == false) throw ErrorClass(" Fail unit test with Vol on volumeTest.osil");
01547                 delete solver;
01548                 solver = NULL;
01549                 delete osolreader;
01550                 osolreader = NULL;      
01551                 unitTestResult << "Solved problem volumeTest.osil with Vol" << std::endl;
01552                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01553         }
01554         catch(const ErrorClass& eclass){
01555                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01556                 cout << endl << endl << endl;
01557                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the Vol Solver:"  + eclass.errormsg << endl;
01558         }       
01559 #endif
01560         
01561 #ifdef COIN_HAS_GLPK
01562         try{
01563                 cout << endl << "TEST " << ++nOfTest << ": GLPK solver on p0033.osil" << endl << endl;
01564                 ok = true; 
01565                 osilFileName = dataDir  + "osilFiles" + dirsep + "p0033.osil";
01566                 osolFileName = dataDir  + "osolFiles" + dirsep + "p0033_glpk.osol";
01567                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01568                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01569                 osilreader = new OSiLReader(); 
01570                 osolreader = new OSoLReader(); 
01571                 solver = new CoinSolver();
01572                 solver->sSolverName = "glpk";
01573                 solver->osinstance = osilreader->readOSiL( osil);
01574                 solver->osoption   = osolreader->readOSoL( osol);
01575                 cout << "call the GLPK Solver for p0033" << endl;
01576                 solver->buildSolverInstance();
01577                 solver->solve();
01578                 cout << "Here is the GLPK solver solution for p0033" << endl;
01579                 cout << solver->osrl << endl;
01580                 check = 3089;
01581                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01582                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01583                 if(ok == false) throw ErrorClass(" Fail unit test with GLPK on p0033.osil");
01584                 delete solver;
01585                 solver = NULL;
01586                 delete osilreader;
01587                 osilreader = NULL;      
01588                 delete osolreader;
01589                 osolreader = NULL;      
01590                 unitTestResult << "Solved problem p0033.osil with GLPK" << std::endl;
01591                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01592         }
01593         catch(const ErrorClass& eclass){
01594                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01595                 cout << endl << endl << endl;
01596                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the Glpk Solver:"  + eclass.errormsg << endl;
01597         }       
01598         #endif
01599         
01600 
01601 
01602 #ifdef COIN_HAS_CPX
01603         try{
01604                 cout << endl << "TEST " << ++nOfTest << ": Cplex solver on p0033.osil" << endl << endl;
01605                 ok = true; 
01606                 osilFileName = dataDir  + "osilFiles" + dirsep + "p0033.osil";
01607                 osolFileName = dataDir  + "osolFiles" + dirsep + "p0033_cpx.osol";
01608                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01609                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01610                 solver = new CoinSolver();
01611                 solver->sSolverName = "cplex";
01612                 solver->osil = osil;
01613                 solver->osol = osol;  
01614                 solver->osinstance = NULL; 
01615                 cout << "call the CPLEX Solver for p0033" << endl;
01616                 solver->buildSolverInstance();
01617                 solver->solve();
01618                 cout << "Here is the CPLEX solver solution for p0033" << endl;
01619                 cout << solver->osrl << endl;
01620                 check = 3089;
01621                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01622                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01623                 if(ok == false) throw ErrorClass(" Fail unit test with CPLEX on p0033.osil");
01624                 delete solver;
01625                 solver = NULL;
01626                 unitTestResult << "Solved problem p0033.osil with CPLEX" << std::endl;
01627                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01628         }
01629         catch(const ErrorClass& eclass){
01630                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01631                 cout << endl << endl << endl;
01632                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the Cplex Solver:"  + eclass.errormsg << endl;
01633         }       
01634 #endif
01635         
01636         
01637 #ifdef COIN_HAS_LINDO
01638         try{
01639                 cout << endl << "TEST " << ++nOfTest << ": Lindo solver on lindoapiaddins.osil" << endl << endl;
01640                 ok = true;
01641                 osilFileName = dataDir  + "osilFiles" + dirsep + "lindoapiaddins.osil";
01642                 osolFileName = dataDir  + "osolFiles" + dirsep + "lindoapiaddins_lindo.osol";
01643                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01644                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01645                 osilreader = new OSiLReader(); 
01646                 cout << "create a new LINDO Solver for OSiL string solution" << endl;
01647                 solver = new LindoSolver();     
01648                 solver->osinstance = osilreader->readOSiL( osil);
01649                 solver->osol = osol;
01650                 cout << "call the LINDO Solver" << endl;
01651                 solver->buildSolverInstance();
01652                 solver->solve();
01653                 cout << "Here is the LINDO solver solution" << endl;
01654                 cout << solver->osrl << endl;
01655                 check = 99;
01656                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01657                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01658                 if(ok == false) throw ErrorClass(" Fail unit test with LINDO on lindoapiaddins.osil");
01659                 solver->osinstance = NULL;
01660                 delete solver;
01661                 solver = NULL;
01662                 osilreader = NULL;      
01663                 delete osolreader;
01664                 unitTestResult << "Solved problem lindoapiaddins.osil with Lindo" << std::endl;
01665                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01666 
01667 #ifdef THOUROUGH
01668                 // now solve the rosenbrock problem from the OSiL paper
01669                 cout << endl << "TEST " << ++nOfTest << ": Lindo solver on rosenbrockmod.osil" << endl << endl;
01670                 osilFileName = dataDir  + "osilFiles" + dirsep + "rosenbrockmod.osil";
01671                 osolFileName = dataDir  + "osolFiles" + dirsep + "rosenbrockmod_lindo.osol";
01672                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01673                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01674                 solver = new LindoSolver();     
01675                 solver->osil = osil;
01676                 solver->osol = osol;
01677                 solver->osinstance = NULL;
01678                 cout << "call the LINDO Solver" << endl;
01679                 solver->buildSolverInstance();
01680                 solver->solve();
01681                 cout << "Here is the LINDO solver solution" << endl;
01682                 cout << solver->osrl << endl;
01683                 check = 6.7279;
01684                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01685                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01686                 if(ok == false) throw ErrorClass(" Fail unit test with LINDO on rosenbrockmod.osil");
01687                 solver->osinstance = NULL;
01688                 delete solver;
01689                 solver = NULL;
01690                 unitTestResult << "Solved problem rosenbrockmod.osil with Lindo" << std::endl;
01691                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01692 
01693                 // now solve a pure quadratic
01694                 cout << endl << "TEST " << ++nOfTest << ": Lindo solver on parincQuadratic.osil" << endl << endl;
01695                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincQuadratic.osil";
01696                 osolFileName = dataDir  + "osolFiles" + dirsep + "parincQuadratic_lindo.osol";
01697                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01698                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01699                 osolreader = new OSoLReader(); 
01700                 solver = new LindoSolver();     
01701                 solver->osil = osil;
01702                 solver->osol = osol;
01703                 solver->osinstance = NULL;
01704                 solver->osoption   = osolreader->readOSoL( osol);
01705                 cout << "call the LINDO Solver" << endl;
01706                 solver->buildSolverInstance();
01707                 solver->solve();
01708                 cout << "Here is the LINDO solver solution" << endl;
01709                 cout << solver->osrl << endl;
01710                 check = 49920.5;
01711                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01712                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01713                 if(ok == false) throw ErrorClass(" Fail unit test with LINDO on parincQuadratic.osil");
01714                 delete solver;
01715                 solver = NULL;
01716                 delete osolreader;
01717                 osolreader = NULL;      
01718                 unitTestResult << "Solved problem parincQuadratic.osil with Lindo" << std::endl;
01719                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01720 
01721                 // now solve a quadratic binary problem
01722                 // wayneQuadratic.osil
01723                 /*
01724                 cout << endl << "TEST " << ++nOfTest << ": Lindo solver on wayneQuadratic.osil" << endl << endl;
01725                 osilFileName = dataDir  + "osilFiles" + dirsep + "wayneQuadratic.osil";
01726                 osolFileName = dataDir  + "osolFiles" + dirsep + "wayneQuadratic_lindo.osol";
01727                 osil = fileUtil->getFileAsString( osilFileName.c_str());
01728                 osol = fileUtil->getFileAsString( osolFileName.c_str());
01729                 osilreader = new OSiLReader(); 
01730                 solver = new LindoSolver();     
01731                 solver->osil = osil;
01732                 solver->osol = osol;
01733                 solver->osinstance = osilreader->readOSiL( osil);
01734                 cout << "call the LINDO Solver" << endl;
01735                 solver->buildSolverInstance();
01736                 solver->solve();
01737                 cout << "Here is the LINDO solver solution" << endl;
01738                 cout << solver->osrl << endl;
01739                 check = 2.925;
01740                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01741                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-10 , 1e-10);
01742                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01743                 std::cout << "CALL NEAR_EQUAL" << std::endl;
01744                 if(ok == false) throw ErrorClass(" Fail unit test with LINDO on wayneQuadratic.osil");
01745                 delete solver;
01746                 solver = NULL;
01747                 osilreader = NULL;      
01748                 delete osolreader;
01749                 unitTestResult << "Solved problem wayneQuadratic.osil with Lindo" << std::endl;
01750                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01751                 */
01752 #endif          
01753         }
01754         catch(const ErrorClass& eclass){
01755                 //cout << "OSrL =  " <<  solver->osrl <<  endl;
01756                 cout << endl << endl << endl;
01757                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the LINDO Solver:"  + eclass.errormsg << endl << endl;
01758         }
01759 #endif
01760 // end solving using the osil file
01761 
01762 
01763 
01764 // now solve with an OSInstance created from an MPS file
01765         try{
01766                 cout << endl << "TEST " << ++nOfTest << ": Cbc solver using MPS file" << endl << endl;
01767                 ok = true;
01768 //              cout << endl;
01769 //              cout << "START MPS TESTING" << endl << endl;
01770                 cout << "create a COIN Solver for MPS - OSInstance solution" << endl;
01771                 solver = new CoinSolver();
01772                 solver->sSolverName = "cbc";
01773                 mps2osil = new OSmps2osil( mpsFileName);
01774                 mps2osil->createOSInstance() ;
01775                 solver->osinstance = mps2osil->osinstance;
01776                 osol = "<osol t></osol>";
01777                 solver->osol = osol;
01778                 cout << "call COIN Solve" << endl;
01779                 solver->buildSolverInstance();
01780                 solver->solve();
01781                 cout << "Here is the COIN solver solution" << endl;
01782                 cout << solver->osrl << endl;
01783                 check = -7668;
01784                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
01785                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01786                 if(ok == false) throw ErrorClass(" Fail unit test with COIN Solver on MPS test problem parincLinear.mps");
01787                 delete solver;
01788                 solver = NULL;
01789                 delete mps2osil; 
01790                 mps2osil = NULL;
01791 //              cout << endl;
01792 //              cout << "DONE WITH MPS TESTING" << endl;
01793                 unitTestResult << "Test the MPS -> OSiL converter on parinc.mps using Cbc" << std::endl;
01794                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01795         }
01796         catch(const ErrorClass& eclass){
01797                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01798                 cout << endl << endl << endl;
01799                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing the MPS converter:"  + eclass.errormsg << endl;
01800         }
01801 
01802 // now solve with an OSInstance created from an AMPL nl file
01803         try{
01804 #ifdef COIN_HAS_ASL
01805                 cout << endl << "TEST " << ++nOfTest << ": AMPL solver interface" << endl << endl;
01806                 ok = true;
01807                 cout << "create a cbc Solver for AMPL nl - OSInstance solution" << endl;
01808                 solver = new CoinSolver();
01809                 solver->sSolverName = "cbc";
01810                 nl2osil = new OSnl2osil( nlFileName); 
01811                 nl2osil->createOSInstance() ;
01812                 solver->osinstance = nl2osil->osinstance;       
01813                 osol = "";  //<osol t></osol>";
01814                 solver->osol = osol;
01815                 cout << "call Cbc Solve" << endl;
01816                 solver->buildSolverInstance();
01817                 solver->solve();
01818                 cout << "Here is the Cbc solver solution" << endl;
01819                 cout << solver->osrl << endl;
01820                 check = 7668;
01821                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
01822                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01823                 if(ok == false) throw ErrorClass(" Fail unit test with OSnl2osil on problem parinc.nl");
01824                 solver->osinstance = NULL;
01825                 delete solver;
01826                 solver = NULL;
01827                 cout << "call delete nl2osil" << endl;
01828                 delete nl2osil;
01829                 nl2osil = NULL; 
01830                 unitTestResult << "Test the AMPL nl -> OSiL converter on parinc.nl using Cbc" << std::endl; 
01831                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01832 #endif
01833         }       
01834                 catch(const ErrorClass& eclass){
01835                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01836                 cout << endl << endl << endl;
01837                 unitTestResultFailure  <<"Sorry Unit Test Failed Testing AMPL:"  + eclass.errormsg << endl;
01838         }
01839 
01840         //
01841         // Now test the mps feature
01842         //
01843         try{
01844                 cout << endl << "TEST " << ++nOfTest << ": b64 operations" << endl << endl;
01845                 ok = true;
01846                 OSiLWriter osilwriter;
01847                 osilwriter.m_bWriteBase64 = true;
01848                 solver = new CoinSolver();
01849                 solver->sSolverName = "cbc";
01850                 mps2osil = new OSmps2osil( mpsFileName);
01851                 solver->osinstance = NULL;
01852                 osol = "<osol></osol>";
01853                 solver->osol = osol;
01854                 mps2osil->createOSInstance() ;
01855                 solver->osil = osilwriter.writeOSiL( mps2osil->osinstance) ;
01856                 std::cout << solver->osil << std::endl;
01857                 solver->buildSolverInstance();
01858                 solver->solve();
01859                 cout << endl << endl;
01860                 cout << "COIN solution of a OSiL string in b64 format" << endl;
01861                 cout << solver->osrl;
01862                 check = -7668;
01863                 //ok &= NearEqual(getObjVal( solver->osrl) , check,  1e-1 , 1e-1);
01864                 ok = ( fabs(check - getObjVal( solver->osrl) )/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01865                 if(ok == false) throw ErrorClass(" Fail unit test with COIN Cbc cSolver on b64 test problem parincLinear.mps");
01866                 solver->osinstance = NULL;
01867                 delete solver;
01868                 solver = NULL;
01869                 delete mps2osil;
01870                 mps2osil = NULL;
01871                 unitTestResult << "Test a problem written in b64 and then converted to OSInstance" << std::endl;
01872                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01873         }       
01874         catch(const ErrorClass& eclass){
01875                 cout << endl << endl;
01876                 cout << eclass.errormsg <<  endl << endl;
01877                 cout << "OSrL =  " <<  solver->osrl <<  endl;
01878                 cout << endl << endl << endl;
01879                 unitTestResultFailure   << "Sorry Unit Test Failed Testing Use of Base 64" << endl;
01880 
01881         }  
01882 #endif      //INSTALLATION_TEST
01883 
01884 
01885 #ifdef COMPONENT_DEBUG
01886 
01887         // now test postfix and prefix routines
01888         try{
01889                 cout << endl << "TEST " << ++nOfTest << ": postfix and prefix routines" << endl << endl;
01890                 std::string expTreeTest =  dataDir  + "osilFiles" + dirsep + "rosenbrockmod.osil";
01891                 osil = fileUtil->getFileAsString( expTreeTest.c_str() ) ;
01892                 OSInstance *osinstance = NULL;
01893                 //osinstance = new OSInstance();
01894                 OSiLReader *osilreader = NULL;
01895                 osilreader = new OSiLReader();
01896                 //create an osinstance
01897                 osinstance = osilreader->readOSiL( osil);
01898                 OSExpressionTree* expTree = osinstance->getNonlinearExpressionTree( -1);
01899                 if(expTree == NULL) throw ErrorClass(" Null expression tree when testing prefix and postfix routines");
01900                 std::vector<OSnLNode*> postfixVec;
01901                 //postfixVec = expTree->m_treeRoot->getPostfixFromExpressionTree();
01902                 postfixVec = osinstance->getNonlinearExpressionTreeInPostfix( -1);
01903         
01904                 unsigned int n = postfixVec.size();
01905                 //unsigned int i;
01906                 std::string *nodeNames1 = new std::string[ n];
01907                 std::string *nodeNames2 = new std::string[ n];
01908                 for (int i = 0 ; i < n; i++){
01909                         std::cout << postfixVec[i]->snodeName << std::endl;
01910                         nodeNames1[i] = postfixVec[i]->snodeName;
01911                 }
01912                 
01913                 // now create back the expression tree 
01914                 expTree->m_treeRoot = postfixVec[ n - 1]->createExpressionTreeFromPostfix( postfixVec);
01915         
01916                 // now get in prefix
01917                 std::vector<OSnLNode*> prefixVec;
01918                 //prefixVec = expTree->m_treeRoot->getPrefixFromExpressionTree();
01919                 prefixVec = osinstance->getNonlinearExpressionTreeInPrefix( -1);
01920                 
01921                 // now create back the expression tree
01922                 expTree->m_treeRoot = prefixVec[ 0]->createExpressionTreeFromPrefix( prefixVec);
01923                 
01924                 // now get postfix vector again and compare with original
01925                 postfixVec = expTree->m_treeRoot->getPostfixFromExpressionTree();
01926                 //postfixVec = osinstance->getNonlinearExpressionTreeInPostfix( -1);
01927                 if(postfixVec.size() != n) throw ErrorClass(" Problem with creating expression trees");
01928                 std::cout << std::endl << std::endl;
01929                 for (int i = 0 ; i < n; i++){
01930                         //std::cout << postfixVec[i]->snodeName << std::endl;
01931                         nodeNames2[i] = postfixVec[i]->snodeName;
01932                         if( nodeNames1[i] != nodeNames2[ i]) throw ErrorClass(" Problem with creating expression trees");
01933                 }       
01934                 
01935                 //delete osinstance;
01936                 delete[] nodeNames1;
01937                 delete[] nodeNames2; 
01938 
01939                 delete osilreader;
01940                 osilreader = NULL;
01941                 osinstance = NULL;              
01942                 unitTestResult << "Successful test of prefix and postfix conversion routines" << std::endl;
01943                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01944                 
01945         }
01946         catch(const ErrorClass& eclass){
01947                 cout << endl << endl << endl;
01948                 unitTestResultFailure << eclass.errormsg << endl;
01949         }
01950         // now test the nonlinear operators     
01951         try{
01952                 cout << endl << "TEST " << ++nOfTest << ": nonlinear operators" << endl << endl;
01953                 ok = true;
01954                 std::string operatorTest =  dataDir  + "osilFiles" + dirsep + "testOperators.osil";
01955                 osil = fileUtil->getFileAsString( operatorTest.c_str() );
01956                 OSInstance *osinstance = NULL;
01957                 //osinstance = new OSInstance();
01958                 OSiLReader *osilreader = NULL;
01959                 osilreader = new OSiLReader();
01960                 OSiLWriter *osilwriter = NULL;
01961                 osilwriter = new OSiLWriter();
01962 //              cout << "Read testOperators.osil...";
01963                 osinstance = osilreader->readOSiL( osil);
01964 //              cout << "Done" << endl;
01965                 OSExpressionTree* expTree = osinstance->getNonlinearExpressionTree( -1);
01966                 std::vector<OSnLNode*> postfixVec;
01967                 postfixVec = expTree->m_treeRoot->getPostfixFromExpressionTree();
01968                 int n = postfixVec.size();
01969                 std::string *nodeNames1 = new std::string[ n];
01970                 for (int i = 0 ; i < n; i++){
01971                         std::cout << postfixVec[i]->snodeName << std::endl;
01972                         nodeNames1[i] = postfixVec[i]->snodeName;
01973                 }
01974                 std::cout << std::endl << std::endl;
01975                 std::cout << osilwriter->writeOSiL( osinstance) << std::endl;
01976                 // now test value
01977                 double *x = NULL;
01978                 x = new double[2];
01979                 x[0] = 1;
01980                 x[1] = 2;
01981                 double parserTestVal = expTree->m_treeRoot->calculateFunction( x);
01982                 std::cout << "ParserTest Val = " << parserTestVal << std::endl;
01983                 check = 11;
01984                 //ok &= NearEqual(expTree->m_treeRoot->calculateFunction( x) , check,  1e-10 , 1e-10);
01985                 ok = ( fabs(check -  expTree->m_treeRoot->calculateFunction( x))/(fabs( check) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
01986                 if(ok == false) throw ErrorClass(" Problem evaluating expression tree");
01987                 delete[] x;
01988                 delete[] nodeNames1;
01989                 delete osilreader;
01990                 osilreader = NULL;
01991                 delete osilwriter;
01992                 osilwriter = NULL;
01993                 osinstance = NULL;
01994                 //create an osinstance
01995                 unitTestResult << "Successful test of nonlinear operators using file testOperators.osil" << std::endl;
01996                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
01997         }
01998         catch(const ErrorClass& eclass){
01999                 cout << endl << endl << endl;
02000                 unitTestResultFailure << eclass.errormsg << endl;
02001         }
02002 // Automatic differentiation
02003         try{
02004                 cout << endl << "TEST " << ++nOfTest << ": Automatic differentiation" << endl << endl;
02005 //              std::cout << std::endl << std::endl;
02006 //              std::cout << "Testing AD Features " << std::endl;
02007                 std::string expTreeTest =  dataDir  + "osilFiles" + dirsep + "CppADTestLag.osil";
02008                 /*
02009                 min x0^2 + 9*x1   -- w[0]
02010                 s.t. 
02011                 33 - 105 + 1.37*x1 + 2*x3 + 5*x1 <= 10  -- y[0]
02012                 ln(x0*x3)  + 7*x2 >= 10  -- y[1]
02013                 Note: in the first constraint 33 is a constant term and 105 
02014                 is part of the nl node
02015                 */
02016                 osil = fileUtil->getFileAsString( expTreeTest.c_str() );
02017                 OSInstance *osinstance = NULL;
02018                 //osinstance = new OSInstance();
02019                 OSiLReader *osilreader = NULL;
02020                 osilreader = new OSiLReader();
02021                 //create an osinstance
02022                 osinstance = osilreader->readOSiL( osil);
02023                 double *x;
02024                 x = new double[ 4];
02025                 x[0] = 1;
02026                 x[1] = 5;
02027                 x[2] = 10;
02028                 x[3] = 5;
02029                 SparseVector *sp;
02030                 // get the gradient for constraint 1
02031                 osinstance->getJacobianSparsityPattern();
02032                 sp = osinstance->calculateConstraintFunctionGradient(x, 1, true);
02033                 for(int i = 0; i < sp->number; i++){
02034                         std::cout << "gradient value " << sp->values[i] << std::endl;
02035                 }
02036                 ok = true;
02037                 //check gradient for constraint with index 1
02038                 double checkPartial2Con1 = 7.0 ;
02039                 //ok &= NearEqual( sp->values[ 0], checkPartial2Con1, 1e-10, 1e-10); 
02040                 ok = ( fabs(checkPartial2Con1 - sp->values[ 0] )/(fabs( checkPartial2Con1) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02041                 if(ok == false) throw ErrorClass(" Fail testing gradient calculation");
02042                 double checkPartial0Con1 = (1./x[0])  ;
02043                 //ok &= NearEqual(sp->values[ 1], checkPartial0Con1, 1e-10, 1e-10); 
02044                 ok = ( fabs(checkPartial0Con1 - sp->values[ 1] )/(fabs( checkPartial0Con1) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02045                 if(ok == false) throw ErrorClass(" Fail testing gradient calculation");
02046                 double checkPartial3Con1 = (1./x[3]) ;
02047                 //ok &= NearEqual( sp->values[ 2], checkPartial3Con1, 1e-10, 1e-10); 
02048                 ok = ( fabs(checkPartial3Con1 - sp->values[ 2] )/(fabs( checkPartial3Con1) + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02049                 if(ok == false) throw ErrorClass(" Fail testing gradient calculation");
02050                 delete sp;
02051                 SparseHessianMatrix *sh;
02052                 // calcuate Hessian of objective function (index = -1)
02053                 osinstance->getLagrangianHessianSparsityPattern( );
02054                 sh = osinstance->calculateHessian(x, -1, true);
02055                 for(int i = 0; i < sh->hessDimension; i++){
02056                         std::cout << "Hessian value " << sh->hessValues[i] << std::endl;
02057                 }
02058                 //ok &= NearEqual( sh->hessValues[ 0], 2., 1e-10, 1e-10);
02059                 ok = ( fabs(2. - sh->hessValues[0] )/(2. + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02060                 if(ok == false) throw ErrorClass(" Fail testing Hessian calculation"); 
02061                 //ok &= NearEqual( sh->hessValues[ 1], 0., 1e-10, 1e-10);
02062                 ok = ( fabs(0. - sh->hessValues[ 1] )/(0. + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02063                 if(ok == false) throw ErrorClass(" Fail testing Hessian calculation");
02064                 //ok &= NearEqual( sh->hessValues[ 2], 0., 1e-10, 1e-10);
02065                 ok = ( fabs(0. - sh->hessValues[2] )/(0. + OS_NEAR_EQUAL) <= OS_NEAR_EQUAL) ? true : false;
02066                 if(ok == false) throw ErrorClass(" Fail testing Hessian calculation");
02067                 unitTestResult << "Successful test of AD gradient and Hessian calculations" << std::endl;
02068                 delete[] x;
02069                 delete osilreader;
02070                 osilreader = NULL;
02071                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
02072         }       
02073         catch(const ErrorClass& eclass){
02074                 cout << endl << endl << endl;
02075                 unitTestResultFailure << eclass.errormsg << endl;
02076         }
02077         //
02078         // Now just test the OSiL parser
02079         try{ 
02080                 cout << endl << "TEST " << ++nOfTest << ":  OSiL parser" << endl << endl;
02081                 clock_t start, finish;
02082                 double duration;
02083                 OSiLWriter *osilwriter = NULL;
02084                 osilwriter = new OSiLWriter();
02085                 //delete fileUtil;
02086                 //fileUtil = NULL;
02087                 //fileUtil = new FileUtil();
02088                 cout << "TEST PARSING A MODEL" << endl;
02089                 cout << "FIRST READ THE FILE INTO A STRING" << endl;
02090                 start = clock();
02091                 osilFileName = dataDir  + "osilFiles" + dirsep + "parincLinear.osil";
02092                 osil = fileUtil->getFileAsString( osilFileName.c_str());
02093                 finish = clock();
02094                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
02095                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
02096                 OSiLReader *osilreader = NULL;
02097                 osilreader = new OSiLReader(); 
02098                 start = clock();
02099                 cout << "PARSE THE OSIL STRING INTO AN OSINSTANCE OBJECT" << endl;
02100                 osilreader->readOSiL( osil);
02101                 //cout << osilwriter->writeOSiL( osilreader->readOSiL( osil)) << endl;
02102                 delete osilreader;
02103                 osilreader = 0;
02104                 delete osilwriter;
02105                 osilwriter = NULL;
02106                 finish = clock();
02107                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
02108                 cout << "Parsing took (seconds): "<< duration << endl;
02109                 unitTestResult << "Successful test of OSiL parser on problem parincLinear.osil" << std::endl;
02110                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
02111         }       
02112                 catch(const ErrorClass& eclass){
02113                 cout << endl << endl << endl;
02114                 cout << eclass.errormsg << endl;
02115                 unitTestResultFailure << "Sorry Unit Test Failed Testing An OSiL Parser" << endl;
02116                 
02117         }       
02118 
02119         //
02120         // Now test the extensions to the OSiL format: <timeDomain>, etc.
02121 
02122         try{ 
02123                 cout << endl << "TEST " << ++nOfTest << ": Stochastic extensions to OSiL" << endl << endl;
02124                 clock_t start, finish;
02125                 double duration;
02126                 OSiLWriter *osilwriter = NULL;
02127                 osilwriter = new OSiLWriter();
02128                 //delete fileUtil;
02129                 //fileUtil = NULL;
02130                 //fileUtil = new FileUtil();
02131                 cout << "\nTEST PARSING A STOCHASTIC MODEL" << endl;
02132                 cout << "FIRST READ THE FILE INTO A STRING" << endl;
02133                 start = clock();
02134                 osilFileName = dataDir  + "osilFiles" + dirsep + "finplan1.osil";
02135                 osil = fileUtil->getFileAsString( &osilFileName[0]);
02136                 finish = clock();
02137                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
02138                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
02139                 OSiLReader *osilreader = NULL;
02140                 osilreader = new OSiLReader(); 
02141                 start = clock();
02142                 cout << "PARSE THE OSIL STRING INTO AN OSINSTANCE OBJECT" << endl;
02143                 osilreader->readOSiL( osil);
02144                 //cout << osilwriter->writeOSiL( osilreader->readOSiL( &osil)) << endl;
02145                 delete osilreader;
02146                 osilreader = 0;
02147                 delete osilwriter;
02148                 osilwriter = NULL;
02149                 finish = clock();
02150                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
02151                 cout << "Parsing took (seconds): "<< duration << endl;
02152                 unitTestResult << "Successful test of OSiL parser on problem finplan1.osil" << std::endl;
02153                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
02154         }       
02155         catch(const ErrorClass& eclass){
02156                 cout << endl << endl << endl;
02157                 cout << eclass.errormsg << endl;
02158                 unitTestResultFailure << "Error parsing an osil file with time domain information" << endl;             
02159         }       
02163         try{ 
02164                 cout << endl << "TEST " << ++nOfTest << ": GET() AND SET() METHODS FOR TimeDomain OBJECT" << endl << endl;
02165                 OSInstance *osinstance = NULL;
02166                 //osinstance = new OSInstance();
02167                 //OSiLReader *osilreader = NULL;
02168                 osilreader = new OSiLReader();
02169                 //create an osinstance
02170                 osinstance = osilreader->readOSiL( osil);
02171                 std::string f = osinstance->getTimeDomainFormat();
02172                 ok = (f == "stages");
02173                 int n = osinstance->getTimeDomainStageNumber();
02174                 ok &= (n == 6);
02175 
02176                 std::string* sncheck = new std::string[6];
02177                 sncheck[0] = "";
02178                 sncheck[1] = "";
02179                 sncheck[2] = "";
02180                 sncheck[3] = "test";
02181                 sncheck[4] = "Wha'zzup?";
02182                 sncheck[5] = "";
02183 
02184                 std::string* sn = osinstance->getTimeDomainStageNames();
02185 
02186                 for (int i = 0; i < 6; i++)
02187                         ok &= (sn[i] == sncheck[i]);
02188 
02189                 int* nv = osinstance->getTimeDomainStageNumberOfVariables();
02190 
02191                 int* nvcheck = new int[6];
02192                 nvcheck[0] = 2;
02193                 nvcheck[1] = 2;
02194                 nvcheck[2] = 0;
02195                 nvcheck[3] = 0;
02196                 nvcheck[4] = 2;
02197                 nvcheck[5] = 2;
02198 
02199                 for (int i = 0; i < 6; i++)
02200                         ok &= (nv[i] == nvcheck[i]);
02201 
02202                 int* nc = osinstance->getTimeDomainStageNumberOfConstraints();
02203 
02204                 int* nccheck = new int[6];
02205                 nccheck[0] = 1;
02206                 nccheck[1] = 1;
02207                 nccheck[2] = 0;
02208                 nccheck[3] = 0;
02209                 nccheck[4] = 1;
02210                 nccheck[5] = 1;
02211 
02212                 for (int i = 0; i < 6; i++)
02213                         ok &= (nc[i] == nccheck[i]);
02214 
02215                 int* no = osinstance->getTimeDomainStageNumberOfObjectives();
02216 
02217                 int* nocheck = new int[6];
02218                 nocheck[0] = 1;
02219                 nocheck[1] = 1;
02220                 nocheck[2] = 1;
02221                 nocheck[3] = 0;
02222                 nocheck[4] = 1;
02223                 nocheck[5] = 1;
02224 
02225                 for (int i = 0; i < 6; i++)
02226                         ok &= (no[i] == nocheck[i]);
02227 
02228                 int** lv = osinstance->getTimeDomainStageVarList();
02229                 int** lc = osinstance->getTimeDomainStageConList();
02230                 int** lo = osinstance->getTimeDomainStageObjList();
02231 
02232                 int** lvcheck = new int*[6];
02233                 int** lccheck = new int*[6];
02234                 int** locheck = new int*[6];
02235                 for (int i = 0; i < 6; i++) {
02236                         lvcheck[i] = new int[2];
02237                         lccheck[i] = new int[2];
02238                         locheck[i] = new int[2];
02239                 };
02240                 lvcheck[0][0] = 0;
02241                 lvcheck[0][1] = 1;
02242                 lvcheck[1][0] = 2;
02243                 lvcheck[1][1] = 3;
02244                 lvcheck[4][0] = 4;
02245                 lvcheck[4][1] = 5;
02246                 lvcheck[5][0] = 6;
02247                 lvcheck[5][1] = 7;
02248                 lccheck[0][0] = 0;
02249                 lccheck[1][0] = 1;
02250                 lccheck[4][0] = 2;
02251                 lccheck[5][0] = 3;
02252                 locheck[0][0] = -1;
02253                 locheck[1][0] = -1;
02254                 locheck[2][0] = -1;
02255                 locheck[4][0] = -1;
02256                 locheck[5][0] = -1;
02257 
02258                 for (int i = 0; i < 6; i++) {
02259                         for (int j = 0; j < nv[i]; j++) 
02260                                 ok &= (lvcheck[i][j] == lv[i][j]);
02261                         for (int j = 0; j < nc[i]; j++) 
02262                                 ok &= (lccheck[i][j] == lc[i][j]);
02263                         for (int j = 0; j < no[i]; j++) 
02264                                 ok &= (locheck[i][j] == lo[i][j]);
02265                 };
02266 
02267                 std::string* sn1 = new std::string[6];
02268                 int* nv1 = new int[6];
02269                 int* nc1 = new int[6];
02270                 int* no1 = new int[6];
02271                 int** lv1 = new int*[6];
02272                 int** lc1 = new int*[6];
02273                 int** lo1 = new int*[6];
02274                 for (int i = 0; i < 6; i++) {
02275                         lv1[i] = new int[2];
02276                         lc1[i] = new int[2];
02277                         lo1[i] = new int[2];
02278                 };
02279                 for (int i = 0; i < 6; i++) {
02280                         sn1[i] = sn[i];
02281                         nv1[i] = nv[i];
02282                         nc1[i] = nc[i];
02283                         no1[i] = no[i];
02284                         for (int j = 0; j < nv[i]; j++) {
02285                                 lv1[i][j] = lv[i][j];
02286                         };
02287                         for (int j = 0; j < nc[i]; j++) {
02288                                 lc1[i][j] = lc[i][j];
02289                         };
02290                         for (int j = 0; j < no[i]; j++) {
02291                                 lo1[i][j] = lo[i][j];
02292                         };
02293                 };
02294 
02295                 ok &= osinstance->setTimeDomain("none");
02296                 n = 0;
02297                 ok &= osinstance->setTimeDomainStages(n,NULL);
02298                 ok &= osinstance->setTimeDomainStages(4,NULL);
02299 
02300                 n = osinstance->getTimeDomainStageNumber();
02301                 ok &= (n == 4);
02302 
02303                 int *nelem, *startIdx, **VI;
02304                 nelem = new int[4];
02305                 startIdx = new int[4];
02306                 VI = new int*[4];
02307                 for (int i = 0; i < 4; i++)
02308                 {       nelem[i] = 2;
02309                         startIdx[i] = 2*i;
02310                         VI[i] = new int[2];
02311                         VI[i][0] = 2*i;
02312                         VI[i][1] = 2*i + 1;
02313                 };
02314                 ok &= osinstance->setTimeDomainStageVariablesUnordered(4,nelem,VI);
02315 
02316                 for (int i = 0; i < 4; i++)
02317                 {       nelem[i] = 1;
02318                         startIdx[i] = i;
02319                 };
02320                 ok &= osinstance->setTimeDomainStageConstraintsOrdered(4,nelem,startIdx);
02321 
02322                 for (int i = 0; i < 4; i++)
02323                 {       nelem[i] = 1;
02324                         startIdx[i] = -1;
02325                 };
02326                 ok &= osinstance->setTimeDomainStageObjectivesOrdered(4,nelem,startIdx);
02327 
02328                 ok &= osinstance->setTimeDomain("none");
02329 
02330                 ok &= osinstance->setTimeDomain("interval");
02331 
02332                 ok &= osinstance->setTimeDomainInterval(0.0, 1.0);
02333                 double lower = osinstance->getTimeDomainIntervalStart();
02334                 ok &= (lower == 0.0);
02335                 double upper = osinstance->getTimeDomainIntervalHorizon();
02336                 ok &= (upper == 1.0);
02337 
02338                 ok &= osinstance->setTimeDomain("none");
02339 
02340                 ok &= osinstance->setTimeDomainStages(6,sncheck);
02341                 ok &= osinstance->setTimeDomainStageVariablesUnordered(6,nvcheck,lvcheck);
02342                 ok &= osinstance->setTimeDomainStageObjectivesUnordered(6,nocheck,locheck);
02343                 ok &= osinstance->setTimeDomainStageConstraintsUnordered(6,nccheck,lccheck);
02344                 int n2 = osinstance->getTimeDomainStageNumber();
02345                 ok &= (n2 == 6);
02346                 std::string* sn2 = osinstance->getTimeDomainStageNames();
02347                 int* nv2 = osinstance->getTimeDomainStageNumberOfVariables();
02348                 int* nc2 = osinstance->getTimeDomainStageNumberOfConstraints();
02349                 int* no2 = osinstance->getTimeDomainStageNumberOfObjectives();
02350                 int** lv2 = osinstance->getTimeDomainStageVarList();
02351                 int** lc2 = osinstance->getTimeDomainStageConList();
02352                 int** lo2 = osinstance->getTimeDomainStageObjList();
02353                 for (int i = 0; i < n2; i++)
02354                 {       ok &= (sn2[i] == sncheck[i]);
02355                         ok &= (nv2[i] == nvcheck[i]);
02356                         ok &= (nc2[i] == nccheck[i]);
02357                         ok &= (no2[i] == nocheck[i]);
02358                         for (int j = 0; j < nv2[i]; j++)
02359                                 ok &= (lv2[i][j] == lvcheck[i][j]);
02360                         for (int j = 0; j < nc2[i]; j++)
02361                                 ok &= (lc2[i][j] == lccheck[i][j]);
02362                         for (int j = 0; j < no2[i]; j++)
02363                                 ok &= (lo2[i][j] == locheck[i][j]);
02364                 };
02365                 delete [] sncheck;
02366                 sncheck = NULL;
02367                 delete [] nvcheck;
02368                 nvcheck = NULL;
02369                 delete [] nccheck;
02370                 nccheck = NULL;
02371                 delete [] nocheck;
02372                 nocheck = NULL;
02373                 for (int i = 0; i < 6; i++) {
02374                         delete [] lvcheck[i];
02375                         delete [] lccheck[i];
02376                         delete [] locheck[i];
02377                         delete [] lv1[i];
02378                         delete [] lc1[i];
02379                         delete [] lo1[i];
02380                 };
02381                 delete [] lvcheck;
02382                 lvcheck = NULL;
02383                 delete [] lccheck;
02384                 lccheck = NULL;
02385                 delete [] locheck;
02386                 locheck = NULL;
02387                 delete [] lv1;
02388                 lv1 = NULL;
02389                 delete [] lc1;
02390                 lc1 = NULL;
02391                 delete [] lo1;
02392                 lo1 = NULL;
02393                 delete [] sn1;
02394                 sn1 = NULL;
02395                 delete[] nv1;
02396                 nv1 = NULL;
02397                 delete[] nc1;
02398                 nc1 = NULL;
02399                 delete[] no1;
02400                 no1 = NULL;
02401                 delete [] nelem;
02402                 nelem = NULL;
02403                 delete [] startIdx;
02404                 startIdx = NULL;
02405                 for (int i = 0; i < 4; i++) {
02406                         delete [] VI[i];
02407                 };
02408                 delete [] VI;
02409                 VI = NULL;
02410                 delete osilreader;
02411                 unitTestResult << "Successful test of osinstance get() and set() methods" << std::endl;
02412                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
02413         }       
02414         catch(const ErrorClass& eclass){
02415                 cout << endl << endl << endl;
02416                 cout << eclass.errormsg << endl;
02417                 unitTestResultFailure << "Sorry Unit Test Failed osinstance get() and set() Methods" << endl;           
02418         }       
02419 //#endif
02420         //
02421         // Now test the OSoL parser
02422         OSoLWriter *osolwriter = NULL;
02423 //      OSoLReader *osolreader = NULL;
02424         //osolwriter = new OSoLWriter();
02425         //osolreader = new OSoLReader();
02426 
02427         try{ 
02441                 cout << endl << "TEST " << ++nOfTest << ": OSoL parser" << endl << endl;
02442                 std::string tmpOSoL;
02443                 clock_t start, finish;
02444                 double duration;
02445                 osolwriter = new OSoLWriter();
02446                 osolreader = new OSoLReader();
02447                 OSOption *osoption = NULL;
02448                 //osoption = new OSOption(); 
02449                 cout << "TEST PARSING AN OSoL FILE" << endl;
02450                 cout << "FIRST READ THE OSoL FILE INTO A STRING" << endl;
02451                 osolFileName = dataDir  + "osolFiles" + dirsep + "parsertest.osol"; 
02452                 start = clock();
02453                 std::string osol = fileUtil->getFileAsString( osolFileName.c_str() );
02454                 finish = clock();
02455                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
02456                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
02457                 start = clock();
02458                 cout << "PARSE THE OSOL STRING INTO AN OSOPTION OBJECT" << endl;
02459                 osoption = osolreader->readOSoL( osol);
02460 
02461                 //Pad all the arrays
02462                 cout << endl << "Test the add() methods" << endl;
02463                 
02464                 ok = osoption->setAnOtherGeneralOption("testing","one","two  three");
02465                 ok = osoption->setOtherSystemOptions(0,NULL) && ok; 
02466                 ok = osoption->setAnOtherSystemOption("Ho Ho Ho","","") && ok;
02467                 ok = osoption->setAnOtherServiceOption("OneMore","Option","To Go") && ok;
02468                 ok = osoption->setAnotherJobDependency("DoReMi") && ok;
02469                 ok = osoption->setAnotherRequiredDirectory("C:\\MSYS") && ok;
02470                 ok = osoption->setAnotherRequiredFile("C:\\MSYS\\junk.tmp") && ok;
02471                 ok = osoption->setAnotherDirectoryToMake("C:\\tempdir") && ok;
02472                 ok = osoption->setAnotherFileToMake("C:\\tempdir\\temp.tmp") && ok;
02473                 ok = osoption->setAnotherInputDirectoryToMove("C:\\tempdir","C:\\OS\\calc",true) && ok;
02474                 ok = osoption->setAnotherInputFileToMove("C:\\OS\\parinc.osil","C:\\OS\\calc\\input.osil",true) && ok;
02475                 ok = osoption->setAnotherOutputFileToMove("C:\\OS\\calc\\putput.osrl","C:\\OS\\parinc.osol",false) && ok;
02476                 ok = osoption->setAnotherOutputDirectoryToMove("C:\\OS\\calc","C:\\OS\\save",false) && ok;
02477                 ok = osoption->setAnotherFileToDelete("C:\\OS\\calc\\input.osil") && ok;
02478                 ok = osoption->setAnotherDirectoryToDelete("C:\\tempdir") && ok;
02479                 ok = osoption->setAnotherProcessToKill("ABC123") && ok;
02480                 ok = osoption->setAnOtherJobOption("DoReMi","ABC","One Two Three") && ok;
02481                 ok = osoption->setAnotherInitVarValue(5,12.3) && ok;
02482                 ok = osoption->setAnotherInitVarValueString(6,"BLUE") && ok;
02483                 ok = osoption->setAnotherInitBasisStatus(6,"unknown") && ok;
02484                 ok = osoption->setAnotherIntegerVariableBranchingWeight(5,100.) && ok;
02485 
02486                 int SOS3idx[2];
02487                 double SOS3val[2];
02488                 SOS3idx[0] = 3;
02489                 SOS3idx[1] = 6;
02490                 SOS3val[0] = 1.0;
02491                 SOS3val[1] = 2.0;
02492                 int tnvar = osoption->getNumberOfSOS(); 
02493                 ok = osoption->setAnotherSOSVariableBranchingWeight(3,2,1.0,SOS3idx,SOS3val) && ok;
02494                 assert (osoption->getNumberOfSOS() == (tnvar + 1));
02495                 assert (osoption->optimization->variables->sosVariableBranchingWeights->sos[tnvar]->var[0]->idx == 3);
02496                 assert (osoption->optimization->variables->sosVariableBranchingWeights->sos[tnvar]->var[1]->idx == 6);
02497                 assert (osoption->optimization->variables->sosVariableBranchingWeights->sos[tnvar]->var[0]->value == 1.0);
02498                 assert (osoption->optimization->variables->sosVariableBranchingWeights->sos[tnvar]->var[1]->value == 2.0);
02499 #ifdef DEBUG
02500                 cout << endl << "another SOS has been added" << endl << endl;
02501 #endif
02502 
02503                 OtherVariableOption *varopt;
02504                 varopt = new OtherVariableOption();
02505                 varopt->name = "testVarOpt";
02506                 varopt->numberOfVar = 0;
02507                 ok = osoption->setAnOtherVariableOption(varopt) && ok;
02508                 delete varopt;
02509                 varopt = NULL;
02510 
02511                 OtherObjectiveOption *objopt;
02512                 objopt = new OtherObjectiveOption();
02513                 objopt->name = "testObjOpt";
02514                 objopt->numberOfObj = 0;
02515                 ok = osoption->setAnOtherObjectiveOption(objopt) && ok;
02516                 delete objopt;
02517                 objopt = NULL;
02518 
02519                 ok = osoption->setAnotherInitConValue(2,17.0) && ok;
02520                 ok = osoption->setAnotherInitDualVarValue(2,0.0,DBL_MAX) && ok;
02521 
02522                 OtherConstraintOption *conopt;
02523                 conopt = new OtherConstraintOption();
02524                 conopt->name = "testObjOpt";
02525                 conopt->numberOfCon = 2;
02526                 conopt->con = new OtherConOption*[2];
02527                 conopt->con[0] = new OtherConOption();
02528                 conopt->con[0]->idx = 0;
02529                 conopt->con[0]->value = "3.0";
02530                 conopt->con[1] = new OtherConOption();
02531                 conopt->con[1]->idx = 1;
02532                 conopt->con[1]->lbValue = "0.0";
02533                 conopt->con[1]->ubValue = "10.0";
02534                 ok = osoption->setAnOtherConstraintOption(conopt) && ok;
02535                 delete conopt;
02536                 conopt = NULL;
02537 
02538                 ok = osoption->setAnotherSolverOption("HoHum","gus","PhoNY","","test","") && ok;
02539 
02540                 if (!ok)
02541                         throw ErrorClass(" Could not add to osoption data structure");
02542 
02543                 //Now transfer to another osoption using get() and set() methods
02544                 std::string optionstring;
02545                 int option_i;
02546                 double option_d;
02547                 OSOption* osoption2 = new OSOption();
02548 
02549                 cout << endl << "transfer osoption to another OSOption object" << endl;
02550 
02551                 optionstring = osoption->getServiceURI();
02552                 ok = osoption2->setServiceURI(optionstring);
02553 #ifdef DEBUG
02554                 if (!ok)
02555                         throw ErrorClass(" error in get/set ServiceURI");
02556 #endif
02557 
02558                 optionstring = osoption->getServiceName();
02559                 ok = osoption2->setServiceName(optionstring) && ok;
02560 #ifdef DEBUG
02561                 if (!ok)
02562                         throw ErrorClass(" error in get/set ServiceName");
02563 #endif
02564 
02565                 optionstring = osoption->getInstanceName();
02566                 ok = osoption2->setInstanceName(optionstring) && ok;
02567 #ifdef DEBUG
02568                 if (!ok)
02569                         throw ErrorClass(" error in get/set InstanceName");
02570 #endif
02571 
02572                 optionstring = osoption->getInstanceLocation();
02573                 ok = osoption2->setInstanceLocation(optionstring) && ok;
02574 #ifdef DEBUG
02575                 if (!ok)
02576                         throw ErrorClass(" error in get/set InstanceLocation");
02577 #endif
02578 
02579                 optionstring = osoption->getInstanceLocationType();
02580                 ok = osoption2->setInstanceLocationType(optionstring) && ok;
02581 #ifdef DEBUG
02582                 if (!ok)
02583                         throw ErrorClass(" error in get/set InstanceLocationtype");
02584 #endif
02585 
02586                 optionstring = osoption->getJobID();
02587                 ok = osoption2->setJobID(optionstring) && ok;
02588 #ifdef DEBUG
02589                 if (!ok)
02590                         throw ErrorClass(" error in get/set JobID");
02591 #endif
02592 
02593                 optionstring = osoption->getSolverToInvoke();
02594                 ok = osoption2->setSolverToInvoke(optionstring) && ok;
02595 #ifdef DEBUG
02596                 if (!ok)
02597                         throw ErrorClass(" error in get/set SolverToInvoke");
02598 #endif
02599 
02600                 optionstring = osoption->getInstanceLocationType();
02601                 ok = osoption2->setInstanceLocationType(optionstring) && ok;
02602 #ifdef DEBUG
02603                 if (!ok)
02604                         throw ErrorClass(" error in get/set InstanceLocationType");
02605 #endif
02606 
02607                 optionstring = osoption->getUserName();
02608                 ok = osoption2->setUserName(optionstring) && ok;
02609 #ifdef DEBUG
02610                 if (!ok)
02611                         throw ErrorClass(" error in get/set UserName");
02612 #endif
02613 
02614                 optionstring = osoption->getPassword();
02615 #ifdef DEBUG
02616                 if (!ok)
02617                         throw ErrorClass(" error in get/set Password");
02618 #endif
02619                 ok = osoption2->setPassword(optionstring) && ok;
02620 
02621                 optionstring = osoption->getContact();
02622                 ok = osoption2->setContact(optionstring) && ok;
02623 #ifdef DEBUG
02624                 if (!ok)
02625                         throw ErrorClass(" error in get/set Contact");
02626 #endif
02627                 
02628                 optionstring = osoption->getContactTransportType();
02629                 ok = osoption2->setContactTransportType(optionstring) && ok;
02630 #ifdef DEBUG
02631                 if (!ok)
02632                         throw ErrorClass(" error in get/set TransportType");
02633 #endif
02634 
02635                 int nopt;
02636                 OtherOption** otherOpt;
02637                 nopt = osoption->getNumberOfOtherGeneralOptions();
02638                 otherOpt = osoption->getOtherGeneralOptions();
02639                 ok = osoption2->setOtherGeneralOptions(nopt, otherOpt) && ok;
02640 #ifdef DEBUG
02641                 if (!ok)
02642                         throw ErrorClass(" error in get/set OtherGeneralOption");
02643 #endif
02644 
02645                 option_d = osoption->getMinDiskSpace();
02646                 ok = osoption2->setMinDiskSpace(option_d) && ok;
02647 #ifdef DEBUG
02648                 if (!ok)
02649                         throw ErrorClass(" error in get/set MinDiskSpace");
02650 #endif
02651 
02652                 optionstring = osoption->getMinDiskSpaceUnit();
02653                 ok = osoption2->setMinDiskSpaceUnit(optionstring) && ok;
02654 #ifdef DEBUG
02655                 if (!ok)
02656                         throw ErrorClass(" error in get/set MinDiskSpaceUnit");
02657 #endif
02658 
02659                 option_d = osoption->getMinMemorySize();
02660                 ok = osoption2->setMinMemorySize(option_d) && ok;
02661 #ifdef DEBUG
02662                 if (!ok)
02663                         throw ErrorClass(" error in get/set MinMemorySize");
02664 #endif
02665 
02666                 optionstring = osoption->getMinMemoryUnit();
02667                 ok = osoption2->setMinMemoryUnit(optionstring) && ok;
02668 #ifdef DEBUG
02669                 if (!ok)
02670                         throw ErrorClass(" error in get/set MinMemoryUnit");
02671 #endif
02672 
02673                 option_d = osoption->getMinCPUSpeed();
02674                 ok = osoption2->setMinCPUSpeed(option_d) && ok;
02675 #ifdef DEBUG
02676                 if (!ok)
02677                         throw ErrorClass(" error in get/set MinCPUSpeed");
02678 #endif
02679 
02680                 optionstring = osoption->getMinCPUSpeedUnit();
02681                 ok = osoption2->setMinCPUSpeedUnit(optionstring) && ok;
02682 #ifdef DEBUG
02683                 if (!ok)
02684                         throw ErrorClass(" error in get/set MinCPUSpeedUnit");
02685 #endif
02686 
02687                 option_i = osoption->getMinCPUNumber();
02688                 ok = osoption2->setMinCPUNumber(option_i) && ok;
02689 #ifdef DEBUG
02690                 if (!ok)
02691                         throw ErrorClass(" error in get/set MinCPUNumber");
02692 #endif
02693 
02694                 OtherOption** otherOpt2;
02695                 nopt = osoption->getNumberOfOtherSystemOptions();
02696                 otherOpt2 = osoption->getOtherSystemOptions();
02697                 ok = osoption2->setOtherSystemOptions(nopt, otherOpt2) && ok;
02698 #ifdef DEBUG
02699                 if (!ok)
02700                         throw ErrorClass(" error in get/set OtherSystemOptions");
02701 #endif
02702 
02703 
02704                 optionstring = osoption->getServiceType();
02705                 ok = osoption2->setServiceType(optionstring) && ok;
02706 #ifdef DEBUG
02707                 if (!ok)
02708                         throw ErrorClass(" error in get/set ServiceType");
02709 #endif
02710 
02711                 OtherOption** otherOpt3;
02712                 nopt = osoption->getNumberOfOtherServiceOptions();
02713                 otherOpt3 = osoption->getOtherServiceOptions();
02714                 ok = osoption2->setOtherServiceOptions(nopt, otherOpt3) && ok;
02715 #ifdef DEBUG
02716                 if (!ok)
02717                         throw ErrorClass(" error in get/set OtherServiceOptions");
02718 #endif
02719 
02720 
02721                 option_d = osoption->getMaxTime();
02722                 ok = osoption2->setMaxTime(option_d) && ok;
02723 #ifdef DEBUG
02724                 if (!ok)
02725                         throw ErrorClass(" error in get/set MaxTime");
02726 #endif
02727 
02728                 optionstring = osoption->getMaxTimeUnit();
02729                 ok = osoption2->setMaxTimeUnit(optionstring) && ok;
02730 #ifdef DEBUG
02731                 if (!ok)
02732                         throw ErrorClass(" error in get/set MaxTimeUnit");
02733 #endif
02734 
02735                 optionstring = osoption->getRequestedStartTime();
02736                 ok = osoption2->setRequestedStartTime(optionstring) && ok;
02737 #ifdef DEBUG
02738                 if (!ok)
02739                         throw ErrorClass(" error in get/set RequestedStartTime");
02740 #endif
02741 
02742                 nopt = osoption->getNumberOfJobDependencies();
02743                 std::string* tJobID = osoption->getJobDependencies();
02744                 ok = osoption2->setJobDependencies(nopt, tJobID) && ok;
02745 #ifdef DEBUG
02746                 if (!ok)
02747                         throw ErrorClass(" error in get/set JobDependencies");
02748 #endif
02749 
02750                 nopt = osoption->getNumberOfRequiredDirectories();
02751                 std::string* reqDir = osoption->getRequiredDirectories();
02752                 ok = osoption2->setRequiredDirectories(nopt, reqDir) && ok;
02753 #ifdef DEBUG
02754                 if (!ok)
02755                         throw ErrorClass(" error in get/set RequiredDirectories");
02756 #endif
02757 
02758                 nopt = osoption->getNumberOfRequiredFiles();
02759                 std::string* reqFil = osoption->getRequiredFiles();
02760                 ok = osoption2->setRequiredFiles(nopt, reqFil) && ok;
02761 #ifdef DEBUG
02762                 if (!ok)
02763                         throw ErrorClass(" error in get/set RequiredFiles");
02764 #endif
02765 
02766                 nopt = osoption->getNumberOfDirectoriesToMake();
02767                 std::string* mkDir = osoption->getDirectoriesToMake();
02768                 ok = osoption2->setDirectoriesToMake(nopt, mkDir) && ok;
02769 #ifdef DEBUG
02770                 if (!ok)
02771                         throw ErrorClass(" error in get/set DirectoriesToMake");
02772 #endif
02773 
02774                 nopt = osoption->getNumberOfFilesToMake();
02775                 std::string* mkFil = osoption->getFilesToMake();
02776                 ok = osoption2->setFilesToMake(nopt, mkFil) && ok;
02777 #ifdef DEBUG
02778                 if (!ok)
02779                         throw ErrorClass(" error in get/set FilesToMake");
02780 #endif
02781 
02782                 nopt = osoption->getNumberOfInputDirectoriesToMove();
02783                 PathPair** inDMv = osoption->getInputDirectoriesToMove();
02784                 ok = osoption2->setInputDirectoriesToMove(nopt, inDMv) && ok;
02785 #ifdef DEBUG
02786                 if (!ok)
02787                         throw ErrorClass(" error in get/set InputDirectoriesToMove");
02788 #endif
02789 
02790                 nopt = osoption->getNumberOfInputFilesToMove();
02791                 PathPair** inFMv = osoption->getInputFilesToMove();
02792                 ok = osoption2->setInputFilesToMove(nopt, inFMv) && ok;
02793 #ifdef DEBUG
02794                 if (!ok)
02795                         throw ErrorClass(" error in get/set InputFilesToMove");
02796 #endif
02797 
02798                 nopt = osoption->getNumberOfOutputFilesToMove();
02799                 PathPair** outFMv = osoption->getOutputFilesToMove();
02800                 ok = osoption2->setOutputFilesToMove(nopt, outFMv) && ok;
02801 #ifdef DEBUG
02802                 if (!ok)
02803                         throw ErrorClass(" error in get/set OutputFilesToMove");
02804 #endif
02805 
02806                 nopt = osoption->getNumberOfOutputDirectoriesToMove();
02807                 PathPair** outDMv = osoption->getOutputDirectoriesToMove();
02808                 ok = osoption2->setOutputDirectoriesToMove(nopt, outDMv) && ok;
02809 #ifdef DEBUG
02810                 if (!ok)
02811                         throw ErrorClass(" error in get/set OutputDirectoriesToMove");
02812 #endif
02813 
02814                 nopt = osoption->getNumberOfFilesToDelete();
02815                 std::string* rmFil = osoption->getFilesToDelete();
02816                 ok = osoption2->setFilesToDelete(nopt, rmFil) && ok;
02817 #ifdef DEBUG
02818                 if (!ok)
02819                         throw ErrorClass(" error in get/set FilesToDelete");
02820 #endif
02821 
02822                 nopt = osoption->getNumberOfDirectoriesToDelete();
02823                 std::string* rmDir = osoption->getDirectoriesToDelete();
02824                 ok = osoption2->setDirectoriesToDelete(nopt, rmDir) && ok;
02825 #ifdef DEBUG
02826                 if (!ok)
02827                         throw ErrorClass(" error in get/set DirectoriesToDelete");
02828 #endif
02829 
02830                 nopt = osoption->getNumberOfProcessesToKill();
02831                 std::string* rmProc = osoption->getProcessesToKill();
02832                 ok = osoption2->setProcessesToKill(nopt, rmProc) && ok;
02833 #ifdef DEBUG
02834                 if (!ok)
02835                         throw ErrorClass(" error in get/set ProcessesToKill");
02836 #endif
02837 
02838                 OtherOption** otherOpt4;
02839                 nopt = osoption->getNumberOfOtherJobOptions();
02840                 otherOpt4 = osoption->getOtherJobOptions();
02841                 ok = osoption2->setOtherJobOptions(nopt, otherOpt4) && ok;
02842 #ifdef DEBUG
02843                 if (!ok)
02844                         throw ErrorClass(" error in get/set OtherJobOptions");
02845 #endif
02846 
02847                 int nvar, nobj, ncon;
02848                 nvar = osoption->getOptionInt("numberOfVariables");
02849                 ok = osoption2->setNumberOfVariables(nvar) && ok;
02850                 nobj = osoption->getOptionInt("numberOfObjectives");
02851                 ok = osoption2->setNumberOfObjectives(nobj) && ok;
02852                 ncon = osoption->getOptionInt("numberOfConstraints");
02853                 ok = osoption2->setNumberOfConstraints(ncon) && ok;
02854 #ifdef DEBUG
02855                 if (!ok)
02856                         throw ErrorClass(" error in get/set problem dimensions");
02857 #endif
02858  
02859 // for the variables, objectives and constraints use a mixture of dense and sparse methods
02860                 double* IVV;
02861                 IVV = osoption->getInitVarValuesDense();
02862                 ok = osoption2->setInitVarValuesDense(nvar, IVV) && ok;
02863 #ifdef DEBUG
02864                 if (!ok)
02865                         throw ErrorClass(" error in get/set InitVarValues");
02866 #endif
02867 
02868                 nopt = osoption->getNumberOfInitVarValuesString();
02869                 InitVarValueString** IVV2;
02870                 IVV2 = osoption->getInitVarValuesStringSparse();
02871                 ok = osoption2->setInitVarValuesStringSparse(nopt, IVV2) && ok;         
02872 #ifdef DEBUG
02873                 if (!ok)
02874                         throw ErrorClass(" error in get/set InitVarValuesString");
02875 #endif
02876 
02877                 std::string*  IBS;
02878                 IBS = osoption->getInitBasisStatusDense();
02879                 ok = osoption2->setInitBasisStatusDense(nvar, IBS) && ok;               
02880 #ifdef DEBUG
02881                 if (!ok)
02882                         throw ErrorClass(" error in get/set InitBasisStatus");
02883 #endif
02884 
02885                 double* IVBW;
02886                 IVBW = osoption->getIntegerVariableBranchingWeightsDense();
02887                 ok = osoption2->setIntegerVariableBranchingWeightsDense(nvar, IVBW) && ok;              
02888 #ifdef DEBUG
02889                 if (!ok)
02890                         throw ErrorClass(" error in get/set IntegerVariableBranchingWeights");
02891 #endif
02892 
02893                 SOSWeights** sos;
02894                 sos = osoption->getSOSVariableBranchingWeightsSparse();
02895                 nopt = osoption->getNumberOfSOS();
02896                 ok = osoption2->setSOSVariableBranchingWeights(nopt, sos) && ok;
02897 #ifdef DEBUG
02898                 if (!ok)
02899                         throw ErrorClass(" error in get/set SOSVariableBranchingWeights");
02900 #endif
02901 
02902                 OtherVariableOption** otherV;
02903                 otherV = osoption->getAllOtherVariableOptions();
02904                 nopt = osoption->getNumberOfOtherVariableOptions();
02905                 ok = osoption2->setOtherVariableOptions(nopt, otherV) && ok;
02906 #ifdef DEBUG
02907                 if (!ok)
02908                         throw ErrorClass(" error in get/set OtherVariableOptions");
02909 #endif
02910 
02911                 double* IOV;
02912                 IOV = osoption->getInitObjValuesDense();
02913                 ok = osoption2->setInitObjValuesDense(nobj, IOV) && ok;         
02914 #ifdef DEBUG
02915                 if (!ok)
02916                         throw ErrorClass(" error in get/set InitObjValues");
02917 #endif
02918 
02919                 nopt = osoption->getNumberOfInitObjBounds();
02920                 InitObjBound** IOB;
02921                 IOB = osoption->getInitObjBoundsSparse();
02922                 ok = osoption2->setInitObjBoundsSparse(nopt, IOB) && ok;                
02923 #ifdef DEBUG
02924                 if (!ok)
02925                         throw ErrorClass(" error in get/set InitObjBounds");
02926 #endif
02927 
02928                 OtherObjectiveOption** otherO;
02929                 otherO = osoption->getAllOtherObjectiveOptions();
02930                 nopt = osoption->getNumberOfOtherObjectiveOptions();
02931                 ok = osoption2->setOtherObjectiveOptions(nopt, otherO) && ok;
02932 #ifdef DEBUG
02933                 if (!ok)
02934                         throw ErrorClass(" error in get/set OtherObjectiveOptions");
02935 #endif
02936 
02937                 
02938                 double* ICV;
02939                 ICV = osoption->getInitConValuesDense();
02940                 ok = osoption2->setInitConValuesDense(ncon, ICV) && ok;         
02941 #ifdef DEBUG
02942                 if (!ok)
02943                         throw ErrorClass(" error in get/set InitConValues");
02944 #endif
02945 
02946                 nopt = osoption->getNumberOfInitDualVarValues();
02947                 InitDualVarValue** IDV;
02948                 IDV = osoption->getInitDualVarValuesSparse();
02949                 ok = osoption2->setInitDualVarValuesSparse(nopt, IDV) && ok;            
02950 #ifdef DEBUG
02951                 if (!ok)
02952                         throw ErrorClass(" error in get/set InitDualVarValues");
02953 #endif
02954 
02955                 OtherConstraintOption** otherC;
02956                 otherC = osoption->getAllOtherConstraintOptions();
02957                 nopt = osoption->getNumberOfOtherConstraintOptions();
02958                 ok = osoption2->setOtherConstraintOptions(nopt, otherC) && ok;
02959 #ifdef DEBUG
02960                 if (!ok)
02961                         throw ErrorClass(" error in get/set OtherConstraintOptions");
02962 #endif
02963 
02964                 SolverOption** SO;
02965                 SO = osoption->getAllSolverOptions();
02966                 nopt = osoption->getNumberOfSolverOptions();
02967                 ok = osoption2->setSolverOptions(nopt, SO) && ok;
02968 #ifdef DEBUG
02969                 if (!ok)
02970                         throw ErrorClass(" error in get/set SolverOptions");
02971 #endif
02972 
02973                 ok = osoption->IsEqual(osoption2) && ok;
02974                 if (!ok)
02975                         throw ErrorClass(" OSOption get() and  set() methods do not work correctly");
02976 
02977                 cout << endl << "delete osoption2" << endl;
02978                 delete osoption2;
02979                 osoption2 = NULL;
02980                 cout << "osoption2 deleted" << endl << endl;
02981 
02982                 cout << "Write the content to a new file" <<endl;               
02983                 tmpOSoL = osolwriter->writeOSoL( osoption);
02984                 cout << endl << "Here is tmpOSoL:" <<endl;
02985                 cout << endl << endl << tmpOSoL << endl;
02986                 cout << "-----------------------------------------" << endl << endl;
02987 //              delete osolreader;
02988 //              osolreader = NULL;
02989 
02990                 // make sure we can parse without error
02991                 OSoLReader *osolreader2;
02992                 osolreader2 = new OSoLReader();
02993                 cout << "Read the string back" << endl;
02994 
02995                 OSOption *osoption3 = NULL;
02996                 osoption3 = osolreader2->readOSoL( tmpOSoL);
02997 
02998                 ok = osoption->IsEqual(osoption3);
02999                 if (!ok)
03000                         throw ErrorClass(" Loss of information in OSoL write/read");
03001                 delete osolreader2;
03002                 osolreader2 = NULL;
03003 
03004 
03005                 delete osolwriter;
03006                 osolwriter = NULL;
03007                 delete osolreader;
03008                 osolreader = NULL;
03009                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
03010 
03011 
03012                 // now a second example
03013                 cout << endl << "TEST " << ++nOfTest << ": Parse another .osol file" << endl << endl;
03014                 osolwriter = new OSoLWriter();
03015                 osolreader = new OSoLReader();
03016                 cout << "First read the OSoL file into a string" << endl;
03017                 osolFileName = dataDir  + "osolFiles" + dirsep + "parsertest2.osol"; 
03018                 osol = fileUtil->getFileAsString( osolFileName.c_str() );
03019                 finish = clock();
03020                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
03021                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
03022                 cout << "Parse the OSoL string into an OSOption object" << endl;
03023                 osoption = osolreader->readOSoL( osol);
03024                 tmpOSoL = osolwriter->writeOSoL( osoption) ;
03025                 delete osolreader;
03026                 osolreader = NULL;
03027                 osolreader = new OSoLReader();
03028                 osolreader->readOSoL( tmpOSoL);
03029                 delete osolwriter;
03030                 osolwriter = NULL;
03031                 delete osolreader;
03032                 osolreader = NULL;
03033 
03034                 // and a third example
03035                 cout << "Test parsing another OSoL file" << endl;
03036                 osolwriter = new OSoLWriter();
03037                 osolreader = new OSoLReader();
03038                 cout << "First read the OSoL file into a string" << endl;
03039                 osolFileName = dataDir  + "osolFiles" + dirsep + "parsertest3.osol"; 
03040                 osol = fileUtil->getFileAsString( osolFileName.c_str() );
03041                 finish = clock();
03042                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
03043                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
03044                 cout << "Parse the OSoL string into an OSOption object" << endl;
03045                 osoption = osolreader->readOSoL( osol);
03046                 tmpOSoL = osolwriter->writeOSoL( osoption) ;
03047                 delete osolreader;
03048                 osolreader = NULL;
03049                 osolreader = new OSoLReader();
03050                 osolreader->readOSoL( tmpOSoL);
03051                 delete osolwriter;
03052                 osolwriter = NULL;
03053                 delete osolreader;
03054                 osolreader = NULL;
03055 
03056 
03057                 // a trivial string
03058                 cout << "Test parsing a trivial string" << endl;
03059                 osolreader = new OSoLReader();
03060                 osol = "<osol></osol>";
03061                 cout << "Parse the OSoL string into an OSOption object" << endl;
03062                 osoption = osolreader->readOSoL( osol);
03063                 delete osolreader;
03064                 osolreader = NULL;
03065 
03066 
03067                 unitTestResult << 
03068                      "Successful test of OSoL parser on file parsertest.osol" 
03069                       << std::endl;
03070                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
03071 
03072 
03073         }       
03074         
03075                 catch(const ErrorClass& eclass){
03076                 cout << endl << endl << endl;
03077                 if(osolwriter != NULL) delete osolwriter;
03078                 if(osolreader != NULL) delete osolreader;
03079                 // " Problem with the test reading OSoL data";
03080                 unitTestResultFailure << eclass.errormsg << endl;
03081                 unitTestResultFailure << "There was a failure in the test for reading OSoL" << endl;
03082         }
03083 
03084 
03085 
03086         //
03087         // Now just test the OSrL parser
03088         try{ 
03097                 cout << endl << "TEST " << ++nOfTest << ": OSrL parser" << endl << endl;
03098                 std::string tmpOSrL;
03099                 clock_t start, finish;
03100                 double duration;
03101                 osrlwriter = new OSrLWriter();
03102                 osrlreader = new OSrLReader();
03103                 OSResult *osresult = NULL;
03104                 //osresult = new OSResult(); 
03105                 cout << "TEST PARSING AN OSrL FILE" << endl;
03106                 cout << "FIRST READ THE OSrL FILE INTO A STRING" << endl;
03107 //              osrlFileName = dataDir  + "osrlFiles" + dirsep + "parincLinear.osrl"; 
03108                 osrlFileName = dataDir  + "osrlFiles" + dirsep + "parserTest.osrl"; 
03109                 start = clock();
03110                 std::string osrl = fileUtil->getFileAsString( osrlFileName.c_str() );
03111                 finish = clock();
03112                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
03113                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
03114                 cout << osrl << endl;
03115                 start = clock();
03116                 cout << "PARSE THE OSRL STRING INTO AN OSRESULT OBJECT" << endl;
03117                 osresult = osrlreader->readOSrL( osrl);
03118                 cout << "Finished read; write OSResult object to temporary string" << endl;
03119                 tmpOSrL = osrlwriter->writeOSrL( osresult) ;
03120                 cout << tmpOSrL << endl;
03121                 // make sure we can parse without error
03122                 delete osrlreader;
03123                 osrlreader = NULL;
03124                 osrlreader = new OSrLReader();
03125                 cout << "Parse temporary string" << endl;
03126                 osrlreader->readOSrL( tmpOSrL);
03127                 delete osrlwriter;
03128                 osrlwriter = NULL;
03129                 delete osrlreader;
03130                 osrlreader = NULL;
03131 /*
03132                 // now a second example
03133                 cout << endl << "TEST PARSING ANOTHER OSrL FILE" << endl;
03134                 osrlwriter = new OSrLWriter();
03135                 osrlreader = new OSrLReader();
03136                 cout << "FIRST READ THE OSrL FILE INTO A STRING" << endl;
03137                 //errorExample.osrl -- check to see if we read an error message correct;
03138                 osrlFileName = dataDir  + "osrlFiles" + dirsep + "errorExample.osrl"; 
03139                 osrl = fileUtil->getFileAsString( osrlFileName.c_str() );
03140                 finish = clock();
03141                 duration = (double) (finish - start) / CLOCKS_PER_SEC;
03142                 cout << "Reading the file into a string took (seconds): "<< duration << endl;
03143                 cout << "PARSE THE OSRL STRING INTO AN OSRESULT OBJECT" << endl;
03144                 osresult = osrlreader->readOSrL( osrl);
03145                 tmpOSrL = osrlwriter->writeOSrL( osresult) ;
03146                 delete osrlreader;
03147                 osrlreader = NULL;
03148                 osrlreader = new OSrLReader();
03149                 osrlreader->readOSrL( tmpOSrL);
03150                 delete osrlwriter;
03151                 osrlwriter = NULL;
03152                 delete osrlreader;
03153                 osrlreader = NULL;
03154 */
03155                 unitTestResult << 
03156                      "Successful test of OSrL parser on problems parincLinear.osrl and errorExample.osrl" 
03157                       << std::endl;
03158                 cout << endl << "TEST " << nOfTest << ": Completed successfully" << endl << endl;
03159         }       
03160                 catch(const ErrorClass& eclass){
03161                 cout << endl << endl << endl;
03162                 if(osrlwriter != NULL) delete osrlwriter;
03163                 if(osrlreader != NULL) delete osrlreader;
03164                 // " Problem with the test reading OSrL data";
03165                 unitTestResultFailure << eclass.errormsg << endl;
03166                 unitTestResultFailure << "There was a failure in the test for reading OSrL" << endl;
03167         }
03168 
03169 
03170 
03171 
03172 
03173 #endif       // COMPONENT_DEBUG
03174 
03175                 
03176                 
03177                 
03178                 
03179 // 
03180         delete fileUtil;
03181         fileUtil = NULL;
03182             
03183         if(unitTestResultFailure.str().length() > 0){
03184                 cout << endl << "THE UNIT TEST PASSED THE FOLLOWING:" << endl << endl;
03185                 cout << unitTestResult.str() << endl << endl;
03186                 cout << "UNFORTUNATELY, YOU FAILED ON THE FOLLOWING:" << endl << endl;
03187                 cout << unitTestResultFailure.str() << endl << endl;
03188                 cout << "Conclusion: FAILURE" << endl;
03189                 return 1;
03190         }
03191         else{
03192                 cout << endl << "THE UNIT TEST PASSED THE FOLLOWING:" << endl << endl;
03193                 cout << unitTestResult.str() << endl << endl;
03194                 cout << "All tests completed successfully" <<  endl <<  endl;
03195                 return 0;
03196         }
03197 }//end main
03198 
03199 double getObjVal( std::string osrl){
03200         std::string sObjVal;
03201         double dObjVal;
03202         string::size_type pos2;
03203         string::size_type pos1 = osrl.find( "<obj ");
03204         if(pos1 != std::string::npos){
03205                 // get the end of the obj start tag
03206                 pos1 = osrl.find(">", pos1 + 1);
03207                 if(pos1 != std::string::npos){
03208                         // get the start of obj end tag
03209                         pos2 = osrl.find( "</obj", pos1 + 1);
03210                         if( pos2 != std::string::npos){
03211                                 // get the substring
03212                                 sObjVal = osrl.substr( pos1 + 1, pos2 - pos1 - 1);
03213                                 //std::cout << "HERE IS THE OBJECTIVE FUNCTION VALUE SUBSTRING  " << sObjVal<< std::endl; 
03214                                 // return dObjVal = strtod(sObjVal.c_str(), NULL);
03215                                 return dObjVal = os_strtod(sObjVal.c_str(), NULL); 
03216                         }
03217                         else return OSNAN;
03218                 }
03219                 else return OSNAN;
03220         }
03221         else return OSNAN;
03222 }

Generated on Tue Mar 30 03:04:43 2010 by  doxygen 1.4.7