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