1 #define BOOST_TEST_DYN_LINK
2 #include <boost/test/unit_test.hpp>
3
4 namespace tt = boost::test_tools;
5
6 #include <adolc/adolc.h>
7
8 #include "const.h"
9
10 BOOST_AUTO_TEST_SUITE( trace_vector )
11
12
13 /***********************************/
14 /* Tests for trace vector mode */
15 /* Author: Philipp Schuette */
16 /***********************************/
17
18
19 /* Naming convention for test cases: Operatorname_Operator_FOV_Forward for
20 * foward derivative evulation in vector mode.
21 *
22 * For documentation of concrete test implementation, check traceless scalar
23 * mode test implementation. The testing order is consistent with that file
24 * as well.
25 */
26
BOOST_AUTO_TEST_CASE(ExpOperator_FOV_Forward)27 BOOST_AUTO_TEST_CASE(ExpOperator_FOV_Forward)
28 {
29 double a = 2., aout;
30 adouble ad;
31
32 trace_on(1);
33 ad <<= a;
34
35 ad = exp(ad);
36
37 ad >>= aout;
38 trace_off();
39
40 a = std::exp(a);
41 double aDerivative = a;
42
43 double *x = myalloc1(1);
44 double **xd = myalloc2(1, 2);
45 double *y = myalloc1(1);
46 double **yd = myalloc2(1, 2);
47
48 x[0] = 2.0;
49
50 for (int i = 0; i < 2; i++) {
51 xd[0][i] = 1. + i;
52 }
53
54 fov_forward(1, 1, 1, 2, x, xd, y, yd);
55
56 BOOST_TEST(*y == a, tt::tolerance(tol));
57 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
58 BOOST_TEST(yd[0][1] == aDerivative * 2., tt::tolerance(tol));
59
60 myfree1(x);
61 myfree2(xd);
62 myfree1(y);
63 myfree2(yd);
64 }
65
BOOST_AUTO_TEST_CASE(ExpOperator_FOV_Reverse)66 BOOST_AUTO_TEST_CASE(ExpOperator_FOV_Reverse)
67 {
68 double a = 2., aout;
69 adouble ad;
70
71 trace_on(1, 1);
72 ad <<= a;
73
74 ad = exp(ad);
75
76 ad >>= aout;
77 trace_off();
78
79 double aDerivative = std::exp(a);
80
81 double **u = myalloc2(2, 1);
82 double **z = myalloc2(2, 1);
83
84 u[0][0] = 1.;
85 u[1][0] = std::exp(3.);
86
87 fov_reverse(1, 1, 1, 2, u, z);
88
89 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
90 BOOST_TEST(z[1][0] == aDerivative*std::exp(3.), tt::tolerance(tol));
91
92 myfree2(u);
93 myfree2(z);
94 }
95
BOOST_AUTO_TEST_CASE(MultOperator_FOV_Forward)96 BOOST_AUTO_TEST_CASE(MultOperator_FOV_Forward)
97 {
98 double a = 2., b = 3.5, out;
99 adouble ad, bd;
100
101 trace_on(1);
102 ad <<= a;
103 bd <<= b;
104
105 ad = ad * bd;
106
107 ad >>= out;
108 trace_off();
109
110 double aDerivative = b;
111 double bDerivative = a;
112 a = a * b;
113
114 double *x = myalloc1(2);
115 double **xd = myalloc2(2, 2);
116 double *y = myalloc1(1);
117 double **yd = myalloc2(1, 2);
118
119 /* Test partial derivative wrt a and b. */
120 x[0] = 2.;
121 x[1] = 3.5;
122
123 for (int i = 0; i < 2; i++) {
124 for (int j = 0; j < 2; j++) {
125 if (i == j)
126 xd[i][j] = 1.;
127 else
128 xd[i][j] = 0.;
129 }
130 }
131
132 fov_forward(1, 1, 2, 2, x, xd, y, yd);
133
134 BOOST_TEST(*y == a, tt::tolerance(tol));
135 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
136 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
137
138 myfree1(x);
139 myfree2(xd);
140 myfree1(y);
141 myfree2(yd);
142 }
143
BOOST_AUTO_TEST_CASE(MultOperator_FOV_Reverse)144 BOOST_AUTO_TEST_CASE(MultOperator_FOV_Reverse)
145 {
146 double a = 2., b = 3.5, aout;
147 adouble ad, bd;
148
149 trace_on(1, 1);
150 ad <<= a;
151 bd <<= b;
152
153 ad = ad * bd;
154
155 ad >>= aout;
156 trace_off();
157
158 double aDerivative = b;
159 double bDerivative = a;
160
161 double **u = myalloc2(2, 1);
162 double **z = myalloc2(2, 2);
163
164 u[0][0] = 1.;
165 u[1][0] = 2.;
166
167 fov_reverse(1, 1, 2, 2, u, z);
168
169 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
170 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
171 BOOST_TEST(z[1][0] == 2.*aDerivative, tt::tolerance(tol));
172 BOOST_TEST(z[1][1] == 2.*bDerivative, tt::tolerance(tol));
173
174 myfree2(u);
175 myfree2(z);
176 }
177
BOOST_AUTO_TEST_CASE(AddOperator_FOV_Forward)178 BOOST_AUTO_TEST_CASE(AddOperator_FOV_Forward)
179 {
180 double a = 2.5, b = 3., out;
181 adouble ad, bd;
182
183 trace_on(1);
184 ad <<= a;
185 bd <<= b;
186
187 ad = ad + bd;
188
189 ad >>= out;
190 trace_off();
191
192 double aDerivative = 1.;
193 double bDerivative = 1.;
194 a = a + b;
195
196 double *x = myalloc1(2);
197 double **xd = myalloc2(2, 2);
198 double *y = myalloc1(1);
199 double **yd = myalloc2(1, 2);
200
201 /* Test partial derivative wrt a and b. */
202 x[0] = 2.5;
203 x[1] = 3.;
204
205 for (int i = 0; i < 2; i++) {
206 for (int j = 0; j < 2; j++) {
207 if (i == j)
208 xd[i][j] = 1.;
209 else
210 xd[i][j] = 0.;
211 }
212 }
213
214 fov_forward(1, 1, 2, 2, x, xd, y, yd);
215
216 BOOST_TEST(*y == a, tt::tolerance(tol));
217 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
218 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
219
220 myfree1(x);
221 myfree2(xd);
222 myfree1(y);
223 myfree2(yd);
224 }
225
BOOST_AUTO_TEST_CASE(AddOperator_FOV_Reverse)226 BOOST_AUTO_TEST_CASE(AddOperator_FOV_Reverse)
227 {
228 double a = 2.5, b = 3., aout;
229 adouble ad, bd;
230
231 trace_on(1, 1);
232 ad <<= a;
233 bd <<= b;
234
235 ad = ad + bd;
236
237 ad >>= aout;
238 trace_off();
239
240 double aDerivative = 1.;
241 double bDerivative = 1.;
242
243 double **u = myalloc2(2, 1);
244 double **z = myalloc2(2, 2);
245
246 u[0][0] = 1.;
247 u[1][0] = 9.;
248
249 fov_reverse(1, 1, 2, 2, u, z);
250
251 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
252 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
253 BOOST_TEST(z[1][0] == 9.*aDerivative, tt::tolerance(tol));
254 BOOST_TEST(z[1][1] == 9.*bDerivative, tt::tolerance(tol));
255
256 myfree2(u);
257 myfree2(z);
258 }
259
BOOST_AUTO_TEST_CASE(SubOperator_FOV_Forward)260 BOOST_AUTO_TEST_CASE(SubOperator_FOV_Forward)
261 {
262 double a = 1.5, b = 3.2, out;
263 adouble ad, bd;
264
265 trace_on(1);
266 ad <<= a;
267 bd <<= b;
268
269 ad = ad - bd;
270
271 ad >>= out;
272 trace_off();
273
274 double aDerivative = 1.;
275 double bDerivative = -1.;
276 a = a - b;
277
278 double *x = myalloc1(2);
279 double **xd = myalloc2(2, 2);
280 double *y = myalloc1(1);
281 double **yd = myalloc2(1, 2);
282
283 /* Test partial derivative wrt a and b. */
284 x[0] = 1.5;
285 x[1] = 3.2;
286
287 for (int i = 0; i < 2; i++) {
288 for (int j = 0; j < 2; j++) {
289 if (i == j)
290 xd[i][j] = 1.;
291 else
292 xd[i][j] = 0.;
293 }
294 }
295
296 fov_forward(1, 1, 2, 2, x, xd, y, yd);
297
298 BOOST_TEST(*y == a, tt::tolerance(tol));
299 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
300 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
301
302 myfree1(x);
303 myfree2(xd);
304 myfree1(y);
305 myfree2(yd);
306 }
307
BOOST_AUTO_TEST_CASE(SubOperator_FOV_Reverse)308 BOOST_AUTO_TEST_CASE(SubOperator_FOV_Reverse)
309 {
310 double a = 1.5, b = 3.2, aout;
311 adouble ad, bd;
312
313 trace_on(1, 1);
314 ad <<= a;
315 bd <<= b;
316
317 ad = ad - bd;
318
319 ad >>= aout;
320 trace_off();
321
322 double aDerivative = 1.;
323 double bDerivative = -1.;
324
325 double **u = myalloc2(2, 1);
326 double **z = myalloc2(2, 2);
327
328 u[0][0] = 1.;
329 u[1][0] = std::sqrt(2);
330
331 fov_reverse(1, 1, 2, 2, u, z);
332
333 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
334 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
335 BOOST_TEST(z[1][0] == std::sqrt(2)*aDerivative, tt::tolerance(tol));
336 BOOST_TEST(z[1][1] == std::sqrt(2)*bDerivative, tt::tolerance(tol));
337
338 myfree2(u);
339 myfree2(z);
340 }
341
BOOST_AUTO_TEST_CASE(DivOperator_FOV_Forward)342 BOOST_AUTO_TEST_CASE(DivOperator_FOV_Forward)
343 {
344 double a = 0.5, b = 4.5, out;
345 adouble ad, bd;
346
347 trace_on(1);
348 ad <<= a;
349 bd <<= b;
350
351 ad = ad / bd;
352
353 ad >>= out;
354 trace_off();
355
356 double aDerivative = 1. / b;
357 double bDerivative = -a / (b*b);
358 a = a / b;
359
360 double *x = myalloc1(2);
361 double **xd = myalloc2(2, 2);
362 double *y = myalloc1(1);
363 double **yd = myalloc2(1, 2);
364
365 /* Test partial derivative wrt a and b. */
366 x[0] = 0.5;
367 x[1] = 4.5;
368
369 for (int i = 0; i < 2; i++) {
370 for (int j = 0; j < 2; j++) {
371 if (i == j)
372 xd[i][j] = 1.;
373 else
374 xd[i][j] = 0.;
375 }
376 }
377
378 fov_forward(1, 1, 2, 2, x, xd, y, yd);
379
380 BOOST_TEST(*y == a, tt::tolerance(tol));
381 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
382 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
383
384 myfree1(x);
385 myfree2(xd);
386 myfree1(y);
387 myfree2(yd);
388 }
389
BOOST_AUTO_TEST_CASE(DivOperator_FOV_Reverse)390 BOOST_AUTO_TEST_CASE(DivOperator_FOV_Reverse)
391 {
392 double a = 0.5, b = 4.5, aout;
393 adouble ad, bd;
394
395 trace_on(1, 1);
396 ad <<= a;
397 bd <<= b;
398
399 ad = ad / bd;
400
401 ad >>= aout;
402 trace_off();
403
404 double aDerivative = 1. / b;
405 double bDerivative = -a / (b*b);
406
407 double **u = myalloc2(2, 1);
408 double **z = myalloc2(2, 2);
409
410 u[0][0] = 1.;
411 u[1][0] = 0.9;
412
413 fov_reverse(1, 1, 2, 2, u, z);
414
415 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
416 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
417 BOOST_TEST(z[1][0] == 0.9*aDerivative, tt::tolerance(tol));
418 BOOST_TEST(z[1][1] == 0.9*bDerivative, tt::tolerance(tol));
419
420 myfree2(u);
421 myfree2(z);
422 }
423
BOOST_AUTO_TEST_CASE(TanOperator_FOV_Forward)424 BOOST_AUTO_TEST_CASE(TanOperator_FOV_Forward)
425 {
426 double a = 0.7, aout;
427 adouble ad;
428
429 trace_on(1);
430 ad <<= a;
431
432 ad = tan(ad);
433
434 ad >>= aout;
435 trace_off();
436
437 a = tan(a);
438 double aDerivative = 1. + a*a;
439
440 double *x = myalloc1(1);
441 double **xd = myalloc2(1, 2);
442 double *y = myalloc1(1);
443 double **yd = myalloc2(1, 2);
444
445 x[0] = 0.7;
446
447 for (int i = 0; i < 2; i++) {
448 xd[0][i] = 1. + std::pow(2, i);
449 }
450
451 fov_forward(1, 1, 1, 2, x, xd, y, yd);
452
453 BOOST_TEST(*y == a, tt::tolerance(tol));
454 BOOST_TEST(yd[0][0] == aDerivative * (1. + std::pow(2, 0)), tt::tolerance(tol));
455 BOOST_TEST(yd[0][1] == aDerivative * (1. + std::pow(2, 1)), tt::tolerance(tol));
456
457 myfree1(x);
458 myfree2(xd);
459 myfree1(y);
460 myfree2(yd);
461 }
462
BOOST_AUTO_TEST_CASE(TanOperator_FOV_Reverse)463 BOOST_AUTO_TEST_CASE(TanOperator_FOV_Reverse)
464 {
465 double a = 0.7, aout;
466 adouble ad;
467
468 trace_on(1, 1);
469 ad <<= a;
470
471 ad = tan(ad);
472
473 ad >>= aout;
474 trace_off();
475
476 a = std::tan(a);
477 double aDerivative = 1. + a*a;
478
479 double **u = myalloc2(2, 1);
480 double **z = myalloc2(2, 1);
481
482 u[0][0] = 1.;
483 u[1][0] = 1.1;
484
485 fov_reverse(1, 1, 1, 2, u, z);
486
487 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
488 BOOST_TEST(z[1][0] == aDerivative*1.1, tt::tolerance(tol));
489
490 myfree2(u);
491 myfree2(z);
492 }
493
BOOST_AUTO_TEST_CASE(SinOperator_FOV_Forward)494 BOOST_AUTO_TEST_CASE(SinOperator_FOV_Forward)
495 {
496 double a = 1.2, aout;
497 adouble ad;
498
499 trace_on(1);
500 ad <<= a;
501
502 ad = sin(ad);
503
504 ad >>= aout;
505 trace_off();
506
507 double aDerivative = std::cos(a);
508 a = sin(a);
509
510 double *x = myalloc1(1);
511 double **xd = myalloc2(1, 2);
512 double *y = myalloc1(1);
513 double **yd = myalloc2(1, 2);
514
515 x[0] = 1.2;
516
517 for (int i = 0; i < 2; i++) {
518 xd[0][i] = 1. + i * (-2.0);
519 }
520
521 fov_forward(1, 1, 1, 2, x, xd, y, yd);
522
523 BOOST_TEST(*y == a, tt::tolerance(tol));
524 BOOST_TEST(yd[0][0] == aDerivative , tt::tolerance(tol));
525 BOOST_TEST(yd[0][1] == aDerivative * (-1.), tt::tolerance(tol));
526
527 myfree1(x);
528 myfree2(xd);
529 myfree1(y);
530 myfree2(yd);
531 }
532
BOOST_AUTO_TEST_CASE(SinOperator_FOV_Reverse)533 BOOST_AUTO_TEST_CASE(SinOperator_FOV_Reverse)
534 {
535 double a = 1.2, aout;
536 adouble ad;
537
538 trace_on(1, 1);
539 ad <<= a;
540
541 ad = sin(ad);
542
543 ad >>= aout;
544 trace_off();
545
546 double aDerivative = std::cos(a);
547
548 double **u = myalloc2(2, 1);
549 double **z = myalloc2(2, 1);
550
551 u[0][0] = 1.;
552 u[1][0] = std::tan(4.4);
553
554 fov_reverse(1, 1, 1, 2, u, z);
555
556 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
557 BOOST_TEST(z[1][0] == aDerivative*std::tan(4.4), tt::tolerance(tol));
558
559 myfree2(u);
560 myfree2(z);
561 }
562
BOOST_AUTO_TEST_CASE(CosOperator_FOV_Forward)563 BOOST_AUTO_TEST_CASE(CosOperator_FOV_Forward)
564 {
565 double a = 1.2, aout;
566 adouble ad;
567
568 trace_on(1);
569 ad <<= a;
570
571 ad = cos(ad);
572
573 ad >>= aout;
574 trace_off();
575
576 double aDerivative = -std::sin(a);
577 a = cos(a);
578
579 double *x = myalloc1(1);
580 double **xd = myalloc2(1, 2);
581 double *y = myalloc1(1);
582 double **yd = myalloc2(1, 2);
583
584 x[0] = 1.2;
585
586 for (int i = 0; i < 2; i++) {
587 xd[0][i] = 1. + i * 2.;
588 }
589
590 fov_forward(1, 1, 1, 2, x, xd, y, yd);
591
592 BOOST_TEST(*y == a, tt::tolerance(tol));
593 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
594 BOOST_TEST(yd[0][1] == aDerivative * 3., tt::tolerance(tol));
595
596 myfree1(x);
597 myfree2(xd);
598 myfree1(y);
599 myfree2(yd);
600 }
601
BOOST_AUTO_TEST_CASE(CosOperator_FOV_Reverse)602 BOOST_AUTO_TEST_CASE(CosOperator_FOV_Reverse)
603 {
604 double a = 1.2, aout;
605 adouble ad;
606
607 trace_on(1, 1);
608 ad <<= a;
609
610 ad = cos(ad);
611
612 ad >>= aout;
613 trace_off();
614
615 double aDerivative = -std::sin(a);
616
617 double **u = myalloc2(2, 1);
618 double **z = myalloc2(2, 1);
619
620 u[0][0] = 1.;
621 u[1][0] = std::log(2.);
622
623 fov_reverse(1, 1, 1, 2, u, z);
624
625 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
626 BOOST_TEST(z[1][0] == aDerivative*std::log(2.), tt::tolerance(tol));
627
628 myfree2(u);
629 myfree2(z);
630 }
631
BOOST_AUTO_TEST_CASE(SqrtOperator_FOV_Forward)632 BOOST_AUTO_TEST_CASE(SqrtOperator_FOV_Forward)
633 {
634 double a = 2.2, aout;
635 adouble ad;
636
637 trace_on(1);
638 ad <<= a;
639
640 ad = sqrt(ad);
641
642 ad >>= aout;
643 trace_off();
644
645 a = std::sqrt(a);
646 double aDerivative = 1. / (2.*a);
647
648 double *x = myalloc1(1);
649 double **xd = myalloc2(1, 2);
650 double *y = myalloc1(1);
651 double **yd = myalloc2(1, 2);
652
653 x[0] = 2.2;
654
655 for (int i = 0; i < 2; i++) {
656 xd[0][i] = 1. * std::pow(2, i);
657 }
658
659 fov_forward(1, 1, 1, 2, x, xd, y, yd);
660
661 BOOST_TEST(*y == a, tt::tolerance(tol));
662 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
663 BOOST_TEST(yd[0][1] == aDerivative * 2., tt::tolerance(tol));
664
665 myfree1(x);
666 myfree2(xd);
667 myfree1(y);
668 myfree2(yd);
669 }
670
BOOST_AUTO_TEST_CASE(SqrtOperator_FOV_Reverse)671 BOOST_AUTO_TEST_CASE(SqrtOperator_FOV_Reverse)
672 {
673 double a = 2.2, aout;
674 adouble ad;
675
676 trace_on(1, 1);
677 ad <<= a;
678
679 ad = sqrt(ad);
680
681 ad >>= aout;
682 trace_off();
683
684 double aDerivative = 1. / (2.*std::sqrt(a));
685
686 double **u = myalloc2(2, 1);
687 double **z = myalloc2(2, 1);
688
689 u[0][0] = 1.;
690 u[1][0] = std::exp(2.);
691
692 fov_reverse(1, 1, 1, 2, u, z);
693
694 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
695 BOOST_TEST(z[1][0] == aDerivative*std::exp(2.), tt::tolerance(tol));
696
697 myfree2(u);
698 myfree2(z);
699 }
700
BOOST_AUTO_TEST_CASE(LogOperator_FOV_Forward)701 BOOST_AUTO_TEST_CASE(LogOperator_FOV_Forward)
702 {
703 double a = 4.9, aout;
704 adouble ad;
705
706 trace_on(1);
707 ad <<= a;
708
709 ad = log(ad);
710
711 ad >>= aout;
712 trace_off();
713
714 double aDerivative = 1. / a;
715 a = std::log(a);
716
717 double *x = myalloc1(1);
718 double **xd = myalloc2(1, 2);
719 double *y = myalloc1(1);
720 double **yd = myalloc2(1, 2);
721
722 x[0] = 4.9;
723
724 for (int i = 0; i < 2; i++) {
725 xd[0][i] = 1. + i * 5.5;
726 }
727
728 fov_forward(1, 1, 1, 2, x, xd, y, yd);
729
730 BOOST_TEST(*y == a, tt::tolerance(tol));
731 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
732 BOOST_TEST(yd[0][1] == aDerivative * 6.5, tt::tolerance(tol));
733
734 myfree1(x);
735 myfree2(xd);
736 myfree1(y);
737 myfree2(yd);
738 }
739
BOOST_AUTO_TEST_CASE(LogOperator_FOV_Reverse)740 BOOST_AUTO_TEST_CASE(LogOperator_FOV_Reverse)
741 {
742 double a = 4.9, aout;
743 adouble ad;
744
745 trace_on(1, 1);
746 ad <<= a;
747
748 ad = log(ad);
749
750 ad >>= aout;
751 trace_off();
752
753 double aDerivative = 1. / a;
754
755 double **u = myalloc2(2, 1);
756 double **z = myalloc2(2, 1);
757
758 u[0][0] = 1.;
759 u[1][0] = std::exp(-1.);
760
761 fov_reverse(1, 1, 1, 2, u, z);
762
763 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
764 BOOST_TEST(z[1][0] == aDerivative*std::exp(-1.), tt::tolerance(tol));
765
766 myfree2(u);
767 myfree2(z);
768 }
769
BOOST_AUTO_TEST_CASE(SinhOperator_FOV_Forward)770 BOOST_AUTO_TEST_CASE(SinhOperator_FOV_Forward)
771 {
772 double a = 4., aout;
773 adouble ad;
774
775 trace_on(1);
776 ad <<= a;
777
778 ad = sinh(ad);
779
780 ad >>= aout;
781 trace_off();
782
783 double aDerivative = std::cosh(a);
784 a = std::sinh(a);
785
786 double *x = myalloc1(1);
787 double **xd = myalloc2(1, 2);
788 double *y = myalloc1(1);
789 double **yd = myalloc2(1, 2);
790
791 x[0] = 4.;
792
793 for (int i = 0; i < 2; i++) {
794 xd[0][i] = 1. - std::sqrt(2.*i);
795 }
796
797 fov_forward(1, 1, 1, 2, x, xd, y, yd);
798
799 BOOST_TEST(*y == a, tt::tolerance(tol));
800 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
801 BOOST_TEST(yd[0][1] == aDerivative * (1. - std::sqrt(2.)), tt::tolerance(tol));
802
803 myfree1(x);
804 myfree2(xd);
805 myfree1(y);
806 myfree2(yd);
807 }
808
BOOST_AUTO_TEST_CASE(SinhOperator_FOV_Reverse)809 BOOST_AUTO_TEST_CASE(SinhOperator_FOV_Reverse)
810 {
811 double a = 4., aout;
812 adouble ad;
813
814 trace_on(1, 1);
815 ad <<= a;
816
817 ad = sinh(ad);
818
819 ad >>= aout;
820 trace_off();
821
822 double aDerivative = std::cosh(a);
823
824 double **u = myalloc2(2, 1);
825 double **z = myalloc2(2, 1);
826
827 u[0][0] = 1.;
828 u[1][0] = std::cosh(3.5);
829
830 fov_reverse(1, 1, 1, 2, u, z);
831
832 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
833 BOOST_TEST(z[1][0] == aDerivative*std::cosh(3.5), tt::tolerance(tol));
834
835 myfree2(u);
836 myfree2(z);
837 }
838
BOOST_AUTO_TEST_CASE(CoshOperator_FOV_Forward)839 BOOST_AUTO_TEST_CASE(CoshOperator_FOV_Forward)
840 {
841 double a = 4., aout;
842 adouble ad;
843
844 trace_on(1);
845 ad <<= a;
846
847 ad = cosh(ad);
848
849 ad >>= aout;
850 trace_off();
851
852 double aDerivative = std::sinh(a);
853 a = std::cosh(a);
854
855 double *x = myalloc1(1);
856 double **xd = myalloc2(1, 2);
857 double *y = myalloc1(1);
858 double **yd = myalloc2(1, 2);
859
860 x[0] = 4.;
861
862 for (int i = 0; i < 2; i++) {
863 xd[0][i] = 1. + i * 3.2;
864 }
865
866 fov_forward(1, 1, 1, 2, x, xd, y, yd);
867
868 BOOST_TEST(*y == a, tt::tolerance(tol));
869 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
870 BOOST_TEST(yd[0][1] == aDerivative * 4.2, tt::tolerance(tol));
871
872 myfree1(x);
873 myfree2(xd);
874 myfree1(y);
875 myfree2(yd);
876 }
877
BOOST_AUTO_TEST_CASE(CoshOperator_FOV_Reverse)878 BOOST_AUTO_TEST_CASE(CoshOperator_FOV_Reverse)
879 {
880 double a = 4., aout;
881 adouble ad;
882
883 trace_on(1, 1);
884 ad <<= a;
885
886 ad = cosh(ad);
887
888 ad >>= aout;
889 trace_off();
890
891 double aDerivative = std::sinh(a);
892
893 double **u = myalloc2(2, 1);
894 double **z = myalloc2(2, 1);
895
896 u[0][0] = 1.;
897 u[1][0] = std::sinh(3.5);
898
899 fov_reverse(1, 1, 1, 2, u, z);
900
901 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
902 BOOST_TEST(z[1][0] == aDerivative*std::sinh(3.5), tt::tolerance(tol));
903
904 myfree2(u);
905 myfree2(z);
906 }
907
BOOST_AUTO_TEST_CASE(TanhOperator_FOV_Forward)908 BOOST_AUTO_TEST_CASE(TanhOperator_FOV_Forward)
909 {
910 double a = 4., aout;
911 adouble ad;
912
913 trace_on(1);
914 ad <<= a;
915
916 ad = tanh(ad);
917
918 ad >>= aout;
919 trace_off();
920
921 a = std::tanh(a);
922 double aDerivative = 1. - a*a;
923
924 double *x = myalloc1(1);
925 double **xd = myalloc2(1, 2);
926 double *y = myalloc1(1);
927 double **yd = myalloc2(1, 2);
928
929 x[0] = 4.;
930
931 for (int i = 0; i < 2; i++) {
932 xd[0][i] = 1. - 1.3*i;
933 }
934
935 fov_forward(1, 1, 1, 2, x, xd, y, yd);
936
937 BOOST_TEST(*y == a, tt::tolerance(tol));
938 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
939 BOOST_TEST(yd[0][1] == aDerivative * (1. - 1.3), tt::tolerance(tol));
940
941 myfree1(x);
942 myfree2(xd);
943 myfree1(y);
944 myfree2(yd);
945 }
946
BOOST_AUTO_TEST_CASE(TanhOperator_FOV_Reverse)947 BOOST_AUTO_TEST_CASE(TanhOperator_FOV_Reverse)
948 {
949 double a = 4., aout;
950 adouble ad;
951
952 trace_on(1, 1);
953 ad <<= a;
954
955 ad = tanh(ad);
956
957 ad >>= aout;
958 trace_off();
959
960 a = std::tanh(a);
961 double aDerivative = 1. - a*a;
962
963 double **u = myalloc2(2, 1);
964 double **z = myalloc2(2, 1);
965
966 u[0][0] = 1.;
967 u[1][0] = 5.4;
968
969 fov_reverse(1, 1, 1, 2, u, z);
970
971 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
972 BOOST_TEST(z[1][0] == 5.4*aDerivative, tt::tolerance(tol));
973
974 myfree2(u);
975 myfree2(z);
976 }
977
BOOST_AUTO_TEST_CASE(AsinOperator_FOV_Forward)978 BOOST_AUTO_TEST_CASE(AsinOperator_FOV_Forward)
979 {
980 double a = 0.9, aout;
981 adouble ad;
982
983 trace_on(1);
984 ad <<= a;
985
986 ad = asin(ad);
987
988 ad >>= aout;
989 trace_off();
990
991 double aDerivative = 1. / (std::sqrt(1. - a*a));
992 a = std::asin(a);
993
994 double *x = myalloc1(1);
995 double **xd = myalloc2(1, 2);
996 double *y = myalloc1(1);
997 double **yd = myalloc2(1, 2);
998
999 x[0] = 0.9;
1000
1001 for (int i = 0; i < 2; i++) {
1002 xd[0][i] = 1. + i*(i + 1.7)*4.3;
1003 }
1004
1005 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1006
1007 BOOST_TEST(*y == a, tt::tolerance(tol));
1008 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1009 BOOST_TEST(yd[0][1] == aDerivative*(1. + 2.7*4.3), tt::tolerance(tol));
1010
1011 myfree1(x);
1012 myfree2(xd);
1013 myfree1(y);
1014 myfree2(yd);
1015 }
1016
BOOST_AUTO_TEST_CASE(AsinOperator_FOV_Reverse)1017 BOOST_AUTO_TEST_CASE(AsinOperator_FOV_Reverse)
1018 {
1019 double a = 0.9, aout;
1020 adouble ad;
1021
1022 trace_on(1, 1);
1023 ad <<= a;
1024
1025 ad = asin(ad);
1026
1027 ad >>= aout;
1028 trace_off();
1029
1030 double aDerivative = 1. / (std::sqrt(1. - a*a));
1031
1032 double **u = myalloc2(2, 1);
1033 double **z = myalloc2(2, 1);
1034
1035 u[0][0] = 1.;
1036 u[1][0] = 1. + 2.7*4.3;
1037
1038 fov_reverse(1, 1, 1, 2, u, z);
1039
1040 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1041 BOOST_TEST(z[1][0] == aDerivative*(1. + 2.7*4.3), tt::tolerance(tol));
1042
1043 myfree2(u);
1044 myfree2(z);
1045 }
1046
BOOST_AUTO_TEST_CASE(AcosOperator_FOV_Forward)1047 BOOST_AUTO_TEST_CASE(AcosOperator_FOV_Forward)
1048 {
1049 double a = 0.8, aout;
1050 adouble ad;
1051
1052 trace_on(1);
1053 ad <<= a;
1054
1055 ad = acos(ad);
1056
1057 ad >>= aout;
1058 trace_off();
1059
1060 double aDerivative = -1. / (std::sqrt(1. - a*a));
1061 a = std::acos(a);
1062
1063 double *x = myalloc1(1);
1064 double **xd = myalloc2(1, 2);
1065 double *y = myalloc1(1);
1066 double **yd = myalloc2(1, 2);
1067
1068 x[0] = 0.8;
1069
1070 for (int i = 0; i < 2; i++) {
1071 xd[0][i] = 1. - i*(i + 0.7)*3.4;
1072 }
1073
1074 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1075
1076 BOOST_TEST(*y == a, tt::tolerance(tol));
1077 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1078 BOOST_TEST(yd[0][1] == aDerivative*(1. - 1.7*3.4), tt::tolerance(tol));
1079
1080 myfree1(x);
1081 myfree2(xd);
1082 myfree1(y);
1083 myfree2(yd);
1084 }
1085
BOOST_AUTO_TEST_CASE(AcosOperator_FOV_Reverse)1086 BOOST_AUTO_TEST_CASE(AcosOperator_FOV_Reverse)
1087 {
1088 double a = 0.8, aout;
1089 adouble ad;
1090
1091 trace_on(1, 1);
1092 ad <<= a;
1093
1094 ad = acos(ad);
1095
1096 ad >>= aout;
1097 trace_off();
1098
1099 double aDerivative = -1. / (std::sqrt(1. - a*a));
1100
1101 double **u = myalloc2(2, 1);
1102 double **z = myalloc2(2, 1);
1103
1104 u[0][0] = 1.;
1105 u[1][0] = 1. - 1.7*3.4;
1106
1107 fov_reverse(1, 1, 1, 2, u, z);
1108
1109 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1110 BOOST_TEST(z[1][0] == aDerivative*(1. - 1.7*3.4), tt::tolerance(tol));
1111
1112 myfree2(u);
1113 myfree2(z);
1114 }
1115
BOOST_AUTO_TEST_CASE(AtanOperator_FOV_Forward)1116 BOOST_AUTO_TEST_CASE(AtanOperator_FOV_Forward)
1117 {
1118 double a = 9.8, aout;
1119 adouble ad;
1120
1121 trace_on(1);
1122 ad <<= a;
1123
1124 ad = atan(ad);
1125
1126 ad >>= aout;
1127 trace_off();
1128
1129 double aDerivative = 1. / (1. + a*a);
1130 a = std::atan(a);
1131
1132 double *x = myalloc1(1);
1133 double **xd = myalloc2(1, 2);
1134 double *y = myalloc1(1);
1135 double **yd = myalloc2(1, 2);
1136
1137 x[0] = 9.8;
1138
1139 for (int i = 0; i < 2; i++) {
1140 xd[0][i] = 1. - i*(i - 0.3)*4.3;
1141 }
1142
1143 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1144
1145 BOOST_TEST(*y == a, tt::tolerance(tol));
1146 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1147 BOOST_TEST(yd[0][1] == aDerivative*(1. - 0.7*4.3), tt::tolerance(tol));
1148
1149 myfree1(x);
1150 myfree2(xd);
1151 myfree1(y);
1152 myfree2(yd);
1153 }
1154
BOOST_AUTO_TEST_CASE(Atanperator_FOV_Reverse)1155 BOOST_AUTO_TEST_CASE(Atanperator_FOV_Reverse)
1156 {
1157 double a = 9.8, aout;
1158 adouble ad;
1159
1160 trace_on(1, 1);
1161 ad <<= a;
1162
1163 ad = atan(ad);
1164
1165 ad >>= aout;
1166 trace_off();
1167
1168 double aDerivative = 1. / (1. + a*a);
1169
1170 double **u = myalloc2(2, 1);
1171 double **z = myalloc2(2, 1);
1172
1173 u[0][0] = 1.;
1174 u[1][0] = 1. - 0.7*4.3;
1175
1176 fov_reverse(1, 1, 1, 2, u, z);
1177
1178 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1179 BOOST_TEST(z[1][0] == aDerivative*(1. - 0.7*4.3), tt::tolerance(tol));
1180
1181 myfree2(u);
1182 myfree2(z);
1183 }
1184
BOOST_AUTO_TEST_CASE(Log10Operator_FOV_Forward)1185 BOOST_AUTO_TEST_CASE(Log10Operator_FOV_Forward)
1186 {
1187 double a = 12.3, aout;
1188 adouble ad;
1189
1190 trace_on(1);
1191 ad <<= a;
1192
1193 ad = log10(ad);
1194
1195 ad >>= aout;
1196 trace_off();
1197
1198 double aDerivative = 1. / (a * std::log(10));
1199 a = std::log10(a);
1200
1201 double *x = myalloc1(1);
1202 double **xd = myalloc2(1, 2);
1203 double *y = myalloc1(1);
1204 double **yd = myalloc2(1, 2);
1205
1206 x[0] = 12.3;
1207
1208 for (int i = 0; i < 2; i++) {
1209 xd[0][i] = 1. + i*9.9;
1210 }
1211
1212 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1213
1214 BOOST_TEST(*y == a, tt::tolerance(tol));
1215 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1216 BOOST_TEST(yd[0][1] == aDerivative * (1. + 9.9), tt::tolerance(tol));
1217
1218 myfree1(x);
1219 myfree2(xd);
1220 myfree1(y);
1221 myfree2(yd);
1222 }
1223
BOOST_AUTO_TEST_CASE(Log10perator_FOV_Reverse)1224 BOOST_AUTO_TEST_CASE(Log10perator_FOV_Reverse)
1225 {
1226 double a = 12.3, aout;
1227 adouble ad;
1228
1229 trace_on(1, 1);
1230 ad <<= a;
1231
1232 ad = log10(ad);
1233
1234 ad >>= aout;
1235 trace_off();
1236
1237 double aDerivative = 1. / (a*std::log(10));
1238
1239 double **u = myalloc2(2, 1);
1240 double **z = myalloc2(2, 1);
1241
1242 u[0][0] = 1.;
1243 u[1][0] = 1. + 9.9;
1244
1245 fov_reverse(1, 1, 1, 2, u, z);
1246
1247 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1248 BOOST_TEST(z[1][0] == aDerivative*(1. + 9.9), tt::tolerance(tol));
1249
1250 myfree2(u);
1251 myfree2(z);
1252 }
1253
1254 #if defined(ATRIG_ERF)
BOOST_AUTO_TEST_CASE(AsinhOperator_FOV_Forward)1255 BOOST_AUTO_TEST_CASE(AsinhOperator_FOV_Forward)
1256 {
1257 double a = 0.6, aout;
1258 adouble ad;
1259
1260 trace_on(1);
1261 ad <<= a;
1262
1263 ad = asinh(ad);
1264
1265 ad >>= aout;
1266 trace_off();
1267
1268 double aDerivative = 1. / (std::sqrt(a*a + 1.));
1269 a = std::asinh(a);
1270
1271 double *x = myalloc1(1);
1272 double **xd = myalloc2(1, 2);
1273 double *y = myalloc1(1);
1274 double **yd = myalloc2(1, 2);
1275
1276 x[0] = 0.6;
1277
1278 for (int i = 0; i < 2; i++) {
1279 xd[0][i] = 1. - i*6.2;
1280 }
1281
1282 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1283
1284 BOOST_TEST(*y == a, tt::tolerance(tol));
1285 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1286 BOOST_TEST(yd[0][1] == aDerivative * (1. - 6.2), tt::tolerance(tol));
1287
1288 myfree1(x);
1289 myfree2(xd);
1290 myfree1(y);
1291 myfree2(yd);
1292 }
1293
BOOST_AUTO_TEST_CASE(Asinhperator_FOV_Reverse)1294 BOOST_AUTO_TEST_CASE(Asinhperator_FOV_Reverse)
1295 {
1296 double a = 0.6, aout;
1297 adouble ad;
1298
1299 trace_on(1, 1);
1300 ad <<= a;
1301
1302 ad = asinh(ad);
1303
1304 ad >>= aout;
1305 trace_off();
1306
1307 double aDerivative = 1. / (std::sqrt(a*a + 1.));
1308
1309 double **u = myalloc2(2, 1);
1310 double **z = myalloc2(2, 1);
1311
1312 u[0][0] = 1.;
1313 u[1][0] = 1. - 6.1;
1314
1315 fov_reverse(1, 1, 1, 2, u, z);
1316
1317 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1318 BOOST_TEST(z[1][0] == aDerivative*(1. - 6.1), tt::tolerance(tol));
1319
1320 myfree2(u);
1321 myfree2(z);
1322 }
1323
BOOST_AUTO_TEST_CASE(AcoshOperator_FOV_Forward)1324 BOOST_AUTO_TEST_CASE(AcoshOperator_FOV_Forward)
1325 {
1326 double a = 1.7, aout;
1327 adouble ad;
1328
1329 trace_on(1);
1330 ad <<= a;
1331
1332 ad = acosh(ad);
1333
1334 ad >>= aout;
1335 trace_off();
1336
1337 double aDerivative = 1. / (std::sqrt(a*a - 1.));
1338 a = std::acosh(a);
1339
1340 double *x = myalloc1(1);
1341 double **xd = myalloc2(1, 2);
1342 double *y = myalloc1(1);
1343 double **yd = myalloc2(1, 2);
1344
1345 x[0] = 1.7;
1346
1347 for (int i = 0; i < 2; i++) {
1348 xd[0][i] = 1. + i*3.1;
1349 }
1350
1351 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1352
1353 BOOST_TEST(*y == a, tt::tolerance(tol));
1354 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1355 BOOST_TEST(yd[0][1] == aDerivative * (1. + 3.1), tt::tolerance(tol));
1356
1357 myfree1(x);
1358 myfree2(xd);
1359 myfree1(y);
1360 myfree2(yd);
1361 }
1362
BOOST_AUTO_TEST_CASE(Acoshperator_FOV_Reverse)1363 BOOST_AUTO_TEST_CASE(Acoshperator_FOV_Reverse)
1364 {
1365 double a = 1.6, aout;
1366 adouble ad;
1367
1368 trace_on(1, 1);
1369 ad <<= a;
1370
1371 ad = acosh(ad);
1372
1373 ad >>= aout;
1374 trace_off();
1375
1376 double aDerivative = 1. / (std::sqrt(a*a - 1.));
1377
1378 double **u = myalloc2(2, 1);
1379 double **z = myalloc2(2, 1);
1380
1381 u[0][0] = 1.;
1382 u[1][0] = 1. + 3.1;
1383
1384 fov_reverse(1, 1, 1, 2, u, z);
1385
1386 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1387 BOOST_TEST(z[1][0] == aDerivative*(1. + 3.1), tt::tolerance(tol));
1388
1389 myfree2(u);
1390 myfree2(z);
1391 }
1392
BOOST_AUTO_TEST_CASE(AtanhOperator_FOV_Forward)1393 BOOST_AUTO_TEST_CASE(AtanhOperator_FOV_Forward)
1394 {
1395 double a = 0.6, aout;
1396 adouble ad;
1397
1398 trace_on(1);
1399 ad <<= a;
1400
1401 ad = atanh(ad);
1402
1403 ad >>= aout;
1404 trace_off();
1405
1406 double aDerivative = 1. / (1. - a*a);
1407 a = std::atanh(a);
1408
1409 double *x = myalloc1(1);
1410 double **xd = myalloc2(1, 2);
1411 double *y = myalloc1(1);
1412 double **yd = myalloc2(1, 2);
1413
1414 x[0] = 0.6;
1415
1416 for (int i = 0; i < 2; i++) {
1417 xd[0][i] = 1. + i*2.2;
1418 }
1419
1420 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1421
1422 BOOST_TEST(*y == a, tt::tolerance(tol));
1423 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1424 BOOST_TEST(yd[0][1] == aDerivative * (1. + 2.2), tt::tolerance(tol));
1425
1426 myfree1(x);
1427 myfree2(xd);
1428 myfree1(y);
1429 myfree2(yd);
1430 }
1431
BOOST_AUTO_TEST_CASE(Atanhperator_FOV_Reverse)1432 BOOST_AUTO_TEST_CASE(Atanhperator_FOV_Reverse)
1433 {
1434 double a = 0.6, aout;
1435 adouble ad;
1436
1437 trace_on(1, 1);
1438 ad <<= a;
1439
1440 ad = atanh(ad);
1441
1442 ad >>= aout;
1443 trace_off();
1444
1445 double aDerivative = 1. / (1. - a*a);
1446
1447 double **u = myalloc2(2, 1);
1448 double **z = myalloc2(2, 1);
1449
1450 u[0][0] = 1.;
1451 u[1][0] = 1. + 2.2;
1452
1453 fov_reverse(1, 1, 1, 2, u, z);
1454
1455 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1456 BOOST_TEST(z[1][0] == aDerivative*(1. + 2.2), tt::tolerance(tol));
1457
1458 myfree2(u);
1459 myfree2(z);
1460 }
1461 #endif
1462
BOOST_AUTO_TEST_CASE(InclOperator_FOV_Forward)1463 BOOST_AUTO_TEST_CASE(InclOperator_FOV_Forward)
1464 {
1465 double a = 5., aout;
1466 adouble ad;
1467
1468 trace_on(1);
1469 ad <<= a;
1470
1471 ad = ++ad;
1472
1473 ad >>= aout;
1474 trace_off();
1475
1476 double aDerivative = 1.;
1477 a = ++a;
1478
1479 double *x = myalloc1(1);
1480 double **xd = myalloc2(1, 2);
1481 double *y = myalloc1(1);
1482 double **yd = myalloc2(1, 2);
1483
1484 x[0] = 5.;
1485
1486 for (int i = 0; i < 2; i++) {
1487 xd[0][i] = 1. - i*4.2;
1488 }
1489
1490 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1491
1492 BOOST_TEST(*y == a, tt::tolerance(tol));
1493 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1494 BOOST_TEST(yd[0][1] == aDerivative * (1. - 4.2), tt::tolerance(tol));
1495
1496 myfree1(x);
1497 myfree2(xd);
1498 myfree1(y);
1499 myfree2(yd);
1500 }
1501
BOOST_AUTO_TEST_CASE(Inclperator_FOV_Reverse)1502 BOOST_AUTO_TEST_CASE(Inclperator_FOV_Reverse)
1503 {
1504 double a = 5., aout;
1505 adouble ad;
1506
1507 trace_on(1, 1);
1508 ad <<= a;
1509
1510 ad = ++ad;
1511
1512 ad >>= aout;
1513 trace_off();
1514
1515 double aDerivative = 1.;
1516
1517 double **u = myalloc2(2, 1);
1518 double **z = myalloc2(2, 1);
1519
1520 u[0][0] = 1.;
1521 u[1][0] = std::sqrt(5);
1522
1523 fov_reverse(1, 1, 1, 2, u, z);
1524
1525 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1526 BOOST_TEST(z[1][0] == aDerivative*std::sqrt(5), tt::tolerance(tol));
1527
1528 myfree2(u);
1529 myfree2(z);
1530 }
1531
BOOST_AUTO_TEST_CASE(DeclOperator_FOV_Forward)1532 BOOST_AUTO_TEST_CASE(DeclOperator_FOV_Forward)
1533 {
1534 double a = 5., aout;
1535 adouble ad;
1536
1537 trace_on(1);
1538 ad <<= a;
1539
1540 ad = --ad;
1541
1542 ad >>= aout;
1543 trace_off();
1544
1545 double aDerivative = 1.;
1546 a = --a;
1547
1548 double *x = myalloc1(1);
1549 double **xd = myalloc2(1, 2);
1550 double *y = myalloc1(1);
1551 double **yd = myalloc2(1, 2);
1552
1553 x[0] = 5.;
1554
1555 for (int i = 0; i < 2; i++) {
1556 xd[0][i] = 1. - i*4.2;
1557 }
1558
1559 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1560
1561 BOOST_TEST(*y == a, tt::tolerance(tol));
1562 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1563 BOOST_TEST(yd[0][1] == aDerivative * (1. - 4.2), tt::tolerance(tol));
1564
1565 myfree1(x);
1566 myfree2(xd);
1567 myfree1(y);
1568 myfree2(yd);
1569 }
1570
BOOST_AUTO_TEST_CASE(Declperator_FOV_Reverse)1571 BOOST_AUTO_TEST_CASE(Declperator_FOV_Reverse)
1572 {
1573 double a = 5., aout;
1574 adouble ad;
1575
1576 trace_on(1, 1);
1577 ad <<= a;
1578
1579 ad = --ad;
1580
1581 ad >>= aout;
1582 trace_off();
1583
1584 double aDerivative = 1.;
1585
1586 double **u = myalloc2(2, 1);
1587 double **z = myalloc2(2, 1);
1588
1589 u[0][0] = 1.;
1590 u[1][0] = std::sqrt(5);
1591
1592 fov_reverse(1, 1, 1, 2, u, z);
1593
1594 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1595 BOOST_TEST(z[1][0] == aDerivative*std::sqrt(5), tt::tolerance(tol));
1596
1597 myfree2(u);
1598 myfree2(z);
1599 }
1600
BOOST_AUTO_TEST_CASE(SignPlusOperator_FOV_Forward)1601 BOOST_AUTO_TEST_CASE(SignPlusOperator_FOV_Forward)
1602 {
1603 double a = 1.5, aout;
1604 adouble ad;
1605
1606 trace_on(1);
1607 ad <<= a;
1608
1609 ad = +ad;
1610
1611 ad >>= aout;
1612 trace_off();
1613
1614 double aDerivative = 1.;
1615 a = +a;
1616
1617 double *x = myalloc1(1);
1618 double **xd = myalloc2(1, 2);
1619 double *y = myalloc1(1);
1620 double **yd = myalloc2(1, 2);
1621
1622 x[0] = 1.5;
1623
1624 for (int i = 0; i < 2; i++) {
1625 xd[0][i] = 1. + i*0.8;
1626 }
1627
1628 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1629
1630 BOOST_TEST(*y == a, tt::tolerance(tol));
1631 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1632 BOOST_TEST(yd[0][1] == aDerivative * (1. + 0.8), tt::tolerance(tol));
1633
1634 myfree1(x);
1635 myfree2(xd);
1636 myfree1(y);
1637 myfree2(yd);
1638 }
1639
BOOST_AUTO_TEST_CASE(SignPlusOperator_FOV_Reverse)1640 BOOST_AUTO_TEST_CASE(SignPlusOperator_FOV_Reverse)
1641 {
1642 double a = 1.5, aout;
1643 adouble ad;
1644
1645 trace_on(1, 1);
1646 ad <<= a;
1647
1648 ad = +ad;
1649
1650 ad >>= aout;
1651 trace_off();
1652
1653 double aDerivative = 1.;
1654
1655 double **u = myalloc2(2, 1);
1656 double **z = myalloc2(2, 1);
1657
1658 u[0][0] = 1.;
1659 u[1][0] = std::sqrt(3);
1660
1661 fov_reverse(1, 1, 1, 2, u, z);
1662
1663 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1664 BOOST_TEST(z[1][0] == aDerivative*std::sqrt(3), tt::tolerance(tol));
1665
1666 myfree2(u);
1667 myfree2(z);
1668 }
1669
BOOST_AUTO_TEST_CASE(SignMinusOperator_FOV_Forward)1670 BOOST_AUTO_TEST_CASE(SignMinusOperator_FOV_Forward)
1671 {
1672 double a = 1.5, aout;
1673 adouble ad;
1674
1675 trace_on(1);
1676 ad <<= a;
1677
1678 ad = -ad;
1679
1680 ad >>= aout;
1681 trace_off();
1682
1683 double aDerivative = -1.;
1684 a = -a;
1685
1686 double *x = myalloc1(1);
1687 double **xd = myalloc2(1, 2);
1688 double *y = myalloc1(1);
1689 double **yd = myalloc2(1, 2);
1690
1691 x[0] = 1.5;
1692
1693 for (int i = 0; i < 2; i++) {
1694 xd[0][i] = 1. + i*0.8;
1695 }
1696
1697 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1698
1699 BOOST_TEST(*y == a, tt::tolerance(tol));
1700 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1701 BOOST_TEST(yd[0][1] == aDerivative * (1. + 0.8), tt::tolerance(tol));
1702
1703 myfree1(x);
1704 myfree2(xd);
1705 myfree1(y);
1706 myfree2(yd);
1707 }
1708
BOOST_AUTO_TEST_CASE(SignMinusOperator_FOV_Reverse)1709 BOOST_AUTO_TEST_CASE(SignMinusOperator_FOV_Reverse)
1710 {
1711 double a = 1.5, aout;
1712 adouble ad;
1713
1714 trace_on(1, 1);
1715 ad <<= a;
1716
1717 ad = -ad;
1718
1719 ad >>= aout;
1720 trace_off();
1721
1722 double aDerivative = -1.;
1723
1724 double **u = myalloc2(2, 1);
1725 double **z = myalloc2(2, 1);
1726
1727 u[0][0] = 1.;
1728 u[1][0] = std::sqrt(3);
1729
1730 fov_reverse(1, 1, 1, 2, u, z);
1731
1732 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1733 BOOST_TEST(z[1][0] == aDerivative*std::sqrt(3), tt::tolerance(tol));
1734
1735 myfree2(u);
1736 myfree2(z);
1737 }
1738
BOOST_AUTO_TEST_CASE(Atan2Operator_FOV_Forward)1739 BOOST_AUTO_TEST_CASE(Atan2Operator_FOV_Forward)
1740 {
1741 double a = 12.3, b = 2.1, out;
1742 adouble ad, bd;
1743
1744 trace_on(1);
1745 ad <<= a;
1746 bd <<= b;
1747
1748 ad = atan2(ad, bd);
1749
1750 ad >>= out;
1751 trace_off();
1752
1753 double aDerivative = b / (a*a + b*b);
1754 double bDerivative = -a / (a*a + b*b);
1755 a = std::atan2(a, b);
1756
1757 double *x = myalloc1(2);
1758 double **xd = myalloc2(2, 2);
1759 double *y = myalloc1(1);
1760 double **yd = myalloc2(1, 2);
1761
1762 /* Test partial derivative wrt a and b. */
1763 x[0] = 12.3;
1764 x[1] = 2.1;
1765
1766 for (int i = 0; i < 2; i++) {
1767 for (int j = 0; j < 2; j++) {
1768 if (i == j)
1769 xd[i][j] = 1.;
1770 else
1771 xd[i][j] = 0.;
1772 }
1773 }
1774
1775 fov_forward(1, 1, 2, 2, x, xd, y, yd);
1776
1777 BOOST_TEST(*y == a, tt::tolerance(tol));
1778 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1779 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
1780
1781 myfree1(x);
1782 myfree2(xd);
1783 myfree1(y);
1784 myfree2(yd);
1785 }
1786
BOOST_AUTO_TEST_CASE(Atan2Operator_FOV_Reverse)1787 BOOST_AUTO_TEST_CASE(Atan2Operator_FOV_Reverse)
1788 {
1789 double a = 12.3, b = 2.1, aout;
1790 adouble ad, bd;
1791
1792 trace_on(1, 1);
1793 ad <<= a;
1794 bd <<= b;
1795
1796 ad = atan2(ad, bd);
1797
1798 ad >>= aout;
1799 trace_off();
1800
1801 double aDerivative = b / (a*a + b*b);
1802 double bDerivative = -a / (a*a + b*b);
1803
1804 double **u = myalloc2(2, 1);
1805 double **z = myalloc2(2, 2);
1806
1807 u[0][0] = 1.;
1808 u[1][0] = std::exp(1.);
1809
1810 fov_reverse(1, 1, 2, 2, u, z);
1811
1812 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1813 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
1814 BOOST_TEST(z[1][0] == aDerivative*std::exp(1.), tt::tolerance(tol));
1815 BOOST_TEST(z[1][1] == bDerivative*std::exp(1.), tt::tolerance(tol));
1816
1817 myfree2(u);
1818 myfree2(z);
1819 }
1820
BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_1)1821 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_1)
1822 {
1823 double a = 2.3, e = 3.5, aout;
1824 adouble ad;
1825
1826 trace_on(1);
1827 ad <<= a;
1828
1829 ad = pow(ad, e);
1830
1831 ad >>= aout;
1832 trace_off();
1833
1834 double aDerivative = e * std::pow(a, e - 1.);
1835 a = std::pow(a, e);
1836
1837 double *x = myalloc1(1);
1838 double **xd = myalloc2(1, 2);
1839 double *y = myalloc1(1);
1840 double **yd = myalloc2(1, 2);
1841
1842 x[0] = 2.3;
1843
1844 for (int i = 0; i < 2; i++) {
1845 xd[0][i] = 1. + i*0.5;
1846 }
1847
1848 fov_forward(1, 1, 1, 2, x, xd, y, yd);
1849
1850 BOOST_TEST(*y == a, tt::tolerance(tol));
1851 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1852 BOOST_TEST(yd[0][1] == aDerivative * (1. + 0.5), tt::tolerance(tol));
1853
1854 myfree1(x);
1855 myfree2(xd);
1856 myfree1(y);
1857 myfree2(yd);
1858 }
1859 /*
1860 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Reverse_1)
1861 {
1862 double a = 2.3, e = 3.5, aout;
1863 adouble ad;
1864
1865 trace_on(1, 1);
1866 ad <<= a;
1867
1868 ad = pow(ad, e);
1869
1870 ad >>= aout;
1871 trace_off();
1872
1873 double aDerivative = e * std::pow(a, e - 1.);
1874
1875 double **u = myalloc2(2, 1);
1876 double **z = myalloc2(2, 1);
1877
1878 u[0][0] = 1.;
1879 u[1][0] = -1.1;
1880
1881 fov_reverse(1, 1, 1, 2, u, z);
1882
1883 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1884 BOOST_TEST(z[1][0] == -1.1*aDerivative, tt::tolerance(tol));
1885
1886 myfree2(u);
1887 myfree2(z);
1888 }
1889 */
BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_2)1890 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_2)
1891 {
1892 double a = 2.3, b = 3.5, out;
1893 adouble ad, bd;
1894
1895 trace_on(1);
1896 ad <<= a;
1897 bd <<= b;
1898
1899 ad = pow(ad, bd);
1900
1901 ad >>= out;
1902 trace_off();
1903
1904 double aDerivative = b * std::pow(a, b - 1.);
1905 double bDerivative = std::log(a) * std::pow(a, b);
1906 a = std::pow(a, b);
1907
1908 double *x = myalloc1(2);
1909 double **xd = myalloc2(2, 2);
1910 double *y = myalloc1(1);
1911 double **yd = myalloc2(1, 2);
1912
1913 /* Test partial derivative wrt a and b. */
1914 x[0] = 2.3;
1915 x[1] = 3.5;
1916
1917 for (int i = 0; i < 2; i++) {
1918 for (int j = 0; j < 2; j++) {
1919 if (i == j)
1920 xd[i][j] = 1.;
1921 else
1922 xd[i][j] = 0.;
1923 }
1924 }
1925
1926 fov_forward(1, 1, 2, 2, x, xd, y, yd);
1927
1928 BOOST_TEST(*y == a, tt::tolerance(tol));
1929 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
1930 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
1931
1932 myfree1(x);
1933 myfree2(xd);
1934 myfree1(y);
1935 myfree2(yd);
1936 }
1937
BOOST_AUTO_TEST_CASE(PowOperator_FOV_Reverse_2)1938 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Reverse_2)
1939 {
1940 double a = 2.3, b = 3.5, aout;
1941 adouble ad, bd;
1942
1943 trace_on(1, 1);
1944 ad <<= a;
1945 bd <<= b;
1946
1947 ad = pow(ad, bd);
1948
1949 ad >>= aout;
1950 trace_off();
1951
1952 double aDerivative = b * std::pow(a, b - 1.);
1953 double bDerivative = std::pow(a, b)*std::log(a);
1954
1955 double **u = myalloc2(2, 1);
1956 double **z = myalloc2(2, 2);
1957
1958 u[0][0] = 1.;
1959 u[1][0] = 2.;
1960
1961 fov_reverse(1, 1, 2, 2, u, z);
1962
1963 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
1964 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
1965 BOOST_TEST(z[1][0] == 2.*aDerivative, tt::tolerance(tol));
1966 BOOST_TEST(z[1][1] == 2.*bDerivative, tt::tolerance(tol));
1967
1968 myfree2(u);
1969 myfree2(z);
1970 }
1971
BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_3)1972 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Forward_3)
1973 {
1974 double a = 2.3, e = 3.5, eout;
1975 adouble ed;
1976
1977 trace_on(1);
1978 ed <<= e;
1979
1980 ed = pow(a, ed);
1981
1982 ed >>= eout;
1983 trace_off();
1984
1985 double eDerivative = std::log(a) * std::pow(a, e);
1986 a = std::pow(a, e);
1987
1988 double *x = myalloc1(1);
1989 double **xd = myalloc2(1, 2);
1990 double *y = myalloc1(1);
1991 double **yd = myalloc2(1, 2);
1992
1993 x[0] = 3.5;
1994
1995 for (int i = 0; i < 2; i++) {
1996 xd[0][i] = 1. + i*0.5;
1997 }
1998
1999 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2000
2001 BOOST_TEST(*y == a, tt::tolerance(tol));
2002 BOOST_TEST(yd[0][0] == eDerivative, tt::tolerance(tol));
2003 BOOST_TEST(yd[0][1] == eDerivative * (1. + 0.5), tt::tolerance(tol));
2004
2005 myfree1(x);
2006 myfree2(xd);
2007 myfree1(y);
2008 myfree2(yd);
2009 }
2010
BOOST_AUTO_TEST_CASE(PowOperator_FOV_Reverse_3)2011 BOOST_AUTO_TEST_CASE(PowOperator_FOV_Reverse_3)
2012 {
2013 double a = 2.3, e = 3.4, eout;
2014 adouble ed;
2015
2016 trace_on(1, 1);
2017 ed <<= e;
2018
2019 ed = pow(a, ed);
2020
2021 ed >>= eout;
2022 trace_off();
2023
2024 double eDerivative = std::pow(a, e)*std::log(a);
2025
2026 double **u = myalloc2(2, 1);
2027 double **z = myalloc2(2, 1);
2028
2029 u[0][0] = 1.;
2030 u[1][0] = -1.1;
2031
2032 fov_reverse(1, 1, 1, 2, u, z);
2033
2034 BOOST_TEST(z[0][0] == eDerivative, tt::tolerance(tol));
2035 BOOST_TEST(z[1][0] == -1.1*eDerivative, tt::tolerance(tol));
2036
2037 myfree2(u);
2038 myfree2(z);
2039 }
2040
2041 /* Frexp operator is not differentiable and does not have to be tested. */
2042
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_1)2043 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_1)
2044 {
2045 double a = 4., b = 3., out;
2046 adouble ad, bd;
2047
2048 trace_on(1);
2049 ad <<= a;
2050 bd <<= b;
2051
2052 ad = ad * pow(2., bd);
2053
2054 ad >>= out;
2055 trace_off();
2056
2057 double aDerivative = std::pow(2., b);
2058 double bDerivative = a * std::log(2.) * std::pow(2., b);
2059 a = a * std::pow(2., b);
2060
2061 double *x = myalloc1(2);
2062 double **xd = myalloc2(2, 2);
2063 double *y = myalloc1(1);
2064 double **yd = myalloc2(1, 2);
2065
2066 /* Test partial derivative wrt a and b. */
2067 x[0] = 4.;
2068 x[1] = 3.;
2069
2070 for (int i = 0; i < 2; i++) {
2071 for (int j = 0; j < 2; j++) {
2072 if (i == j)
2073 xd[i][j] = 1.;
2074 else
2075 xd[i][j] = 0.;
2076 }
2077 }
2078
2079 fov_forward(1, 1, 2, 2, x, xd, y, yd);
2080
2081 BOOST_TEST(*y == a, tt::tolerance(tol));
2082 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2083 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
2084
2085 myfree1(x);
2086 myfree2(xd);
2087 myfree1(y);
2088 myfree2(yd);
2089 }
2090
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_1)2091 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_1)
2092 {
2093 double a = 4., b = 3., aout;
2094 adouble ad, bd;
2095
2096 trace_on(1, 1);
2097 ad <<= a;
2098 bd <<= b;
2099
2100 ad = ad * pow(2., bd);
2101
2102 ad >>= aout;
2103 trace_off();
2104
2105 double aDerivative = std::pow(2., b);
2106 double bDerivative = a * std::pow(2., b)*std::log(2.);
2107
2108 double **u = myalloc2(2, 1);
2109 double **z = myalloc2(2, 2);
2110
2111 u[0][0] = 1.;
2112 u[1][0] = -2.;
2113
2114 fov_reverse(1, 1, 2, 2, u, z);
2115
2116 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2117 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
2118 BOOST_TEST(z[1][0] == -2.*aDerivative, tt::tolerance(tol));
2119 BOOST_TEST(z[1][1] == -2.*bDerivative, tt::tolerance(tol));
2120
2121 myfree2(u);
2122 myfree2(z);
2123 }
2124
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_2)2125 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_2)
2126 {
2127 double a = 4., e = 3., aout;
2128 adouble ad;
2129
2130 trace_on(1);
2131 ad <<= a;
2132
2133 ad = ldexp(ad, e);
2134
2135 ad >>= aout;
2136 trace_off();
2137
2138 double aDerivative = std::pow(2., e);
2139 a = std::ldexp(a, e);
2140
2141 double *x = myalloc1(1);
2142 double **xd = myalloc2(1, 2);
2143 double *y = myalloc1(1);
2144 double **yd = myalloc2(1, 2);
2145
2146 x[0] = 4.;
2147
2148 for (int i = 0; i < 2; i++) {
2149 xd[0][i] = 1. + i;
2150 }
2151
2152 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2153
2154 BOOST_TEST(*y == a, tt::tolerance(tol));
2155 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2156 BOOST_TEST(yd[0][1] == aDerivative * 2., tt::tolerance(tol));
2157
2158 myfree1(x);
2159 myfree2(xd);
2160 myfree1(y);
2161 myfree2(yd);
2162 }
2163
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_2)2164 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_2)
2165 {
2166 double a = 4., e = 3., aout;
2167 adouble ad;
2168
2169 trace_on(1, 1);
2170 ad <<= a;
2171
2172 ad = ldexp(ad, e);
2173
2174 ad >>= aout;
2175 trace_off();
2176
2177 double aDerivative = std::pow(2., e);
2178
2179 double **u = myalloc2(2, 1);
2180 double **z = myalloc2(2, 1);
2181
2182 u[0][0] = 1.;
2183 u[1][0] = std::exp(std::log(10.));
2184
2185 fov_reverse(1, 1, 1, 2, u, z);
2186
2187 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2188 BOOST_TEST(
2189 z[1][0] == std::exp(std::log(10.))*aDerivative, tt::tolerance(tol)
2190 );
2191
2192 myfree2(u);
2193 myfree2(z);
2194 }
2195
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_3)2196 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Forward_3)
2197 {
2198 double a = 4., e = 3., eout;
2199 adouble ed;
2200
2201 trace_on(1);
2202 ed <<= e;
2203
2204 ed = a * pow(2., ed);
2205
2206 ed >>= eout;
2207 trace_off();
2208
2209 double eDerivative = a * std::log(2.) * std::pow(2., e);
2210 e = std::ldexp(a, e);
2211
2212 double *x = myalloc1(1);
2213 double **xd = myalloc2(1, 2);
2214 double *y = myalloc1(1);
2215 double **yd = myalloc2(1, 2);
2216
2217 x[0] = 3.;
2218
2219 for (int i = 0; i < 2; i++) {
2220 xd[0][i] = 1. + i;
2221 }
2222
2223 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2224
2225 BOOST_TEST(*y == e, tt::tolerance(tol));
2226 BOOST_TEST(yd[0][0] == eDerivative, tt::tolerance(tol));
2227 BOOST_TEST(yd[0][1] == eDerivative * 2., tt::tolerance(tol));
2228
2229 myfree1(x);
2230 myfree2(xd);
2231 myfree1(y);
2232 myfree2(yd);
2233 }
2234
BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_3)2235 BOOST_AUTO_TEST_CASE(LdexpOperator_FOV_Reverse_3)
2236 {
2237 double a = 4., e = 3., eout;
2238 adouble ed;
2239
2240 trace_on(1, 1);
2241 ed <<= e;
2242
2243 ed = a * pow(2., ed);
2244
2245 ed >>= eout;
2246 trace_off();
2247
2248 double eDerivative = a * std::pow(2., e) * std::log(2.);
2249
2250 double **u = myalloc2(2, 1);
2251 double **z = myalloc2(2, 1);
2252
2253 u[0][0] = 1.;
2254 u[1][0] = 2.2;
2255
2256 fov_reverse(1, 1, 1, 2, u, z);
2257
2258 BOOST_TEST(z[0][0] == eDerivative, tt::tolerance(tol));
2259 BOOST_TEST(z[1][0] == 2.2*eDerivative, tt::tolerance(tol));
2260
2261 myfree2(u);
2262 myfree2(z);
2263 }
2264
BOOST_AUTO_TEST_CASE(FabsOperator_FOV_Forward)2265 BOOST_AUTO_TEST_CASE(FabsOperator_FOV_Forward)
2266 {
2267 double a = 1.4, aout;
2268 adouble ad;
2269
2270 trace_on(1);
2271 ad <<= a;
2272
2273 ad = fabs(ad);
2274
2275 ad >>= aout;
2276 trace_off();
2277
2278 double aDerivative = 1.;
2279 a = std::fabs(a);
2280
2281 double *x = myalloc1(1);
2282 double **xd = myalloc2(1, 2);
2283 double *y = myalloc1(1);
2284 double **yd = myalloc2(1, 2);
2285
2286 x[0] = 1.4;
2287
2288 for (int i = 0; i < 2; i++) {
2289 xd[0][i] = 1. - i*1.5;
2290 }
2291
2292 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2293
2294 BOOST_TEST(*y == a, tt::tolerance(tol));
2295 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2296 BOOST_TEST(yd[0][1] == aDerivative * (1. - 1.5), tt::tolerance(tol));
2297
2298 x[0] = -5.;
2299
2300 a = std::fabs(-5.);
2301 aDerivative = -1.;
2302
2303 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2304
2305 BOOST_TEST(*y == a, tt::tolerance(tol));
2306 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2307 BOOST_TEST(yd[0][1] == aDerivative * (1. - 1.5), tt::tolerance(tol));
2308
2309 x[0] = 0.;
2310
2311 xd[0][0] = 2.5;
2312 xd[0][1] = -3.5;
2313
2314 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2315
2316 BOOST_TEST(*y == 0., tt::tolerance(tol));
2317 BOOST_TEST(yd[0][0] == 2.5, tt::tolerance(tol));
2318 BOOST_TEST(yd[0][1] == 3.5, tt::tolerance(tol));
2319
2320 myfree1(x);
2321 myfree2(xd);
2322 myfree1(y);
2323 myfree2(yd);
2324 }
2325
BOOST_AUTO_TEST_CASE(FabsOperator_FOV_Reverse)2326 BOOST_AUTO_TEST_CASE(FabsOperator_FOV_Reverse)
2327 {
2328 double a = 1.4, aout;
2329 adouble ad;
2330
2331 trace_on(1, 1);
2332 ad <<= a;
2333
2334 ad = fabs(ad);
2335
2336 ad >>= aout;
2337 trace_off();
2338
2339 double aDerivative = 1.;
2340
2341 double **u = myalloc2(2, 1);
2342 double **z = myalloc2(2, 1);
2343
2344 u[0][0] = 1.;
2345 u[1][0] = 3.3;
2346
2347 fov_reverse(1, 1, 1, 2, u, z);
2348
2349 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2350 BOOST_TEST(z[1][0] == 3.3*aDerivative, tt::tolerance(tol));
2351
2352 a = -5.;
2353
2354 trace_on(1, 1);
2355 ad <<= a;
2356
2357 ad = fabs(ad);
2358
2359 ad >>= aout;
2360 trace_off();
2361
2362 aDerivative = -1.;
2363
2364 u[0][0] = 1.;
2365 u[1][0] = 3.3;
2366
2367 fov_reverse(1, 1, 1, 2, u, z);
2368
2369 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2370 BOOST_TEST(z[1][0] == 3.3*aDerivative, tt::tolerance(tol));
2371
2372 a = 0.;
2373
2374 trace_on(1, 1);
2375 ad <<= a;
2376
2377 ad = fabs(ad);
2378
2379 ad >>= aout;
2380 trace_off();
2381
2382 u[0][0] = 2.5;
2383 u[1][0] = -3.5;
2384
2385 fov_reverse(1, 1, 1, 2, u, z);
2386
2387 BOOST_TEST(z[0][0] == 0., tt::tolerance(tol));
2388 BOOST_TEST(z[1][0] == 0., tt::tolerance(tol));
2389
2390 myfree2(u);
2391 myfree2(z);
2392 }
2393
BOOST_AUTO_TEST_CASE(CeilOperator_FOV_Forward)2394 BOOST_AUTO_TEST_CASE(CeilOperator_FOV_Forward)
2395 {
2396 double a = 3.573, aout;
2397 adouble ad;
2398
2399 trace_on(1);
2400 ad <<= a;
2401
2402 ad = ceil(ad);
2403
2404 ad >>= aout;
2405 trace_off();
2406
2407 double aDerivative = 0.;
2408 a = std::ceil(a);
2409
2410 double *x = myalloc1(1);
2411 double **xd = myalloc2(1, 2);
2412 double *y = myalloc1(1);
2413 double **yd = myalloc2(1, 2);
2414
2415 x[0] = 3.573;
2416
2417 for (int i = 0; i < 2; i++) {
2418 xd[0][i] = 1. + i*5.8;
2419 }
2420
2421 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2422
2423 BOOST_TEST(*y == a, tt::tolerance(tol));
2424 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2425 BOOST_TEST(yd[0][1] == aDerivative * 6.8, tt::tolerance(tol));
2426
2427 myfree1(x);
2428 myfree2(xd);
2429 myfree1(y);
2430 myfree2(yd);
2431 }
2432
BOOST_AUTO_TEST_CASE(CeilOperator_FOV_Reverse)2433 BOOST_AUTO_TEST_CASE(CeilOperator_FOV_Reverse)
2434 {
2435 double a = 3.573, aout;
2436 adouble ad;
2437
2438 trace_on(1, 1);
2439 ad <<= a;
2440
2441 ad = ceil(ad);
2442
2443 ad >>= aout;
2444 trace_off();
2445
2446 double aDerivative = 0.;
2447
2448 double **u = myalloc2(2, 1);
2449 double **z = myalloc2(2, 1);
2450
2451 u[0][0] = 1.;
2452 u[1][0] = 6.8;
2453
2454 fov_reverse(1, 1, 1, 2, u, z);
2455
2456 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2457 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
2458
2459 myfree2(u);
2460 myfree2(z);
2461 }
2462
BOOST_AUTO_TEST_CASE(FloorOperator_FOV_Forward)2463 BOOST_AUTO_TEST_CASE(FloorOperator_FOV_Forward)
2464 {
2465 double a = 4.483, aout;
2466 adouble ad;
2467
2468 trace_on(1);
2469 ad <<= a;
2470
2471 ad = floor(ad);
2472
2473 ad >>= aout;
2474 trace_off();
2475
2476 double aDerivative = 0.;
2477 a = std::floor(a);
2478
2479 double *x = myalloc1(1);
2480 double **xd = myalloc2(1, 2);
2481 double *y = myalloc1(1);
2482 double **yd = myalloc2(1, 2);
2483
2484 x[0] = 4.483;
2485
2486 for (int i = 0; i < 2; i++) {
2487 xd[0][i] = 1. - i*5.8;
2488 }
2489
2490 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2491
2492 BOOST_TEST(*y == a, tt::tolerance(tol));
2493 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2494 BOOST_TEST(yd[0][1] == aDerivative * (-4.8), tt::tolerance(tol));
2495
2496 myfree1(x);
2497 myfree2(xd);
2498 myfree1(y);
2499 myfree2(yd);
2500 }
2501
BOOST_AUTO_TEST_CASE(FloorOperator_FOV_Reverse)2502 BOOST_AUTO_TEST_CASE(FloorOperator_FOV_Reverse)
2503 {
2504 double a = 4.483, aout;
2505 adouble ad;
2506
2507 trace_on(1, 1);
2508 ad <<= a;
2509
2510 ad = floor(ad);
2511
2512 ad >>= aout;
2513 trace_off();
2514
2515 double aDerivative = 0.;
2516
2517 double **u = myalloc2(2, 1);
2518 double **z = myalloc2(2, 1);
2519
2520 u[0][0] = 1.;
2521 u[1][0] = 6.8;
2522
2523 fov_reverse(1, 1, 1, 2, u, z);
2524
2525 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2526 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
2527
2528 myfree2(u);
2529 myfree2(z);
2530 }
2531
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_1)2532 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_1)
2533 {
2534 double a = 4., b = 3.2, out;
2535 adouble ad, bd;
2536
2537 trace_on(1);
2538 ad <<= a;
2539 bd <<= b;
2540
2541 ad = fmax(ad, bd);
2542
2543 ad >>= out;
2544 trace_off();
2545
2546 double aDerivative = 1.;
2547 double bDerivative = 0.;
2548 a = std::fmax(a, b);
2549
2550 double *x = myalloc1(2);
2551 double **xd = myalloc2(2, 2);
2552 double *y = myalloc1(1);
2553 double **yd = myalloc2(1, 2);
2554
2555 /* Test partial derivative wrt a and b. */
2556 x[0] = 4.;
2557 x[1] = 3.2;
2558
2559 for (int i = 0; i < 2; i++) {
2560 for (int j = 0; j < 2; j++) {
2561 if (i == j)
2562 xd[i][j] = 1.;
2563 else
2564 xd[i][j] = 0.;
2565 }
2566 }
2567
2568 fov_forward(1, 1, 2, 2, x, xd, y, yd);
2569
2570 BOOST_TEST(*y == a, tt::tolerance(tol));
2571 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2572 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
2573
2574 x[0] = 2.5;
2575 x[1] = 2.5;
2576
2577 xd[0][0] = 1.3;
2578 xd[0][1] = 3.7;
2579 xd[1][0] = -1.3;
2580 xd[1][0] = -3.7;
2581
2582 a = std::fmax(2.5, 2.5);
2583 aDerivative = 1.3;
2584 bDerivative = 1.3;
2585
2586 fov_forward(1, 1, 2, 2, x, xd, y, yd);
2587
2588 BOOST_TEST(*y == a, tt::tolerance(tol));
2589 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2590 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
2591
2592 myfree1(x);
2593 myfree2(xd);
2594 myfree1(y);
2595 myfree2(yd);
2596 }
2597
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_1)2598 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_1)
2599 {
2600 double a = 4., b = 3.2, aout;
2601 adouble ad, bd;
2602
2603 trace_on(1, 1);
2604 ad <<= a;
2605 bd <<= b;
2606
2607 ad = fmax(ad, bd);
2608
2609 ad >>= aout;
2610 trace_off();
2611
2612 double aDerivative = 1.;
2613 double bDerivative = 0.;
2614
2615 double **u = myalloc2(2, 1);
2616 double **z = myalloc2(2, 2);
2617
2618 u[0][0] = 1.;
2619 u[1][0] = 2.;
2620
2621 fov_reverse(1, 1, 2, 2, u, z);
2622
2623 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2624 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
2625 BOOST_TEST(z[1][0] == 2.*aDerivative, tt::tolerance(tol));
2626 BOOST_TEST(z[1][1] == 2.*bDerivative, tt::tolerance(tol));
2627
2628 a = 2.5, b = 2.5;
2629
2630 trace_on(1, 1);
2631 ad <<= a;
2632 bd <<= b;
2633
2634 ad = fmax(ad, bd);
2635
2636 ad >>= aout;
2637 trace_off();
2638
2639 u[0][0] = 1.;
2640 u[1][0] = -1.;
2641
2642 fov_reverse(1, 1, 2, 2, u, z);
2643
2644 BOOST_TEST(z[0][0] == 0.5, tt::tolerance(tol));
2645 BOOST_TEST(z[0][1] == 0.5, tt::tolerance(tol));
2646 BOOST_TEST(z[1][0] == -0.5, tt::tolerance(tol));
2647 BOOST_TEST(z[1][1] == -0.5, tt::tolerance(tol));
2648
2649 myfree2(u);
2650 myfree2(z);
2651 }
2652
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_2)2653 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_2)
2654 {
2655 double a = 4., b = 3.2, bout;
2656 adouble bd;
2657
2658 trace_on(1);
2659 bd <<= b;
2660
2661 bd = fmax(a, bd);
2662
2663 bd >>= bout;
2664 trace_off();
2665
2666 double bDerivative = 0.;
2667 b = std::fmax(a, b);
2668
2669 double *x = myalloc1(1);
2670 double **xd = myalloc2(1, 2);
2671 double *y = myalloc1(1);
2672 double **yd = myalloc2(1, 2);
2673
2674 x[0] = 3.2;
2675
2676 for (int i = 0; i < 2; i++) {
2677 xd[0][i] = 1. - i*2.1;
2678 }
2679
2680 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2681
2682 BOOST_TEST(*y == b, tt::tolerance(tol));
2683 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
2684 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
2685
2686 x[0] = 5.2;
2687
2688 for (int i = 0; i < 2; i++) {
2689 xd[0][i] = 1. - i*2.1;
2690 }
2691
2692 b = std::fmax(a, x[0]);
2693 bDerivative = 1.;
2694
2695 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2696
2697 BOOST_TEST(*y == b, tt::tolerance(tol));
2698 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
2699 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
2700
2701 x[0] = 4.5;
2702
2703 for (int i = 0; i < 2; i++) {
2704 xd[0][i] = 1. - i*2.1;
2705 }
2706
2707 b = std::fmax(a, x[0]);
2708 bDerivative = 1.;
2709
2710 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2711
2712 BOOST_TEST(*y == b, tt::tolerance(tol));
2713 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
2714 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
2715
2716 myfree1(x);
2717 myfree2(xd);
2718 myfree1(y);
2719 myfree2(yd);
2720 }
2721
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_2)2722 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_2)
2723 {
2724 double a = 4., b = 3.2, bout;
2725 adouble bd;
2726
2727 trace_on(1, 1);
2728 bd <<= b;
2729
2730 bd = fmax(a, bd);
2731
2732 bd >>= bout;
2733 trace_off();
2734
2735 double bDerivative = 0.;
2736
2737 double **u = myalloc2(2, 1);
2738 double **z = myalloc2(2, 1);
2739
2740 u[0][0] = 1.;
2741 u[1][0] = 6.8;
2742
2743 fov_reverse(1, 1, 1, 2, u, z);
2744
2745 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
2746 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
2747
2748 b = 5.2;
2749
2750 trace_on(1, 1);
2751 bd <<= b;
2752
2753 bd = fmax(a, bd);
2754
2755 bd >>= bout;
2756 trace_off();
2757
2758 bDerivative = 1.;
2759
2760 u[0][0] = 1.;
2761 u[1][0] = 6.8;
2762
2763 fov_reverse(1, 1, 1, 2, u, z);
2764
2765 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
2766 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
2767
2768 b = 4.;
2769
2770 trace_on(1, 1);
2771 bd <<= b;
2772
2773 bd = fmax(a, bd);
2774
2775 bd >>= bout;
2776 trace_off();
2777
2778 bDerivative = 0.5;
2779
2780 u[0][0] = 1.;
2781 u[1][0] = 6.8;
2782
2783 fov_reverse(1, 1, 1, 2, u, z);
2784
2785 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
2786 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
2787
2788 myfree2(u);
2789 myfree2(z);
2790 }
2791
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_3)2792 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Forward_3)
2793 {
2794 double a = 4., b = 3.2, aout;
2795 adouble ad;
2796
2797 trace_on(1);
2798 ad <<= a;
2799
2800 ad = fmax(ad, b);
2801
2802 ad >>= aout;
2803 trace_off();
2804
2805 double aDerivative = 1.;
2806 a = std::fmax(a, b);
2807
2808 double *x = myalloc1(1);
2809 double **xd = myalloc2(1, 2);
2810 double *y = myalloc1(1);
2811 double **yd = myalloc2(1, 2);
2812
2813 x[0] = 4.;
2814
2815 for (int i = 0; i < 2; i++) {
2816 xd[0][i] = 1. - i*2.1;
2817 }
2818
2819 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2820
2821 BOOST_TEST(*y == a, tt::tolerance(tol));
2822 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2823 BOOST_TEST(yd[0][1] == aDerivative * (1. - 2.1), tt::tolerance(tol));
2824
2825 x[0] = 2.3;
2826
2827 for (int i = 0; i < 2; i++) {
2828 xd[0][i] = 1. - i*2.1;
2829 }
2830
2831 a = std::fmax(x[0], b);
2832 aDerivative = 0.;
2833
2834 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2835
2836 BOOST_TEST(*y == a, tt::tolerance(tol));
2837 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2838 BOOST_TEST(yd[0][1] == aDerivative * (1. - 2.1), tt::tolerance(tol));
2839
2840 x[0] = 3.2;
2841
2842 for (int i = 0; i < 2; i++) {
2843 xd[0][i] = 1. - i*2.1;
2844 }
2845
2846 a = std::fmax(x[0], b);
2847 aDerivative = 1.;
2848
2849 fov_forward(1, 1, 1, 2, x, xd, y, yd);
2850
2851 BOOST_TEST(*y == a, tt::tolerance(tol));
2852 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2853 BOOST_TEST(yd[0][1] == aDerivative, tt::tolerance(tol));
2854
2855 myfree1(x);
2856 myfree2(xd);
2857 myfree1(y);
2858 myfree2(yd);
2859 }
2860
BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_3)2861 BOOST_AUTO_TEST_CASE(FmaxOperator_FOV_Reverse_3)
2862 {
2863 double a = 4., b = 3.2, aout;
2864 adouble ad;
2865
2866 trace_on(1, 1);
2867 ad <<= a;
2868
2869 ad = fmax(ad, b);
2870
2871 ad >>= aout;
2872 trace_off();
2873
2874 double aDerivative = 1.;
2875
2876 double **u = myalloc2(2, 1);
2877 double **z = myalloc2(2, 1);
2878
2879 u[0][0] = 1.;
2880 u[1][0] = 6.8;
2881
2882 fov_reverse(1, 1, 1, 2, u, z);
2883
2884 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2885 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
2886
2887 a = 2.5;
2888
2889 trace_on(1, 1);
2890 ad <<= a;
2891
2892 ad = fmax(ad, b);
2893
2894 ad >>= aout;
2895 trace_off();
2896
2897 aDerivative = 0.;
2898
2899 u[0][0] = 1.;
2900 u[1][0] = 6.8;
2901
2902 fov_reverse(1, 1, 1, 2, u, z);
2903
2904 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2905 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
2906
2907 a = 3.2;
2908
2909 trace_on(1, 1);
2910 ad <<= a;
2911
2912 ad = fmax(ad, b);
2913
2914 ad >>= aout;
2915 trace_off();
2916
2917 aDerivative = 0.5;
2918
2919 u[0][0] = 1.;
2920 u[1][0] = 6.8;
2921
2922 fov_reverse(1, 1, 1, 2, u, z);
2923
2924 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
2925 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
2926
2927 myfree2(u);
2928 myfree2(z);
2929 }
2930
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_1)2931 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_1)
2932 {
2933 double a = 4., b = 3.2, out;
2934 adouble ad, bd;
2935
2936 trace_on(1);
2937 ad <<= a;
2938 bd <<= b;
2939
2940 ad = fmin(ad, bd);
2941
2942 ad >>= out;
2943 trace_off();
2944
2945 double aDerivative = 0.;
2946 double bDerivative = 1.;
2947 a = std::fmin(a, b);
2948
2949 double *x = myalloc1(2);
2950 double **xd = myalloc2(2, 2);
2951 double *y = myalloc1(1);
2952 double **yd = myalloc2(1, 2);
2953
2954 /* Test partial derivative wrt a and b. */
2955 x[0] = 4.;
2956 x[1] = 3.2;
2957
2958 for (int i = 0; i < 2; i++) {
2959 for (int j = 0; j < 2; j++) {
2960 if (i == j)
2961 xd[i][j] = 1.;
2962 else
2963 xd[i][j] = 0.;
2964 }
2965 }
2966
2967 fov_forward(1, 1, 2, 2, x, xd, y, yd);
2968
2969 BOOST_TEST(*y == a, tt::tolerance(tol));
2970 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2971 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
2972
2973 x[0] = 2.5;
2974 x[1] = 2.5;
2975
2976 xd[0][0] = 1.3;
2977 xd[0][1] = 3.7;
2978 xd[1][0] = -1.3;
2979 xd[1][0] = -3.7;
2980
2981 a = std::fmax(2.5, 2.5);
2982 aDerivative = -3.7;
2983 bDerivative = -3.7;
2984
2985 fov_forward(1, 1, 2, 2, x, xd, y, yd);
2986
2987 BOOST_TEST(*y == a, tt::tolerance(tol));
2988 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
2989 BOOST_TEST(yd[0][1] == bDerivative, tt::tolerance(tol));
2990
2991 myfree1(x);
2992 myfree2(xd);
2993 myfree1(y);
2994 myfree2(yd);
2995 }
2996
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_1)2997 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_1)
2998 {
2999 double a = 4., b = 3.2, aout;
3000 adouble ad, bd;
3001
3002 trace_on(1, 1);
3003 ad <<= a;
3004 bd <<= b;
3005
3006 ad = fmin(ad, bd);
3007
3008 ad >>= aout;
3009 trace_off();
3010
3011 double aDerivative = 0.;
3012 double bDerivative = 1.;
3013
3014 double **u = myalloc2(2, 1);
3015 double **z = myalloc2(2, 2);
3016
3017 u[0][0] = 1.;
3018 u[1][0] = 2.;
3019
3020 fov_reverse(1, 1, 2, 2, u, z);
3021
3022 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3023 BOOST_TEST(z[0][1] == bDerivative, tt::tolerance(tol));
3024 BOOST_TEST(z[1][0] == 2.*aDerivative, tt::tolerance(tol));
3025 BOOST_TEST(z[1][1] == 2.*bDerivative, tt::tolerance(tol));
3026
3027 a = 2.5, b = 2.5;
3028
3029 trace_on(1, 1);
3030 ad <<= a;
3031 bd <<= b;
3032
3033 ad = fmin(ad, bd);
3034
3035 ad >>= aout;
3036 trace_off();
3037
3038 u[0][0] = 1.;
3039 u[1][0] = -1.;
3040
3041 fov_reverse(1, 1, 2, 2, u, z);
3042
3043 BOOST_TEST(z[0][0] == 0.5, tt::tolerance(tol));
3044 BOOST_TEST(z[0][1] == 0.5, tt::tolerance(tol));
3045 BOOST_TEST(z[1][0] == -0.5, tt::tolerance(tol));
3046 BOOST_TEST(z[1][1] == -0.5, tt::tolerance(tol));
3047
3048 myfree2(u);
3049 myfree2(z);
3050 }
3051
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_2)3052 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_2)
3053 {
3054 double a = 4., b = 3.2, bout;
3055 adouble bd;
3056
3057 trace_on(1);
3058 bd <<= b;
3059
3060 bd = fmin(a, bd);
3061
3062 bd >>= bout;
3063 trace_off();
3064
3065 double bDerivative = 1.;
3066 b = std::fmin(a, b);
3067
3068 double *x = myalloc1(1);
3069 double **xd = myalloc2(1, 2);
3070 double *y = myalloc1(1);
3071 double **yd = myalloc2(1, 2);
3072
3073 x[0] = 3.2;
3074
3075 for (int i = 0; i < 2; i++) {
3076 xd[0][i] = 1. - i*2.1;
3077 }
3078
3079 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3080
3081 BOOST_TEST(*y == b, tt::tolerance(tol));
3082 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
3083 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
3084
3085 x[0] = 5.2;
3086
3087 for (int i = 0; i < 2; i++) {
3088 xd[0][i] = 1. - i*2.1;
3089 }
3090
3091 b = std::fmin(a, x[0]);
3092 bDerivative = 0.;
3093
3094 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3095
3096 BOOST_TEST(*y == b, tt::tolerance(tol));
3097 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
3098 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
3099
3100 x[0] = 4.5;
3101
3102 for (int i = 0; i < 2; i++) {
3103 xd[0][i] = 1. - i*2.1;
3104 }
3105
3106 b = std::fmin(a, x[0]);
3107 bDerivative = 0.;
3108
3109 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3110
3111 BOOST_TEST(*y == b, tt::tolerance(tol));
3112 BOOST_TEST(yd[0][0] == bDerivative, tt::tolerance(tol));
3113 BOOST_TEST(yd[0][1] == bDerivative * (1. - 2.1), tt::tolerance(tol));
3114
3115 myfree1(x);
3116 myfree2(xd);
3117 myfree1(y);
3118 myfree2(yd);
3119 }
3120
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_2)3121 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_2)
3122 {
3123 double a = 4., b = 3.2, bout;
3124 adouble bd;
3125
3126 trace_on(1, 1);
3127 bd <<= b;
3128
3129 bd = fmin(a, bd);
3130
3131 bd >>= bout;
3132 trace_off();
3133
3134 double bDerivative = 1.;
3135
3136 double **u = myalloc2(2, 1);
3137 double **z = myalloc2(2, 1);
3138
3139 u[0][0] = 1.;
3140 u[1][0] = 6.8;
3141
3142 fov_reverse(1, 1, 1, 2, u, z);
3143
3144 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
3145 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
3146
3147 b = 5.2;
3148
3149 trace_on(1, 1);
3150 bd <<= b;
3151
3152 bd = fmin(a, bd);
3153
3154 bd >>= bout;
3155 trace_off();
3156
3157 bDerivative = 0.;
3158
3159 u[0][0] = 1.;
3160 u[1][0] = 6.8;
3161
3162 fov_reverse(1, 1, 1, 2, u, z);
3163
3164 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
3165 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
3166
3167 b = 4.;
3168
3169 trace_on(1, 1);
3170 bd <<= b;
3171
3172 bd = fmin(a, bd);
3173
3174 bd >>= bout;
3175 trace_off();
3176
3177 bDerivative = 0.5;
3178
3179 u[0][0] = 1.;
3180 u[1][0] = 6.8;
3181
3182 fov_reverse(1, 1, 1, 2, u, z);
3183
3184 BOOST_TEST(z[0][0] == bDerivative, tt::tolerance(tol));
3185 BOOST_TEST(z[1][0] == bDerivative * 6.8, tt::tolerance(tol));
3186
3187 myfree2(u);
3188 myfree2(z);
3189 }
3190
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_3)3191 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Forward_3)
3192 {
3193 double a = 4., b = 3.2, aout;
3194 adouble ad;
3195
3196 trace_on(1);
3197 ad <<= a;
3198
3199 ad = fmin(ad, b);
3200
3201 ad >>= aout;
3202 trace_off();
3203
3204 double aDerivative = 0.;
3205 a = std::fmin(a, b);
3206
3207 double *x = myalloc1(1);
3208 double **xd = myalloc2(1, 2);
3209 double *y = myalloc1(1);
3210 double **yd = myalloc2(1, 2);
3211
3212 x[0] = 4.;
3213
3214 for (int i = 0; i < 2; i++) {
3215 xd[0][i] = 1. - i*2.1;
3216 }
3217
3218 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3219
3220 BOOST_TEST(*y == a, tt::tolerance(tol));
3221 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3222 BOOST_TEST(yd[0][1] == aDerivative * (1. - 2.1), tt::tolerance(tol));
3223
3224 x[0] = 2.3;
3225
3226 for (int i = 0; i < 2; i++) {
3227 xd[0][i] = 1. - i*2.1;
3228 }
3229
3230 a = std::fmin(x[0], b);
3231 aDerivative = 1.;
3232
3233 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3234
3235 BOOST_TEST(*y == a, tt::tolerance(tol));
3236 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3237 BOOST_TEST(yd[0][1] == aDerivative * (1. - 2.1), tt::tolerance(tol));
3238
3239 x[0] = 3.2;
3240
3241 for (int i = 0; i < 2; i++) {
3242 xd[0][i] = 1. - i*2.1;
3243 }
3244
3245 a = std::fmin(x[0], b);
3246 aDerivative = 0.;
3247
3248 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3249
3250 BOOST_TEST(*y == a, tt::tolerance(tol));
3251 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3252 BOOST_TEST(yd[0][1] == aDerivative, tt::tolerance(tol));
3253
3254 myfree1(x);
3255 myfree2(xd);
3256 myfree1(y);
3257 myfree2(yd);
3258 }
3259
BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_3)3260 BOOST_AUTO_TEST_CASE(FminOperator_FOV_Reverse_3)
3261 {
3262 double a = 4., b = 3.2, aout;
3263 adouble ad;
3264
3265 trace_on(1, 1);
3266 ad <<= a;
3267
3268 ad = fmin(ad, b);
3269
3270 ad >>= aout;
3271 trace_off();
3272
3273 double aDerivative = 0.;
3274
3275 double **u = myalloc2(2, 1);
3276 double **z = myalloc2(2, 1);
3277
3278 u[0][0] = 1.;
3279 u[1][0] = 6.8;
3280
3281 fov_reverse(1, 1, 1, 2, u, z);
3282
3283 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3284 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
3285
3286 a = 2.5;
3287
3288 trace_on(1, 1);
3289 ad <<= a;
3290
3291 ad = fmin(ad, b);
3292
3293 ad >>= aout;
3294 trace_off();
3295
3296 aDerivative = 1.;
3297
3298 u[0][0] = 1.;
3299 u[1][0] = 6.8;
3300
3301 fov_reverse(1, 1, 1, 2, u, z);
3302
3303 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3304 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
3305
3306 a = 3.2;
3307
3308 trace_on(1, 1);
3309 ad <<= a;
3310
3311 ad = fmin(ad, b);
3312
3313 ad >>= aout;
3314 trace_off();
3315
3316 aDerivative = 0.5;
3317
3318 u[0][0] = 1.;
3319 u[1][0] = 6.8;
3320
3321 fov_reverse(1, 1, 1, 2, u, z);
3322
3323 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3324 BOOST_TEST(z[1][0] == aDerivative * 6.8, tt::tolerance(tol));
3325
3326 myfree2(u);
3327 myfree2(z);
3328 }
3329
3330 #if defined(ATRIG_ERF)
BOOST_AUTO_TEST_CASE(ErfOperator_FOV_Forward)3331 BOOST_AUTO_TEST_CASE(ErfOperator_FOV_Forward)
3332 {
3333 double a = 7.1, aout;
3334 adouble ad;
3335
3336 trace_on(1);
3337 ad <<= a;
3338
3339 ad = erf(ad);
3340
3341 ad >>= aout;
3342 trace_off();
3343
3344 double aDerivative = 2. / std::sqrt(std::acos(-1.)) * std::exp(-a*a);
3345 a = std::erf(a);
3346
3347 double *x = myalloc1(1);
3348 double **xd = myalloc2(1, 2);
3349 double *y = myalloc1(1);
3350 double **yd = myalloc2(1, 2);
3351
3352 x[0] = 7.1;
3353
3354 for (int i = 0; i < 2; i++) {
3355 xd[0][i] = std::pow(3., i*2.);
3356 }
3357
3358 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3359
3360 BOOST_TEST(*y == a, tt::tolerance(tol));
3361 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3362 BOOST_TEST(yd[0][1] == aDerivative * std::pow(3., 2.), tt::tolerance(tol));
3363
3364 myfree1(x);
3365 myfree2(xd);
3366 myfree1(y);
3367 myfree2(yd);
3368 }
3369
BOOST_AUTO_TEST_CASE(ErfOperator_FOV_Reverse)3370 BOOST_AUTO_TEST_CASE(ErfOperator_FOV_Reverse)
3371 {
3372 double a = 7.1, aout;
3373 adouble ad;
3374
3375 trace_on(1, 1);
3376 ad <<= a;
3377
3378 ad = erf(ad);
3379
3380 ad >>= aout;
3381 trace_off();
3382
3383 double aDerivative = 2. / std::sqrt(std::acos(-1.)) * std::exp(-a*a);
3384
3385 double **u = myalloc2(2, 1);
3386 double **z = myalloc2(2, 1);
3387
3388 u[0][0] = 1.;
3389 u[1][0] = -1.1;
3390
3391 fov_reverse(1, 1, 1, 2, u, z);
3392
3393 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3394 BOOST_TEST(z[1][0] == -1.1*aDerivative, tt::tolerance(tol));
3395
3396 myfree2(u);
3397 myfree2(z);
3398 }
3399 #endif
3400
BOOST_AUTO_TEST_CASE(EqPlusOperator_FOV_Forward)3401 BOOST_AUTO_TEST_CASE(EqPlusOperator_FOV_Forward)
3402 {
3403 double a = 5.132, aout;
3404 adouble ad;
3405
3406 trace_on(1);
3407 ad <<= a;
3408
3409 ad += 5.2;
3410
3411 ad >>= aout;
3412 trace_off();
3413
3414 double aDerivative = 1.;
3415 a += 5.2;
3416
3417 double *x = myalloc1(1);
3418 double **xd = myalloc2(1, 2);
3419 double *y = myalloc1(1);
3420 double **yd = myalloc2(1, 2);
3421
3422 x[0] = 5.132;
3423
3424 for (int i = 0; i < 2; i++) {
3425 xd[0][i] = std::pow(4., i*1.5);
3426 }
3427
3428 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3429
3430 BOOST_TEST(*y == a, tt::tolerance(tol));
3431 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3432 BOOST_TEST(yd[0][1] == aDerivative * std::pow(4., 1.5), tt::tolerance(tol));
3433
3434 myfree1(x);
3435 myfree2(xd);
3436 myfree1(y);
3437 myfree2(yd);
3438 }
3439
BOOST_AUTO_TEST_CASE(EqPlusOperator_FOV_Reverse)3440 BOOST_AUTO_TEST_CASE(EqPlusOperator_FOV_Reverse)
3441 {
3442 double a = 5.132, aout;
3443 adouble ad;
3444
3445 trace_on(1, 1);
3446 ad <<= a;
3447
3448 ad += 5.2;
3449
3450 ad >>= aout;
3451 trace_off();
3452
3453 double aDerivative = 1.;
3454
3455 double **u = myalloc2(2, 1);
3456 double **z = myalloc2(2, 1);
3457
3458 u[0][0] = 1.;
3459 u[1][0] = std::pow(2., -1.1);
3460
3461 fov_reverse(1, 1, 1, 2, u, z);
3462
3463 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3464 BOOST_TEST(z[1][0] == aDerivative*std::pow(2., -1.1), tt::tolerance(tol));
3465
3466 myfree2(u);
3467 myfree2(z);
3468 }
3469
BOOST_AUTO_TEST_CASE(EqMinusOperator_FOV_Forward)3470 BOOST_AUTO_TEST_CASE(EqMinusOperator_FOV_Forward)
3471 {
3472 double a = 5.132, aout;
3473 adouble ad;
3474
3475 trace_on(1);
3476 ad <<= a;
3477
3478 ad -= 5.2;
3479
3480 ad >>= aout;
3481 trace_off();
3482
3483 double aDerivative = 1.;
3484 a -= 5.2;
3485
3486 double *x = myalloc1(1);
3487 double **xd = myalloc2(1, 2);
3488 double *y = myalloc1(1);
3489 double **yd = myalloc2(1, 2);
3490
3491 x[0] = 5.132;
3492
3493 for (int i = 0; i < 2; i++) {
3494 xd[0][i] = std::pow(4., i*1.5);
3495 }
3496
3497 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3498
3499 BOOST_TEST(*y == a, tt::tolerance(tol));
3500 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3501 BOOST_TEST(yd[0][1] == aDerivative * std::pow(4., 1.5), tt::tolerance(tol));
3502
3503 myfree1(x);
3504 myfree2(xd);
3505 myfree1(y);
3506 myfree2(yd);
3507 }
3508
BOOST_AUTO_TEST_CASE(EqMinusOperator_FOV_Reverse)3509 BOOST_AUTO_TEST_CASE(EqMinusOperator_FOV_Reverse)
3510 {
3511 double a = 5.132, aout;
3512 adouble ad;
3513
3514 trace_on(1, 1);
3515 ad <<= a;
3516
3517 ad -= 5.2;
3518
3519 ad >>= aout;
3520 trace_off();
3521
3522 double aDerivative = 1.;
3523
3524 double **u = myalloc2(2, 1);
3525 double **z = myalloc2(2, 1);
3526
3527 u[0][0] = 1.;
3528 u[1][0] = std::pow(2., -1.1);
3529
3530 fov_reverse(1, 1, 1, 2, u, z);
3531
3532 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3533 BOOST_TEST(z[1][0] == aDerivative*std::pow(2., -1.1), tt::tolerance(tol));
3534
3535 myfree2(u);
3536 myfree2(z);
3537 }
3538
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOV_Forward)3539 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOV_Forward)
3540 {
3541 double a = 5.132, aout;
3542 adouble ad;
3543
3544 trace_on(1);
3545 ad <<= a;
3546
3547 ad *= 5.2;
3548
3549 ad >>= aout;
3550 trace_off();
3551
3552 double aDerivative = 5.2;
3553 a *= 5.2;
3554
3555 double *x = myalloc1(1);
3556 double **xd = myalloc2(1, 2);
3557 double *y = myalloc1(1);
3558 double **yd = myalloc2(1, 2);
3559
3560 x[0] = 5.132;
3561
3562 for (int i = 0; i < 2; i++) {
3563 xd[0][i] = std::pow(4., i*1.5);
3564 }
3565
3566 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3567
3568 BOOST_TEST(*y == a, tt::tolerance(tol));
3569 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3570 BOOST_TEST(yd[0][1] == aDerivative * std::pow(4., 1.5), tt::tolerance(tol));
3571
3572 myfree1(x);
3573 myfree2(xd);
3574 myfree1(y);
3575 myfree2(yd);
3576 }
3577
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOV_Reverse)3578 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOV_Reverse)
3579 {
3580 double a = 5.132, aout;
3581 adouble ad;
3582
3583 trace_on(1, 1);
3584 ad <<= a;
3585
3586 ad *= 5.2;
3587
3588 ad >>= aout;
3589 trace_off();
3590
3591 double aDerivative = 5.2;
3592
3593 double **u = myalloc2(2, 1);
3594 double **z = myalloc2(2, 1);
3595
3596 u[0][0] = 1.;
3597 u[1][0] = std::pow(2., -1.1);
3598
3599 fov_reverse(1, 1, 1, 2, u, z);
3600
3601 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3602 BOOST_TEST(z[1][0] == aDerivative*std::pow(2., -1.1), tt::tolerance(tol));
3603
3604 myfree2(u);
3605 myfree2(z);
3606 }
3607
BOOST_AUTO_TEST_CASE(EqDivOperator_FOV_Forward)3608 BOOST_AUTO_TEST_CASE(EqDivOperator_FOV_Forward)
3609 {
3610 double a = 5.132, aout;
3611 adouble ad;
3612
3613 trace_on(1);
3614 ad <<= a;
3615
3616 ad /= 5.2;
3617
3618 ad >>= aout;
3619 trace_off();
3620
3621 double aDerivative = 1. / 5.2;
3622 a /= 5.2;
3623
3624 double *x = myalloc1(1);
3625 double **xd = myalloc2(1, 2);
3626 double *y = myalloc1(1);
3627 double **yd = myalloc2(1, 2);
3628
3629 x[0] = 5.132;
3630
3631 for (int i = 0; i < 2; i++) {
3632 xd[0][i] = std::pow(4., i*1.5);
3633 }
3634
3635 fov_forward(1, 1, 1, 2, x, xd, y, yd);
3636
3637 BOOST_TEST(*y == a, tt::tolerance(tol));
3638 BOOST_TEST(yd[0][0] == aDerivative, tt::tolerance(tol));
3639 BOOST_TEST(yd[0][1] == aDerivative * std::pow(4., 1.5), tt::tolerance(tol));
3640
3641 myfree1(x);
3642 myfree2(xd);
3643 myfree1(y);
3644 myfree2(yd);
3645 }
3646
BOOST_AUTO_TEST_CASE(EqDivOperator_FOV_Reverse)3647 BOOST_AUTO_TEST_CASE(EqDivOperator_FOV_Reverse)
3648 {
3649 double a = 5.132, aout;
3650 adouble ad;
3651
3652 trace_on(1, 1);
3653 ad <<= a;
3654
3655 ad /= 5.2;
3656
3657 ad >>= aout;
3658 trace_off();
3659
3660 double aDerivative = 1./5.2;
3661
3662 double **u = myalloc2(2, 1);
3663 double **z = myalloc2(2, 1);
3664
3665 u[0][0] = 1.;
3666 u[1][0] = std::pow(2., -1.1);
3667
3668 fov_reverse(1, 1, 1, 2, u, z);
3669
3670 BOOST_TEST(z[0][0] == aDerivative, tt::tolerance(tol));
3671 BOOST_TEST(z[1][0] == aDerivative*std::pow(2., -1.1), tt::tolerance(tol));
3672
3673 myfree2(u);
3674 myfree2(z);
3675 }
3676
BOOST_AUTO_TEST_CASE(CondassignOperator_FOV_Forward)3677 BOOST_AUTO_TEST_CASE(CondassignOperator_FOV_Forward)
3678 {
3679 double out;
3680 adouble cond, arg1, arg2;
3681 adouble p;
3682
3683 trace_on(1);
3684 cond <<= 1.;
3685 arg1 <<= 3.5;
3686 arg2 <<= 5.3;
3687
3688 condassign(p, cond, arg1, arg2);
3689
3690 p >>= out;
3691 trace_off();
3692
3693 double *x = myalloc1(3);
3694 double **xd = myalloc2(3, 2);
3695 double *y = myalloc1(1);
3696 double **yd = myalloc2(1, 2);
3697
3698 x[0] = 1.;
3699 x[1] = 3.5;
3700 x[2] = 5.3;
3701 xd[0][0] = 0.;
3702 xd[0][1] = 0.;
3703 xd[1][0] = 0.1;
3704 xd[1][1] = 1.;
3705 xd[2][0] = 0.2;
3706 xd[2][1] = 2.;
3707
3708 for (int i = 0; i < 2; i++) {
3709 xd[0][i] = 1. + i;
3710 }
3711
3712 fov_forward(1, 1, 3, 2, x, xd, y, yd);
3713
3714 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
3715 BOOST_TEST(yd[0][0] == 0.1, tt::tolerance(tol));
3716 BOOST_TEST(yd[0][1] == 1., tt::tolerance(tol));
3717
3718 myfree1(x);
3719 myfree2(xd);
3720 myfree1(y);
3721 myfree2(yd);
3722 }
3723
BOOST_AUTO_TEST_CASE(CondeqassignOperator_FOV_Forward)3724 BOOST_AUTO_TEST_CASE(CondeqassignOperator_FOV_Forward)
3725 {
3726 double out;
3727 adouble cond, arg1, arg2;
3728 adouble p;
3729
3730 trace_on(1);
3731 cond <<= 1.;
3732 arg1 <<= 3.5;
3733 arg2 <<= 5.3;
3734
3735 condeqassign(p, cond, arg1, arg2);
3736
3737 p >>= out;
3738 trace_off();
3739
3740 double *x = myalloc1(3);
3741 double **xd = myalloc2(3, 2);
3742 double *y = myalloc1(1);
3743 double **yd = myalloc2(1, 2);
3744
3745 x[0] = 1.;
3746 x[1] = 3.5;
3747 x[2] = 5.3;
3748 xd[0][0] = 0.;
3749 xd[0][1] = 0.;
3750 xd[1][0] = 0.1;
3751 xd[1][1] = 1.;
3752 xd[2][0] = 0.2;
3753 xd[2][1] = 2.;
3754
3755 for (int i = 0; i < 2; i++) {
3756 xd[0][i] = 1. + i;
3757 }
3758
3759 fov_forward(1, 1, 3, 2, x, xd, y, yd);
3760
3761 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
3762 BOOST_TEST(yd[0][0] == 0.1, tt::tolerance(tol));
3763 BOOST_TEST(yd[0][1] == 1., tt::tolerance(tol));
3764
3765 myfree1(x);
3766 myfree2(xd);
3767 myfree1(y);
3768 myfree2(yd);
3769 }
3770
3771
3772 BOOST_AUTO_TEST_SUITE_END()
3773
3774