1 #include "TestMainEffectsConverter.h"
2 #include <cstdlib>
3 #include <cstdio>
4 #include <fstream>
5 #include <iostream>
6 #include <vector>
7 #include <string>
8 #include <limits>
9 
10 using namespace std;
11 
12 
13 TestMainEffectsConverter::
TestMainEffectsConverter()14     TestMainEffectsConverter(){
15 }
16 
17 TestMainEffectsConverter::
~TestMainEffectsConverter()18     ~TestMainEffectsConverter(){
19 }
20 
run()21 void TestMainEffectsConverter::run() {
22 
23 	testConstructor();
24 	testConvert();
25     testConvertTableOfDoublesToArray();
26 	testConvertAllDoublesToCountingNumbers();
27 	testSliceOutOneInputVarAndOneOutputVar();
28 }
29 
30 
31 void TestMainEffectsConverter::
testConvertTableOfDoublesToArray()32     testConvertTableOfDoublesToArray() {
33 
34     	MainEffectsConverter x;
35 
36     	/* empty input data */
37     	std::vector<std::vector<double> > vectorInputDataPoints;
38         ValueAndRowIndexAndColumnIndex * array =
39     	    x.convertTableOfDoublesToArray
40     	    (vectorInputDataPoints);
41     	//Can't test for an empty array
42     	delete[] array;
43 
44     	/* one data point */
45     	vectorInputDataPoints.clear();
46     	std::vector<double> row1;
47     	row1.push_back(5);
48     	vectorInputDataPoints.push_back(row1);
49         array =
50     	    x.convertTableOfDoublesToArray
51     	    (vectorInputDataPoints);
52     	_test(array[0].value==5);
53     	_test(array[0].indexRow==0);
54     	_test(array[0].indexColumn==0);
55         delete[] array;
56 
57     	/* one row, two columns */
58     	vectorInputDataPoints.clear();
59     	row1.clear();
60     	row1.push_back(5);
61     	row1.push_back(6);
62     	vectorInputDataPoints.push_back(row1);
63         array =
64     	    x.convertTableOfDoublesToArray
65     	    (vectorInputDataPoints);
66 
67     	_test(array[0].value==5);
68     	_test(array[0].indexRow==0);
69     	_test(array[0].indexColumn==0);
70 
71     	_test(array[1].value==6);
72     	_test(array[1].indexRow==0);
73     	_test(array[1].indexColumn==1);
74 
75     	delete[] array;
76 
77 
78 
79     	/* one row, three columns */
80     	vectorInputDataPoints.clear();
81     	row1.clear();
82     	row1.push_back(5);
83     	row1.push_back(6);
84     	row1.push_back(7);
85     	vectorInputDataPoints.push_back(row1);
86         array =
87     	    x.convertTableOfDoublesToArray
88     	    (vectorInputDataPoints);
89 
90     	_test(array[0].value==5);
91     	_test(array[0].indexRow==0);
92     	_test(array[0].indexColumn==0);
93 
94     	_test(array[1].value==6);
95     	_test(array[1].indexRow==0);
96     	_test(array[1].indexColumn==1);
97 
98     	_test(array[2].value==7);
99     	_test(array[2].indexRow==0);
100     	_test(array[2].indexColumn==2);
101 
102 
103     	delete[] array;
104 
105 
106     	/* two rows, one column */
107     	vectorInputDataPoints.clear();
108     	row1.clear();
109     	row1.push_back(5);
110         std::vector<double>row2;
111         row2.push_back(6);
112     	vectorInputDataPoints.push_back(row1);
113     	vectorInputDataPoints.push_back(row2);
114         array =
115     	    x.convertTableOfDoublesToArray
116     	    (vectorInputDataPoints);
117 
118     	_test(array[0].value==5);
119     	_test(array[0].indexRow==0);
120     	_test(array[0].indexColumn==0);
121 
122     	_test(array[1].value==6);
123     	_test(array[1].indexRow==1);
124     	_test(array[1].indexColumn==0);
125 
126     	delete[] array;
127 
128 
129     	/* three rows in ZYX order, one column */
130     	vectorInputDataPoints.clear();
131     	row1.clear();
132     	row2.clear();
133     	std::vector<double>row3;
134     	row1.push_back(7);
135     	row2.push_back(6);
136         row3.push_back(5);
137     	vectorInputDataPoints.push_back(row1);
138     	vectorInputDataPoints.push_back(row2);
139     	vectorInputDataPoints.push_back(row3);
140         array =
141     	    x.convertTableOfDoublesToArray
142     	    (vectorInputDataPoints);
143 
144     	_test(array[0].value==7);
145     	_test(array[0].indexRow==0);
146     	_test(array[0].indexColumn==0);
147 
148     	_test(array[1].value==6);
149     	_test(array[1].indexRow==1);
150     	_test(array[1].indexColumn==0);
151 
152     	_test(array[2].value==5);
153     	_test(array[2].indexRow==2);
154     	_test(array[2].indexColumn==0);
155 
156     	delete[] array;
157 
158 
159     	/* two rows, two columns in random order */
160     	vectorInputDataPoints.clear();
161     	row1.clear();
162     	row2.clear();
163     	row1.push_back(5);
164     	row1.push_back(7);
165     	row2.push_back(5);
166         row2.push_back(6);
167     	vectorInputDataPoints.push_back(row1);
168     	vectorInputDataPoints.push_back(row2);
169         array =
170     	    x.convertTableOfDoublesToArray
171     	    (vectorInputDataPoints);
172 
173     	_test(array[0].value==5);
174     	_test(array[0].indexRow==0);
175     	_test(array[0].indexColumn==0);
176 
177     	_test(array[1].value==7);
178     	_test(array[1].indexRow==0);
179     	_test(array[1].indexColumn==1);
180 
181     	_test(array[2].value==5);
182     	_test(array[2].indexRow==1);
183     	_test(array[2].indexColumn==0);
184 
185     	_test(array[3].value==6);
186     	_test(array[3].indexRow==1);
187     	_test(array[3].indexColumn==1);
188 
189     	delete[] array;
190 
191     	/* three rows, three columns in random order */
192     	vectorInputDataPoints.clear();
193     	row1.clear();
194     	row2.clear();
195     	row3.clear();
196     	row1.push_back(5);
197     	row1.push_back(7);
198     	row1.push_back(6);
199     	row2.push_back(5);
200         row2.push_back(6);
201         row2.push_back(5);
202     	row3.push_back(7);
203         row3.push_back(6);
204         row3.push_back(7);
205     	vectorInputDataPoints.push_back(row1);
206     	vectorInputDataPoints.push_back(row2);
207         vectorInputDataPoints.push_back(row3);
208         array =
209     	    x.convertTableOfDoublesToArray
210     	    (vectorInputDataPoints);
211 
212     	_test(array[0].value==5);
213     	_test(array[0].indexRow==0);
214     	_test(array[0].indexColumn==0);
215 
216     	_test(array[1].value==7);
217     	_test(array[1].indexRow==0);
218     	_test(array[1].indexColumn==1);
219 
220         _test(array[2].value==6);
221     	_test(array[2].indexRow==0);
222     	_test(array[2].indexColumn==2);
223 
224     	_test(array[3].value==5);
225     	_test(array[3].indexRow==1);
226     	_test(array[3].indexColumn==0);
227 
228     	_test(array[4].value==6);
229     	_test(array[4].indexRow==1);
230     	_test(array[4].indexColumn==1);
231 
232         _test(array[5].value==5);
233     	_test(array[5].indexRow==1);
234     	_test(array[5].indexColumn==2);
235 
236     	_test(array[6].value==7);
237     	_test(array[6].indexRow==2);
238     	_test(array[6].indexColumn==0);
239 
240     	_test(array[7].value==6);
241     	_test(array[7].indexRow==2);
242     	_test(array[7].indexColumn==1);
243 
244         _test(array[8].value==7);
245     	_test(array[8].indexRow==2);
246     	_test(array[8].indexColumn==2);
247 
248         delete[] array;
249 }
250 
251 
252 void TestMainEffectsConverter::
testConvertAllDoublesToCountingNumbers()253     testConvertAllDoublesToCountingNumbers(){
254 
255     	MainEffectsConverter x;
256 
257     	/* empty input data */
258     	std::vector<std::vector<double> > vectorInputDataPoints;
259         VectorCountingNumbersAndCount vectorAndCount =
260     	    x.convertAllDoublesToCountingNumbers
261     	    (vectorInputDataPoints);
262         std::vector<std::vector<int> > vectorCountingNumbers =
263             vectorAndCount.vectorCountingNumbers;
264         int count = vectorAndCount.count;
265         _test(count==0);
266 
267 
268     	/* one data point */
269     	vectorInputDataPoints.clear();
270     	std::vector<double> row1;
271     	row1.push_back(5);
272     	vectorInputDataPoints.push_back(row1);
273         vectorAndCount =
274     	    x.convertAllDoublesToCountingNumbers
275     	    (vectorInputDataPoints);
276         vectorCountingNumbers =
277             vectorAndCount.vectorCountingNumbers;
278         count = vectorAndCount.count;
279         _test(count==1);
280         _test(vectorCountingNumbers[0][0]==0);
281 
282     	/* one row, two columns */
283     	vectorInputDataPoints.clear();
284     	row1.clear();
285     	row1.push_back(5);
286     	row1.push_back(6);
287     	vectorInputDataPoints.push_back(row1);
288         vectorAndCount =
289     	    x.convertAllDoublesToCountingNumbers
290     	    (vectorInputDataPoints);
291         vectorCountingNumbers =
292             vectorAndCount.vectorCountingNumbers;
293         count = vectorAndCount.count;
294         _test(count==2);
295         _test(vectorCountingNumbers[0][0]==0);
296         _test(vectorCountingNumbers[0][1]==1);
297 
298 
299     	/* one row, two columns in ZYX order */
300     	vectorInputDataPoints.clear();
301     	row1.clear();
302     	row1.push_back(6);
303     	row1.push_back(5);
304     	vectorInputDataPoints.push_back(row1);
305         vectorAndCount =
306     	    x.convertAllDoublesToCountingNumbers
307     	    (vectorInputDataPoints);
308         vectorCountingNumbers =
309             vectorAndCount.vectorCountingNumbers;
310         count = vectorAndCount.count;
311         _test(count==2);
312         _test(vectorCountingNumbers[0][0]==1);
313         _test(vectorCountingNumbers[0][1]==0);
314 
315     	/* one row, three columns */
316     	vectorInputDataPoints.clear();
317     	row1.clear();
318     	row1.push_back(5);
319     	row1.push_back(6);
320     	row1.push_back(7);
321     	vectorInputDataPoints.push_back(row1);
322         vectorAndCount =
323     	    x.convertAllDoublesToCountingNumbers
324     	    (vectorInputDataPoints);
325         vectorCountingNumbers =
326             vectorAndCount.vectorCountingNumbers;
327         count = vectorAndCount.count;
328         _test(count==3);
329         _test(vectorCountingNumbers[0][0]==0);
330         _test(vectorCountingNumbers[0][1]==1);
331         _test(vectorCountingNumbers[0][2]==2);
332 
333     	/* one row, three columns in ZYX order */
334     	vectorInputDataPoints.clear();
335     	row1.clear();
336     	row1.push_back(7);
337     	row1.push_back(6);
338     	row1.push_back(5);
339     	vectorInputDataPoints.push_back(row1);
340         vectorAndCount =
341     	    x.convertAllDoublesToCountingNumbers
342     	    (vectorInputDataPoints);
343         vectorCountingNumbers =
344             vectorAndCount.vectorCountingNumbers;
345         count = vectorAndCount.count;
346         _test(count==3);
347         _test(vectorCountingNumbers[0][0]==2);
348         _test(vectorCountingNumbers[0][1]==1);
349         _test(vectorCountingNumbers[0][2]==0);
350 
351     	/* one row, three columns in random order */
352     	vectorInputDataPoints.clear();
353     	row1.clear();
354     	row1.push_back(5);
355     	row1.push_back(7);
356     	row1.push_back(6);
357     	vectorInputDataPoints.push_back(row1);
358         vectorAndCount =
359     	    x.convertAllDoublesToCountingNumbers
360     	    (vectorInputDataPoints);
361         vectorCountingNumbers =
362             vectorAndCount.vectorCountingNumbers;
363         count = vectorAndCount.count;
364         _test(count==3);
365         _test(vectorCountingNumbers[0][0]==0);
366         _test(vectorCountingNumbers[0][1]==2);
367         _test(vectorCountingNumbers[0][2]==1);
368 
369     	/* one row, three columns in random order */
370     	vectorInputDataPoints.clear();
371     	row1.clear();
372     	row1.push_back(6);
373     	row1.push_back(5);
374     	row1.push_back(7);
375     	vectorInputDataPoints.push_back(row1);
376         vectorAndCount =
377     	    x.convertAllDoublesToCountingNumbers
378     	    (vectorInputDataPoints);
379         vectorCountingNumbers =
380             vectorAndCount.vectorCountingNumbers;
381         count = vectorAndCount.count;
382         _test(count==3);
383         _test(vectorCountingNumbers[0][0]==1);
384         _test(vectorCountingNumbers[0][1]==0);
385         _test(vectorCountingNumbers[0][2]==2);
386 
387     	/* one row, three columns in random order */
388     	vectorInputDataPoints.clear();
389     	row1.clear();
390     	row1.push_back(7);
391     	row1.push_back(5);
392     	row1.push_back(6);
393     	vectorInputDataPoints.push_back(row1);
394         vectorAndCount =
395     	    x.convertAllDoublesToCountingNumbers
396     	    (vectorInputDataPoints);
397         vectorCountingNumbers =
398             vectorAndCount.vectorCountingNumbers;
399         count = vectorAndCount.count;
400         _test(count==3);
401         _test(vectorCountingNumbers[0][0]==2);
402         _test(vectorCountingNumbers[0][1]==0);
403         _test(vectorCountingNumbers[0][2]==1);
404 
405     	/* two rows, one column */
406     	vectorInputDataPoints.clear();
407     	row1.clear();
408     	row1.push_back(5);
409         std::vector<double>row2;
410         row2.push_back(6);
411     	vectorInputDataPoints.push_back(row1);
412     	vectorInputDataPoints.push_back(row2);
413         vectorAndCount =
414     	    x.convertAllDoublesToCountingNumbers
415     	    (vectorInputDataPoints);
416         vectorCountingNumbers =
417             vectorAndCount.vectorCountingNumbers;
418         count = vectorAndCount.count;
419         _test(count==2);
420         _test(vectorCountingNumbers[0][0]==0);
421         _test(vectorCountingNumbers[1][0]==1);
422 
423     	/* two rows in ZYX order, one column */
424     	vectorInputDataPoints.clear();
425     	row1.clear();
426     	row2.clear();
427     	row1.push_back(6);
428         row2.push_back(5);
429     	vectorInputDataPoints.push_back(row1);
430     	vectorInputDataPoints.push_back(row2);
431         vectorAndCount =
432     	    x.convertAllDoublesToCountingNumbers
433     	    (vectorInputDataPoints);
434         vectorCountingNumbers =
435             vectorAndCount.vectorCountingNumbers;
436         count = vectorAndCount.count;
437         _test(count==2);
438         _test(vectorCountingNumbers[0][0]==1);
439         _test(vectorCountingNumbers[1][0]==0);
440 
441     	/* three rows, one column */
442     	vectorInputDataPoints.clear();
443     	row1.clear();
444     	row2.clear();
445     	row1.push_back(5);
446     	row2.push_back(6);
447         std::vector<double>row3;
448         row3.push_back(7);
449     	vectorInputDataPoints.push_back(row1);
450     	vectorInputDataPoints.push_back(row2);
451     	vectorInputDataPoints.push_back(row3);
452         vectorAndCount =
453     	    x.convertAllDoublesToCountingNumbers
454     	    (vectorInputDataPoints);
455         vectorCountingNumbers =
456             vectorAndCount.vectorCountingNumbers;
457         count = vectorAndCount.count;
458         _test(count==3);
459         _test(vectorCountingNumbers[0][0]==0);
460         _test(vectorCountingNumbers[1][0]==1);
461         _test(vectorCountingNumbers[2][0]==2);
462 
463 
464     	/* three rows in ZYX order, one column */
465     	vectorInputDataPoints.clear();
466     	row1.clear();
467     	row2.clear();
468     	row3.clear();
469     	row1.push_back(7);
470     	row2.push_back(6);
471         row3.push_back(5);
472     	vectorInputDataPoints.push_back(row1);
473     	vectorInputDataPoints.push_back(row2);
474     	vectorInputDataPoints.push_back(row3);
475         vectorAndCount =
476     	    x.convertAllDoublesToCountingNumbers
477     	    (vectorInputDataPoints);
478         vectorCountingNumbers =
479             vectorAndCount.vectorCountingNumbers;
480         count = vectorAndCount.count;
481         _test(count==3);
482         _test(vectorCountingNumbers[0][0]==2);
483         _test(vectorCountingNumbers[1][0]==1);
484         _test(vectorCountingNumbers[2][0]==0);
485 
486     	/* three rows in random order, one column */
487     	vectorInputDataPoints.clear();
488     	row1.clear();
489     	row2.clear();
490     	row3.clear();
491     	row1.push_back(5);
492     	row2.push_back(7);
493         row3.push_back(6);
494     	vectorInputDataPoints.push_back(row1);
495     	vectorInputDataPoints.push_back(row2);
496     	vectorInputDataPoints.push_back(row3);
497         vectorAndCount =
498     	    x.convertAllDoublesToCountingNumbers
499     	    (vectorInputDataPoints);
500         vectorCountingNumbers =
501             vectorAndCount.vectorCountingNumbers;
502         count = vectorAndCount.count;
503         _test(count==3);
504         _test(vectorCountingNumbers[0][0]==0);
505         _test(vectorCountingNumbers[1][0]==2);
506         _test(vectorCountingNumbers[2][0]==1);
507 
508     	/* three rows in ZYX order, one column */
509     	vectorInputDataPoints.clear();
510     	row1.clear();
511     	row2.clear();
512     	row3.clear();
513     	row1.push_back(6);
514     	row2.push_back(5);
515         row3.push_back(7);
516     	vectorInputDataPoints.push_back(row1);
517     	vectorInputDataPoints.push_back(row2);
518     	vectorInputDataPoints.push_back(row3);
519         vectorAndCount =
520     	    x.convertAllDoublesToCountingNumbers
521     	    (vectorInputDataPoints);
522         vectorCountingNumbers =
523             vectorAndCount.vectorCountingNumbers;
524         count = vectorAndCount.count;
525         _test(count==3);
526         _test(vectorCountingNumbers[0][0]==1);
527         _test(vectorCountingNumbers[1][0]==0);
528         _test(vectorCountingNumbers[2][0]==2);
529 
530     	/* three rows in ZYX order, one column */
531     	vectorInputDataPoints.clear();
532     	row1.clear();
533     	row2.clear();
534     	row3.clear();
535     	row1.push_back(6);
536     	row2.push_back(7);
537         row3.push_back(5);
538     	vectorInputDataPoints.push_back(row1);
539     	vectorInputDataPoints.push_back(row2);
540     	vectorInputDataPoints.push_back(row3);
541         vectorAndCount =
542     	    x.convertAllDoublesToCountingNumbers
543     	    (vectorInputDataPoints);
544         vectorCountingNumbers =
545             vectorAndCount.vectorCountingNumbers;
546         count = vectorAndCount.count;
547         _test(count==3);
548         _test(vectorCountingNumbers[0][0]==1);
549         _test(vectorCountingNumbers[1][0]==2);
550         _test(vectorCountingNumbers[2][0]==0);
551 
552     	/* three rows in ZYX order, one column */
553     	vectorInputDataPoints.clear();
554     	row1.clear();
555     	row2.clear();
556     	row3.clear();
557     	row1.push_back(7);
558     	row2.push_back(5);
559         row3.push_back(6);
560     	vectorInputDataPoints.push_back(row1);
561     	vectorInputDataPoints.push_back(row2);
562     	vectorInputDataPoints.push_back(row3);
563         vectorAndCount =
564     	    x.convertAllDoublesToCountingNumbers
565     	    (vectorInputDataPoints);
566         vectorCountingNumbers =
567             vectorAndCount.vectorCountingNumbers;
568         count = vectorAndCount.count;
569         _test(count==3);
570         _test(vectorCountingNumbers[0][0]==2);
571         _test(vectorCountingNumbers[1][0]==0);
572         _test(vectorCountingNumbers[2][0]==1);
573 
574     	/* two rows, two columns in random order */
575     	vectorInputDataPoints.clear();
576     	row1.clear();
577     	row2.clear();
578     	row1.push_back(5);
579     	row1.push_back(7);
580     	row2.push_back(5);
581         row2.push_back(6);
582     	vectorInputDataPoints.push_back(row1);
583     	vectorInputDataPoints.push_back(row2);
584         vectorAndCount =
585     	    x.convertAllDoublesToCountingNumbers
586     	    (vectorInputDataPoints);
587         vectorCountingNumbers =
588             vectorAndCount.vectorCountingNumbers;
589         count = vectorAndCount.count;
590         _test(count==3);
591         _test(vectorCountingNumbers[0][0]==0);
592         _test(vectorCountingNumbers[0][1]==2);
593         _test(vectorCountingNumbers[1][0]==0);
594         _test(vectorCountingNumbers[1][1]==1);
595 
596     	/* three rows, three columns in random order */
597     	vectorInputDataPoints.clear();
598     	row1.clear();
599     	row2.clear();
600     	row3.clear();
601     	row1.push_back(5);
602     	row1.push_back(7);
603     	row1.push_back(6);
604     	row2.push_back(5);
605         row2.push_back(6);
606         row2.push_back(5);
607     	row3.push_back(7);
608         row3.push_back(6);
609         row3.push_back(7);
610     	vectorInputDataPoints.push_back(row1);
611     	vectorInputDataPoints.push_back(row2);
612         vectorInputDataPoints.push_back(row3);
613         vectorAndCount =
614     	    x.convertAllDoublesToCountingNumbers
615     	    (vectorInputDataPoints);
616         vectorCountingNumbers =
617             vectorAndCount.vectorCountingNumbers;
618         count = vectorAndCount.count;
619         _test(count==3);
620         _test(vectorCountingNumbers[0][0]==0);
621         _test(vectorCountingNumbers[0][1]==2);
622         _test(vectorCountingNumbers[0][2]==1);
623         _test(vectorCountingNumbers[1][0]==0);
624         _test(vectorCountingNumbers[1][1]==1);
625         _test(vectorCountingNumbers[1][2]==0);
626         _test(vectorCountingNumbers[2][0]==2);
627         _test(vectorCountingNumbers[2][1]==1);
628         _test(vectorCountingNumbers[2][2]==2);
629 
630 
631     	/* three rows, three columns, with noise in random order */
632     	vectorInputDataPoints.clear();
633     	row1.clear();
634     	row2.clear();
635     	row3.clear();
636     	row1.push_back(5.0001);
637     	row1.push_back(6.9999);
638     	row1.push_back(6);
639     	row2.push_back(4.9999);
640         row2.push_back(6.0001);
641         row2.push_back(5);
642     	row3.push_back(7);
643         row3.push_back(5.9999);
644         row3.push_back(7.0001);
645     	vectorInputDataPoints.push_back(row1);
646     	vectorInputDataPoints.push_back(row2);
647         vectorInputDataPoints.push_back(row3);
648         vectorAndCount =
649     	    x.convertAllDoublesToCountingNumbers
650     	    (vectorInputDataPoints);
651         vectorCountingNumbers =
652             vectorAndCount.vectorCountingNumbers;
653         count = vectorAndCount.count;
654         _test(count==3);
655         _test(vectorCountingNumbers[0][0]==0);
656         _test(vectorCountingNumbers[0][1]==2);
657         _test(vectorCountingNumbers[0][2]==1);
658         _test(vectorCountingNumbers[1][0]==0);
659         _test(vectorCountingNumbers[1][1]==1);
660         _test(vectorCountingNumbers[1][2]==0);
661         _test(vectorCountingNumbers[2][0]==2);
662         _test(vectorCountingNumbers[2][1]==1);
663         _test(vectorCountingNumbers[2][2]==2);
664 
665 
666  }
667 
668 
669 
670 
671 
672 void TestMainEffectsConverter::
testSliceOutOneInputVarAndOneOutputVar()673     testSliceOutOneInputVarAndOneOutputVar(){
674 
675     	MainEffectsConverter x;
676     	std::vector< std::vector<int> > vectorInputDataPoints(0);
677     	std::vector< std::vector<double> > vectorOutputDataPoints(0);
678     	int indexOfInputVariable = 0;
679     	int indexOfOutputVariable = 0;
680     	int numberOfValuesAvailableForOneInputVar = 0;
681     	std::vector<double> oneRowOfDoubles(0);
682     	std::vector<int> oneRowOfInts(0);
683     	std::vector<double> row2OfDoubles(0);
684     	std::vector<int> row2OfInts(0);
685     	DDaceMainEffects::Factor factor;
686     	std::vector<int> factors;
687     	DDaceMainEffects::Response responses;
688 
689 
690     	/* empty data sets */
691     	vectorInputDataPoints.clear();
692     	vectorOutputDataPoints.clear();
693     	indexOfInputVariable = 0;
694     	indexOfOutputVariable = 0;
695     	numberOfValuesAvailableForOneInputVar = 0;
696     	factor =
697     	    x.sliceOutOneInputVarAndOneOutputVar
698     	    (vectorInputDataPoints,
699     	     vectorOutputDataPoints,
700     	     indexOfInputVariable,
701     	     indexOfOutputVariable,
702     	     numberOfValuesAvailableForOneInputVar);
703     	factors = factor.getFactors();
704     	responses = factor.getResponse();
705     	_test(factors.size() == 0);
706     	_test(factor.getNumberOfLevels()==0);
707     	_test(responses.getNumOfObservations()==0);
708 
709     	/* left data set is empty */
710     	vectorInputDataPoints.clear();
711     	vectorOutputDataPoints.clear();
712     	oneRowOfDoubles.push_back(100.0);
713     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
714     	indexOfInputVariable = 0;
715         indexOfOutputVariable = 0;
716     	numberOfValuesAvailableForOneInputVar = 1;
717     	factor =
718     	    x.sliceOutOneInputVarAndOneOutputVar
719     	    (vectorInputDataPoints,
720     	     vectorOutputDataPoints,
721     	     indexOfInputVariable,
722     	     indexOfOutputVariable,
723     	     numberOfValuesAvailableForOneInputVar);
724     	factors = factor.getFactors();
725     	responses = factor.getResponse();
726     	_test(factors.size() == 0);
727     	_test(factor.getNumberOfLevels()==0);
728     	_test(responses.getNumOfObservations()==0);
729 
730     	/* right data set is empty */
731     	vectorInputDataPoints.clear();
732     	oneRowOfInts.push_back(0);
733     	vectorInputDataPoints.push_back(oneRowOfInts);
734     	vectorOutputDataPoints.clear();
735     	indexOfInputVariable = 0;
736         indexOfOutputVariable = 0;
737     	numberOfValuesAvailableForOneInputVar = 1;
738     	factor =
739     	    x.sliceOutOneInputVarAndOneOutputVar
740     	    (vectorInputDataPoints,
741     	     vectorOutputDataPoints,
742     	     indexOfInputVariable,
743     	     indexOfOutputVariable,
744     	     numberOfValuesAvailableForOneInputVar);
745     	factors = factor.getFactors();
746     	responses = factor.getResponse();
747     	_test(factors.size() == 0);
748     	_test(factor.getNumberOfLevels()==0);
749     	_test(responses.getNumOfObservations()==0);
750 
751 
752     	/* one data point */
753     	vectorInputDataPoints.clear();
754     	vectorInputDataPoints.push_back(oneRowOfInts);
755     	vectorOutputDataPoints.clear();
756     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
757     	indexOfInputVariable = 0;
758         indexOfOutputVariable = 0;
759     	numberOfValuesAvailableForOneInputVar = 1;
760     	factor =
761     	    x.sliceOutOneInputVarAndOneOutputVar
762     	    (vectorInputDataPoints,
763     	     vectorOutputDataPoints,
764     	     indexOfInputVariable,
765     	     indexOfOutputVariable,
766     	     numberOfValuesAvailableForOneInputVar);
767     	factors = factor.getFactors();
768     	responses = factor.getResponse();
769     	_test(factors.size() == 1);
770     	_test(factors[0] == 0);
771     	_test(factor.getNumberOfLevels()==1);
772     	_test(responses.getNumOfObservations()==1);
773     	_test(responses[0] == 100.0);
774 
775     	/* one row, 2 columns */
776     	vectorInputDataPoints.clear();
777     	oneRowOfInts.clear();
778     	oneRowOfInts.push_back(0);
779     	oneRowOfInts.push_back(1);
780     	vectorInputDataPoints.push_back(oneRowOfInts);
781     	vectorOutputDataPoints.clear();
782     	oneRowOfDoubles.clear();
783     	oneRowOfDoubles.push_back(100.0);
784     	oneRowOfDoubles.push_back(101.0);
785     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
786 
787     	indexOfInputVariable = 0;
788         indexOfOutputVariable = 0;
789     	numberOfValuesAvailableForOneInputVar = 2;
790     	factor =
791     	    x.sliceOutOneInputVarAndOneOutputVar
792     	    (vectorInputDataPoints,
793     	     vectorOutputDataPoints,
794     	     indexOfInputVariable,
795     	     indexOfOutputVariable,
796     	     numberOfValuesAvailableForOneInputVar);
797     	factors = factor.getFactors();
798     	responses = factor.getResponse();
799     	_test(factors.size() == 1);
800     	_test(factors[0] == 0);
801     	_test(factor.getNumberOfLevels()==1);
802     	_test(responses.getNumOfObservations()==1);
803     	_test(responses[0] == 100.0);
804 
805   	    indexOfInputVariable = 0;
806         indexOfOutputVariable = 1;
807     	numberOfValuesAvailableForOneInputVar = 2;
808     	factor =
809     	    x.sliceOutOneInputVarAndOneOutputVar
810     	    (vectorInputDataPoints,
811     	     vectorOutputDataPoints,
812     	     indexOfInputVariable,
813     	     indexOfOutputVariable,
814     	     numberOfValuesAvailableForOneInputVar);
815     	factors = factor.getFactors();
816     	responses = factor.getResponse();
817     	_test(factors.size() == 1);
818     	_test(factors[0] == 0);
819     	_test(factor.getNumberOfLevels()==1);
820     	_test(responses.getNumOfObservations()==1);
821     	_test(responses[0] == 101.0);
822 
823     	indexOfInputVariable = 1;
824         indexOfOutputVariable = 0;
825     	numberOfValuesAvailableForOneInputVar = 2;
826     	factor =
827     	    x.sliceOutOneInputVarAndOneOutputVar
828     	    (vectorInputDataPoints,
829     	     vectorOutputDataPoints,
830     	     indexOfInputVariable,
831     	     indexOfOutputVariable,
832     	     numberOfValuesAvailableForOneInputVar);
833     	factors = factor.getFactors();
834     	responses = factor.getResponse();
835     	_test(factors.size() == 1);
836     	_test(factors[0] == 1);
837     	_test(factor.getNumberOfLevels()==1);
838     	_test(responses.getNumOfObservations()==1);
839     	_test(responses[0] == 100.0);
840 
841     	indexOfInputVariable = 1;
842         indexOfOutputVariable = 1;
843     	numberOfValuesAvailableForOneInputVar = 2;
844     	factor =
845     	    x.sliceOutOneInputVarAndOneOutputVar
846     	    (vectorInputDataPoints,
847     	     vectorOutputDataPoints,
848     	     indexOfInputVariable,
849     	     indexOfOutputVariable,
850     	     numberOfValuesAvailableForOneInputVar);
851     	factors = factor.getFactors();
852     	responses = factor.getResponse();
853     	_test(factors.size() == 1);
854     	_test(factors[0] == 1);
855     	_test(factor.getNumberOfLevels()==1);
856     	_test(responses.getNumOfObservations()==1);
857     	_test(responses[0] == 101.0);
858 
859     	/* two rows, 1 column */
860     	vectorInputDataPoints.clear();
861     	oneRowOfInts.clear();
862     	oneRowOfInts.push_back(0);
863     	vectorInputDataPoints.push_back(oneRowOfInts);
864     	row2OfInts.clear();
865     	row2OfInts.push_back(1);
866     	vectorInputDataPoints.push_back(row2OfInts);
867     	vectorOutputDataPoints.clear();
868     	oneRowOfDoubles.clear();
869     	oneRowOfDoubles.push_back(100.0);
870     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
871     	row2OfDoubles.clear();
872     	row2OfDoubles.push_back(101.0);
873     	vectorOutputDataPoints.push_back(row2OfDoubles);
874 
875     	indexOfInputVariable = 0;
876         indexOfOutputVariable = 0;
877     	numberOfValuesAvailableForOneInputVar = 2;
878     	factor =
879     	    x.sliceOutOneInputVarAndOneOutputVar
880     	    (vectorInputDataPoints,
881     	     vectorOutputDataPoints,
882     	     indexOfInputVariable,
883     	     indexOfOutputVariable,
884     	     numberOfValuesAvailableForOneInputVar);
885     	factors = factor.getFactors();
886     	responses = factor.getResponse();
887     	_test(factors.size() == 2);
888     	_test(factors[0] == 0);
889     	_test(factors[1] == 1);
890     	_test(factor.getNumberOfLevels()==2);
891     	_test(responses.getNumOfObservations()==2);
892     	_test(responses[0] == 100.0);
893     	_test(responses[1] == 101.0);
894 
895     	/* two rows, 1 column */
896     	vectorInputDataPoints.clear();
897     	oneRowOfInts.clear();
898     	oneRowOfInts.push_back(1);
899     	vectorInputDataPoints.push_back(oneRowOfInts);
900     	row2OfInts.clear();
901     	row2OfInts.push_back(0);
902     	vectorInputDataPoints.push_back(row2OfInts);
903     	vectorOutputDataPoints.clear();
904     	oneRowOfDoubles.clear();
905     	oneRowOfDoubles.push_back(101.0);
906     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
907     	row2OfDoubles.clear();
908     	row2OfDoubles.push_back(100.0);
909     	vectorOutputDataPoints.push_back(row2OfDoubles);
910 
911     	indexOfInputVariable = 0;
912         indexOfOutputVariable = 0;
913     	numberOfValuesAvailableForOneInputVar = 2;
914     	factor =
915     	    x.sliceOutOneInputVarAndOneOutputVar
916     	    (vectorInputDataPoints,
917     	     vectorOutputDataPoints,
918     	     indexOfInputVariable,
919     	     indexOfOutputVariable,
920     	     numberOfValuesAvailableForOneInputVar);
921     	factors = factor.getFactors();
922     	responses = factor.getResponse();
923     	_test(factors.size() == 2);
924     	_test(factors[0] == 1);
925     	_test(factors[1] == 0);
926     	_test(factor.getNumberOfLevels()==2);
927     	_test(responses.getNumOfObservations()==2);
928     	_test(responses[0] == 101.0);
929     	_test(responses[1] == 100.0);
930 
931     	/* two rows, 2 columns */
932     	vectorInputDataPoints.clear();
933     	oneRowOfInts.clear();
934     	oneRowOfInts.push_back(0);
935     	oneRowOfInts.push_back(1);
936     	vectorInputDataPoints.push_back(oneRowOfInts);
937     	row2OfInts.clear();
938     	row2OfInts.push_back(2);
939     	row2OfInts.push_back(3);
940     	vectorInputDataPoints.push_back(row2OfInts);
941     	vectorOutputDataPoints.clear();
942     	oneRowOfDoubles.clear();
943     	oneRowOfDoubles.push_back(100.0);
944     	oneRowOfDoubles.push_back(101.0);
945     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
946     	row2OfDoubles.clear();
947     	row2OfDoubles.push_back(102.0);
948         row2OfDoubles.push_back(103.0);
949     	vectorOutputDataPoints.push_back(row2OfDoubles);
950 
951 
952     	indexOfInputVariable = 0;
953         indexOfOutputVariable = 0;
954     	numberOfValuesAvailableForOneInputVar = 4;
955     	factor =
956     	    x.sliceOutOneInputVarAndOneOutputVar
957     	    (vectorInputDataPoints,
958     	     vectorOutputDataPoints,
959     	     indexOfInputVariable,
960     	     indexOfOutputVariable,
961     	     numberOfValuesAvailableForOneInputVar);
962     	factors = factor.getFactors();
963     	responses = factor.getResponse();
964     	_test(factors.size() == 2);
965     	_test(factors[0] == 0);
966     	_test(factors[1] == 2);
967     	_test(factor.getNumberOfLevels()==2);
968     	_test(responses.getNumOfObservations()==2);
969     	_test(responses[0] == 100.0);
970     	_test(responses[1] == 102.0);
971 
972     	indexOfInputVariable = 0;
973         indexOfOutputVariable = 1;
974     	numberOfValuesAvailableForOneInputVar = 4;
975     	factor =
976     	    x.sliceOutOneInputVarAndOneOutputVar
977     	    (vectorInputDataPoints,
978     	     vectorOutputDataPoints,
979     	     indexOfInputVariable,
980     	     indexOfOutputVariable,
981     	     numberOfValuesAvailableForOneInputVar);
982     	factors = factor.getFactors();
983     	responses = factor.getResponse();
984     	_test(factors.size() == 2);
985     	_test(factors[0] == 0);
986     	_test(factors[1] == 2);
987     	_test(factor.getNumberOfLevels()==2);
988     	_test(responses.getNumOfObservations()==2);
989     	_test(responses[0] == 101.0);
990     	_test(responses[1] == 103.0);
991 
992     	indexOfInputVariable = 1;
993         indexOfOutputVariable = 0;
994     	numberOfValuesAvailableForOneInputVar = 4;
995     	factor =
996     	    x.sliceOutOneInputVarAndOneOutputVar
997     	    (vectorInputDataPoints,
998     	     vectorOutputDataPoints,
999     	     indexOfInputVariable,
1000     	     indexOfOutputVariable,
1001     	     numberOfValuesAvailableForOneInputVar);
1002     	factors = factor.getFactors();
1003     	responses = factor.getResponse();
1004     	_test(factors.size() == 2);
1005     	_test(factors[0] == 1);
1006     	_test(factors[1] == 3);
1007     	_test(factor.getNumberOfLevels()==2);
1008     	_test(responses.getNumOfObservations()==2);
1009     	_test(responses[0] == 100.0);
1010     	_test(responses[1] == 102.0);
1011 
1012     	indexOfInputVariable = 1;
1013         indexOfOutputVariable = 1;
1014     	numberOfValuesAvailableForOneInputVar = 4;
1015     	factor =
1016     	    x.sliceOutOneInputVarAndOneOutputVar
1017     	    (vectorInputDataPoints,
1018     	     vectorOutputDataPoints,
1019     	     indexOfInputVariable,
1020     	     indexOfOutputVariable,
1021     	     numberOfValuesAvailableForOneInputVar);
1022     	factors = factor.getFactors();
1023     	responses = factor.getResponse();
1024     	_test(factors.size() == 2);
1025     	_test(factors[0] == 1);
1026     	_test(factors[1] == 3);
1027     	_test(factor.getNumberOfLevels()==2);
1028     	_test(responses.getNumOfObservations()==2);
1029     	_test(responses[0] == 101.0);
1030     	_test(responses[1] == 103.0);
1031 
1032 
1033 
1034 
1035 
1036 
1037 
1038 
1039 
1040 
1041     	/* two rows, 2 columns */
1042     	vectorInputDataPoints.clear();
1043     	oneRowOfInts.clear();
1044     	oneRowOfInts.push_back(3);
1045     	oneRowOfInts.push_back(2);
1046     	vectorInputDataPoints.push_back(oneRowOfInts);
1047     	row2OfInts.clear();
1048     	row2OfInts.push_back(1);
1049     	row2OfInts.push_back(0);
1050     	vectorInputDataPoints.push_back(row2OfInts);
1051     	vectorOutputDataPoints.clear();
1052     	oneRowOfDoubles.clear();
1053     	oneRowOfDoubles.push_back(103.0);
1054     	oneRowOfDoubles.push_back(102.0);
1055     	vectorOutputDataPoints.push_back(oneRowOfDoubles);
1056     	row2OfDoubles.clear();
1057     	row2OfDoubles.push_back(101.0);
1058         row2OfDoubles.push_back(100.0);
1059     	vectorOutputDataPoints.push_back(row2OfDoubles);
1060 
1061 
1062     	indexOfInputVariable = 0;
1063         indexOfOutputVariable = 0;
1064     	numberOfValuesAvailableForOneInputVar = 4;
1065     	factor =
1066     	    x.sliceOutOneInputVarAndOneOutputVar
1067     	    (vectorInputDataPoints,
1068     	     vectorOutputDataPoints,
1069     	     indexOfInputVariable,
1070     	     indexOfOutputVariable,
1071     	     numberOfValuesAvailableForOneInputVar);
1072     	factors = factor.getFactors();
1073     	responses = factor.getResponse();
1074     	_test(factors.size() == 2);
1075     	_test(factors[0] == 3);
1076     	_test(factors[1] == 1);
1077     	_test(factor.getNumberOfLevels()==2);
1078     	_test(responses.getNumOfObservations()==2);
1079     	_test(responses[0] == 103.0);
1080     	_test(responses[1] == 101.0);
1081 
1082     	indexOfInputVariable = 0;
1083         indexOfOutputVariable = 1;
1084     	numberOfValuesAvailableForOneInputVar = 4;
1085     	factor =
1086     	    x.sliceOutOneInputVarAndOneOutputVar
1087     	    (vectorInputDataPoints,
1088     	     vectorOutputDataPoints,
1089     	     indexOfInputVariable,
1090     	     indexOfOutputVariable,
1091     	     numberOfValuesAvailableForOneInputVar);
1092     	factors = factor.getFactors();
1093     	responses = factor.getResponse();
1094     	_test(factors.size() == 2);
1095     	_test(factors[0] == 3);
1096     	_test(factors[1] == 1);
1097     	_test(factor.getNumberOfLevels()==2);
1098     	_test(responses.getNumOfObservations()==2);
1099     	_test(responses[0] == 102.0);
1100     	_test(responses[1] == 100.0);
1101 
1102     	indexOfInputVariable = 1;
1103         indexOfOutputVariable = 0;
1104     	numberOfValuesAvailableForOneInputVar = 4;
1105     	factor =
1106     	    x.sliceOutOneInputVarAndOneOutputVar
1107     	    (vectorInputDataPoints,
1108     	     vectorOutputDataPoints,
1109     	     indexOfInputVariable,
1110     	     indexOfOutputVariable,
1111     	     numberOfValuesAvailableForOneInputVar);
1112     	factors = factor.getFactors();
1113     	responses = factor.getResponse();
1114     	_test(factors.size() == 2);
1115     	_test(factors[0] == 2);
1116     	_test(factors[1] == 0);
1117     	_test(factor.getNumberOfLevels()==2);
1118     	_test(responses.getNumOfObservations()==2);
1119     	_test(responses[0] == 103.0);
1120     	_test(responses[1] == 101.0);
1121 
1122     	indexOfInputVariable = 1;
1123         indexOfOutputVariable = 1;
1124     	numberOfValuesAvailableForOneInputVar = 4;
1125     	factor =
1126     	    x.sliceOutOneInputVarAndOneOutputVar
1127     	    (vectorInputDataPoints,
1128     	     vectorOutputDataPoints,
1129     	     indexOfInputVariable,
1130     	     indexOfOutputVariable,
1131     	     numberOfValuesAvailableForOneInputVar);
1132     	factors = factor.getFactors();
1133     	responses = factor.getResponse();
1134     	_test(factors.size() == 2);
1135     	_test(factors[0] == 2);
1136     	_test(factors[1] == 0);
1137     	_test(factor.getNumberOfLevels()==2);
1138     	_test(responses.getNumOfObservations()==2);
1139     	_test(responses[0] == 102.0);
1140     	_test(responses[1] == 100.0);
1141 
1142 }
1143 
testConvert()1144 void TestMainEffectsConverter::testConvert(){
1145 
1146 	std::vector<std::vector<double> > vectorInputDataPoints(0);
1147 	std::vector<std::vector<double> > vectorOutputDataPoints(0);
1148 	std::vector<DDaceMainEffects::Factor>  vectorFactors(0);
1149 	DDaceMainEffects::Factor factor;
1150     std::vector<double> row1OfDoubles(0);
1151     std::vector<double> row2OfDoubles(0);
1152     std::vector<double> row3OfDoubles(0);
1153     std::vector<double> row4OfDoubles(0);
1154     std::vector<int> factors;
1155     DDaceMainEffects::Response responses;
1156 
1157 
1158 
1159 	MainEffectsConverter x;
1160 
1161 	/* empty data sets */
1162 	vectorInputDataPoints.clear();
1163 	vectorOutputDataPoints.clear();
1164 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1165     _test(vectorFactors.size() == 0);
1166 
1167     /* left side empty */
1168 	vectorInputDataPoints.clear();
1169 	vectorOutputDataPoints.clear();
1170 	row1OfDoubles.clear();
1171 	row1OfDoubles.push_back(5.0);
1172 	vectorOutputDataPoints.push_back(row1OfDoubles);
1173 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1174     _test(vectorFactors.size() == 0);
1175 
1176     /* right side empty */
1177 	vectorInputDataPoints.clear();
1178 	vectorOutputDataPoints.clear();
1179 	row1OfDoubles.clear();
1180 	row1OfDoubles.push_back(5.0);
1181 	vectorInputDataPoints.push_back(row1OfDoubles);
1182 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1183     _test(vectorFactors.size() == 0);
1184 
1185     /* one data point */
1186 	vectorInputDataPoints.clear();
1187 	vectorOutputDataPoints.clear();
1188 	row1OfDoubles.clear();
1189 	row1OfDoubles.push_back(5.0);
1190 	vectorInputDataPoints.push_back(row1OfDoubles);
1191 	row2OfDoubles.clear();
1192 	row2OfDoubles.push_back(100.0);
1193 	vectorOutputDataPoints.push_back(row2OfDoubles);
1194 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1195     _test(vectorFactors.size() == 1);
1196     factor = vectorFactors[0];
1197     factors = factor.getFactors();
1198     responses = factor.getResponse();
1199     _test(factors.size() == 1);
1200     _test(factor.getNumberOfLevels()==1);
1201     _test(responses.getNumOfObservations()==1);
1202     _test(factors[0] == 0);
1203     _test(responses[0] = 100.0);
1204 
1205     /* one row, two columns */
1206 	vectorInputDataPoints.clear();
1207 	vectorOutputDataPoints.clear();
1208 	row1OfDoubles.clear();
1209 	row1OfDoubles.push_back(5.0);
1210 	row1OfDoubles.push_back(6.0);
1211 	vectorInputDataPoints.push_back(row1OfDoubles);
1212 	row2OfDoubles.clear();
1213 	row2OfDoubles.push_back(100.0);
1214 	row2OfDoubles.push_back(101.0);
1215 	vectorOutputDataPoints.push_back(row2OfDoubles);
1216 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1217     _test(vectorFactors.size() == 4);
1218 
1219     factor = vectorFactors[0];
1220     factors = factor.getFactors();
1221     responses = factor.getResponse();
1222     _test(factors.size() == 1);
1223     _test(factor.getNumberOfLevels()==1);
1224     _test(responses.getNumOfObservations()==1);
1225     _test(factors[0] == 0);
1226     _test(responses[0] == 100.0);
1227 
1228     factor = vectorFactors[1];
1229     factors = factor.getFactors();
1230     responses = factor.getResponse();
1231     _test(factors.size() == 1);
1232     _test(factor.getNumberOfLevels()==1);
1233     _test(responses.getNumOfObservations()==1);
1234     _test(factors[0] == 0);
1235     _test(responses[0] == 101.0);
1236 
1237     factor = vectorFactors[2];
1238     factors = factor.getFactors();
1239     responses = factor.getResponse();
1240     _test(factors.size() == 1);
1241     _test(factor.getNumberOfLevels()==1);
1242     _test(responses.getNumOfObservations()==1);
1243     _test(factors[0] == 1);
1244     _test(responses[0] == 100.0);
1245 
1246 
1247     factor = vectorFactors[3];
1248     factors = factor.getFactors();
1249     responses = factor.getResponse();
1250     _test(factors.size() == 1);
1251     _test(factor.getNumberOfLevels()==1);
1252     _test(responses.getNumOfObservations()==1);
1253     _test(factors[0] == 1);
1254     _test(responses[0] == 101.0);
1255 
1256 
1257 
1258 
1259     /* one row, three columns */
1260 	vectorInputDataPoints.clear();
1261 	vectorOutputDataPoints.clear();
1262 	row1OfDoubles.clear();
1263 	row1OfDoubles.push_back(5.0);
1264 	row1OfDoubles.push_back(6.0);
1265 	row1OfDoubles.push_back(7.0);
1266 	vectorInputDataPoints.push_back(row1OfDoubles);
1267 	row2OfDoubles.clear();
1268 	row2OfDoubles.push_back(100.0);
1269 	row2OfDoubles.push_back(101.0);
1270 	row2OfDoubles.push_back(102.0);
1271 	vectorOutputDataPoints.push_back(row2OfDoubles);
1272 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1273     _test(vectorFactors.size() == 9);
1274 
1275     factor = vectorFactors[0];
1276     factors = factor.getFactors();
1277     responses = factor.getResponse();
1278     _test(factors.size() == 1);
1279     _test(factor.getNumberOfLevels()==1);
1280     _test(responses.getNumOfObservations()==1);
1281     _test(factors[0] == 0);
1282     _test(responses[0] == 100.0);
1283 
1284     factor = vectorFactors[1];
1285     factors = factor.getFactors();
1286     responses = factor.getResponse();
1287     _test(factors.size() == 1);
1288     _test(factor.getNumberOfLevels()==1);
1289     _test(responses.getNumOfObservations()==1);
1290     _test(factors[0] == 0);
1291     _test(responses[0] == 101.0);
1292 
1293     factor = vectorFactors[2];
1294     factors = factor.getFactors();
1295     responses = factor.getResponse();
1296     _test(factors.size() == 1);
1297     _test(factor.getNumberOfLevels()==1);
1298     _test(responses.getNumOfObservations()==1);
1299     _test(factors[0] == 0);
1300     _test(responses[0] == 102.0);
1301 
1302 
1303     factor = vectorFactors[3];
1304     factors = factor.getFactors();
1305     responses = factor.getResponse();
1306     _test(factors.size() == 1);
1307     _test(factor.getNumberOfLevels()==1);
1308     _test(responses.getNumOfObservations()==1);
1309     _test(factors[0] == 1);
1310     _test(responses[0] == 100.0);
1311 
1312     factor = vectorFactors[4];
1313     factors = factor.getFactors();
1314     responses = factor.getResponse();
1315     _test(factors.size() == 1);
1316     _test(factor.getNumberOfLevels()==1);
1317     _test(responses.getNumOfObservations()==1);
1318     _test(factors[0] == 1);
1319     _test(responses[0] == 101.0);
1320 
1321     factor = vectorFactors[5];
1322     factors = factor.getFactors();
1323     responses = factor.getResponse();
1324     _test(factors.size() == 1);
1325     _test(factor.getNumberOfLevels()==1);
1326     _test(responses.getNumOfObservations()==1);
1327     _test(factors[0] == 1);
1328     _test(responses[0] == 102.0);
1329 
1330     factor = vectorFactors[6];
1331     factors = factor.getFactors();
1332     responses = factor.getResponse();
1333     _test(factors.size() == 1);
1334     _test(factor.getNumberOfLevels()==1);
1335     _test(responses.getNumOfObservations()==1);
1336     _test(factors[0] == 2);
1337     _test(responses[0] == 100.0);
1338 
1339     factor = vectorFactors[7];
1340     factors = factor.getFactors();
1341     responses = factor.getResponse();
1342     _test(factors.size() == 1);
1343     _test(factor.getNumberOfLevels()==1);
1344     _test(responses.getNumOfObservations()==1);
1345     _test(factors[0] == 2);
1346     _test(responses[0] == 101.0);
1347 
1348     factor = vectorFactors[8];
1349     factors = factor.getFactors();
1350     responses = factor.getResponse();
1351     _test(factors.size() == 1);
1352     _test(factor.getNumberOfLevels()==1);
1353     _test(responses.getNumOfObservations()==1);
1354     _test(factors[0] == 2);
1355     _test(responses[0] == 102.0);
1356 
1357     /* two rows, one column */
1358 	vectorInputDataPoints.clear();
1359 	vectorOutputDataPoints.clear();
1360 	row1OfDoubles.clear();
1361 	row1OfDoubles.push_back(5.0);
1362 	vectorInputDataPoints.push_back(row1OfDoubles);
1363 	row2OfDoubles.clear();
1364 	row2OfDoubles.push_back(6.0);
1365 	vectorInputDataPoints.push_back(row2OfDoubles);
1366 	row3OfDoubles.clear();
1367 	row3OfDoubles.push_back(100.0);
1368 	vectorOutputDataPoints.push_back(row3OfDoubles);
1369 	row4OfDoubles.clear();
1370 	row4OfDoubles.push_back(101.0);
1371 	vectorOutputDataPoints.push_back(row4OfDoubles);
1372 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1373     _test(vectorFactors.size() == 1);
1374 
1375     factor = vectorFactors[0];
1376     factors = factor.getFactors();
1377     responses = factor.getResponse();
1378     _test(factors.size() == 2);
1379     _test(factor.getNumberOfLevels()==2);
1380     _test(responses.getNumOfObservations()==2);
1381     _test(factors[0] == 0);
1382     _test(factors[1] == 1);
1383     _test(responses[0] == 100.0);
1384     _test(responses[1] == 101.0);
1385 
1386     /* two rows, one column */
1387 	vectorInputDataPoints.clear();
1388 	vectorOutputDataPoints.clear();
1389 	row1OfDoubles.clear();
1390 	row1OfDoubles.push_back(6.0);
1391 	vectorInputDataPoints.push_back(row1OfDoubles);
1392 	row2OfDoubles.clear();
1393 	row2OfDoubles.push_back(5.0);
1394 	vectorInputDataPoints.push_back(row2OfDoubles);
1395 	row3OfDoubles.clear();
1396 	row3OfDoubles.push_back(101.0);
1397 	vectorOutputDataPoints.push_back(row3OfDoubles);
1398 	row4OfDoubles.clear();
1399 	row4OfDoubles.push_back(100.0);
1400 	vectorOutputDataPoints.push_back(row4OfDoubles);
1401 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1402     _test(vectorFactors.size() == 1);
1403 
1404     factor = vectorFactors[0];
1405     factors = factor.getFactors();
1406     responses = factor.getResponse();
1407     _test(factors.size() == 2);
1408     _test(factor.getNumberOfLevels()==2);
1409     _test(responses.getNumOfObservations()==2);
1410     _test(factors[0] == 1);
1411     _test(factors[1] == 0);
1412     _test(responses[0] == 101.0);
1413     _test(responses[1] == 100.0);
1414 
1415 
1416     /* two rows, one column */
1417 	vectorInputDataPoints.clear();
1418 	vectorOutputDataPoints.clear();
1419 	row1OfDoubles.clear();
1420 	row1OfDoubles.push_back(5.0);
1421 	vectorInputDataPoints.push_back(row1OfDoubles);
1422 	row2OfDoubles.clear();
1423 	row2OfDoubles.push_back(5.0);
1424 	vectorInputDataPoints.push_back(row2OfDoubles);
1425 	row3OfDoubles.clear();
1426 	row3OfDoubles.push_back(101.0);
1427 	vectorOutputDataPoints.push_back(row3OfDoubles);
1428 	row4OfDoubles.clear();
1429 	row4OfDoubles.push_back(100.0);
1430 	vectorOutputDataPoints.push_back(row4OfDoubles);
1431 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1432     _test(vectorFactors.size() == 1);
1433 
1434     factor = vectorFactors[0];
1435     factors = factor.getFactors();
1436     responses = factor.getResponse();
1437     _test(factors.size() == 2);
1438     _test(factor.getNumberOfLevels()==1);
1439     _test(responses.getNumOfObservations()==2);
1440     _test(factors[0] == 0);
1441     _test(factors[1] == 0);
1442     _test(responses[0] == 101.0);
1443     _test(responses[1] == 100.0);
1444 
1445     /* two rows, two columns */
1446 	vectorInputDataPoints.clear();
1447 	vectorOutputDataPoints.clear();
1448 	row1OfDoubles.clear();
1449 	row1OfDoubles.push_back(5.0);
1450 	row1OfDoubles.push_back(6.0);
1451 	vectorInputDataPoints.push_back(row1OfDoubles);
1452 	row2OfDoubles.clear();
1453 	row2OfDoubles.push_back(7.0);
1454 	row2OfDoubles.push_back(8.0);
1455 	vectorInputDataPoints.push_back(row2OfDoubles);
1456 	row3OfDoubles.clear();
1457 	row3OfDoubles.push_back(100.0);
1458 	row3OfDoubles.push_back(101.0);
1459 	vectorOutputDataPoints.push_back(row3OfDoubles);
1460 	row4OfDoubles.clear();
1461 	row4OfDoubles.push_back(102.0);
1462 	row4OfDoubles.push_back(103.0);
1463 	vectorOutputDataPoints.push_back(row4OfDoubles);
1464 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1465     _test(vectorFactors.size() == 4);
1466 
1467     factor = vectorFactors[0];
1468     factors = factor.getFactors();
1469     responses = factor.getResponse();
1470     _test(factors.size() == 2);
1471     _test(factor.getNumberOfLevels()==2);
1472     _test(responses.getNumOfObservations()==2);
1473     _test(factors[0] == 0);
1474     _test(factors[1] == 2);
1475     _test(responses[0] == 100.0);
1476     _test(responses[1] == 102.0);
1477 
1478     factor = vectorFactors[1];
1479     factors = factor.getFactors();
1480     responses = factor.getResponse();
1481     _test(factors.size() == 2);
1482     _test(factor.getNumberOfLevels()==2);
1483     _test(responses.getNumOfObservations()==2);
1484     _test(factors[0] == 0);
1485     _test(factors[1] == 2);
1486     _test(responses[0] == 101.0);
1487     _test(responses[1] == 103.0);
1488 
1489     factor = vectorFactors[2];
1490     factors = factor.getFactors();
1491     responses = factor.getResponse();
1492     _test(factors.size() == 2);
1493     _test(factor.getNumberOfLevels()==2);
1494     _test(responses.getNumOfObservations()==2);
1495     _test(factors[0] == 1);
1496     _test(factors[1] == 3);
1497     _test(responses[0] == 100.0);
1498     _test(responses[1] == 102.0);
1499 
1500     factor = vectorFactors[3];
1501     factors = factor.getFactors();
1502     responses = factor.getResponse();
1503     _test(factors.size() == 2);
1504     _test(factor.getNumberOfLevels()==2);
1505     _test(responses.getNumOfObservations()==2);
1506     _test(factors[0] == 1);
1507     _test(factors[1] == 3);
1508     _test(responses[0] == 101.0);
1509     _test(responses[1] == 103.0);
1510 
1511     /* two rows, two columns */
1512 	vectorInputDataPoints.clear();
1513 	vectorOutputDataPoints.clear();
1514 	row1OfDoubles.clear();
1515 	row1OfDoubles.push_back(8.0);
1516 	row1OfDoubles.push_back(7.0);
1517 	vectorInputDataPoints.push_back(row1OfDoubles);
1518 	row2OfDoubles.clear();
1519 	row2OfDoubles.push_back(6.0);
1520 	row2OfDoubles.push_back(5.0);
1521 	vectorInputDataPoints.push_back(row2OfDoubles);
1522 	row3OfDoubles.clear();
1523 	row3OfDoubles.push_back(103.0);
1524 	row3OfDoubles.push_back(102.0);
1525 	vectorOutputDataPoints.push_back(row3OfDoubles);
1526 	row4OfDoubles.clear();
1527 	row4OfDoubles.push_back(101.0);
1528 	row4OfDoubles.push_back(100.0);
1529 	vectorOutputDataPoints.push_back(row4OfDoubles);
1530 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1531     _test(vectorFactors.size() == 4);
1532 
1533     factor = vectorFactors[0];
1534     factors = factor.getFactors();
1535     responses = factor.getResponse();
1536     _test(factors.size() == 2);
1537     _test(factor.getNumberOfLevels()==2);
1538     _test(responses.getNumOfObservations()==2);
1539     _test(factors[0] == 3);
1540     _test(factors[1] == 1);
1541     _test(responses[0] == 103.0);
1542     _test(responses[1] == 101.0);
1543 
1544     factor = vectorFactors[1];
1545     factors = factor.getFactors();
1546     responses = factor.getResponse();
1547     _test(factors.size() == 2);
1548     _test(factor.getNumberOfLevels()==2);
1549     _test(responses.getNumOfObservations()==2);
1550     _test(factors[0] == 3);
1551     _test(factors[1] == 1);
1552     _test(responses[0] == 102.0);
1553     _test(responses[1] == 100.0);
1554 
1555     factor = vectorFactors[2];
1556     factors = factor.getFactors();
1557     responses = factor.getResponse();
1558     _test(factors.size() == 2);
1559     _test(factor.getNumberOfLevels()==2);
1560     _test(responses.getNumOfObservations()==2);
1561     _test(factors[0] == 2);
1562     _test(factors[1] == 0);
1563     _test(responses[0] == 103.0);
1564     _test(responses[1] == 101.0);
1565 
1566     factor = vectorFactors[3];
1567     factors = factor.getFactors();
1568     responses = factor.getResponse();
1569     _test(factors.size() == 2);
1570     _test(factor.getNumberOfLevels()==2);
1571     _test(responses.getNumOfObservations()==2);
1572     _test(factors[0] == 2);
1573     _test(factors[1] == 0);
1574     _test(responses[0] == 102.0);
1575     _test(responses[1] == 100.0);
1576 
1577 
1578     /* two rows, two columns */
1579 	vectorInputDataPoints.clear();
1580 	vectorOutputDataPoints.clear();
1581 	row1OfDoubles.clear();
1582 	row1OfDoubles.push_back(5.0);
1583 	row1OfDoubles.push_back(5.0);
1584 	vectorInputDataPoints.push_back(row1OfDoubles);
1585 	row2OfDoubles.clear();
1586 	row2OfDoubles.push_back(7.0);
1587 	row2OfDoubles.push_back(8.0);
1588 	vectorInputDataPoints.push_back(row2OfDoubles);
1589 	row3OfDoubles.clear();
1590 	row3OfDoubles.push_back(100.0);
1591 	row3OfDoubles.push_back(101.0);
1592 	vectorOutputDataPoints.push_back(row3OfDoubles);
1593 	row4OfDoubles.clear();
1594 	row4OfDoubles.push_back(102.0);
1595 	row4OfDoubles.push_back(103.0);
1596 	vectorOutputDataPoints.push_back(row4OfDoubles);
1597 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1598     _test(vectorFactors.size() == 4);
1599 
1600     factor = vectorFactors[0];
1601     factors = factor.getFactors();
1602     responses = factor.getResponse();
1603     _test(factors.size() == 2);
1604     _test(factor.getNumberOfLevels()==2);
1605     _test(responses.getNumOfObservations()==2);
1606     _test(factors[0] == 0);
1607     _test(factors[1] == 1);
1608     _test(responses[0] == 100.0);
1609     _test(responses[1] == 102.0);
1610 
1611     factor = vectorFactors[1];
1612     factors = factor.getFactors();
1613     responses = factor.getResponse();
1614     _test(factors.size() == 2);
1615     _test(factor.getNumberOfLevels()==2);
1616     _test(responses.getNumOfObservations()==2);
1617     _test(factors[0] == 0);
1618     _test(factors[1] == 1);
1619     _test(responses[0] == 101.0);
1620     _test(responses[1] == 103.0);
1621 
1622     factor = vectorFactors[2];
1623     factors = factor.getFactors();
1624     responses = factor.getResponse();
1625     _test(factors.size() == 2);
1626     _test(factor.getNumberOfLevels()==2);
1627     _test(responses.getNumOfObservations()==2);
1628     _test(factors[0] == 0);
1629     _test(factors[1] == 2);
1630     _test(responses[0] == 100.0);
1631     _test(responses[1] == 102.0);
1632 
1633     factor = vectorFactors[3];
1634     factors = factor.getFactors();
1635     responses = factor.getResponse();
1636     _test(factors.size() == 2);
1637     _test(factor.getNumberOfLevels()==2);
1638     _test(responses.getNumOfObservations()==2);
1639     _test(factors[0] == 0);
1640     _test(factors[1] == 2);
1641     _test(responses[0] == 101.0);
1642     _test(responses[1] == 103.0);
1643 
1644 
1645     /* two rows, two columns */
1646 	vectorInputDataPoints.clear();
1647 	vectorOutputDataPoints.clear();
1648 	row1OfDoubles.clear();
1649 	row1OfDoubles.push_back(5.0);
1650 	row1OfDoubles.push_back(6.0);
1651 	vectorInputDataPoints.push_back(row1OfDoubles);
1652 	row2OfDoubles.clear();
1653 	row2OfDoubles.push_back(5.0);
1654 	row2OfDoubles.push_back(8.0);
1655 	vectorInputDataPoints.push_back(row2OfDoubles);
1656 	row3OfDoubles.clear();
1657 	row3OfDoubles.push_back(100.0);
1658 	row3OfDoubles.push_back(101.0);
1659 	vectorOutputDataPoints.push_back(row3OfDoubles);
1660 	row4OfDoubles.clear();
1661 	row4OfDoubles.push_back(102.0);
1662 	row4OfDoubles.push_back(103.0);
1663 	vectorOutputDataPoints.push_back(row4OfDoubles);
1664 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1665     _test(vectorFactors.size() == 4);
1666 
1667     factor = vectorFactors[0];
1668     factors = factor.getFactors();
1669     responses = factor.getResponse();
1670     _test(factors.size() == 2);
1671     _test(factor.getNumberOfLevels()==1);
1672     _test(responses.getNumOfObservations()==2);
1673     _test(factors[0] == 0);
1674     _test(factors[1] == 0);
1675     _test(responses[0] == 100.0);
1676     _test(responses[1] == 102.0);
1677 
1678     factor = vectorFactors[1];
1679     factors = factor.getFactors();
1680     responses = factor.getResponse();
1681     _test(factors.size() == 2);
1682     _test(factor.getNumberOfLevels()==1);
1683     _test(responses.getNumOfObservations()==2);
1684     _test(factors[0] == 0);
1685     _test(factors[1] == 0);
1686     _test(responses[0] == 101.0);
1687     _test(responses[1] == 103.0);
1688 
1689     factor = vectorFactors[2];
1690     factors = factor.getFactors();
1691     responses = factor.getResponse();
1692     _test(factors.size() == 2);
1693     _test(factor.getNumberOfLevels()==2);
1694     _test(responses.getNumOfObservations()==2);
1695     _test(factors[0] == 1);
1696     _test(factors[1] == 2);
1697     _test(responses[0] == 100.0);
1698     _test(responses[1] == 102.0);
1699 
1700     factor = vectorFactors[3];
1701     factors = factor.getFactors();
1702     responses = factor.getResponse();
1703     _test(factors.size() == 2);
1704     _test(factor.getNumberOfLevels()==2);
1705     _test(responses.getNumOfObservations()==2);
1706     _test(factors[0] == 1);
1707     _test(factors[1] == 2);
1708     _test(responses[0] == 101.0);
1709     _test(responses[1] == 103.0);
1710 
1711 
1712 
1713     /* two rows, two columns */
1714 	vectorInputDataPoints.clear();
1715 	vectorOutputDataPoints.clear();
1716 	row1OfDoubles.clear();
1717 	row1OfDoubles.push_back(5.0);
1718 	row1OfDoubles.push_back(6.0);
1719 	vectorInputDataPoints.push_back(row1OfDoubles);
1720 	row2OfDoubles.clear();
1721 	row2OfDoubles.push_back(7.0);
1722 	row2OfDoubles.push_back(5.0);
1723 	vectorInputDataPoints.push_back(row2OfDoubles);
1724 	row3OfDoubles.clear();
1725 	row3OfDoubles.push_back(100.0);
1726 	row3OfDoubles.push_back(101.0);
1727 	vectorOutputDataPoints.push_back(row3OfDoubles);
1728 	row4OfDoubles.clear();
1729 	row4OfDoubles.push_back(102.0);
1730 	row4OfDoubles.push_back(103.0);
1731 	vectorOutputDataPoints.push_back(row4OfDoubles);
1732 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1733     _test(vectorFactors.size() == 4);
1734 
1735     factor = vectorFactors[0];
1736     factors = factor.getFactors();
1737     responses = factor.getResponse();
1738     _test(factors.size() == 2);
1739     _test(factor.getNumberOfLevels()==2);
1740     _test(responses.getNumOfObservations()==2);
1741     _test(factors[0] == 0);
1742     _test(factors[1] == 2);
1743     _test(responses[0] == 100.0);
1744     _test(responses[1] == 102.0);
1745 
1746 
1747     factor = vectorFactors[1];
1748     factors = factor.getFactors();
1749     responses = factor.getResponse();
1750     _test(factors.size() == 2);
1751     _test(factor.getNumberOfLevels()==2);
1752     _test(responses.getNumOfObservations()==2);
1753 
1754     _test(factors[0] == 0);
1755     _test(factors[1] == 2);
1756     _test(responses[0] == 101.0);
1757     _test(responses[1] == 103.0);
1758 
1759     factor = vectorFactors[2];
1760     factors = factor.getFactors();
1761     responses = factor.getResponse();
1762     _test(factors.size() == 2);
1763     _test(factor.getNumberOfLevels()==2);
1764     _test(responses.getNumOfObservations()==2);
1765     _test(factors[0] == 1);
1766     _test(factors[1] == 0);
1767     _test(responses[0] == 100.0);
1768     _test(responses[1] == 102.0);
1769 
1770     factor = vectorFactors[3];
1771     factors = factor.getFactors();
1772     responses = factor.getResponse();
1773     _test(factors.size() == 2);
1774     _test(factor.getNumberOfLevels()==2);
1775     _test(responses.getNumOfObservations()==2);
1776     _test(factors[0] == 1);
1777     _test(factors[1] == 0);
1778     _test(responses[0] == 101.0);
1779     _test(responses[1] == 103.0);
1780 
1781     /* two rows, two columns */
1782 	vectorInputDataPoints.clear();
1783 	vectorOutputDataPoints.clear();
1784 	row1OfDoubles.clear();
1785 	row1OfDoubles.push_back(5.0);
1786 	row1OfDoubles.push_back(6.0);
1787 	vectorInputDataPoints.push_back(row1OfDoubles);
1788 	row2OfDoubles.clear();
1789 	row2OfDoubles.push_back(6.0);
1790 	row2OfDoubles.push_back(8.0);
1791 	vectorInputDataPoints.push_back(row2OfDoubles);
1792 	row3OfDoubles.clear();
1793 	row3OfDoubles.push_back(100.0);
1794 	row3OfDoubles.push_back(101.0);
1795 	vectorOutputDataPoints.push_back(row3OfDoubles);
1796 	row4OfDoubles.clear();
1797 	row4OfDoubles.push_back(102.0);
1798 	row4OfDoubles.push_back(103.0);
1799 	vectorOutputDataPoints.push_back(row4OfDoubles);
1800 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1801     _test(vectorFactors.size() == 4);
1802 
1803     factor = vectorFactors[0];
1804     factors = factor.getFactors();
1805     responses = factor.getResponse();
1806     _test(factors.size() == 2);
1807     _test(factor.getNumberOfLevels()==2);
1808     _test(responses.getNumOfObservations()==2);
1809     _test(factors[0] == 0);
1810     _test(factors[1] == 1);
1811     _test(responses[0] == 100.0);
1812     _test(responses[1] == 102.0);
1813 
1814     factor = vectorFactors[1];
1815     factors = factor.getFactors();
1816     responses = factor.getResponse();
1817     _test(factors.size() == 2);
1818     _test(factor.getNumberOfLevels()==2);
1819     _test(responses.getNumOfObservations()==2);
1820     _test(factors[0] == 0);
1821     _test(factors[1] == 1);
1822     _test(responses[0] == 101.0);
1823     _test(responses[1] == 103.0);
1824 
1825     factor = vectorFactors[2];
1826     factors = factor.getFactors();
1827     responses = factor.getResponse();
1828     _test(factors.size() == 2);
1829     _test(factor.getNumberOfLevels()==2);
1830     _test(responses.getNumOfObservations()==2);
1831     _test(factors[0] == 1);
1832     _test(factors[1] == 2);
1833     _test(responses[0] == 100.0);
1834     _test(responses[1] == 102.0);
1835 
1836     factor = vectorFactors[3];
1837     factors = factor.getFactors();
1838     responses = factor.getResponse();
1839     _test(factors.size() == 2);
1840     _test(factor.getNumberOfLevels()==2);
1841     _test(responses.getNumOfObservations()==2);
1842     _test(factors[0] == 1);
1843     _test(factors[1] == 2);
1844     _test(responses[0] == 101.0);
1845     _test(responses[1] == 103.0);
1846 
1847 
1848     /* two rows, two columns */
1849 	vectorInputDataPoints.clear();
1850 	vectorOutputDataPoints.clear();
1851 	row1OfDoubles.clear();
1852 	row1OfDoubles.push_back(5.0);
1853 	row1OfDoubles.push_back(6.0);
1854 	vectorInputDataPoints.push_back(row1OfDoubles);
1855 	row2OfDoubles.clear();
1856 	row2OfDoubles.push_back(7.0);
1857 	row2OfDoubles.push_back(6.0);
1858 	vectorInputDataPoints.push_back(row2OfDoubles);
1859 	row3OfDoubles.clear();
1860 	row3OfDoubles.push_back(100.0);
1861 	row3OfDoubles.push_back(101.0);
1862 	vectorOutputDataPoints.push_back(row3OfDoubles);
1863 	row4OfDoubles.clear();
1864 	row4OfDoubles.push_back(102.0);
1865 	row4OfDoubles.push_back(103.0);
1866 	vectorOutputDataPoints.push_back(row4OfDoubles);
1867 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1868     _test(vectorFactors.size() == 4);
1869 
1870     factor = vectorFactors[0];
1871     factors = factor.getFactors();
1872     responses = factor.getResponse();
1873     _test(factors.size() == 2);
1874     _test(factor.getNumberOfLevels()==2);
1875     _test(responses.getNumOfObservations()==2);
1876     _test(factors[0] == 0);
1877     _test(factors[1] == 2);
1878     _test(responses[0] == 100.0);
1879     _test(responses[1] == 102.0);
1880 
1881     factor = vectorFactors[1];
1882     factors = factor.getFactors();
1883     responses = factor.getResponse();
1884     _test(factors.size() == 2);
1885     _test(factor.getNumberOfLevels()==2);
1886     _test(responses.getNumOfObservations()==2);
1887     _test(factors[0] == 0);
1888     _test(factors[1] == 2);
1889     _test(responses[0] == 101.0);
1890     _test(responses[1] == 103.0);
1891 
1892     factor = vectorFactors[2];
1893     factors = factor.getFactors();
1894     responses = factor.getResponse();
1895     _test(factors.size() == 2);
1896     _test(factor.getNumberOfLevels()==1);
1897     _test(responses.getNumOfObservations()==2);
1898     _test(factors[0] == 1);
1899     _test(factors[1] == 1);
1900     _test(responses[0] == 100.0);
1901     _test(responses[1] == 102.0);
1902 
1903     factor = vectorFactors[3];
1904     factors = factor.getFactors();
1905     responses = factor.getResponse();
1906     _test(factors.size() == 2);
1907     _test(factor.getNumberOfLevels()==1);
1908     _test(responses.getNumOfObservations()==2);
1909     _test(factors[0] == 1);
1910     _test(factors[1] == 1);
1911     _test(responses[0] == 101.0);
1912     _test(responses[1] == 103.0);
1913 
1914 
1915     /* two rows, two columns */
1916 	vectorInputDataPoints.clear();
1917 	vectorOutputDataPoints.clear();
1918 	row1OfDoubles.clear();
1919 	row1OfDoubles.push_back(5.0);
1920 	row1OfDoubles.push_back(6.0);
1921 	vectorInputDataPoints.push_back(row1OfDoubles);
1922 	row2OfDoubles.clear();
1923 	row2OfDoubles.push_back(7.0);
1924 	row2OfDoubles.push_back(7.0);
1925 	vectorInputDataPoints.push_back(row2OfDoubles);
1926 	row3OfDoubles.clear();
1927 	row3OfDoubles.push_back(100.0);
1928 	row3OfDoubles.push_back(101.0);
1929 	vectorOutputDataPoints.push_back(row3OfDoubles);
1930 	row4OfDoubles.clear();
1931 	row4OfDoubles.push_back(102.0);
1932 	row4OfDoubles.push_back(103.0);
1933 	vectorOutputDataPoints.push_back(row4OfDoubles);
1934 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
1935     _test(vectorFactors.size() == 4);
1936 
1937     factor = vectorFactors[0];
1938     factors = factor.getFactors();
1939     responses = factor.getResponse();
1940     _test(factors.size() == 2);
1941     _test(factor.getNumberOfLevels()==2);
1942     _test(responses.getNumOfObservations()==2);
1943     _test(factors[0] == 0);
1944     _test(factors[1] == 2);
1945     _test(responses[0] == 100.0);
1946     _test(responses[1] == 102.0);
1947 
1948     factor = vectorFactors[1];
1949     factors = factor.getFactors();
1950     responses = factor.getResponse();
1951     _test(factors.size() == 2);
1952     _test(factor.getNumberOfLevels()==2);
1953     _test(responses.getNumOfObservations()==2);
1954     _test(factors[0] == 0);
1955     _test(factors[1] == 2);
1956     _test(responses[0] == 101.0);
1957     _test(responses[1] == 103.0);
1958 
1959     factor = vectorFactors[2];
1960     factors = factor.getFactors();
1961     responses = factor.getResponse();
1962     _test(factors.size() == 2);
1963     _test(factor.getNumberOfLevels()==2);
1964     _test(responses.getNumOfObservations()==2);
1965     _test(factors[0] == 1);
1966     _test(factors[1] == 2);
1967     _test(responses[0] == 100.0);
1968     _test(responses[1] == 102.0);
1969 
1970     factor = vectorFactors[3];
1971     factors = factor.getFactors();
1972     responses = factor.getResponse();
1973     _test(factors.size() == 2);
1974     _test(factor.getNumberOfLevels()==2);
1975     _test(responses.getNumOfObservations()==2);
1976     _test(factors[0] == 1);
1977     _test(factors[1] == 2);
1978     _test(responses[0] == 101.0);
1979     _test(responses[1] == 103.0);
1980 
1981 
1982     /* two rows, two columns */
1983 	vectorInputDataPoints.clear();
1984 	vectorOutputDataPoints.clear();
1985 	row1OfDoubles.clear();
1986 	row1OfDoubles.push_back(4.9999);
1987 	row1OfDoubles.push_back(6.0001);
1988 	vectorInputDataPoints.push_back(row1OfDoubles);
1989 	row2OfDoubles.clear();
1990 	row2OfDoubles.push_back(5.9999);
1991 	row2OfDoubles.push_back(5.0001);
1992 	vectorInputDataPoints.push_back(row2OfDoubles);
1993 	row3OfDoubles.clear();
1994 	row3OfDoubles.push_back(100.0);
1995 	row3OfDoubles.push_back(101.0);
1996 	vectorOutputDataPoints.push_back(row3OfDoubles);
1997 	row4OfDoubles.clear();
1998 	row4OfDoubles.push_back(102.0);
1999 	row4OfDoubles.push_back(103.0);
2000 	vectorOutputDataPoints.push_back(row4OfDoubles);
2001 	vectorFactors = x.convert(vectorInputDataPoints, vectorOutputDataPoints);
2002     _test(vectorFactors.size() == 4);
2003 
2004     factor = vectorFactors[0];
2005     factors = factor.getFactors();
2006     responses = factor.getResponse();
2007     _test(factors.size() == 2);
2008     _test(factor.getNumberOfLevels()==2);
2009     _test(responses.getNumOfObservations()==2);
2010     _test(factors[0] == 0);
2011     _test(factors[1] == 1);
2012     _test(responses[0] == 100.0);
2013     _test(responses[1] == 102.0);
2014 
2015     factor = vectorFactors[1];
2016     factors = factor.getFactors();
2017     responses = factor.getResponse();
2018     _test(factors.size() == 2);
2019     _test(factor.getNumberOfLevels()==2);
2020     _test(responses.getNumOfObservations()==2);
2021     _test(factors[0] == 0);
2022     _test(factors[1] == 1);
2023     _test(responses[0] == 101.0);
2024     _test(responses[1] == 103.0);
2025 
2026     factor = vectorFactors[2];
2027     factors = factor.getFactors();
2028     responses = factor.getResponse();
2029     _test(factors.size() == 2);
2030     _test(factor.getNumberOfLevels()==2);
2031     _test(responses.getNumOfObservations()==2);
2032     _test(factors[0] == 1);
2033     _test(factors[1] == 0);
2034     _test(responses[0] == 100.0);
2035     _test(responses[1] == 102.0);
2036 
2037     factor = vectorFactors[3];
2038     factors = factor.getFactors();
2039     responses = factor.getResponse();
2040     _test(factors.size() == 2);
2041     _test(factor.getNumberOfLevels()==2);
2042     _test(responses.getNumOfObservations()==2);
2043     _test(factors[0] == 1);
2044     _test(factors[1] == 0);
2045     _test(responses[0] == 101.0);
2046     _test(responses[1] == 103.0);
2047 
2048 
2049 
2050 
2051 
2052 }
2053 
2054 
testConstructor()2055 void TestMainEffectsConverter::testConstructor(){
2056 }
2057 
2058 
2059 
2060 
2061 
2062 
2063