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