1 /** 2 * 3 * Copyright (c) 2005-2021 by Pierre-Henri WUILLEMIN(_at_LIP6) & Christophe GONZALES(_at_AMU) 4 * info_at_agrum_dot_org 5 * 6 * This library is free software: you can redistribute it and/or modify 7 * it under the terms of the GNU Lesser General Public License as published by 8 * the Free Software Foundation, either version 3 of the License, or 9 * (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public License 17 * along with this library. If not, see <http://www.gnu.org/licenses/>. 18 * 19 */ 20 21 22 #include <cstdlib> 23 #include <iostream> 24 #include <sstream> 25 #include <string> 26 27 #include <gumtest/AgrumTestSuite.h> 28 #include <gumtest/testsuite_utils.h> 29 30 #include <agrum/tools/core/debug.h> 31 #include <agrum/tools/core/set.h> 32 #include <agrum/tools/core/utils_random.h> 33 #include <agrum/tools/multidim/implementations/multiDimArray.h> 34 #include <agrum/tools/multidim/implementations/multiDimPartialInstantiation.h> 35 #include <agrum/tools/multidim/instantiation.h> 36 #include <agrum/tools/multidim/potential.h> 37 #include <agrum/tools/multidim/utils/partialInstantiation4MultiDim.h> 38 #include <agrum/tools/variables/labelizedVariable.h> 39 40 namespace gum_tests { 41 42 class MultiDimPartialInstantiationTestSuite: public CxxTest::TestSuite { 43 private: 44 // ========================================================================== 45 /// initialize randomly a table 46 // ========================================================================== randomInit(gum::MultiDimArray<double> * t)47 void randomInit(gum::MultiDimArray< double >* t) { 48 gum::Instantiation i(t); 49 50 for (i.setFirst(); !i.end(); ++i) 51 t->set(i, double(gum::randomProba())); 52 } 53 54 // ========================================================================== 55 /// initialize randomly a table 56 // ========================================================================== randomInitPointer(gum::MultiDimArray<double * > * t)57 void randomInitPointer(gum::MultiDimArray< double* >* t) { 58 gum::Instantiation i(t); 59 60 for (i.setFirst(); !i.end(); ++i) 61 t->set(i, new double(double(gum::randomProba()))); 62 } 63 64 // ========================================================================== 65 /// initialize randomly a table 66 // ========================================================================== randomInitP(gum::Potential<double> & t)67 void randomInitP(gum::Potential< double >& t) { 68 gum::Instantiation i(t); 69 70 for (i.setFirst(); !i.end(); ++i) 71 t.set(i, gum::randomProba()); 72 } 73 74 // ========================================================================== 75 /// initialize randomly a table 76 // ========================================================================== randomInitPPointer(gum::Potential<double * > & t)77 void randomInitPPointer(gum::Potential< double* >& t) { 78 gum::Instantiation i(t); 79 80 for (i.setFirst(); !i.end(); ++i) 81 t.set(i, new double(gum::randomProba())); 82 } 83 84 template < typename T > pointerDelete(gum::MultiDimArray<T * > * t)85 void pointerDelete(gum::MultiDimArray< T* >* t) { 86 if (t->variablesSequence().size()) { 87 gum::Instantiation i(t); 88 89 for (i.setFirst(); !i.end(); ++i) { 90 delete t->get(i); 91 } 92 } 93 94 delete t; 95 } 96 97 template < typename T > pointerDelete(gum::MultiDimImplementation<T * > * t)98 void pointerDelete(gum::MultiDimImplementation< T* >* t) { 99 if (t->variablesSequence().size()) { 100 gum::Instantiation i(t); 101 102 for (i.setFirst(); !i.end(); ++i) { 103 delete t->get(i); 104 } 105 } 106 107 delete t; 108 } 109 110 template < typename T > pointerDelete(gum::Potential<T * > * t)111 void pointerDelete(gum::Potential< T* >* t) { 112 if (t->variablesSequence().size()) { 113 gum::Instantiation i(t); 114 115 for (i.setFirst(); !i.end(); ++i) { 116 delete t->get(i); 117 } 118 } 119 120 delete t; 121 } 122 123 // ========================================================================== 124 // ========================================================================== 125 template < typename T > equal(const gum::MultiDimImplementation<T * > & t1,const gum::MultiDimImplementation<T * > & t2)126 bool equal(const gum::MultiDimImplementation< T* >& t1, 127 const gum::MultiDimImplementation< T* >& t2) { 128 if ((t1.nbrDim() == t2.nbrDim()) && (t1.domainSize() == t2.domainSize())) { 129 for (const auto var: t1.variablesSequence()) 130 if (!t2.variablesSequence().exists(var)) return false; 131 132 gum::Instantiation i(t1); 133 134 for (i.setFirst(); !i.end(); ++i) { 135 if (*(t1.get(i)) != *(t2.get(i))) { return false; } 136 } 137 138 return true; 139 } else { 140 return false; 141 } 142 } 143 144 // ========================================================================== 145 // ========================================================================== 146 template < typename T > equal(const gum::Potential<T * > & t1,const gum::Potential<T * > & t2)147 bool equal(const gum::Potential< T* >& t1, const gum::Potential< T* >& t2) { 148 if ((t1.nbrDim() == t2.nbrDim()) && (t1.domainSize() == t2.domainSize())) { 149 for (const auto var: t1.variablesSequence()) 150 if (!t2.variablesSequence().exists(var)) return false; 151 152 gum::Instantiation i(t1); 153 154 for (i.setFirst(); !i.end(); ++i) { 155 if (*(t1.get(i)) != *(t2.get(i))) { return false; } 156 } 157 158 return true; 159 } else { 160 return false; 161 } 162 } 163 164 // ========================================================================== 165 // ========================================================================== 166 template < typename T > manual_instantiate(const gum::Potential<T> & t_in,const gum::HashTable<const gum::DiscreteVariable *,gum::Idx> & inst_vars)167 gum::Potential< T >* manual_instantiate( 168 const gum::Potential< T >& t_in, 169 const gum::HashTable< const gum::DiscreteVariable*, gum::Idx >& inst_vars) { 170 // construction of the output table 171 gum::Potential< T >* t_out = new gum::Potential< T >; 172 gum::Instantiation partial_inst; 173 const gum::Sequence< const gum::DiscreteVariable* >& tin_vars = t_in.variablesSequence(); 174 t_out->beginMultipleChanges(); 175 176 for (const auto var: tin_vars) 177 if (!inst_vars.exists(var)) 178 t_out->add(*var); 179 else 180 partial_inst.add(*var); 181 182 t_out->endMultipleChanges(); 183 184 for (const auto& elt: inst_vars) 185 partial_inst.chgVal(elt.first, elt.second); 186 187 // fill the table 188 gum::Instantiation inst_in(t_in); 189 gum::Instantiation inst_out(t_out); 190 inst_in.setFirst(); 191 inst_in.setVals(partial_inst); 192 inst_out.setVals(inst_in); 193 194 while (!inst_in.end()) { 195 t_out->set(inst_out, t_in[inst_in]); 196 inst_in.incOut(partial_inst); 197 inst_out.setVals(inst_in); 198 } 199 200 return t_out; 201 } 202 203 // ========================================================================== 204 // ========================================================================== 205 template < typename T > manual_instantiate(const gum::Potential<T * > & t_in,const gum::HashTable<const gum::DiscreteVariable *,gum::Idx> & inst_vars)206 gum::Potential< T* >* manual_instantiate( 207 const gum::Potential< T* >& t_in, 208 const gum::HashTable< const gum::DiscreteVariable*, gum::Idx >& inst_vars) { 209 // construction of the output table 210 gum::Potential< T* >* t_out = new gum::Potential< T* >; 211 gum::Instantiation partial_inst; 212 const gum::Sequence< const gum::DiscreteVariable* >& tin_vars = t_in.variablesSequence(); 213 t_out->beginMultipleChanges(); 214 215 for (const auto var: tin_vars) 216 if (!inst_vars.exists(var)) 217 t_out->add(*var); 218 else 219 partial_inst.add(*var); 220 221 t_out->endMultipleChanges(); 222 223 for (const auto& elt: inst_vars) 224 partial_inst.chgVal(elt.first, elt.second); 225 226 // fill the table 227 gum::Instantiation inst_in(t_in); 228 gum::Instantiation inst_out(t_out); 229 inst_in.setFirst(); 230 inst_in.setVals(partial_inst); 231 inst_out.setVals(inst_in); 232 233 while (!inst_in.end()) { 234 t_out->set(inst_out, new T(*(t_in[inst_in]))); 235 inst_in.incOut(partial_inst); 236 inst_out.setVals(inst_in); 237 } 238 239 return t_out; 240 } 241 242 // ========================================================================== 243 // ========================================================================== 244 template < typename T > manual_instantiate(const gum::MultiDimArray<T> & t_in,const gum::HashTable<const gum::DiscreteVariable *,gum::Idx> & inst_vars)245 gum::MultiDimArray< T >* manual_instantiate( 246 const gum::MultiDimArray< T >& t_in, 247 const gum::HashTable< const gum::DiscreteVariable*, gum::Idx >& inst_vars) { 248 // construction of the output table 249 gum::MultiDimArray< T >* t_out = new gum::MultiDimArray< T >; 250 gum::Instantiation partial_inst; 251 const gum::Sequence< const gum::DiscreteVariable* >& tin_vars = t_in.variablesSequence(); 252 t_out->beginMultipleChanges(); 253 254 for (const auto var: tin_vars) 255 if (!inst_vars.exists(var)) 256 t_out->add(*var); 257 else 258 partial_inst.add(*var); 259 260 t_out->endMultipleChanges(); 261 262 for (const auto& elt: inst_vars) 263 partial_inst.chgVal(elt.first, elt.second); 264 265 // fill the table 266 gum::Instantiation inst_in(t_in); 267 gum::Instantiation inst_out(t_out); 268 inst_in.setFirst(); 269 inst_in.setVals(partial_inst); 270 inst_out.setVals(inst_in); 271 272 while (!inst_in.end()) { 273 t_out->set(inst_out, t_in[inst_in]); 274 inst_in.incOut(partial_inst); 275 inst_out.setVals(inst_in); 276 } 277 278 return t_out; 279 } 280 281 // ========================================================================== 282 // ========================================================================== 283 template < typename T > manual_instantiate(const gum::MultiDimArray<T * > & t_in,const gum::HashTable<const gum::DiscreteVariable *,gum::Idx> & inst_vars)284 gum::MultiDimArray< T* >* manual_instantiate( 285 const gum::MultiDimArray< T* >& t_in, 286 const gum::HashTable< const gum::DiscreteVariable*, gum::Idx >& inst_vars) { 287 // construction of the output table 288 gum::MultiDimArray< T* >* t_out = new gum::MultiDimArray< T* >; 289 gum::Instantiation partial_inst; 290 const gum::Sequence< const gum::DiscreteVariable* >& tin_vars = t_in.variablesSequence(); 291 t_out->beginMultipleChanges(); 292 293 for (const auto var: tin_vars) 294 if (!inst_vars.exists(var)) 295 t_out->add(*var); 296 else 297 partial_inst.add(*var); 298 299 t_out->endMultipleChanges(); 300 301 for (const auto& elt: inst_vars) 302 partial_inst.chgVal(elt.first, elt.second); 303 304 // fill the table 305 gum::Instantiation inst_in(t_in); 306 gum::Instantiation inst_out(t_out); 307 inst_in.setFirst(); 308 inst_in.setVals(partial_inst); 309 inst_out.setVals(inst_in); 310 311 while (!inst_in.end()) { 312 t_out->set(inst_out, new T(*(t_in[inst_in]))); 313 inst_in.incOut(partial_inst); 314 inst_out.setVals(inst_in); 315 } 316 317 return t_out; 318 } 319 320 public: test_MultiDimArray()321 void test_MultiDimArray() { 322 std::vector< gum::LabelizedVariable* > vars(10); 323 324 for (gum::Idx i = 0; i < 10; ++i) { 325 std::stringstream str; 326 str << "x" << i; 327 std::string s = str.str(); 328 vars[i] = new gum::LabelizedVariable(s, s, 4); 329 } 330 331 gum::MultiDimArray< double > t1; 332 333 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 334 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 335 randomInit(&t1); 336 337 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 338 inst_set.insert(vars[2], 0); 339 inst_set.insert(vars[3], 2); 340 inst_set.insert(vars[5], 1); 341 inst_set.insert(vars[8], 3); 342 inst_set.insert(vars[9], 2); 343 344 gum::MultiDimArray< double >* t2 = partialInstantiationMultiDimArray(&t1, inst_set); 345 346 gum::MultiDimArray< double >* t3 = manual_instantiate(t1, inst_set); 347 348 TS_ASSERT(*t2 == *t3) 349 delete t2; 350 delete t3; 351 352 inst_set.clear(); 353 inst_set.insert(vars[6], 1); 354 inst_set.insert(vars[7], 0); 355 inst_set.insert(vars[8], 2); 356 inst_set.insert(vars[9], 3); 357 t2 = partialInstantiationMultiDimArray(&t1, inst_set); 358 t3 = manual_instantiate(t1, inst_set); 359 TS_ASSERT(*t2 == *t3) 360 delete t2; 361 delete t3; 362 363 inst_set.clear(); 364 inst_set.insert(vars[0], 1); 365 inst_set.insert(vars[1], 0); 366 inst_set.insert(vars[2], 2); 367 inst_set.insert(vars[3], 3); 368 t2 = partialInstantiationMultiDimArray(&t1, inst_set); 369 t3 = manual_instantiate(t1, inst_set); 370 TS_ASSERT(*t2 == *t3) 371 delete t2; 372 delete t3; 373 374 for (gum::Idx i = 0; i < vars.size(); ++i) 375 delete vars[i]; 376 } 377 test_MultiDimImplementation()378 void test_MultiDimImplementation() { 379 std::vector< gum::LabelizedVariable* > vars(10); 380 381 for (gum::Idx i = 0; i < 10; ++i) { 382 std::stringstream str; 383 str << "x" << i; 384 std::string s = str.str(); 385 vars[i] = new gum::LabelizedVariable(s, s, 4); 386 } 387 388 gum::MultiDimArray< double > t1; 389 390 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 391 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 392 randomInit(&t1); 393 394 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 395 inst_set.insert(vars[2], 0); 396 inst_set.insert(vars[3], 2); 397 inst_set.insert(vars[5], 1); 398 inst_set.insert(vars[8], 3); 399 inst_set.insert(vars[9], 2); 400 401 gum::MultiDimImplementation< double >* t2 402 = partialInstantiationMultiDimImplementation(&t1, inst_set); 403 404 gum::MultiDimArray< double >* t3 = manual_instantiate(t1, inst_set); 405 406 TS_ASSERT(*t2 == *t3) 407 delete t2; 408 delete t3; 409 410 inst_set.clear(); 411 inst_set.insert(vars[6], 1); 412 inst_set.insert(vars[7], 0); 413 inst_set.insert(vars[8], 2); 414 inst_set.insert(vars[9], 3); 415 t2 = partialInstantiationMultiDimImplementation(&t1, inst_set); 416 t3 = manual_instantiate(t1, inst_set); 417 TS_ASSERT(*t2 == *t3) 418 delete t2; 419 delete t3; 420 421 inst_set.clear(); 422 inst_set.insert(vars[0], 1); 423 inst_set.insert(vars[1], 0); 424 inst_set.insert(vars[2], 2); 425 inst_set.insert(vars[3], 3); 426 t2 = partialInstantiationMultiDimImplementation(&t1, inst_set); 427 t3 = manual_instantiate(t1, inst_set); 428 TS_ASSERT(*t2 == *t3) 429 delete t2; 430 delete t3; 431 432 for (gum::Idx i = 0; i < vars.size(); ++i) 433 delete vars[i]; 434 } 435 test_MultiDimArrayPointer()436 void test_MultiDimArrayPointer() { 437 std::vector< gum::LabelizedVariable* > vars(10); 438 439 for (gum::Idx i = 0; i < 10; ++i) { 440 std::stringstream str; 441 str << "x" << i; 442 std::string s = str.str(); 443 vars[i] = new gum::LabelizedVariable(s, s, 4); 444 } 445 446 gum::MultiDimArray< double* > t1; 447 448 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 449 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 450 randomInitPointer(&t1); 451 452 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 453 inst_set.insert(vars[2], 0); 454 inst_set.insert(vars[3], 2); 455 inst_set.insert(vars[5], 1); 456 inst_set.insert(vars[8], 3); 457 inst_set.insert(vars[9], 2); 458 459 gum::MultiDimArray< double* >* t2 = partialInstantiationMultiDimArray4Pointers(&t1, inst_set); 460 461 gum::MultiDimArray< double* >* t3 = manual_instantiate(t1, inst_set); 462 463 TS_ASSERT(equal(*t2, *t3)) 464 pointerDelete(t2); 465 pointerDelete(t3); 466 467 inst_set.clear(); 468 inst_set.insert(vars[6], 1); 469 inst_set.insert(vars[7], 0); 470 inst_set.insert(vars[8], 2); 471 inst_set.insert(vars[9], 3); 472 t2 = partialInstantiationMultiDimArray4Pointers(&t1, inst_set); 473 t3 = manual_instantiate(t1, inst_set); 474 TS_ASSERT(equal(*t2, *t3)) 475 pointerDelete(t2); 476 pointerDelete(t3); 477 478 inst_set.clear(); 479 inst_set.insert(vars[0], 1); 480 inst_set.insert(vars[1], 0); 481 inst_set.insert(vars[2], 2); 482 inst_set.insert(vars[3], 3); 483 t2 = partialInstantiationMultiDimArray4Pointers(&t1, inst_set); 484 t3 = manual_instantiate(t1, inst_set); 485 TS_ASSERT(equal(*t2, *t3)) 486 pointerDelete(t2); 487 pointerDelete(t3); 488 489 for (gum::Idx i = 0; i < vars.size(); ++i) 490 delete vars[i]; 491 } 492 test_MultiDimImplementationPointer()493 void test_MultiDimImplementationPointer() { 494 std::vector< gum::LabelizedVariable* > vars(10); 495 496 for (gum::Idx i = 0; i < 10; ++i) { 497 std::stringstream str; 498 str << "x" << i; 499 std::string s = str.str(); 500 vars[i] = new gum::LabelizedVariable(s, s, 4); 501 } 502 503 gum::MultiDimArray< double* > t1; 504 505 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 506 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 507 randomInitPointer(&t1); 508 509 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 510 inst_set.insert(vars[2], 0); 511 inst_set.insert(vars[3], 2); 512 inst_set.insert(vars[5], 1); 513 inst_set.insert(vars[8], 3); 514 inst_set.insert(vars[9], 2); 515 516 gum::MultiDimImplementation< double* >* t2 517 = partialInstantiationMultiDimImplementation4Pointers(&t1, inst_set); 518 519 gum::MultiDimArray< double* >* t3 = manual_instantiate(t1, inst_set); 520 521 TS_ASSERT(equal(*t2, *t3)) 522 pointerDelete(t2); 523 pointerDelete(t3); 524 525 inst_set.clear(); 526 inst_set.insert(vars[6], 1); 527 inst_set.insert(vars[7], 0); 528 inst_set.insert(vars[8], 2); 529 inst_set.insert(vars[9], 3); 530 t2 = partialInstantiationMultiDimImplementation4Pointers(&t1, inst_set); 531 t3 = manual_instantiate(t1, inst_set); 532 TS_ASSERT(equal(*t2, *t3)) 533 pointerDelete(t2); 534 pointerDelete(t3); 535 536 inst_set.clear(); 537 inst_set.insert(vars[0], 1); 538 inst_set.insert(vars[1], 0); 539 inst_set.insert(vars[2], 2); 540 inst_set.insert(vars[3], 3); 541 t2 = partialInstantiationMultiDimImplementation4Pointers(&t1, inst_set); 542 t3 = manual_instantiate(t1, inst_set); 543 TS_ASSERT(equal(*t2, *t3)) 544 pointerDelete(t2); 545 pointerDelete(t3); 546 547 for (gum::Idx i = 0; i < vars.size(); ++i) 548 delete vars[i]; 549 } 550 test_partialInstantiation_init()551 void test_partialInstantiation_init() { 552 gum::partialInstantiation4MultiDimInit< double >(); 553 554 std::vector< gum::LabelizedVariable* > vars(10); 555 556 for (gum::Idx i = 0; i < 10; ++i) { 557 std::stringstream str; 558 str << "x" << i; 559 std::string s = str.str(); 560 vars[i] = new gum::LabelizedVariable(s, s, 4); 561 } 562 563 gum::MultiDimArray< double > t1; 564 565 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 566 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 567 randomInit(&t1); 568 569 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 570 inst_set.insert(vars[2], 0); 571 inst_set.insert(vars[3], 2); 572 inst_set.insert(vars[5], 1); 573 inst_set.insert(vars[8], 3); 574 inst_set.insert(vars[9], 2); 575 576 gum::MultiDimImplementation< double >* t2 = partialInstantiation(t1, inst_set); 577 gum::MultiDimArray< double >* t3 = manual_instantiate(t1, inst_set); 578 579 TS_ASSERT(*t2 == *t3) 580 delete t2; 581 delete t3; 582 583 inst_set.clear(); 584 inst_set.insert(vars[6], 1); 585 inst_set.insert(vars[7], 0); 586 inst_set.insert(vars[8], 2); 587 inst_set.insert(vars[9], 3); 588 t2 = partialInstantiation(t1, inst_set); 589 t3 = manual_instantiate(t1, inst_set); 590 TS_ASSERT(*t2 == *t3) 591 delete t2; 592 delete t3; 593 594 inst_set.clear(); 595 inst_set.insert(vars[0], 1); 596 inst_set.insert(vars[1], 0); 597 inst_set.insert(vars[2], 2); 598 inst_set.insert(vars[3], 3); 599 t2 = partialInstantiation(t1, inst_set); 600 t3 = manual_instantiate(t1, inst_set); 601 TS_ASSERT(*t2 == *t3) 602 delete t2; 603 delete t3; 604 605 for (gum::Idx i = 0; i < vars.size(); ++i) 606 delete vars[i]; 607 } 608 test_partialInstantiationPointer_init()609 void test_partialInstantiationPointer_init() { 610 gum::pointerPartialInstantiation4MultiDimInit< double >(); 611 612 std::vector< gum::LabelizedVariable* > vars(10); 613 614 for (gum::Idx i = 0; i < 10; ++i) { 615 std::stringstream str; 616 str << "x" << i; 617 std::string s = str.str(); 618 vars[i] = new gum::LabelizedVariable(s, s, 4); 619 } 620 621 gum::MultiDimArray< double* > t1; 622 623 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 624 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 625 randomInitPointer(&t1); 626 627 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 628 inst_set.insert(vars[2], 0); 629 inst_set.insert(vars[3], 2); 630 inst_set.insert(vars[5], 1); 631 inst_set.insert(vars[8], 3); 632 inst_set.insert(vars[9], 2); 633 634 gum::MultiDimImplementation< double* >* t2 = partialInstantiation(t1, inst_set); 635 gum::MultiDimArray< double* >* t3 = manual_instantiate(t1, inst_set); 636 637 TS_ASSERT(equal(*t2, *t3)) 638 pointerDelete(t2); 639 pointerDelete(t3); 640 641 inst_set.clear(); 642 inst_set.insert(vars[6], 1); 643 inst_set.insert(vars[7], 0); 644 inst_set.insert(vars[8], 2); 645 inst_set.insert(vars[9], 3); 646 t2 = partialInstantiation(t1, inst_set); 647 t3 = manual_instantiate(t1, inst_set); 648 TS_ASSERT(equal(*t2, *t3)) 649 pointerDelete(t2); 650 pointerDelete(t3); 651 652 inst_set.clear(); 653 inst_set.insert(vars[0], 1); 654 inst_set.insert(vars[1], 0); 655 inst_set.insert(vars[2], 2); 656 inst_set.insert(vars[3], 3); 657 t2 = partialInstantiation(t1, inst_set); 658 t3 = manual_instantiate(t1, inst_set); 659 TS_ASSERT(equal(*t2, *t3)) 660 pointerDelete(t2); 661 pointerDelete(t3); 662 663 for (gum::Idx i = 0; i < vars.size(); ++i) 664 delete vars[i]; 665 } 666 test_potential()667 void test_potential() { 668 std::vector< gum::LabelizedVariable* > vars(10); 669 670 for (gum::Idx i = 0; i < 10; ++i) { 671 std::stringstream str; 672 str << "x" << i; 673 std::string s = str.str(); 674 vars[i] = new gum::LabelizedVariable(s, s, 4); 675 } 676 677 gum::Potential< double > t1; 678 679 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 680 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 681 randomInitP(t1); 682 683 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 684 inst_set.insert(vars[2], 0); 685 inst_set.insert(vars[3], 2); 686 inst_set.insert(vars[5], 1); 687 inst_set.insert(vars[8], 3); 688 inst_set.insert(vars[9], 2); 689 690 gum::Potential< double >* t2 691 = new gum::Potential< double >(partialInstantiation(t1, inst_set)); 692 gum::Potential< double >* t3 = manual_instantiate(t1, inst_set); 693 694 TS_ASSERT(*t2 == *t3) 695 delete t2; 696 delete t3; 697 698 inst_set.clear(); 699 inst_set.insert(vars[6], 1); 700 inst_set.insert(vars[7], 0); 701 inst_set.insert(vars[8], 2); 702 inst_set.insert(vars[9], 3); 703 t2 = new gum::Potential< double >(partialInstantiation(t1, inst_set)); 704 t3 = manual_instantiate(t1, inst_set); 705 TS_ASSERT(*t2 == *t3) 706 delete t2; 707 delete t3; 708 709 inst_set.clear(); 710 inst_set.insert(vars[0], 1); 711 inst_set.insert(vars[1], 0); 712 inst_set.insert(vars[2], 2); 713 inst_set.insert(vars[3], 3); 714 t2 = new gum::Potential< double >(partialInstantiation(t1, inst_set)); 715 t3 = manual_instantiate(t1, inst_set); 716 TS_ASSERT(*t2 == *t3) 717 delete t2; 718 delete t3; 719 720 for (gum::Idx i = 0; i < vars.size(); ++i) 721 delete vars[i]; 722 } 723 test_potential_pointer()724 void test_potential_pointer() { 725 std::vector< gum::LabelizedVariable* > vars(10); 726 727 for (gum::Idx i = 0; i < 10; ++i) { 728 std::stringstream str; 729 str << "x" << i; 730 std::string s = str.str(); 731 vars[i] = new gum::LabelizedVariable(s, s, 4); 732 } 733 734 gum::Potential< double* > t1; 735 736 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 737 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 738 randomInitPPointer(t1); 739 740 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 741 inst_set.insert(vars[2], 0); 742 inst_set.insert(vars[3], 2); 743 inst_set.insert(vars[5], 1); 744 inst_set.insert(vars[8], 3); 745 inst_set.insert(vars[9], 2); 746 747 gum::Potential< double* >* t2 748 = new gum::Potential< double* >(partialInstantiation(t1, inst_set)); 749 gum::Potential< double* >* t3 = manual_instantiate(t1, inst_set); 750 751 TS_ASSERT(equal(*t2, *t3)) 752 pointerDelete(t2); 753 pointerDelete(t3); 754 755 inst_set.clear(); 756 inst_set.insert(vars[6], 1); 757 inst_set.insert(vars[7], 0); 758 inst_set.insert(vars[8], 2); 759 inst_set.insert(vars[9], 3); 760 t2 = new gum::Potential< double* >(partialInstantiation(t1, inst_set)); 761 t3 = manual_instantiate(t1, inst_set); 762 TS_ASSERT(equal(*t2, *t3)) 763 pointerDelete(t2); 764 pointerDelete(t3); 765 766 inst_set.clear(); 767 inst_set.insert(vars[0], 1); 768 inst_set.insert(vars[1], 0); 769 inst_set.insert(vars[2], 2); 770 inst_set.insert(vars[3], 3); 771 t2 = new gum::Potential< double* >(partialInstantiation(t1, inst_set)); 772 t3 = manual_instantiate(t1, inst_set); 773 TS_ASSERT(equal(*t2, *t3)) 774 pointerDelete(t2); 775 pointerDelete(t3); 776 777 for (gum::Idx i = 0; i < vars.size(); ++i) 778 delete vars[i]; 779 } 780 test_multidimPartialInstantiation()781 void test_multidimPartialInstantiation() { 782 std::vector< gum::LabelizedVariable* > vars(10); 783 784 for (gum::Idx i = 0; i < 10; ++i) { 785 std::stringstream str; 786 str << "x" << i; 787 std::string s = str.str(); 788 vars[i] = new gum::LabelizedVariable(s, s, 4); 789 } 790 791 gum::MultiDimPartialInstantiation< double, gum::Potential > MDPI; 792 793 gum::Potential< double > t1; 794 795 t1 << *(vars[0]) << *(vars[1]) << *(vars[2]) << *(vars[3]) << *(vars[4]) << *(vars[5]) 796 << *(vars[6]) << *(vars[7]) << *(vars[8]) << *(vars[9]); 797 randomInitP(t1); 798 799 gum::HashTable< const gum::DiscreteVariable*, gum::Idx > inst_set; 800 inst_set.insert(vars[2], 0); 801 inst_set.insert(vars[3], 2); 802 inst_set.insert(vars[5], 1); 803 inst_set.insert(vars[8], 3); 804 inst_set.insert(vars[9], 2); 805 806 gum::Potential< double >* t2 = MDPI.instantiate(t1, inst_set); 807 gum::Potential< double >* t3 = manual_instantiate(t1, inst_set); 808 809 TS_ASSERT(*t2 == *t3) 810 delete t2; 811 delete t3; 812 813 inst_set.clear(); 814 inst_set.insert(vars[6], 1); 815 inst_set.insert(vars[7], 0); 816 inst_set.insert(vars[8], 2); 817 inst_set.insert(vars[9], 3); 818 t2 = MDPI.instantiate(t1, inst_set); 819 t3 = manual_instantiate(t1, inst_set); 820 TS_ASSERT(*t2 == *t3) 821 delete t2; 822 delete t3; 823 824 inst_set.clear(); 825 inst_set.insert(vars[0], 1); 826 inst_set.insert(vars[1], 0); 827 inst_set.insert(vars[2], 2); 828 inst_set.insert(vars[3], 3); 829 t2 = MDPI.instantiate(t1, inst_set); 830 t3 = manual_instantiate(t1, inst_set); 831 TS_ASSERT(*t2 == *t3) 832 delete t2; 833 delete t3; 834 835 for (gum::Idx i = 0; i < vars.size(); ++i) 836 delete vars[i]; 837 } 838 }; 839 840 } /* namespace gum_tests */ 841