src/pmml/Test/PMMLBasicsTest1.cxx

   1 // Copyright (C) 2007-2023  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : InckA
  20
  21
  22 #include "PMMLBasicsTest1.hxx"
  23 #include "PMMLlib.hxx"
  24 #include "tools.hxx"
  25
  26 using namespace std;
  27
  28 void PMMLBasicsTest1::setUp()
  29 {
  30     resourcesDir = "samples/";
  31 #ifdef WIN32
  32     const char* user = std::getenv("USERPROFILE");
  33     std::string strUser("");
  34     if (user)
  35         strUser = std::string(user);
  36     else
  37         throw std::string("unable to get USERPROFILE");
  38     tmpDir = strUser;
  39     tmpDir += "\\tmp";
  40     tmpDir += "\\PmmlUnitTest\\";
  41     std::string cmd = "mkdir " + tmpDir;
  42     system( cmd.c_str() );
  43 #else
  44     tmpDir = "/tmp/";
  45     tmpDir += getenv("USER");
  46     tmpDir += "/PmmlUnitTest/";
  47     std::string cmd = "mkdir -p " + tmpDir;
  48     system( cmd.c_str() );
  49 #endif
  50 }
  51
  52 void PMMLBasicsTest1::tearDown()
  53 {
  54 #ifdef WIN32
  55     string cmd = "rmdir " + tmpDir + " /s /q ";
  56     system( cmd.c_str() );
  57 #else
  58     string cmd = "rm -rf " + tmpDir;
  59     system( cmd.c_str() );
  60 #endif
  61 }
  62
  63 //**************************************************************
  64 //                                                             *
  65 //                                                             *
  66 //                                                             *
  67 //  méthodes communes à tous les types de modèles              *
  68 //                                                             *
  69 //                                                             *
  70 //                                                             *
  71 //**************************************************************
  72
  73 void PMMLBasicsTest1::testMakeLog()
  74 {
  75     string pmmlFile = resourcesDir + "ann_model.pmml";
  76     bool b = true;
  77     string logRef;
  78     logRef =  "**\n**** Display of PMMLlib ****\n";
  79     logRef += " **  _pmmlFile[";
  80     logRef += pmmlFile;
  81     logRef += "]\n";
  82     logRef += " **  _log[";
  83     logRef += (b?"1":"0");
  84     logRef += "]\n";
  85     logRef += "**\n**** End of display of PMMLlib ****\n";
  86     PMMLlib::PMMLlib p(pmmlFile, b);
  87     p.SetCurrentModel("sANNName", PMMLlib::kANN);
  88     CPPUNIT_ASSERT_EQUAL( p.makeLog(), logRef );
  89 }
  90
  91 void PMMLBasicsTest1::testConstructorFileDoesNotExist()
  92 {
  93     CPPUNIT_ASSERT_THROW( PMMLlib::PMMLlib p("0.mml", true) , std::string );
  94 }
  95
  96 void PMMLBasicsTest1::testSetCurrentModelWithNameAndTypekANNUnknownModel()
  97 {
  98     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
  99     CPPUNIT_ASSERT_THROW( p.SetCurrentModel("toto", PMMLlib::kANN), std::string );
 100 }
 101
 102 void PMMLBasicsTest1::testSetCurrentModelWithNameAndTypekLRUnknownModel()
 103 {
 104     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 105     CPPUNIT_ASSERT_THROW( p.SetCurrentModel( "toto", PMMLlib::kLR), std::string );
 106 }
 107
 108 void PMMLBasicsTest1::testSetCurrentModelWithNameAndTypekUNDEFINEDUnknownModel()
 109 {
 110     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 111     CPPUNIT_ASSERT_THROW( p.SetCurrentModel("toto", PMMLlib::kUNDEFINED), std::string );
 112 }
 113
 114 void PMMLBasicsTest1::testSetCurrentModelWithNameAndType()
 115 {
 116     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 117     p.SetCurrentModel("sANNName", PMMLlib::kANN);
 118     CPPUNIT_ASSERT_EQUAL( p.GetModelsNb(), 1 );
 119     CPPUNIT_ASSERT_EQUAL( p.GetCurrentModelType(), PMMLlib::kANN );
 120 }
 121
 122 void PMMLBasicsTest1::testSetCurrentModelWithNameAndTypeTwoModelsWithSameNames()
 123 {
 124     PMMLlib::PMMLlib p(resourcesDir + "two_models_ann_lr.pmml");
 125     p.SetCurrentModel("modelName", PMMLlib::kLR);
 126     CPPUNIT_ASSERT_EQUAL( p.GetModelsNb(), 2 );
 127     CPPUNIT_ASSERT_EQUAL( p.GetCurrentModelType(), PMMLlib::kLR );
 128 }
 129
 130 void PMMLBasicsTest1::testSetCurrentModelWithNameWrongName()
 131 {
 132     PMMLlib::PMMLlib pANN(resourcesDir + "ann_model.pmml");
 133     CPPUNIT_ASSERT_THROW( pANN.SetCurrentModel("toto"), std::string );
 134 }
 135
 136 void PMMLBasicsTest1::testSetCurrentModelWithNameTwoModelsWithSameNames()
 137 {
 138     PMMLlib::PMMLlib p(resourcesDir + "two_models_ann_lr.pmml");
 139     CPPUNIT_ASSERT_THROW( p.SetCurrentModel("modelName"), std::string );
 140 }
 141
 142 void PMMLBasicsTest1::testSetCurrentModelWithName()
 143 {
 144     // kANN
 145     PMMLlib::PMMLlib pANN(resourcesDir + "ann_model.pmml");
 146     pANN.SetCurrentModel("sANNName");
 147     CPPUNIT_ASSERT_EQUAL( pANN.GetModelsNb(), 1 );
 148     CPPUNIT_ASSERT_EQUAL( pANN.GetCurrentModelType(), PMMLlib::kANN );
 149     // kLR
 150     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 151     PMMLlib::PMMLlib pLR(resourcesDir + "lr_model.pmml");
 152     pLR.SetCurrentModel(strModel);
 153     CPPUNIT_ASSERT_EQUAL( pLR.GetModelsNb(), 1 );
 154     CPPUNIT_ASSERT_EQUAL( pLR.GetCurrentModelType(), PMMLlib::kLR );
 155 }
 156
 157 void PMMLBasicsTest1::testSetCurrentModelNoModel()
 158 {
 159     PMMLlib::PMMLlib p(resourcesDir + "no_model.pmml");
 160     CPPUNIT_ASSERT_THROW( p.SetCurrentModel(), std::string );
 161 }
 162
 163 void PMMLBasicsTest1::testSetCurrentModelMoreThanOneModel()
 164 {
 165     PMMLlib::PMMLlib p(resourcesDir + "two_models_ann_lr.pmml");
 166     CPPUNIT_ASSERT_THROW( p.SetCurrentModel(), std::string );
 167 }
 168
 169 void PMMLBasicsTest1::testSetCurrentModel()
 170 {
 171     // kANN
 172     PMMLlib::PMMLlib pANN(resourcesDir + "ann_model.pmml");
 173     pANN.SetCurrentModel();
 174     CPPUNIT_ASSERT_EQUAL( pANN.GetModelsNb(), 1 );
 175     CPPUNIT_ASSERT_EQUAL( pANN.GetCurrentModelType(), PMMLlib::kANN );
 176     CPPUNIT_ASSERT_EQUAL( pANN.GetCurrentModelName(), string("sANNName") );
 177     // kLR
 178     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 179     PMMLlib::PMMLlib pLR(resourcesDir + "lr_model.pmml");
 180     pLR.SetCurrentModel();
 181     CPPUNIT_ASSERT_EQUAL( pLR.GetModelsNb(), 1 );
 182     CPPUNIT_ASSERT_EQUAL( pLR.GetCurrentModelType(), PMMLlib::kLR );
 183     CPPUNIT_ASSERT_EQUAL( pLR.GetCurrentModelName(), strModel );
 184 }
 185
 186 void PMMLBasicsTest1::testGetModelsNbkANN()
 187 {
 188     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 189     CPPUNIT_ASSERT_EQUAL( p.GetModelsNb(), 1 );
 190 }
 191
 192 void PMMLBasicsTest1::testGetModelsNbkLR()
 193 {
 194     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 195     CPPUNIT_ASSERT_EQUAL( p.GetModelsNb(), 1 );
 196 }
 197
 198 void PMMLBasicsTest1::testWrite()
 199 {
 200     string refPmmlFilename = resourcesDir + "ann_model.pmml";
 201     string pmmlFilename = tmpDir + "unittest_generated_ann_model.pmml";
 202
 203     PMMLlib::PMMLlib p(refPmmlFilename);
 204     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 205     p.Write(pmmlFilename);
 206     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refPmmlFilename, pmmlFilename), 0 );
 207 }
 208
 209 void PMMLBasicsTest1::testWriteNotExistingFile()
 210 {
 211     PMMLlib::PMMLlib p;
 212     CPPUNIT_ASSERT_THROW( p.Write(), std::string );
 213 }
 214
 215 void PMMLBasicsTest1::testUnlinkNode()
 216 {
 217     string pmmlFilename = tmpDir + "unittest_unlinked_ann_model.pmml";
 218     string refPmmlFilename = resourcesDir + "ann_model.pmml";
 219     PMMLlib::PMMLlib refP(refPmmlFilename);
 220     refP.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 221     refP.UnlinkNode();
 222     refP.Write(pmmlFilename);
 223     PMMLlib::PMMLlib p2(pmmlFilename);
 224     CPPUNIT_ASSERT_EQUAL( p2.GetModelsNb(), 0 );
 225 }
 226
 227 void PMMLBasicsTest1::testBackupNode()
 228 {
 229     string pmmlFilename = tmpDir + "unittest_backup_ann_model.pmml";
 230     string refPmmlFilename = resourcesDir + "ann_model.pmml";
 231     PMMLlib::PMMLlib refP(refPmmlFilename, true);
 232     refP.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 233     refP.BackupNode(); // rename sANNName to sANNName_0
 234     refP.BackupNode(); // rename sANNName_0 to sANNName_1
 235     // Create the PMML test file
 236     refP.Write(pmmlFilename);
 237     PMMLlib::PMMLlib p(pmmlFilename, true);
 238     // Still one model:
 239     CPPUNIT_ASSERT_EQUAL( p.GetModelsNb(), 1 );
 240     // Its name is sANNName_1:
 241     p.SetCurrentModel(string("sANNName_1"), PMMLlib::kANN);
 242     // XML tree for NeuralNetwork sANNName_1 is the same than in sANNName
 243     CPPUNIT_ASSERT_EQUAL( p.GetNbOutputs(), 1 );
 244     // sANNName is not there anymore: SetCurrentModel throws an exception
 245     // You'll have to build the new structure from scratch
 246     CPPUNIT_ASSERT_THROW( p.SetCurrentModel(string("sANNName"), PMMLlib::kANN), std::string );
 247 }
 248
 249 //**************************************************************
 250 //                                                             *
 251 //                                                             *
 252 //                                                             *
 253 //  méthodes propres au NeuralNetwork                          *
 254 //                                                             *
 255 //                                                             *
 256 //                                                             *
 257 //**************************************************************
 258
 259 void PMMLBasicsTest1::testGetNbInputsForbiddenModelType()
 260 {
 261     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 262     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 263     p.SetCurrentModel( strModel, PMMLlib::kLR);
 264     CPPUNIT_ASSERT_THROW( p.GetNbInputs(), std::string );
 265 }
 266
 267 void PMMLBasicsTest1::testGetNbInputs8()
 268 {
 269     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 270     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 271     CPPUNIT_ASSERT_EQUAL( p.GetNbInputs(), 8 );
 272 }
 273
 274
 275 void PMMLBasicsTest1::testGetNbOutputsForbiddenModelType()
 276 {
 277     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 278     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 279     p.SetCurrentModel( strModel, PMMLlib::kLR);
 280     CPPUNIT_ASSERT_THROW( p.GetNbOutputs(), std::string );
 281 }
 282
 283 void PMMLBasicsTest1::testGetNbOutputs2()
 284 {
 285     PMMLlib::PMMLlib p(resourcesDir + "ann_model_2.pmml");
 286     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 287     CPPUNIT_ASSERT_EQUAL( p.GetNbOutputs(), 2 );
 288 }
 289
 290
 291 void PMMLBasicsTest1::testGetNameInputForbiddenModelType()
 292 {
 293     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 294     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 295     p.SetCurrentModel( strModel, PMMLlib::kLR);
 296     CPPUNIT_ASSERT_THROW( p.GetNameInput(0), std::string );
 297 }
 298
 299 void PMMLBasicsTest1::testGetNameInputIndexOutOfRange()
 300 {
 301     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 302     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 303     CPPUNIT_ASSERT_EQUAL( p.GetNameInput(18), string("") );
 304 }
 305
 306 void PMMLBasicsTest1::testGetNameInput()
 307 {
 308     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 309     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 310     CPPUNIT_ASSERT_EQUAL( p.GetNameInput(2), string("tu") );
 311 }
 312
 313 void PMMLBasicsTest1::testGetNameOutputForbiddenModelType()
 314 {
 315     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 316     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 317     p.SetCurrentModel( strModel, PMMLlib::kLR);
 318     CPPUNIT_ASSERT_THROW( p.GetNameOutput(0), std::string );
 319 }
 320
 321 void PMMLBasicsTest1::testGetNameOutputIndexOutOfRange()
 322 {
 323     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 324     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 325     CPPUNIT_ASSERT_EQUAL( p.GetNameOutput(3), string("") );
 326 }
 327
 328 void PMMLBasicsTest1::testGetNameOutput()
 329 {
 330     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 331     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 332     CPPUNIT_ASSERT_EQUAL( p.GetNameOutput(0), string("yhat") );
 333 }
 334
 335
 336 void PMMLBasicsTest1::testGetNormalisationInputForbiddenType()
 337 {
 338     double * dnorm = new double[2];
 339     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 340     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 341     p.SetCurrentModel( strModel, PMMLlib::kLR);
 342     CPPUNIT_ASSERT_THROW( p.GetNormalisationInput(0, dnorm), std::string );
 343     delete [] dnorm ;
 344 }
 345
 346 void PMMLBasicsTest1::testGetNormalisationInputIndexUnknown()
 347 {
 348     double * dnorm = new double[2];
 349     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 350     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 351     p.GetNormalisationInput(18, dnorm) ;
 352     CPPUNIT_ASSERT_EQUAL( dnorm[0], 0.0 );
 353     CPPUNIT_ASSERT_EQUAL( dnorm[1], 0.0 );
 354     delete [] dnorm ;
 355 }
 356
 357 void PMMLBasicsTest1::testGetNormalisationInputkMinusOneOne()
 358 {
 359     // Valeurs de reference
 360     double dorig1Ref = 2;
 361     double dorig2Ref = 1.400018e+03;
 362     double * dnormRef = new double[2];
 363     dnormRef[0] = dorig1Ref ;
 364     dnormRef[1] = dorig2Ref ;
 365     double * dnorm = new double[2];
 366     PMMLlib::PMMLlib p(resourcesDir + "ann_model_2.pmml");
 367     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 368     p.GetNormalisationInput(6, dnorm) ;
 369     CPPUNIT_ASSERT_EQUAL( dnorm[0], dnormRef[0] );
 370     CPPUNIT_ASSERT_EQUAL( dnorm[1], dnormRef[1] );
 371     delete [] dnormRef ;
 372     delete [] dnorm ;
 373 }
 374
 375 void PMMLBasicsTest1::testGetNormalisationInputkCRkZeroOne()
 376 {
 377     // Valeurs de reference
 378     double dnorm1Ref = -5.780019e-02;
 379     double dorig2Ref = 1.095001e+04;
 380     double * dnormRef = new double[2];
 381     dnormRef[0] = dorig2Ref ;
 382     dnormRef[1] = -1.0 * dorig2Ref * dnorm1Ref ;
 383     double * dnorm = new double[2];
 384     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 385     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 386     p.GetNormalisationInput(7, dnorm) ;
 387     CPPUNIT_ASSERT_EQUAL( dnorm[0], dnormRef[0] );
 388     CPPUNIT_ASSERT_EQUAL( dnorm[1], dnormRef[1] );
 389     delete [] dnormRef ;
 390     delete [] dnorm ;
 391 }
 392
 393 void PMMLBasicsTest1::testGetNormalisationOutputForbiddenType()
 394 {
 395     double * dnorm = new double[2];
 396     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 397     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 398     p.SetCurrentModel( strModel, PMMLlib::kLR);
 399     CPPUNIT_ASSERT_THROW( p.GetNormalisationOutput(0, dnorm), std::string );
 400     delete [] dnorm ;
 401 }
 402
 403 void PMMLBasicsTest1::testGetNormalisationOutputIndexUnknown()
 404 {
 405     double * dnorm = new double[2];
 406     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 407     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 408     p.GetNormalisationOutput(18, dnorm) ;
 409     CPPUNIT_ASSERT_EQUAL( dnorm[0], 0.0 );
 410     CPPUNIT_ASSERT_EQUAL( dnorm[1], 0.0 );
 411     delete [] dnorm ;
 412 }
 413
 414 void PMMLBasicsTest1::testGetNormalisationOutputkMinusOneOne()
 415 {
 416     // Valeurs de reference
 417     double dorig1Ref = 2;
 418     double dorig2Ref = 5.781171e+01;
 419     double * dnormRef = new double[2];
 420     dnormRef[0] = dorig1Ref ;
 421     dnormRef[1] = dorig2Ref ;
 422     double * dnorm = new double[2];
 423     PMMLlib::PMMLlib p(resourcesDir + "ann_model_2.pmml");
 424     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 425     p.GetNormalisationOutput(1, dnorm) ;
 426     CPPUNIT_ASSERT_EQUAL( dnorm[0], dnormRef[0] );
 427     CPPUNIT_ASSERT_EQUAL( dnorm[1], dnormRef[1] );
 428     delete [] dnormRef ;
 429     delete [] dnorm ;
 430 }
 431
 432 void PMMLBasicsTest1::testGetNormalisationOutputkCRkZeroOne()
 433 {
 434     // Valeurs de reference
 435     double dnorm1Ref = -5.873935e-01;
 436     double dorig2Ref = 7.781171e+01;
 437     double * dnormRef = new double[2];
 438     dnormRef[0] = dorig2Ref ;
 439     dnormRef[1] = -1.0 * dorig2Ref * dnorm1Ref ;
 440     double * dnorm = new double[2];
 441     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 442     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 443     p.GetNormalisationOutput(0, dnorm) ;
 444     CPPUNIT_ASSERT_EQUAL( dnorm[0], dnormRef[0] );
 445     CPPUNIT_ASSERT_EQUAL( dnorm[1], dnormRef[1] );
 446     delete [] dnormRef ;
 447     delete [] dnorm ;
 448 }
 449
 450 void PMMLBasicsTest1::testGetNbLayersForbiddenType()
 451 {
 452     double * dnorm = new double[2];
 453     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 454     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 455     p.SetCurrentModel( strModel, PMMLlib::kLR);
 456     CPPUNIT_ASSERT_THROW( p.GetNbLayers(), std::string );
 457     delete [] dnorm ;
 458 }
 459
 460 void PMMLBasicsTest1::testGetNbLayers()
 461 {
 462     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 463     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 464     CPPUNIT_ASSERT_EQUAL( p.GetNbHiddenLayers(), 2 );
 465     CPPUNIT_ASSERT_EQUAL( p.GetNbLayers(), 4 );
 466 }
 467
 468 void PMMLBasicsTest1::testGetNbNeuronsAtLayerForbiddenType()
 469 {
 470     double * dnorm = new double[2];
 471     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 472     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 473     p.SetCurrentModel( strModel, PMMLlib::kLR);
 474     CPPUNIT_ASSERT_THROW( p.GetNbNeuronsAtLayer(0), std::string );
 475     delete [] dnorm ;
 476 }
 477
 478 void PMMLBasicsTest1::testGetNbNeuronsAtLayerFromIndexOutOfRange()
 479 {
 480     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 481     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 482     CPPUNIT_ASSERT_EQUAL( p.GetNbNeuronsAtLayer(18), 0 );
 483 }
 484
 485 void PMMLBasicsTest1::testGetNbNeuronsAtLayer()
 486 {
 487     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 488     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 489     CPPUNIT_ASSERT_EQUAL( p.GetNbNeuronsAtLayer(0), 1 );
 490 }
 491
 492 void PMMLBasicsTest1::testGetNeuronBiasForbiddenType()
 493 {
 494     double * dnorm = new double[2];
 495     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 496     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 497     p.SetCurrentModel( strModel, PMMLlib::kLR);
 498     CPPUNIT_ASSERT_THROW( p.GetNeuronBias(0,0), std::string );
 499     delete [] dnorm ;
 500 }
 501
 502 void PMMLBasicsTest1::testGetNeuronBiasFromLayerIndexOutOfRange()
 503 {
 504     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 505     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 506     CPPUNIT_ASSERT_EQUAL( p.GetNeuronBias(10,1), 0. );
 507 }
 508
 509 void PMMLBasicsTest1::testGetNeuronBiasFromNeuronIndexOutOfRange()
 510 {
 511     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 512     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 513     CPPUNIT_ASSERT_EQUAL( p.GetNeuronBias(0,10), 0. );
 514 }
 515
 516 void PMMLBasicsTest1::testGetNeuronBias()
 517 {
 518     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 519     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 520     CPPUNIT_ASSERT_EQUAL( p.GetNeuronBias(0,0), -1.263572e+00 );
 521 }
 522
 523 void PMMLBasicsTest1::testGetPrecNeuronSynapseForbiddenType()
 524 {
 525     double * dnorm = new double[2];
 526     string strModel("Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]");
 527     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 528     p.SetCurrentModel( strModel, PMMLlib::kLR );
 529     CPPUNIT_ASSERT_THROW( p.GetPrecNeuronSynapse(0,0,0), std::string );
 530     delete [] dnorm ;
 531 }
 532
 533 void PMMLBasicsTest1::testGetPrecNeuronSynapseFromLayerIndexOutOfRange()
 534 {
 535     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 536     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 537     CPPUNIT_ASSERT_EQUAL( p.GetPrecNeuronSynapse(10,1,1), 0. );
 538 }
 539
 540 void PMMLBasicsTest1::testGetPrecNeuronSynapseFromNeuronIndexOutOfRange()
 541 {
 542     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 543     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 544     CPPUNIT_ASSERT_EQUAL( p.GetPrecNeuronSynapse(1,10,1), 0. );
 545 }
 546
 547 void PMMLBasicsTest1::testGetPrecNeuronSynapseFromPrecIndexOutOfRange()
 548 {
 549     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 550     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 551     CPPUNIT_ASSERT_EQUAL( p.GetPrecNeuronSynapse(1,0,10), 0. );
 552 }
 553
 554 void PMMLBasicsTest1::testGetPrecNeuronSynapse()
 555 {
 556     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 557     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 558     CPPUNIT_ASSERT_EQUAL( p.GetPrecNeuronSynapse(0,0,7), 8.559675e-02 );
 559 }
 560
 561 void PMMLBasicsTest1::testReadNetworkStructure()
 562 {
 563     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 564     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 565     string str = p.ReadNetworkStructure();
 566     CPPUNIT_ASSERT_EQUAL( p.ReadNetworkStructure(), string("rw:r:tu:tl:hu:hl:l:kw,1,@yhat") );
 567 }
 568
 569 void PMMLBasicsTest1::testExportNeuralNetworkCpp()
 570 {
 571     string refCppFilename = resourcesDir + "unittest_ref_ann_model.cpp";
 572     string cppFilename = tmpDir + "unittest_ann_model.cpp";
 573     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 574     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 575     p.ExportCpp(cppFilename,
 576                 "myTestFunc",
 577                 "File used by unit test\n PMMLBasicsTest1::testExportNeuralNetworkCpp" );
 578      CPPUNIT_ASSERT_EQUAL( areFilesEqual( refCppFilename, cppFilename), 0 );
 579 }
 580
 581 void PMMLBasicsTest1::testExportNeuralNetworkFortran()
 582 {
 583     string refFortranFilename = resourcesDir + "unittest_ref_ann_model.f";
 584     string fortranFilename = tmpDir + "unittest_ann_model.f";
 585     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 586     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 587     p.ExportFortran(fortranFilename,
 588                     "myTestFunc",
 589                     "File used by unit test\n PMMLBasicsTest1::testExportNeuralNetworkFortran" );
 590     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refFortranFilename, fortranFilename), 0 );
 591 }
 592
 593 void PMMLBasicsTest1::testExportNeuralNetworkPython()
 594 {
 595     string refPyFilename = resourcesDir + "unittest_ref_ann_model.py";
 596     string pyFilename = tmpDir + "unittest_ann_model.py";
 597     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 598     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN );
 599     p.ExportPython(pyFilename,
 600                    "myTestFunc",
 601                    "File used by unit test\n PMMLBasicsTest1::testExportNeuralNetworkPython" );
 602     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refPyFilename, pyFilename), 0 );
 603 }
 604
 605 void PMMLBasicsTest1::testCreatePmmlNeuralNetwork()
 606 {
 607 #ifdef WIN32
 608     std::string refPmmlFilename = resourcesDir + "win32_ann_model.pmml";
 609 #else
 610     std::string refPmmlFilename = resourcesDir + "ann_model.pmml";
 611 #endif
 612     std::string pmmlFilename = tmpDir + "unittest_generated_ann_model.pmml";
 613
 614     // Données
 615     int nInput = 8;
 616     int nOutput = 1;
 617     int nHidden = 1;
 618     int nWeights = 9;
 619     vector<string>fieldName(nInput+1);
 620     fieldName[0] = "rw";
 621     fieldName[1] = "r";
 622     fieldName[2] = "tu";
 623     fieldName[3] = "tl";
 624     fieldName[4] = "hu";
 625     fieldName[5] = "hl";
 626     fieldName[6] = "l";
 627     fieldName[7] = "kw";
 628     fieldName[8] = "yhat";
 629     double orig1=0, norm2=0;
 630     vector<double>norm1(nInput);
 631     norm1[0] = -2.889932e-01;
 632     norm1[1] = -5.756638e-01;
 633     norm1[2] = -1.699313e-01;
 634     norm1[3] = -1.707007e-01;
 635     norm1[4] = -3.302777e-02;
 636     norm1[5] = -4.562070e-02;
 637     norm1[6] = -1.155882e-01;
 638     norm1[7] = -5.780019e-02;
 639     vector<double>orig2(nInput);
 640     orig2[0] = 9.999901e-02;
 641     orig2[1] = 2.504894e+04;
 642     orig2[2] = 8.933486e+04;
 643     orig2[3] = 8.955232e+01;
 644     orig2[4] = 1.050003e+03;
 645     orig2[5] = 7.600007e+02;
 646     orig2[6] = 1.400018e+03;
 647     orig2[7] = 1.095001e+04;
 648     vector<double>weights(nWeights);
 649     weights[0] = 7.536629e-01;
 650     weights[1] = 1.653660e-03;
 651     weights[2] = 4.725001e-03;
 652     weights[3] = 9.969786e-03;
 653     weights[4] = 1.787976e-01;
 654     weights[5] = -1.809809e-01;
 655     weights[6] = -1.735688e-01;
 656     weights[7] = 8.559675e-02;
 657     weights[8] = 6.965512e+00;
 658
 659     // Construction
 660     PMMLlib::PMMLlib p;
 661
 662     // Header node--------------------------------------------------------
 663     p.SetHeader("myCopyright", "Tests unitaires", "PMMLlib", "myVersion", "Tests unitaires PMMLlib");
 664     // DataDictionnary node--------------------------------------------------------
 665     for(int j=0 ; j<nInput+1 ; j++)
 666     {
 667         p.AddDataField(fieldName[j], fieldName[j], "continuous", "float", "ClosedClosed", 0., 0.);
 668     }
 669     // Set Neural Network (and type)---------------------------------------------
 670     p.AddNeuralNetwork( string("sANNName"), PMMLlib::kREGRESSION);
 671     // Set Mining schema
 672     for(int j=0 ; j<nInput ; j++)
 673     {
 674         p.AddMiningSchema(fieldName[j], "active");
 675     }
 676     p.AddMiningSchema(fieldName[nInput], "predicted");
 677     // Set NeuralInput
 678     for(int j=0 ; j<nInput ; j++)
 679     {
 680         p.AddNeuralInput(j, fieldName[j], "continuous", "float", orig1, norm1[j], orig2[j], norm2);
 681     }
 682     // Set neural layers
 683     p.AddNeuralLayer(PMMLlib::kTANH);
 684     for(int j=0 ; j<nHidden ; j++) // hidden layers
 685     {
 686         vector<double> tmp_weights(nInput);
 687         for(int i=0 ; i<nInput ; i++)
 688         {
 689             tmp_weights[i] = weights[i];
 690         }
 691         p.AddNeuron(nInput+j, -1.263572, nInput, 0, tmp_weights);
 692     }
 693     //
 694     p.AddNeuralLayer(PMMLlib::kIDENTITY);
 695     for(int j=0 ; j<nOutput ; j++)
 696     {
 697         vector<double> tmp_weights(nHidden);
 698         tmp_weights[0] =  weights[nWeights-1];
 699         p.AddNeuron(nInput+nHidden+j, -1.745483, nHidden, nInput, tmp_weights);
 700     }
 701     // Set NeuralOutput
 702     p.AddNeuralOutput(nInput+nHidden, "yhat", "continuous", "float",
 703                           0,-5.873935e-01 ,
 704                           7.781171e+01, 0);
 705     p.Write( pmmlFilename );
 706     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refPmmlFilename, pmmlFilename), 0 );
 707 }
 708
 709 //**************************************************************
 710 //                                                             *
 711 //                                                             *
 712 //                                                             *
 713 //  méthodes propres au RegressionModel                        *
 714 //                                                             *
 715 //                                                             *
 716 //                                                             *
 717 //**************************************************************
 718
 719 void PMMLBasicsTest1::testHasInterceptForbiddenType()
 720 {
 721     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml" );
 722     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 723     CPPUNIT_ASSERT_THROW( p.HasIntercept(), std::string );
 724 }
 725
 726 void PMMLBasicsTest1::testHasIntercept()
 727 {
 728     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 729     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 730     p.SetCurrentModel( strModel, PMMLlib::kLR );
 731     CPPUNIT_ASSERT_EQUAL( p.HasIntercept(), true );
 732 }
 733
 734 void PMMLBasicsTest1::testHasInterceptNo()
 735 {
 736     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 737     PMMLlib::PMMLlib p(resourcesDir + "lr_model_2.pmml");
 738     p.SetCurrentModel( strModel, PMMLlib::kLR );
 739     CPPUNIT_ASSERT_EQUAL( p.HasIntercept(), false );
 740 }
 741
 742 void PMMLBasicsTest1::testGetRegressionTableInterceptForbiddenType()
 743 {
 744     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 745     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 746     CPPUNIT_ASSERT_THROW( p.GetRegressionTableIntercept(), std::string );
 747 }
 748
 749 void PMMLBasicsTest1::testGetRegressionTableIntercept()
 750 {
 751     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 752     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 753     p.SetCurrentModel( strModel, PMMLlib::kLR );
 754     CPPUNIT_ASSERT_EQUAL( p.GetRegressionTableIntercept(), 3.837365 );
 755 }
 756
 757 void PMMLBasicsTest1::testReadRegressionStructure()
 758 {
 759     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 760     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 761     p.SetCurrentModel( strModel, PMMLlib::kLR );
 762     CPPUNIT_ASSERT_EQUAL( p.ReadRegressionStructure(), string("x6:x8,1,@x1") );
 763 }
 764
 765 void PMMLBasicsTest1::testGetNumericPredictorNb()
 766 {
 767     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 768     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 769     p.SetCurrentModel( strModel, PMMLlib::kLR );
 770     CPPUNIT_ASSERT_EQUAL( p.GetNumericPredictorNb(), 2 );
 771 }
 772
 773 void PMMLBasicsTest1::testGetNumericPredictorNbForbiddenType()
 774 {
 775     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 776     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 777     CPPUNIT_ASSERT_THROW( p.GetNumericPredictorNb(), std::string );
 778 }
 779
 780 void PMMLBasicsTest1::testGetPredictorTermNb()
 781 {
 782     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 783     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 784     p.SetCurrentModel( strModel, PMMLlib::kLR );
 785     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermNb(), 2 );
 786 }
 787
 788 void PMMLBasicsTest1::testGetPredictorTermNbForbiddenType()
 789 {
 790     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 791     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 792     CPPUNIT_ASSERT_THROW( p.GetNumericPredictorNb(), std::string );
 793 }
 794
 795 void PMMLBasicsTest1::testGetNumericPredictorName()
 796 {
 797     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 798     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 799     p.SetCurrentModel( strModel, PMMLlib::kLR );
 800     CPPUNIT_ASSERT_EQUAL( p.GetNumericPredictorName(1), string("x8") );
 801 }
 802
 803 void PMMLBasicsTest1::testGetNumericPredictorNameForbiddenType()
 804 {
 805     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 806     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 807     CPPUNIT_ASSERT_THROW( p.GetNumericPredictorName(0), std::string );
 808 }
 809
 810 void PMMLBasicsTest1::testGetNumericPredictorNamePredictorOutOfRange()
 811 {
 812     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 813     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 814     p.SetCurrentModel( strModel, PMMLlib::kLR );
 815     CPPUNIT_ASSERT_EQUAL( p.GetNumericPredictorName(5), string("") );
 816 }
 817
 818 void PMMLBasicsTest1::testGetPredictorTermName()
 819 {
 820     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 821     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 822     p.SetCurrentModel( strModel, PMMLlib::kLR );
 823     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermName(1), string("x6x6x8") );
 824 }
 825
 826 void PMMLBasicsTest1::testGetPredictorTermNameForbiddenType()
 827 {
 828     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 829     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 830     CPPUNIT_ASSERT_THROW( p.GetPredictorTermName(0), std::string );
 831 }
 832
 833 void PMMLBasicsTest1::testGetPredictorTermNamePredictorOutOfRange()
 834 {
 835     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 836     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 837     p.SetCurrentModel( strModel, PMMLlib::kLR );
 838     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermName(5), string("") );
 839 }
 840
 841 void PMMLBasicsTest1::testGetNumericPredictorCoefficient()
 842 {
 843     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 844     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 845     p.SetCurrentModel( strModel, PMMLlib::kLR );
 846     CPPUNIT_ASSERT_EQUAL( p.GetNumericPredictorCoefficient(1), 0.1428838 );
 847 }
 848
 849 void PMMLBasicsTest1::testGetNumericPredictorCoefficientForbiddenType()
 850 {
 851     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 852     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 853     CPPUNIT_ASSERT_THROW( p.GetNumericPredictorCoefficient(0), std::string );
 854 }
 855
 856 void PMMLBasicsTest1::testGetNumericPredictorCoefficientPredictorOutOfRange()
 857 {
 858     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 859     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 860     p.SetCurrentModel( strModel, PMMLlib::kLR );
 861     CPPUNIT_ASSERT_EQUAL( p.GetNumericPredictorCoefficient(2), 0. );
 862 }
 863
 864 void PMMLBasicsTest1::testGetPredictorTermCoefficient()
 865 {
 866     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 867     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 868     p.SetCurrentModel( strModel, PMMLlib::kLR );
 869     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermCoefficient(0), -0.02201903 );
 870 }
 871
 872 void PMMLBasicsTest1::testGetPredictorTermCoefficientForbiddenType()
 873 {
 874     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 875     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 876     CPPUNIT_ASSERT_THROW( p.GetPredictorTermCoefficient(0), std::string );
 877 }
 878
 879 void PMMLBasicsTest1::testGetPredictorTermCoefficientPredictorOutOfRange()
 880 {
 881     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 882     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 883     p.SetCurrentModel( strModel, PMMLlib::kLR );
 884     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermCoefficient(2), 0.);
 885 }
 886
 887 void PMMLBasicsTest1::testGetPredictorTermFieldRefNb()
 888 {
 889     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 890     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 891     p.SetCurrentModel( strModel, PMMLlib::kLR );
 892     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermFieldRefNb(1), 3 );
 893 }
 894
 895 void PMMLBasicsTest1::testGetPredictorTermFieldRefNbForbiddenType()
 896 {
 897     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 898     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 899     CPPUNIT_ASSERT_THROW( p.GetPredictorTermFieldRefNb(0), std::string );
 900 }
 901
 902 void PMMLBasicsTest1::testGetPredictorTermFieldRefNbPredictorOutOfRange()
 903 {
 904     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 905     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 906     p.SetCurrentModel( strModel, PMMLlib::kLR );
 907     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermFieldRefNb(12), 0 );
 908 }
 909
 910 void PMMLBasicsTest1::testGetPredictorTermFieldRefName()
 911 {
 912     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 913     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 914     p.SetCurrentModel( strModel, PMMLlib::kLR );
 915     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermFieldRefName(1,1), string("x6") );
 916 }
 917
 918 void PMMLBasicsTest1::testGetPredictorTermFieldRefNameForbiddenType()
 919 {
 920     PMMLlib::PMMLlib p(resourcesDir + "ann_model.pmml");
 921     p.SetCurrentModel( string("sANNName"), PMMLlib::kANN);
 922     CPPUNIT_ASSERT_THROW( p.GetPredictorTermFieldRefName(1,1), std::string );
 923 }
 924
 925 void PMMLBasicsTest1::testGetPredictorTermFieldRefNamePredictorOutOfRange()
 926 {
 927     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 928     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 929     p.SetCurrentModel( strModel, PMMLlib::kLR );
 930     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermFieldRefName(3,1), string("") );
 931 }
 932
 933 void PMMLBasicsTest1::testGetPredictorTermFieldRefNameFieldOutOfRange()
 934 {
 935     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 936     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 937     p.SetCurrentModel( strModel, PMMLlib::kLR );
 938     CPPUNIT_ASSERT_EQUAL( p.GetPredictorTermFieldRefName(1,5), string("") );
 939 }
 940
 941 void PMMLBasicsTest1::testExportLinearRegressionCpp()
 942 {
 943     string refCppFilename = resourcesDir + "unittest_ref_lr_model.cpp";
 944     string cppFilename = tmpDir + "unittest_lr_model.cpp";
 945     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 946     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 947     p.SetCurrentModel( strModel, PMMLlib::kLR );
 948     p.ExportCpp(cppFilename,
 949                 string("myTestFunc"),
 950                 "File used by unit test\n PMMLBasicsTest1::testExportLinearRegressionCpp" );
 951     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refCppFilename, cppFilename), 0 );
 952 }
 953
 954 void PMMLBasicsTest1::testExportLinearRegressionFortran()
 955 {
 956     string refFortranFilename = resourcesDir + "unittest_ref_lr_model.f";
 957     string fortranFilename = tmpDir + "unittest_lr_model.f";
 958     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 959     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 960     p.SetCurrentModel( strModel, PMMLlib::kLR );
 961     p.ExportFortran(fortranFilename,
 962                     string("myTestFunc"),
 963                     "File used by unit test\n PMMLBasicsTest1::testExportLinearRegressionFortran" );
 964     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refFortranFilename, fortranFilename), 0 );
 965 }
 966
 967 void PMMLBasicsTest1::testExportLinearRegressionPython()
 968 {
 969     string refPyFilename = resourcesDir + "unittest_ref_lr_model.py";
 970     string pyFilename = tmpDir + "unittest_lr_model.py";
 971     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 972     PMMLlib::PMMLlib p(resourcesDir + "lr_model.pmml");
 973     p.SetCurrentModel( strModel, PMMLlib::kLR );
 974     p.ExportPython(pyFilename,
 975                    string("myTestFunc"),
 976                    "File used by unit test\n PMMLBasicsTest1::testExportLinearRegressionPython" );
 977     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refPyFilename, pyFilename), 0 );
 978 }
 979
 980 void PMMLBasicsTest1::testCreatePmmlRegression()
 981 {
 982 #ifdef WIN32
 983     std::string refPmmlFilename = resourcesDir + "win32_lr_model.pmml";
 984 #else
 985     std::string refPmmlFilename = resourcesDir + "lr_model.pmml";
 986 #endif
 987     std::string pmmlFilename = tmpDir + "unittest_generated_lr_model.pmml";
 988     // Données
 989     string strModel = "Modeler[LinearRegression]Tds[steamplant]Predictor[x6:x8:x6x8:x6x6x8]Target[x1]";
 990     int nData = 3;
 991     vector<string>fieldName(nData);
 992     fieldName[0] = "x6";
 993     fieldName[1] = "x8";
 994     fieldName[2] = "x1";
 995     vector<string>displayName(nData);
 996     displayName[0] = " x_{6}";
 997     displayName[1] = " x_{8}";
 998     displayName[2] = " x_{1}";
 999     vector<double>leftMargin(nData);
1000     leftMargin[0] = 1.1e+01;
1001     leftMargin[1] = 2.81e+01;
1002     leftMargin[2] = 6.36e+00;
1003     vector<double>rightMargin(nData);
1004     rightMargin[0] = 2.3e+01;
1005     rightMargin[1] = 7.67e+01;
1006     rightMargin[2] = 1.251e+01;
1007     vector<double>numPredCoeff(nData-1);
1008     numPredCoeff[0] = 0.4759134;
1009     numPredCoeff[1] = 0.1428838;
1010     vector<double>predTermCoeff(nData-1);
1011     predTermCoeff[0] = -0.02201903;
1012     predTermCoeff[1] = 0.000536256;
1013     vector< vector<string> > fieldRefVect(nData-1);
1014     vector<string>fieldRef0(2);
1015     fieldRef0[0] = fieldName[0];
1016     fieldRef0[1] = fieldName[1];
1017     vector<string>fieldRef1(3);
1018     fieldRef1[0] = fieldName[0];
1019     fieldRef1[1] = fieldName[0];
1020     fieldRef1[2] = fieldName[1];
1021     fieldRefVect[0] = fieldRef0;
1022     fieldRefVect[nData-2] = fieldRef1;
1023
1024     // Construction
1025     PMMLlib::PMMLlib p;
1026     // Header node--------------------------------------------------------
1027     p.SetHeader("myCopyright", "Tests unitaires", "PMMLlib", "myVersion", "Tests unitaires PMMLlib");
1028     // DataDictionnary node--------------------------------------------------------
1029     for(int j=0; j<nData; j++)
1030     {
1031         p.AddDataField(fieldName[j], displayName[j],
1032                        "continuous", "double", "ClosedClosed",
1033                        leftMargin[j], rightMargin[j], true);
1034     }
1035     // Set Model (and type)----------------------------------------------
1036     p.AddRegressionModel( strModel, PMMLlib::kREGRESSION,  fieldName[2]);
1037     // Set Mining schema------------------------------------------------
1038     for(int j=0 ; j<nData-1 ; j++)
1039     {
1040         p.AddMiningSchema(fieldName[j], "active");
1041     }
1042     p.AddMiningSchema(fieldName[nData-1], "predicted");
1043     // Set Regression table
1044     double intercept = 3.837365;
1045     p.AddRegressionTable(intercept);
1046     // Set numeric predictor
1047     for(int j=0; j<nData-1; j++)
1048     {
1049         p.AddNumericPredictor(fieldName[j], 1, numPredCoeff[j]);
1050     }
1051     // Set Predictor term
1052     for(int j=0; j<nData-1; j++)
1053     {
1054         p.AddPredictorTerm(predTermCoeff[j], fieldRefVect[j]);
1055     }
1056     p.Write( pmmlFilename );
1057     CPPUNIT_ASSERT_EQUAL( areFilesEqual( refPmmlFilename, pmmlFilename), 0 );
1058 }
1059