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