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_scalar )
11
12
13 /**********************************************/
14 /* Tests for ADOL-C trace scalar mode drivers */
15 /* zos_forward, fos_forward and fos_reverse */
16 /* Author: Philipp Schuette */
17 /**********************************************/
18
19
20 /* Naming convention for test cases: Operatorname_Operator_ZOS_Forward for
21 * primal value (= zero order derivative), Operatorname_Operator_FOS_Forward
22 * for foward derivative evulation and Operatorname_Operator_FOS_Reverse for
23 * reverse mode derivative evalution.
24 *
25 * For documentation of concrete test implementation, check traceless scalar
26 * mode test implementation. The testing order is consistent with that file
27 * as well.
28 */
29
BOOST_AUTO_TEST_CASE(ExpOperator_ZOS_Forward)30 BOOST_AUTO_TEST_CASE(ExpOperator_ZOS_Forward)
31 {
32 double a = 2., aout;
33 adouble ad;
34
35 trace_on(1);
36 ad <<= a;
37
38 ad = exp(ad);
39
40 ad >>= aout;
41 trace_off();
42
43 a = std::exp(a);
44
45 BOOST_TEST(aout == a, tt::tolerance(tol));
46
47 double *x = myalloc1(1);
48 double *y = myalloc1(1);
49
50 *x = 2.;
51
52 zos_forward(1, 1, 1, 0, x, y);
53
54 BOOST_TEST(*y == a, tt::tolerance(tol));
55
56 myfree1(x);
57 myfree1(y);
58 }
59
BOOST_AUTO_TEST_CASE(ExpOperator_FOS_Forward)60 BOOST_AUTO_TEST_CASE(ExpOperator_FOS_Forward)
61 {
62 double a = 2., aout;
63 adouble ad;
64
65 trace_on(1);
66 ad <<= a;
67
68 ad = exp(ad);
69
70 ad >>= aout;
71 trace_off();
72
73 double aDerivative = std::exp(a);
74 a = std::exp(a);
75
76 double *x = myalloc1(1);
77 double *xd = myalloc1(1);
78 double *y = myalloc1(1);
79 double *yd = myalloc1(1);
80
81 *x = 2.;
82 *xd = 1.;
83
84 fos_forward(1, 1, 1, 0, x, xd, y, yd);
85
86 BOOST_TEST(*y == a, tt::tolerance(tol));
87 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
88
89 myfree1(x);
90 myfree1(xd);
91 myfree1(y);
92 myfree1(yd);
93 }
94
BOOST_AUTO_TEST_CASE(ExpOperator_FOS_Reverse)95 BOOST_AUTO_TEST_CASE(ExpOperator_FOS_Reverse)
96 {
97 double a = 2., aout;
98 adouble ad;
99
100 trace_on(1, 1);
101 ad <<= a;
102
103 ad = exp(ad);
104
105 ad >>= aout;
106 trace_off();
107
108 double aDerivative = std::exp(a);
109
110 double *u = myalloc1(1);
111 double *z = myalloc1(1);
112
113 *u = 1.;
114
115 fos_reverse(1, 1, 1, u, z);
116
117 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
118
119 myfree1(u);
120 myfree1(z);
121 }
122
BOOST_AUTO_TEST_CASE(MultOperator_ZOS_Forward)123 BOOST_AUTO_TEST_CASE(MultOperator_ZOS_Forward)
124 {
125 double a = 2., b = 3.5, out;
126 adouble ad, bd;
127
128 trace_on(1);
129 ad <<= a;
130 bd <<= b;
131
132 ad = ad * bd;
133
134 ad >>= out;
135 trace_off();
136
137 a = a * b;
138
139 BOOST_TEST(out == a, tt::tolerance(tol));
140
141 double *x = myalloc1(2);
142 double *y = myalloc1(1);
143
144 //x[0] = 2.;
145 *x = 2.;
146 *(x + 1) = 3.5;
147
148 zos_forward(1, 1, 2, 0, x, y);
149
150 BOOST_TEST(*y == a, tt::tolerance(tol));
151
152 myfree1(x);
153 myfree1(y);
154 }
155
BOOST_AUTO_TEST_CASE(MultOperator_FOS_Forward)156 BOOST_AUTO_TEST_CASE(MultOperator_FOS_Forward)
157 {
158 double a = 2., b = 3.5, out;
159 adouble ad, bd;
160
161 trace_on(1);
162 ad <<= a;
163 bd <<= b;
164
165 ad = ad * bd;
166
167 ad >>= out;
168 trace_off();
169
170 double aDerivative = b;
171 double bDerivative = a;
172 a = a * b;
173
174 double *x = myalloc1(2);
175 double *xd = myalloc1(2);
176 double *y = myalloc1(1);
177 double *yd = myalloc1(1);
178
179 /* Test partial derivative wrt a. */
180 *x = 2.;
181 *(x + 1) = 3.5;
182 *xd = 1.;
183 *(xd + 1) = 0.;
184
185 fos_forward(1, 1, 2, 0, x, xd, y, yd);
186
187 BOOST_TEST(*y == a, tt::tolerance(tol));
188 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
189
190 /* Test partial derivative wrt b. */
191 *xd = 0.;
192 *(xd + 1) = 1.;
193
194 fos_forward(1, 1, 2, 0, x, xd, y, yd);
195
196 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
197
198 myfree1(x);
199 myfree1(xd);
200 myfree1(y);
201 myfree1(yd);
202 }
203
BOOST_AUTO_TEST_CASE(MultOperator_FOS_Reverse)204 BOOST_AUTO_TEST_CASE(MultOperator_FOS_Reverse)
205 {
206 double a = 2., b = 3.5, out;
207 adouble ad, bd;
208
209 trace_on(1, 1);
210 ad <<= a;
211 bd <<= b;
212
213 ad = ad * bd;
214
215 ad >>= out;
216 trace_off();
217
218 double aDerivative = b;
219 double bDerivative = a;
220
221 double *u = myalloc1(1);
222 double *z = myalloc1(2);
223
224 *u = 1.;
225
226 fos_reverse(1, 1, 2, u, z);
227
228 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
229 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
230
231 myfree1(u);
232 myfree1(z);
233 }
234
BOOST_AUTO_TEST_CASE(AddOperator_ZOS_Forward)235 BOOST_AUTO_TEST_CASE(AddOperator_ZOS_Forward)
236 {
237 double a = 2.5, b = 3., out;
238 adouble ad, bd;
239
240 trace_on(1);
241 ad <<= a;
242 bd <<= b;
243
244 ad = ad + bd;
245
246 ad >>= out;
247 trace_off();
248
249 a = a + b;
250
251 BOOST_TEST(out == a, tt::tolerance(tol));
252
253 double *x = myalloc1(2);
254 double *y = myalloc1(1);
255
256 *x = 2.5;
257 *(x + 1) = 3.;
258
259 zos_forward(1, 1, 2, 0, x, y);
260
261 BOOST_TEST(*y == a, tt::tolerance(tol));
262
263 myfree1(x);
264 myfree1(y);
265 }
266
BOOST_AUTO_TEST_CASE(AddOperator_FOS_Forward)267 BOOST_AUTO_TEST_CASE(AddOperator_FOS_Forward)
268 {
269 double a = 2.5, b = 3., out;
270 adouble ad, bd;
271
272 trace_on(1);
273 ad <<= a;
274 bd <<= b;
275
276 ad = ad + bd;
277
278 ad >>= out;
279 trace_off();
280
281 double aDerivative = 1.;
282 double bDerivative = 1.;
283 a = a + b;
284
285 double *x = myalloc1(2);
286 double *xd = myalloc1(2);
287 double *y = myalloc1(1);
288 double *yd = myalloc1(1);
289
290 /* Test partial derivative wrt a. */
291 *x = 2.5;
292 *(x + 1) = 3.;
293 *xd = 1.;
294 *(xd + 1) = 0.;
295
296 fos_forward(1, 1, 2, 0, x, xd, y, yd);
297
298 BOOST_TEST(*y == a, tt::tolerance(tol));
299 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
300
301 /* Test partial derivative wrt b. */
302 *xd = 0.;
303 *(xd + 1) = 1.;
304
305 fos_forward(1, 1, 2, 0, x, xd, y, yd);
306
307 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
308
309 myfree1(x);
310 myfree1(xd);
311 myfree1(y);
312 myfree1(yd);
313 }
314
BOOST_AUTO_TEST_CASE(AddOperator_FOS_Reverse)315 BOOST_AUTO_TEST_CASE(AddOperator_FOS_Reverse)
316 {
317 double a = 2.5, b = 3., out;
318 adouble ad, bd;
319
320 trace_on(1, 1);
321 ad <<= a;
322 bd <<= b;
323
324 ad = ad + bd;
325
326 ad >>= out;
327 trace_off();
328
329 double aDerivative = 1.;
330 double bDerivative = 1.;
331
332 double *u = myalloc1(1);
333 double *z = myalloc1(2);
334
335 *u = 1.;
336
337 fos_reverse(1, 1, 2, u, z);
338
339 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
340 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
341
342 myfree1(u);
343 myfree1(z);
344 }
345
BOOST_AUTO_TEST_CASE(SubOperator_ZOS_Forward)346 BOOST_AUTO_TEST_CASE(SubOperator_ZOS_Forward)
347 {
348 double a = 1.5, b = 3.2, out;
349 adouble ad, bd;
350
351 trace_on(1);
352 ad <<= a;
353 bd <<= b;
354
355 ad = ad - bd;
356
357 ad >>= out;
358 trace_off();
359
360 a = a - b;
361
362 BOOST_TEST(out == a, tt::tolerance(tol));
363
364 double *x = myalloc1(2);
365 double *y = myalloc1(1);
366
367 *x = 1.5;
368 *(x + 1) = 3.2;
369
370 zos_forward(1, 1, 2, 0, x, y);
371
372 BOOST_TEST(*y == a, tt::tolerance(tol));
373
374 myfree1(x);
375 myfree1(y);
376 }
377
BOOST_AUTO_TEST_CASE(SubOperator_FOS_Forward)378 BOOST_AUTO_TEST_CASE(SubOperator_FOS_Forward)
379 {
380 double a = 1.5, b = 3.2, out;
381 adouble ad, bd;
382
383 trace_on(1);
384 ad <<= a;
385 bd <<= b;
386
387 ad = ad - bd;
388
389 ad >>= out;
390 trace_off();
391
392 double aDerivative = 1.;
393 double bDerivative = -1.;
394 a = a - b;
395
396 double *x = myalloc1(2);
397 double *xd = myalloc1(2);
398 double *y = myalloc1(1);
399 double *yd = myalloc1(1);
400
401 /* Test partial derivative wrt a. */
402 *x = 1.5;
403 *(x + 1) = 3.2;
404 *xd = 1.;
405 *(xd + 1) = 0.;
406
407 fos_forward(1, 1, 2, 0, x, xd, y, yd);
408
409 BOOST_TEST(*y == a, tt::tolerance(tol));
410 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
411
412 /* Test partial derivative wrt b. */
413 *xd = 0.;
414 *(xd + 1) = 1.;
415
416 fos_forward(1, 1, 2, 0, x, xd, y, yd);
417
418 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
419
420 myfree1(x);
421 myfree1(xd);
422 myfree1(y);
423 myfree1(yd);
424 }
425
BOOST_AUTO_TEST_CASE(SubOperator_FOS_Reverse)426 BOOST_AUTO_TEST_CASE(SubOperator_FOS_Reverse)
427 {
428 double a = 1.5, b = 3.2, out;
429 adouble ad, bd;
430
431 trace_on(1, 1);
432 ad <<= a;
433 bd <<= b;
434
435 ad = ad - bd;
436
437 ad >>= out;
438 trace_off();
439
440 double aDerivative = 1.;
441 double bDerivative = -1.;
442
443 double *u = myalloc1(1);
444 double *z = myalloc1(2);
445
446 *u = 1.;
447
448 fos_reverse(1, 1, 2, u, z);
449
450 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
451 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
452
453 myfree1(u);
454 myfree1(z);
455 }
456
BOOST_AUTO_TEST_CASE(DivOperator_ZOS_Forward)457 BOOST_AUTO_TEST_CASE(DivOperator_ZOS_Forward)
458 {
459 double a = 0.5, b = 4.5, out;
460 adouble ad, bd;
461
462 trace_on(1);
463 ad <<= a;
464 bd <<= b;
465
466 ad = ad / bd;
467
468 ad >>= out;
469 trace_off();
470
471 a = a / b;
472
473 BOOST_TEST(out == a, tt::tolerance(tol));
474
475 double *x = myalloc1(2);
476 double *y = myalloc1(1);
477
478 *x = 0.5;
479 *(x + 1) = 4.5;
480
481 zos_forward(1, 1, 2, 0, x, y);
482
483 BOOST_TEST(*y == a, tt::tolerance(tol));
484
485 myfree1(x);
486 myfree1(y);
487 }
488
BOOST_AUTO_TEST_CASE(DivOperator_FOS_Forward)489 BOOST_AUTO_TEST_CASE(DivOperator_FOS_Forward)
490 {
491 double a = 0.5, b = 4.5, out;
492 adouble ad, bd;
493
494 trace_on(1);
495 ad <<= a;
496 bd <<= b;
497
498 ad = ad / bd;
499
500 ad >>= out;
501 trace_off();
502
503 double aDerivative = 1. / b;
504 double bDerivative = -a / (b*b);
505 a = a / b;
506
507 double *x = myalloc1(2);
508 double *xd = myalloc1(2);
509 double *y = myalloc1(1);
510 double *yd = myalloc1(1);
511
512 /* Test partial derivative wrt a. */
513 *x = 0.5;
514 *(x + 1) = 4.5;
515 *xd = 1.;
516 *(xd + 1) = 0.;
517
518 fos_forward(1, 1, 2, 0, x, xd, y, yd);
519
520 BOOST_TEST(*y == a, tt::tolerance(tol));
521 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
522
523 /* Test partial derivative wrt b. */
524 *xd = 0.;
525 *(xd + 1) = 1.;
526
527 fos_forward(1, 1, 2, 0, x, xd, y, yd);
528
529 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
530
531 myfree1(x);
532 myfree1(xd);
533 myfree1(y);
534 myfree1(yd);
535 }
536
BOOST_AUTO_TEST_CASE(DivOperator_FOS_Reverse)537 BOOST_AUTO_TEST_CASE(DivOperator_FOS_Reverse)
538 {
539 double a = 0.5, b = 4.5, out;
540 adouble ad, bd;
541
542 trace_on(1, 1);
543 ad <<= a;
544 bd <<= b;
545
546 ad = ad / bd;
547
548 ad >>= out;
549 trace_off();
550
551 double aDerivative = 1. / b;
552 double bDerivative = -a / (b*b);
553
554 double *u = myalloc1(1);
555 double *z = myalloc1(2);
556
557 *u = 1.;
558
559 fos_reverse(1, 1, 2, u, z);
560
561 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
562 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
563
564 myfree1(u);
565 myfree1(z);
566 }
567
BOOST_AUTO_TEST_CASE(TanOperator_ZOS_Forward)568 BOOST_AUTO_TEST_CASE(TanOperator_ZOS_Forward)
569 {
570 double a = 0.7, aout;
571 adouble ad;
572
573 trace_on(1);
574 ad <<= a;
575
576 ad = tan(ad);
577
578 ad >>= aout;
579 trace_off();
580
581 a = std::tan(a);
582
583 BOOST_TEST(aout == a, tt::tolerance(tol));
584
585 double *x = myalloc1(1);
586 double *y = myalloc1(1);
587
588 *x = 0.7;
589
590 zos_forward(1, 1, 1, 0, x, y);
591
592 BOOST_TEST(*y == a, tt::tolerance(tol));
593
594 myfree1(x);
595 myfree1(y);
596 }
597
BOOST_AUTO_TEST_CASE(TanOperator_FOS_Forward)598 BOOST_AUTO_TEST_CASE(TanOperator_FOS_Forward)
599 {
600 double a = 0.7, aout;
601 adouble ad;
602
603 trace_on(1);
604 ad <<= a;
605
606 ad = tan(ad);
607
608 ad >>= aout;
609 trace_off();
610
611 a = std::tan(a);
612 double aDerivative = 1. + a*a;
613
614 double *x = myalloc1(1);
615 double *xd = myalloc1(1);
616 double *y = myalloc1(1);
617 double *yd = myalloc1(1);
618
619 *x = 0.7;
620 *xd = 1.;
621
622 fos_forward(1, 1, 1, 0, x, xd, y, yd);
623
624 BOOST_TEST(*y == a, tt::tolerance(tol));
625 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
626
627 myfree1(x);
628 myfree1(xd);
629 myfree1(y);
630 myfree1(yd);
631 }
632
BOOST_AUTO_TEST_CASE(TanOperator_FOS_Reverse)633 BOOST_AUTO_TEST_CASE(TanOperator_FOS_Reverse)
634 {
635 double a = 0.7, aout;
636 adouble ad;
637
638 trace_on(1, 1);
639 ad <<= a;
640
641 ad = tan(ad);
642
643 ad >>= aout;
644 trace_off();
645
646 a = std::tan(a);
647 double aDerivative = 1. + a*a;
648
649 double *u = myalloc1(1);
650 double *z = myalloc1(1);
651
652 *u = 1.;
653
654 fos_reverse(1, 1, 1, u, z);
655
656 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
657
658 myfree1(u);
659 myfree1(z);
660 }
661
BOOST_AUTO_TEST_CASE(SinOperator_ZOS_Forward)662 BOOST_AUTO_TEST_CASE(SinOperator_ZOS_Forward)
663 {
664 double a = 1.2, aout;
665 adouble ad;
666
667 trace_on(1);
668 ad <<= a;
669
670 ad = sin(ad);
671
672 ad >>= aout;
673 trace_off();
674
675 a = std::sin(a);
676
677 BOOST_TEST(aout == a, tt::tolerance(tol));
678
679 double *x = myalloc1(1);
680 double *y = myalloc1(1);
681
682 *x = 1.2;
683
684 zos_forward(1, 1, 1, 0, x, y);
685
686 BOOST_TEST(*y == a, tt::tolerance(tol));
687
688 myfree1(x);
689 myfree1(y);
690 }
691
BOOST_AUTO_TEST_CASE(SinOperator_FOS_Forward)692 BOOST_AUTO_TEST_CASE(SinOperator_FOS_Forward)
693 {
694 double a = 1.2, aout;
695 adouble ad;
696
697 trace_on(1);
698 ad <<= a;
699
700 ad = sin(ad);
701
702 ad >>= aout;
703 trace_off();
704
705 double aDerivative = std::cos(a);
706 a = std::sin(a);
707
708 double *x = myalloc1(1);
709 double *xd = myalloc1(1);
710 double *y = myalloc1(1);
711 double *yd = myalloc1(1);
712
713 *x = 1.2;
714 *xd = 1.;
715
716 fos_forward(1, 1, 1, 0, x, xd, y, yd);
717
718 BOOST_TEST(*y == a, tt::tolerance(tol));
719 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
720
721 myfree1(x);
722 myfree1(xd);
723 myfree1(y);
724 myfree1(yd);
725 }
726
BOOST_AUTO_TEST_CASE(SinOperator_FOS_Reverse)727 BOOST_AUTO_TEST_CASE(SinOperator_FOS_Reverse)
728 {
729 double a = 1.2, aout;
730 adouble ad;
731
732 trace_on(1, 1);
733 ad <<= a;
734
735 ad = sin(ad);
736
737 ad >>= aout;
738 trace_off();
739
740 double aDerivative = std::cos(a);
741 a = std::sin(a);
742
743 double *u = myalloc1(1);
744 double *z = myalloc1(1);
745
746 *u = 1.;
747
748 fos_reverse(1, 1, 1, u, z);
749
750 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
751
752 myfree1(u);
753 myfree1(z);
754 }
755
BOOST_AUTO_TEST_CASE(CosOperator_ZOS_Forward)756 BOOST_AUTO_TEST_CASE(CosOperator_ZOS_Forward)
757 {
758 double a = 1.2, aout;
759 adouble ad;
760
761 trace_on(1);
762 ad <<= a;
763
764 ad = cos(ad);
765
766 ad >>= aout;
767 trace_off();
768
769 a = std::cos(a);
770
771 BOOST_TEST(aout == a, tt::tolerance(tol));
772
773 double *x = myalloc1(1);
774 double *y = myalloc1(1);
775
776 *x = 1.2;
777
778 zos_forward(1, 1, 1, 0, x, y);
779
780 BOOST_TEST(*y == a, tt::tolerance(tol));
781
782 myfree1(x);
783 myfree1(y);
784 }
785
BOOST_AUTO_TEST_CASE(CosOperator_FOS_Forward)786 BOOST_AUTO_TEST_CASE(CosOperator_FOS_Forward)
787 {
788 double a = 1.2, aout;
789 adouble ad;
790
791 trace_on(1);
792 ad <<= a;
793
794 ad = cos(ad);
795
796 ad >>= aout;
797 trace_off();
798
799 double aDerivative = -std::sin(a);
800 a = std::cos(a);
801
802 double *x = myalloc1(1);
803 double *xd = myalloc1(1);
804 double *y = myalloc1(1);
805 double *yd = myalloc1(1);
806
807 *x = 1.2;
808 *xd = 1.;
809
810 fos_forward(1, 1, 1, 0, x, xd, y, yd);
811
812 BOOST_TEST(*y == a, tt::tolerance(tol));
813 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
814
815 myfree1(x);
816 myfree1(xd);
817 myfree1(y);
818 myfree1(yd);
819 }
820
BOOST_AUTO_TEST_CASE(CosOperator_FOS_Reverse)821 BOOST_AUTO_TEST_CASE(CosOperator_FOS_Reverse)
822 {
823 double a = 1.2, aout;
824 adouble ad;
825
826 trace_on(1, 1);
827 ad <<= a;
828
829 ad = cos(ad);
830
831 ad >>= aout;
832 trace_off();
833
834 double aDerivative = -std::sin(a);
835 a = std::cos(a);
836
837 double *u = myalloc1(1);
838 double *z = myalloc1(1);
839
840 *u = 1.;
841
842 fos_reverse(1, 1, 1, u, z);
843
844 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
845
846 myfree1(u);
847 myfree1(z);
848 }
849
BOOST_AUTO_TEST_CASE(SqrtOperator_ZOS_Forward)850 BOOST_AUTO_TEST_CASE(SqrtOperator_ZOS_Forward)
851 {
852 double a = 2.2, aout;
853 adouble ad;
854
855 trace_on(1);
856 ad <<= a;
857
858 ad = sqrt(ad);
859
860 ad >>= aout;
861 trace_off();
862
863 a = std::sqrt(a);
864
865 BOOST_TEST(aout == a, tt::tolerance(tol));
866
867 double *x = myalloc1(1);
868 double *y = myalloc1(1);
869
870 *x = 2.2;
871
872 zos_forward(1, 1, 1, 0, x, y);
873
874 BOOST_TEST(*y == a, tt::tolerance(tol));
875
876 myfree1(x);
877 myfree1(y);
878 }
879
BOOST_AUTO_TEST_CASE(SqrtOperator_FOS_Forward)880 BOOST_AUTO_TEST_CASE(SqrtOperator_FOS_Forward)
881 {
882 double a = 2.2, aout;
883 adouble ad;
884
885 trace_on(1);
886 ad <<= a;
887
888 ad = sqrt(ad);
889
890 ad >>= aout;
891 trace_off();
892
893 a = std::sqrt(a);
894 double aDerivative = 1. / (2*a);
895
896 double *x = myalloc1(1);
897 double *xd = myalloc1(1);
898 double *y = myalloc1(1);
899 double *yd = myalloc1(1);
900
901 *x = 2.2;
902 *xd = 1.;
903
904 fos_forward(1, 1, 1, 0, x, xd, y, yd);
905
906 BOOST_TEST(*y == a, tt::tolerance(tol));
907 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
908
909 myfree1(x);
910 myfree1(xd);
911 myfree1(y);
912 myfree1(yd);
913 }
914
BOOST_AUTO_TEST_CASE(SqrtOperator_FOS_Reverse)915 BOOST_AUTO_TEST_CASE(SqrtOperator_FOS_Reverse)
916 {
917 double a = 2.2, aout;
918 adouble ad;
919
920 trace_on(1, 1);
921 ad <<= a;
922
923 ad = sqrt(ad);
924
925 ad >>= aout;
926 trace_off();
927
928 a = std::sqrt(a);
929 double aDerivative = 1. / (2*a);
930
931 double *u = myalloc1(1);
932 double *z = myalloc1(1);
933
934 *u = 1.;
935
936 fos_reverse(1, 1, 1, u, z);
937
938 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
939
940 myfree1(u);
941 myfree1(z);
942 }
943
BOOST_AUTO_TEST_CASE(LogOperator_ZOS_Forward)944 BOOST_AUTO_TEST_CASE(LogOperator_ZOS_Forward)
945 {
946 double a = 4.9, aout;
947 adouble ad;
948
949 trace_on(1);
950 ad <<= a;
951
952 ad = log(ad);
953
954 ad >>= aout;
955 trace_off();
956
957 a = std::log(a);
958
959 BOOST_TEST(aout == a, tt::tolerance(tol));
960
961 double *x = myalloc1(1);
962 double *y = myalloc1(1);
963
964 *x = 4.9;
965
966 zos_forward(1, 1, 1, 0, x, y);
967
968 BOOST_TEST(*y == a, tt::tolerance(tol));
969
970 myfree1(x);
971 myfree1(y);
972 }
973
BOOST_AUTO_TEST_CASE(LogOperator_FOS_Forward)974 BOOST_AUTO_TEST_CASE(LogOperator_FOS_Forward)
975 {
976 double a = 4.9, aout;
977 adouble ad;
978
979 trace_on(1);
980 ad <<= a;
981
982 ad = log(ad);
983
984 ad >>= aout;
985 trace_off();
986
987 double aDerivative = 1. / a;
988 a = std::log(a);
989
990 double *x = myalloc1(1);
991 double *xd = myalloc1(1);
992 double *y = myalloc1(1);
993 double *yd = myalloc1(1);
994
995 *x = 4.9;
996 *xd = 1.;
997
998 fos_forward(1, 1, 1, 0, x, xd, y, yd);
999
1000 BOOST_TEST(*y == a, tt::tolerance(tol));
1001 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1002
1003 myfree1(x);
1004 myfree1(xd);
1005 myfree1(y);
1006 myfree1(yd);
1007 }
1008
BOOST_AUTO_TEST_CASE(LogOperator_FOS_Reverse)1009 BOOST_AUTO_TEST_CASE(LogOperator_FOS_Reverse)
1010 {
1011 double a = 4.9, aout;
1012 adouble ad;
1013
1014 trace_on(1, 1);
1015 ad <<= a;
1016
1017 ad = log(ad);
1018
1019 ad >>= aout;
1020 trace_off();
1021
1022 double aDerivative = 1. / a;
1023 a = std::log(a);
1024
1025 double *u = myalloc1(1);
1026 double *z = myalloc1(1);
1027
1028 *u = 1.;
1029
1030 fos_reverse(1, 1, 1, u, z);
1031
1032 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1033
1034 myfree1(u);
1035 myfree1(z);
1036 }
1037
BOOST_AUTO_TEST_CASE(SinhOperator_ZOS_Forward)1038 BOOST_AUTO_TEST_CASE(SinhOperator_ZOS_Forward)
1039 {
1040 double a = 4., aout;
1041 adouble ad;
1042
1043 trace_on(1);
1044 ad <<= a;
1045
1046 ad = sinh(ad);
1047
1048 ad >>= aout;
1049 trace_off();
1050
1051 a = std::sinh(a);
1052
1053 BOOST_TEST(aout == a, tt::tolerance(tol));
1054
1055 double *x = myalloc1(1);
1056 double *y = myalloc1(1);
1057
1058 *x = 4.;
1059
1060 zos_forward(1, 1, 1, 0, x, y);
1061
1062 BOOST_TEST(*y == a, tt::tolerance(tol));
1063
1064 myfree1(x);
1065 myfree1(y);
1066 }
1067
BOOST_AUTO_TEST_CASE(SinhOperator_FOS_Forward)1068 BOOST_AUTO_TEST_CASE(SinhOperator_FOS_Forward)
1069 {
1070 double a = 4., aout;
1071 adouble ad;
1072
1073 trace_on(1);
1074 ad <<= a;
1075
1076 ad = sinh(ad);
1077
1078 ad >>= aout;
1079 trace_off();
1080
1081 double aDerivative = std::cosh(a);
1082 a = std::sinh(a);
1083
1084 double *x = myalloc1(1);
1085 double *xd = myalloc1(1);
1086 double *y = myalloc1(1);
1087 double *yd = myalloc1(1);
1088
1089 *x = 4.;
1090 *xd = 1.;
1091
1092 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1093
1094 BOOST_TEST(*y == a, tt::tolerance(tol));
1095 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1096
1097 myfree1(x);
1098 myfree1(xd);
1099 myfree1(y);
1100 myfree1(yd);
1101 }
1102
BOOST_AUTO_TEST_CASE(SinhOperator_FOS_Reverse)1103 BOOST_AUTO_TEST_CASE(SinhOperator_FOS_Reverse)
1104 {
1105 double a = 4., aout;
1106 adouble ad;
1107
1108 trace_on(1, 1);
1109 ad <<= a;
1110
1111 ad = sinh(ad);
1112
1113 ad >>= aout;
1114 trace_off();
1115
1116 double aDerivative = std::cosh(a);
1117 a = std::sinh(a);
1118
1119 double *u = myalloc1(1);
1120 double *z = myalloc1(1);
1121
1122 *u = 1.;
1123
1124 fos_reverse(1, 1, 1, u, z);
1125
1126 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1127
1128 myfree1(u);
1129 myfree1(z);
1130 }
1131
BOOST_AUTO_TEST_CASE(CoshOperator_ZOS_Forward)1132 BOOST_AUTO_TEST_CASE(CoshOperator_ZOS_Forward)
1133 {
1134 double a = 4., aout;
1135 adouble ad;
1136
1137 trace_on(1);
1138 ad <<= a;
1139
1140 ad = cosh(ad);
1141
1142 ad >>= aout;
1143 trace_off();
1144
1145 a = std::cosh(a);
1146
1147 BOOST_TEST(aout == a, tt::tolerance(tol));
1148
1149 double *x = myalloc1(1);
1150 double *y = myalloc1(1);
1151
1152 *x = 4.;
1153
1154 zos_forward(1, 1, 1, 0, x, y);
1155
1156 BOOST_TEST(*y == a, tt::tolerance(tol));
1157
1158 myfree1(x);
1159 myfree1(y);
1160 }
1161
BOOST_AUTO_TEST_CASE(CoshOperator_FOS_Forward)1162 BOOST_AUTO_TEST_CASE(CoshOperator_FOS_Forward)
1163 {
1164 double a = 4., aout;
1165 adouble ad;
1166
1167 trace_on(1);
1168 ad <<= a;
1169
1170 ad = cosh(ad);
1171
1172 ad >>= aout;
1173 trace_off();
1174
1175 double aDerivative = std::sinh(a);
1176 a = std::cosh(a);
1177
1178 double *x = myalloc1(1);
1179 double *xd = myalloc1(1);
1180 double *y = myalloc1(1);
1181 double *yd = myalloc1(1);
1182
1183 *x = 4.;
1184 *xd = 1.;
1185
1186 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1187
1188 BOOST_TEST(*y == a, tt::tolerance(tol));
1189 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1190
1191 myfree1(x);
1192 myfree1(xd);
1193 myfree1(y);
1194 myfree1(yd);
1195 }
1196
BOOST_AUTO_TEST_CASE(CoshOperator_FOS_Reverse)1197 BOOST_AUTO_TEST_CASE(CoshOperator_FOS_Reverse)
1198 {
1199 double a = 4., aout;
1200 adouble ad;
1201
1202 trace_on(1, 1);
1203 ad <<= a;
1204
1205 ad = cosh(ad);
1206
1207 ad >>= aout;
1208 trace_off();
1209
1210 double aDerivative = std::sinh(a);
1211 a = std::cosh(a);
1212
1213 double *u = myalloc1(1);
1214 double *z = myalloc1(1);
1215
1216 *u = 1.;
1217
1218 fos_reverse(1, 1, 1, u, z);
1219
1220 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1221
1222 myfree1(u);
1223 myfree1(z);
1224 }
1225
BOOST_AUTO_TEST_CASE(TanhOperator_ZOS_Forward)1226 BOOST_AUTO_TEST_CASE(TanhOperator_ZOS_Forward)
1227 {
1228 double a = 4., aout;
1229 adouble ad;
1230
1231 trace_on(1);
1232 ad <<= a;
1233
1234 ad = tanh(ad);
1235
1236 ad >>= aout;
1237 trace_off();
1238
1239 a = std::tanh(a);
1240
1241 BOOST_TEST(aout == a, tt::tolerance(tol));
1242
1243 double *x = myalloc1(1);
1244 double *y = myalloc1(1);
1245
1246 *x = 4.;
1247
1248 zos_forward(1, 1, 1, 0, x, y);
1249
1250 BOOST_TEST(*y == a, tt::tolerance(tol));
1251
1252 myfree1(x);
1253 myfree1(y);
1254 }
1255
BOOST_AUTO_TEST_CASE(TanhOperator_FOS_Forward)1256 BOOST_AUTO_TEST_CASE(TanhOperator_FOS_Forward)
1257 {
1258 double a = 4., aout;
1259 adouble ad;
1260
1261 trace_on(1);
1262 ad <<= a;
1263
1264 ad = tanh(ad);
1265
1266 ad >>= aout;
1267 trace_off();
1268
1269 a = std::tanh(a);
1270 double aDerivative = 1. - a*a;
1271
1272 double *x = myalloc1(1);
1273 double *xd = myalloc1(1);
1274 double *y = myalloc1(1);
1275 double *yd = myalloc1(1);
1276
1277 *x = 4.;
1278 *xd = 1.;
1279
1280 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1281
1282 BOOST_TEST(*y == a, tt::tolerance(tol));
1283 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1284
1285 myfree1(x);
1286 myfree1(xd);
1287 myfree1(y);
1288 myfree1(yd);
1289 }
1290
BOOST_AUTO_TEST_CASE(TanhOperator_FOS_Reverse)1291 BOOST_AUTO_TEST_CASE(TanhOperator_FOS_Reverse)
1292 {
1293 double a = 4., aout;
1294 adouble ad;
1295
1296 trace_on(1, 1);
1297 ad <<= a;
1298
1299 ad = tanh(ad);
1300
1301 ad >>= aout;
1302 trace_off();
1303
1304 a = std::tanh(a);
1305 double aDerivative = 1. - a*a;
1306
1307 double *u = myalloc1(1);
1308 double *z = myalloc1(1);
1309
1310 *u = 1.;
1311
1312 fos_reverse(1, 1, 1, u, z);
1313
1314 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1315
1316 myfree1(u);
1317 myfree1(z);
1318 }
1319
BOOST_AUTO_TEST_CASE(AsinOperator_ZOS_Forward)1320 BOOST_AUTO_TEST_CASE(AsinOperator_ZOS_Forward)
1321 {
1322 double a = 0.9, aout;
1323 adouble ad;
1324
1325 trace_on(1);
1326 ad <<= a;
1327
1328 ad = asin(ad);
1329
1330 ad >>= aout;
1331 trace_off();
1332
1333 a = std::asin(a);
1334
1335 BOOST_TEST(aout == a, tt::tolerance(tol));
1336
1337 double *x = myalloc1(1);
1338 double *y = myalloc1(1);
1339
1340 *x = 0.9;
1341
1342 zos_forward(1, 1, 1, 0, x, y);
1343
1344 BOOST_TEST(*y == a, tt::tolerance(tol));
1345
1346 myfree1(x);
1347 myfree1(y);
1348 }
1349
BOOST_AUTO_TEST_CASE(AsinOperator_FOS_Forward)1350 BOOST_AUTO_TEST_CASE(AsinOperator_FOS_Forward)
1351 {
1352 double a = 0.9, aout;
1353 adouble ad;
1354
1355 trace_on(1);
1356 ad <<= a;
1357
1358 ad = asin(ad);
1359
1360 ad >>= aout;
1361 trace_off();
1362
1363 double aDerivative = 1. / (std::sqrt(1. - a*a));
1364 a = std::asin(a);
1365
1366 double *x = myalloc1(1);
1367 double *xd = myalloc1(1);
1368 double *y = myalloc1(1);
1369 double *yd = myalloc1(1);
1370
1371 *x = 0.9;
1372 *xd = 1.;
1373
1374 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1375
1376 BOOST_TEST(*y == a, tt::tolerance(tol));
1377 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1378
1379 myfree1(x);
1380 myfree1(xd);
1381 myfree1(y);
1382 myfree1(yd);
1383 }
1384
BOOST_AUTO_TEST_CASE(AsinOperator_FOS_Reverse)1385 BOOST_AUTO_TEST_CASE(AsinOperator_FOS_Reverse)
1386 {
1387 double a = 0.9, aout;
1388 adouble ad;
1389
1390 trace_on(1, 1);
1391 ad <<= a;
1392
1393 ad = asin(ad);
1394
1395 ad >>= aout;
1396 trace_off();
1397
1398 double aDerivative = 1. / (std::sqrt(1. - a*a));
1399 a = std::asin(a);
1400
1401 double *u = myalloc1(1);
1402 double *z = myalloc1(1);
1403
1404 *u = 1.;
1405
1406 fos_reverse(1, 1, 1, u, z);
1407
1408 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1409
1410 myfree1(u);
1411 myfree1(z);
1412 }
1413
BOOST_AUTO_TEST_CASE(AcosOperator_ZOS_Forward)1414 BOOST_AUTO_TEST_CASE(AcosOperator_ZOS_Forward)
1415 {
1416 double a = 0.8, aout;
1417 adouble ad;
1418
1419 trace_on(1);
1420 ad <<= a;
1421
1422 ad = acos(ad);
1423
1424 ad >>= aout;
1425 trace_off();
1426
1427 a = std::acos(a);
1428
1429 BOOST_TEST(aout == a, tt::tolerance(tol));
1430
1431 double *x = myalloc1(1);
1432 double *y = myalloc1(1);
1433
1434 *x = 0.8;
1435
1436 zos_forward(1, 1, 1, 0, x, y);
1437
1438 BOOST_TEST(*y == a, tt::tolerance(tol));
1439
1440 myfree1(x);
1441 myfree1(y);
1442 }
1443
BOOST_AUTO_TEST_CASE(AcosOperator_FOS_Forward)1444 BOOST_AUTO_TEST_CASE(AcosOperator_FOS_Forward)
1445 {
1446 double a = 0.8, aout;
1447 adouble ad;
1448
1449 trace_on(1);
1450 ad <<= a;
1451
1452 ad = acos(ad);
1453
1454 ad >>= aout;
1455 trace_off();
1456
1457 double aDerivative = -1. / (std::sqrt(1. - a*a));
1458 a = std::acos(a);
1459
1460 double *x = myalloc1(1);
1461 double *xd = myalloc1(1);
1462 double *y = myalloc1(1);
1463 double *yd = myalloc1(1);
1464
1465 *x = 0.8;
1466 *xd = 1.;
1467
1468 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1469
1470 BOOST_TEST(*y == a, tt::tolerance(tol));
1471 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1472
1473 myfree1(x);
1474 myfree1(xd);
1475 myfree1(y);
1476 myfree1(yd);
1477 }
1478
BOOST_AUTO_TEST_CASE(AcosOperator_FOS_Reverse)1479 BOOST_AUTO_TEST_CASE(AcosOperator_FOS_Reverse)
1480 {
1481 double a = 0.8, aout;
1482 adouble ad;
1483
1484 trace_on(1, 1);
1485 ad <<= a;
1486
1487 ad = acos(ad);
1488
1489 ad >>= aout;
1490 trace_off();
1491
1492 double aDerivative = -1. / (std::sqrt(1. - a*a));
1493 a = std::acos(a);
1494
1495 double *u = myalloc1(1);
1496 double *z = myalloc1(1);
1497
1498 *u = 1.;
1499
1500 fos_reverse(1, 1, 1, u, z);
1501
1502 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1503
1504 myfree1(u);
1505 myfree1(z);
1506 }
1507
BOOST_AUTO_TEST_CASE(AtanOperator_ZOS_Forward)1508 BOOST_AUTO_TEST_CASE(AtanOperator_ZOS_Forward)
1509 {
1510 double a = 9.8, aout;
1511 adouble ad;
1512
1513 trace_on(1);
1514 ad <<= a;
1515
1516 ad = atan(ad);
1517
1518 ad >>= aout;
1519 trace_off();
1520
1521 a = std::atan(a);
1522
1523 BOOST_TEST(aout == a, tt::tolerance(tol));
1524
1525 double *x = myalloc1(1);
1526 double *y = myalloc1(1);
1527
1528 *x = 9.8;
1529
1530 zos_forward(1, 1, 1, 0, x, y);
1531
1532 BOOST_TEST(*y == a, tt::tolerance(tol));
1533
1534 myfree1(x);
1535 myfree1(y);
1536 }
1537
BOOST_AUTO_TEST_CASE(AtanOperator_FOS_Forward)1538 BOOST_AUTO_TEST_CASE(AtanOperator_FOS_Forward)
1539 {
1540 double a = 9.8, aout;
1541 adouble ad;
1542
1543 trace_on(1);
1544 ad <<= a;
1545
1546 ad = atan(ad);
1547
1548 ad >>= aout;
1549 trace_off();
1550
1551 double aDerivative = 1. / (1. + a*a);
1552 a = std::atan(a);
1553
1554 double *x = myalloc1(1);
1555 double *xd = myalloc1(1);
1556 double *y = myalloc1(1);
1557 double *yd = myalloc1(1);
1558
1559 *x = 9.8;
1560 *xd = 1.;
1561
1562 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1563
1564 BOOST_TEST(*y == a, tt::tolerance(tol));
1565 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1566
1567 myfree1(x);
1568 myfree1(xd);
1569 myfree1(y);
1570 myfree1(yd);
1571 }
1572
BOOST_AUTO_TEST_CASE(AtanOperator_FOS_Reverse)1573 BOOST_AUTO_TEST_CASE(AtanOperator_FOS_Reverse)
1574 {
1575 double a = 9.8, aout;
1576 adouble ad;
1577
1578 trace_on(1, 1);
1579 ad <<= a;
1580
1581 ad = atan(ad);
1582
1583 ad >>= aout;
1584 trace_off();
1585
1586 double aDerivative = 1. / (1. + a*a);
1587 a = std::atan(a);
1588
1589 double *u = myalloc1(1);
1590 double *z = myalloc1(1);
1591
1592 *u = 1.;
1593
1594 fos_reverse(1, 1, 1, u, z);
1595
1596 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1597
1598 myfree1(u);
1599 myfree1(z);
1600 }
1601
BOOST_AUTO_TEST_CASE(Log10Operator_ZOS_Forward)1602 BOOST_AUTO_TEST_CASE(Log10Operator_ZOS_Forward)
1603 {
1604 double a = 12.3, aout;
1605 adouble ad;
1606
1607 trace_on(1);
1608 ad <<= a;
1609
1610 ad = log10(ad);
1611
1612 ad >>= aout;
1613 trace_off();
1614
1615 a = std::log10(a);
1616
1617 BOOST_TEST(aout == a, tt::tolerance(tol));
1618
1619 double *x = myalloc1(1);
1620 double *y = myalloc1(1);
1621
1622 *x = 12.3;
1623
1624 zos_forward(1, 1, 1, 0, x, y);
1625
1626 BOOST_TEST(*y == a, tt::tolerance(tol));
1627
1628 myfree1(x);
1629 myfree1(y);
1630 }
1631
BOOST_AUTO_TEST_CASE(Log10Operator_FOS_Forward)1632 BOOST_AUTO_TEST_CASE(Log10Operator_FOS_Forward)
1633 {
1634 double a = 12.3, aout;
1635 adouble ad;
1636
1637 trace_on(1);
1638 ad <<= a;
1639
1640 ad = log10(ad);
1641
1642 ad >>= aout;
1643 trace_off();
1644
1645 double aDerivative = 1. / (a*std::log(10));
1646 a = std::log10(a);
1647
1648 double *x = myalloc1(1);
1649 double *xd = myalloc1(1);
1650 double *y = myalloc1(1);
1651 double *yd = myalloc1(1);
1652
1653 *x = 12.3;
1654 *xd = 1.;
1655
1656 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1657
1658 BOOST_TEST(*y == a, tt::tolerance(tol));
1659 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1660
1661 myfree1(x);
1662 myfree1(xd);
1663 myfree1(y);
1664 myfree1(yd);
1665 }
1666
BOOST_AUTO_TEST_CASE(Log10Operator_FOS_Reverse)1667 BOOST_AUTO_TEST_CASE(Log10Operator_FOS_Reverse)
1668 {
1669 double a = 12.3, aout;
1670 adouble ad;
1671
1672 trace_on(1, 1);
1673 ad <<= a;
1674
1675 ad = log10(ad);
1676
1677 ad >>= aout;
1678 trace_off();
1679
1680 double aDerivative = 1. / (a*std::log(10));
1681 a = std::log10(a);
1682
1683 double *u = myalloc1(1);
1684 double *z = myalloc1(1);
1685
1686 *u = 1.;
1687
1688 fos_reverse(1, 1, 1, u, z);
1689
1690 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1691
1692 myfree1(u);
1693 myfree1(z);
1694 }
1695
1696 #if defined(ATRIG_ERF)
BOOST_AUTO_TEST_CASE(AsinhOperator_ZOS_Forward)1697 BOOST_AUTO_TEST_CASE(AsinhOperator_ZOS_Forward)
1698 {
1699 double a = 0.6, aout;
1700 adouble ad;
1701
1702 trace_on(1);
1703 ad <<= a;
1704
1705 ad = asinh(ad);
1706
1707 ad >>= aout;
1708 trace_off();
1709
1710 a = std::asinh(a);
1711
1712 BOOST_TEST(aout == a, tt::tolerance(tol));
1713
1714 double *x = myalloc1(1);
1715 double *y = myalloc1(1);
1716
1717 *x = 0.6;
1718
1719 zos_forward(1, 1, 1, 0, x, y);
1720
1721 BOOST_TEST(*y == a, tt::tolerance(tol));
1722
1723 myfree1(x);
1724 myfree1(y);
1725 }
1726
BOOST_AUTO_TEST_CASE(AsinhOperator_FOS_Forward)1727 BOOST_AUTO_TEST_CASE(AsinhOperator_FOS_Forward)
1728 {
1729 double a = 0.6, aout;
1730 adouble ad;
1731
1732 trace_on(1);
1733 ad <<= a;
1734
1735 ad = asinh(ad);
1736
1737 ad >>= aout;
1738 trace_off();
1739
1740 double aDerivative = 1. / (std::sqrt(a*a + 1.));
1741 a = std::asinh(a);
1742
1743 double *x = myalloc1(1);
1744 double *xd = myalloc1(1);
1745 double *y = myalloc1(1);
1746 double *yd = myalloc1(1);
1747
1748 *x = 0.6;
1749 *xd = 1.;
1750
1751 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1752
1753 BOOST_TEST(*y == a, tt::tolerance(tol));
1754 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1755
1756 myfree1(x);
1757 myfree1(xd);
1758 myfree1(y);
1759 myfree1(yd);
1760 }
1761
BOOST_AUTO_TEST_CASE(AsinhOperator_FOS_Reverse)1762 BOOST_AUTO_TEST_CASE(AsinhOperator_FOS_Reverse)
1763 {
1764 double a = 0.6, aout;
1765 adouble ad;
1766
1767 trace_on(1, 1);
1768 ad <<= a;
1769
1770 ad = asinh(ad);
1771
1772 ad >>= aout;
1773 trace_off();
1774
1775 double aDerivative = 1. / (std::sqrt(a*a + 1.));
1776 a = std::asinh(a);
1777
1778 double *u = myalloc1(1);
1779 double *z = myalloc1(1);
1780
1781 *u = 1.;
1782
1783 fos_reverse(1, 1, 1, u, z);
1784
1785 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1786
1787 myfree1(u);
1788 myfree1(z);
1789 }
1790
BOOST_AUTO_TEST_CASE(AcoshOperator_ZOS_Forward)1791 BOOST_AUTO_TEST_CASE(AcoshOperator_ZOS_Forward)
1792 {
1793 double a = 1.7, aout;
1794 adouble ad;
1795
1796 trace_on(1);
1797 ad <<= a;
1798
1799 ad = acosh(ad);
1800
1801 ad >>= aout;
1802 trace_off();
1803
1804 a = std::acosh(a);
1805
1806 BOOST_TEST(aout == a, tt::tolerance(tol));
1807
1808 double *x = myalloc1(1);
1809 double *y = myalloc1(1);
1810
1811 *x = 1.7;
1812
1813 zos_forward(1, 1, 1, 0, x, y);
1814
1815 BOOST_TEST(*y == a, tt::tolerance(tol));
1816
1817 myfree1(x);
1818 myfree1(y);
1819 }
1820
BOOST_AUTO_TEST_CASE(AcoshOperator_FOS_Forward)1821 BOOST_AUTO_TEST_CASE(AcoshOperator_FOS_Forward)
1822 {
1823 double a = 1.7, aout;
1824 adouble ad;
1825
1826 trace_on(1);
1827 ad <<= a;
1828
1829 ad = acosh(ad);
1830
1831 ad >>= aout;
1832 trace_off();
1833
1834 double aDerivative = 1. / (std::sqrt(a*a - 1));
1835 a = std::acosh(a);
1836
1837 double *x = myalloc1(1);
1838 double *xd = myalloc1(1);
1839 double *y = myalloc1(1);
1840 double *yd = myalloc1(1);
1841
1842 *x = 1.7;
1843 *xd = 1.;
1844
1845 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1846
1847 BOOST_TEST(*y == a, tt::tolerance(tol));
1848 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1849
1850 myfree1(x);
1851 myfree1(xd);
1852 myfree1(y);
1853 myfree1(yd);
1854 }
1855
BOOST_AUTO_TEST_CASE(AcoshOperator_FOS_Reverse)1856 BOOST_AUTO_TEST_CASE(AcoshOperator_FOS_Reverse)
1857 {
1858 double a = 1.7, aout;
1859 adouble ad;
1860
1861 trace_on(1, 1);
1862 ad <<= a;
1863
1864 ad = acosh(ad);
1865
1866 ad >>= aout;
1867 trace_off();
1868
1869 double aDerivative = 1. / (std::sqrt(a*a - 1.));
1870 a = std::acosh(a);
1871
1872 double *u = myalloc1(1);
1873 double *z = myalloc1(1);
1874
1875 *u = 1.;
1876
1877 fos_reverse(1, 1, 1, u, z);
1878
1879 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1880
1881 myfree1(u);
1882 myfree1(z);
1883 }
1884
BOOST_AUTO_TEST_CASE(AtanhOperator_ZOS_Forward)1885 BOOST_AUTO_TEST_CASE(AtanhOperator_ZOS_Forward)
1886 {
1887 double a = 0.6, aout;
1888 adouble ad;
1889
1890 trace_on(1);
1891 ad <<= a;
1892
1893 ad = atanh(ad);
1894
1895 ad >>= aout;
1896 trace_off();
1897
1898 a = std::atanh(a);
1899
1900 BOOST_TEST(aout == a, tt::tolerance(tol));
1901
1902 double *x = myalloc1(1);
1903 double *y = myalloc1(1);
1904
1905 *x = 0.6;
1906
1907 zos_forward(1, 1, 1, 0, x, y);
1908
1909 BOOST_TEST(*y == a, tt::tolerance(tol));
1910
1911 myfree1(x);
1912 myfree1(y);
1913 }
1914
BOOST_AUTO_TEST_CASE(AtanhOperator_FOS_Forward)1915 BOOST_AUTO_TEST_CASE(AtanhOperator_FOS_Forward)
1916 {
1917 double a = 0.6, aout;
1918 adouble ad;
1919
1920 trace_on(1);
1921 ad <<= a;
1922
1923 ad = atanh(ad);
1924
1925 ad >>= aout;
1926 trace_off();
1927
1928 double aDerivative = 1. / (1. - a*a);
1929 a = std::atanh(a);
1930
1931 double *x = myalloc1(1);
1932 double *xd = myalloc1(1);
1933 double *y = myalloc1(1);
1934 double *yd = myalloc1(1);
1935
1936 *x = 0.6;
1937 *xd = 1.;
1938
1939 fos_forward(1, 1, 1, 0, x, xd, y, yd);
1940
1941 BOOST_TEST(*y == a, tt::tolerance(tol));
1942 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
1943
1944 myfree1(x);
1945 myfree1(xd);
1946 myfree1(y);
1947 myfree1(yd);
1948 }
1949
BOOST_AUTO_TEST_CASE(AtanhOperator_FOS_Reverse)1950 BOOST_AUTO_TEST_CASE(AtanhOperator_FOS_Reverse)
1951 {
1952 double a = 0.6, aout;
1953 adouble ad;
1954
1955 trace_on(1, 1);
1956 ad <<= a;
1957
1958 ad = atanh(ad);
1959
1960 ad >>= aout;
1961 trace_off();
1962
1963 double aDerivative = 1. / (1. - a*a);
1964 a = std::atanh(a);
1965
1966 double *u = myalloc1(1);
1967 double *z = myalloc1(1);
1968
1969 *u = 1.;
1970
1971 fos_reverse(1, 1, 1, u, z);
1972
1973 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
1974
1975 myfree1(u);
1976 myfree1(z);
1977 }
1978 #endif
1979
BOOST_AUTO_TEST_CASE(InclOperator_ZOS_Forward)1980 BOOST_AUTO_TEST_CASE(InclOperator_ZOS_Forward)
1981 {
1982 double a = 5., aout;
1983 adouble ad;
1984
1985 trace_on(1);
1986 ad <<= a;
1987
1988 ad = ++ad;
1989
1990 ad >>= aout;
1991 trace_off();
1992
1993 a = ++a;
1994
1995 BOOST_TEST(aout == a, tt::tolerance(tol));
1996
1997 double *x = myalloc1(1);
1998 double *y = myalloc1(1);
1999
2000 *x = 5.;
2001
2002 zos_forward(1, 1, 1, 0, x, y);
2003
2004 BOOST_TEST(*y == a, tt::tolerance(tol));
2005
2006 myfree1(x);
2007 myfree1(y);
2008 }
2009
BOOST_AUTO_TEST_CASE(InclOperator_FOS_Forward)2010 BOOST_AUTO_TEST_CASE(InclOperator_FOS_Forward)
2011 {
2012 double a = 5., aout;
2013 adouble ad;
2014
2015 trace_on(1);
2016 ad <<= a;
2017
2018 ad = ++ad;
2019
2020 ad >>= aout;
2021 trace_off();
2022
2023 double aDerivative = 1.;
2024 a = ++a;
2025
2026 double *x = myalloc1(1);
2027 double *xd = myalloc1(1);
2028 double *y = myalloc1(1);
2029 double *yd = myalloc1(1);
2030
2031 *x = 5.;
2032 *xd = 1.;
2033
2034 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2035
2036 BOOST_TEST(*y == a, tt::tolerance(tol));
2037 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2038
2039 myfree1(x);
2040 myfree1(xd);
2041 myfree1(y);
2042 myfree1(yd);
2043 }
2044
BOOST_AUTO_TEST_CASE(InclOperator_FOS_Reverse)2045 BOOST_AUTO_TEST_CASE(InclOperator_FOS_Reverse)
2046 {
2047 double a = 5., aout;
2048 adouble ad;
2049
2050 trace_on(1, 1);
2051 ad <<= a;
2052
2053 ad = ++ad;
2054
2055 ad >>= aout;
2056 trace_off();
2057
2058 double aDerivative = 1.;
2059 a = ++a;
2060
2061 double *u = myalloc1(1);
2062 double *z = myalloc1(1);
2063
2064 *u = 1.;
2065
2066 fos_reverse(1, 1, 1, u, z);
2067
2068 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2069
2070 myfree1(u);
2071 myfree1(z);
2072 }
2073
BOOST_AUTO_TEST_CASE(DeclOperator_ZOS_Forward)2074 BOOST_AUTO_TEST_CASE(DeclOperator_ZOS_Forward)
2075 {
2076 double a = 5., aout;
2077 adouble ad;
2078
2079 trace_on(1);
2080 ad <<= a;
2081
2082 ad = --ad;
2083
2084 ad >>= aout;
2085 trace_off();
2086
2087 a = --a;
2088
2089 BOOST_TEST(aout == a, tt::tolerance(tol));
2090
2091 double *x = myalloc1(1);
2092 double *y = myalloc1(1);
2093
2094 *x = 5.;
2095
2096 zos_forward(1, 1, 1, 0, x, y);
2097
2098 BOOST_TEST(*y == a, tt::tolerance(tol));
2099
2100 myfree1(x);
2101 myfree1(y);
2102 }
2103
BOOST_AUTO_TEST_CASE(DeclOperator_FOS_Forward)2104 BOOST_AUTO_TEST_CASE(DeclOperator_FOS_Forward)
2105 {
2106 double a = 5., aout;
2107 adouble ad;
2108
2109 trace_on(1);
2110 ad <<= a;
2111
2112 ad = --ad;
2113
2114 ad >>= aout;
2115 trace_off();
2116
2117 double aDerivative = 1.;
2118 a = --a;
2119
2120 double *x = myalloc1(1);
2121 double *xd = myalloc1(1);
2122 double *y = myalloc1(1);
2123 double *yd = myalloc1(1);
2124
2125 *x = 5.;
2126 *xd = 1.;
2127
2128 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2129
2130 BOOST_TEST(*y == a, tt::tolerance(tol));
2131 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2132
2133 myfree1(x);
2134 myfree1(xd);
2135 myfree1(y);
2136 myfree1(yd);
2137 }
2138
BOOST_AUTO_TEST_CASE(DeclOperator_FOS_Reverse)2139 BOOST_AUTO_TEST_CASE(DeclOperator_FOS_Reverse)
2140 {
2141 double a = 5., aout;
2142 adouble ad;
2143
2144 trace_on(1, 1);
2145 ad <<= a;
2146
2147 ad = --ad;
2148
2149 ad >>= aout;
2150 trace_off();
2151
2152 double aDerivative = 1.;
2153 a = --a;
2154
2155 double *u = myalloc1(1);
2156 double *z = myalloc1(1);
2157
2158 *u = 1.;
2159
2160 fos_reverse(1, 1, 1, u, z);
2161
2162 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2163
2164 myfree1(u);
2165 myfree1(z);
2166 }
2167
BOOST_AUTO_TEST_CASE(SignPlusOperator_ZOS_Forward)2168 BOOST_AUTO_TEST_CASE(SignPlusOperator_ZOS_Forward)
2169 {
2170 double a = 1.5, aout;
2171 adouble ad;
2172
2173 trace_on(1);
2174 ad <<= a;
2175
2176 ad = +ad;
2177
2178 ad >>= aout;
2179 trace_off();
2180
2181 a = +a;
2182
2183 BOOST_TEST(aout == a, tt::tolerance(tol));
2184
2185 double *x = myalloc1(1);
2186 double *y = myalloc1(1);
2187
2188 *x = 1.5;
2189
2190 zos_forward(1, 1, 1, 0, x, y);
2191
2192 BOOST_TEST(*y == a, tt::tolerance(tol));
2193
2194 myfree1(x);
2195 myfree1(y);
2196 }
2197
BOOST_AUTO_TEST_CASE(SignPlusOperator_FOS_Forward)2198 BOOST_AUTO_TEST_CASE(SignPlusOperator_FOS_Forward)
2199 {
2200 double a = 1.5, aout;
2201 adouble ad;
2202
2203 trace_on(1);
2204 ad <<= a;
2205
2206 ad = +ad;
2207
2208 ad >>= aout;
2209 trace_off();
2210
2211 double aDerivative = 1.;
2212 a = +a;
2213
2214 double *x = myalloc1(1);
2215 double *xd = myalloc1(1);
2216 double *y = myalloc1(1);
2217 double *yd = myalloc1(1);
2218
2219 *x = 1.5;
2220 *xd = 1.;
2221
2222 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2223
2224 BOOST_TEST(*y == a, tt::tolerance(tol));
2225 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2226
2227 myfree1(x);
2228 myfree1(xd);
2229 myfree1(y);
2230 myfree1(yd);
2231 }
2232
BOOST_AUTO_TEST_CASE(SignPlusOperator_FOS_Reverse)2233 BOOST_AUTO_TEST_CASE(SignPlusOperator_FOS_Reverse)
2234 {
2235 double a = 1.5, aout;
2236 adouble ad;
2237
2238 trace_on(1, 1);
2239 ad <<= a;
2240
2241 ad = +ad;
2242
2243 ad >>= aout;
2244 trace_off();
2245
2246 double aDerivative = 1.;
2247 a = +a;
2248
2249 double *u = myalloc1(1);
2250 double *z = myalloc1(1);
2251
2252 *u = 1.;
2253
2254 fos_reverse(1, 1, 1, u, z);
2255
2256 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2257
2258 myfree1(u);
2259 myfree1(z);
2260 }
2261
BOOST_AUTO_TEST_CASE(SignMinusOperator_ZOS_Forward)2262 BOOST_AUTO_TEST_CASE(SignMinusOperator_ZOS_Forward)
2263 {
2264 double a = 1.5, aout;
2265 adouble ad;
2266
2267 trace_on(1);
2268 ad <<= a;
2269
2270 ad = -ad;
2271
2272 ad >>= aout;
2273 trace_off();
2274
2275 a = -a;
2276
2277 BOOST_TEST(aout == a, tt::tolerance(tol));
2278
2279 double *x = myalloc1(1);
2280 double *y = myalloc1(1);
2281
2282 *x = 1.5;
2283
2284 zos_forward(1, 1, 1, 0, x, y);
2285
2286 BOOST_TEST(*y == a, tt::tolerance(tol));
2287
2288 myfree1(x);
2289 myfree1(y);
2290 }
2291
BOOST_AUTO_TEST_CASE(SignMinusOperator_FOS_Forward)2292 BOOST_AUTO_TEST_CASE(SignMinusOperator_FOS_Forward)
2293 {
2294 double a = 1.5, aout;
2295 adouble ad;
2296
2297 trace_on(1);
2298 ad <<= a;
2299
2300 ad = -ad;
2301
2302 ad >>= aout;
2303 trace_off();
2304
2305 double aDerivative = -1.;
2306 a = -a;
2307
2308 double *x = myalloc1(1);
2309 double *xd = myalloc1(1);
2310 double *y = myalloc1(1);
2311 double *yd = myalloc1(1);
2312
2313 *x = 1.5;
2314 *xd = 1.;
2315
2316 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2317
2318 BOOST_TEST(*y == a, tt::tolerance(tol));
2319 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2320
2321 myfree1(x);
2322 myfree1(xd);
2323 myfree1(y);
2324 myfree1(yd);
2325 }
2326
BOOST_AUTO_TEST_CASE(SignMinusOperator_FOS_Reverse)2327 BOOST_AUTO_TEST_CASE(SignMinusOperator_FOS_Reverse)
2328 {
2329 double a = 1.5, aout;
2330 adouble ad;
2331
2332 trace_on(1, 1);
2333 ad <<= a;
2334
2335 ad = -ad;
2336
2337 ad >>= aout;
2338 trace_off();
2339
2340 double aDerivative = -1.;
2341 a = -a;
2342
2343 double *u = myalloc1(1);
2344 double *z = myalloc1(1);
2345
2346 *u = 1.;
2347
2348 fos_reverse(1, 1, 1, u, z);
2349
2350 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2351
2352 myfree1(u);
2353 myfree1(z);
2354 }
2355
BOOST_AUTO_TEST_CASE(Atan2Operator_ZOS_Forward)2356 BOOST_AUTO_TEST_CASE(Atan2Operator_ZOS_Forward)
2357 {
2358 double a = 12.3, b = 2.1, out;
2359 adouble ad, bd;
2360
2361 trace_on(1);
2362 ad <<= a;
2363 bd <<= b;
2364
2365 ad = atan2(ad, bd);
2366
2367 ad >>= out;
2368 trace_off();
2369
2370 a = std::atan2(a, b);
2371
2372 BOOST_TEST(out == a, tt::tolerance(tol));
2373
2374 double *x = myalloc1(2);
2375 double *y = myalloc1(1);
2376
2377 *x = 12.3;
2378 *(x + 1) = 2.1;
2379
2380 zos_forward(1, 1, 2, 0, x, y);
2381
2382 BOOST_TEST(*y == a, tt::tolerance(tol));
2383
2384 myfree1(x);
2385 myfree1(y);
2386 }
2387
BOOST_AUTO_TEST_CASE(Atan2Operator_FOS_Forward)2388 BOOST_AUTO_TEST_CASE(Atan2Operator_FOS_Forward)
2389 {
2390 double a = 12.3, b = 2.1, out;
2391 adouble ad, bd;
2392
2393 trace_on(1);
2394 ad <<= a;
2395 bd <<= b;
2396
2397 ad = atan2(ad, bd);
2398
2399 ad >>= out;
2400 trace_off();
2401
2402 double aDerivative = b / (a*a + b*b);
2403 double bDerivative = -a / (a*a + b*b);
2404 a = std::atan2(a, b);
2405
2406 double *x = myalloc1(2);
2407 double *xd = myalloc1(2);
2408 double *y = myalloc1(1);
2409 double *yd = myalloc1(1);
2410
2411 /* Test partial derivative wrt a. */
2412 *x = 12.3;
2413 *(x + 1) = 2.1;
2414 *xd = 1.;
2415 *(xd + 1) = 0.;
2416
2417 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2418
2419 BOOST_TEST(*y == a, tt::tolerance(tol));
2420 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2421
2422 /* Test partial derivative wrt b. */
2423 *xd = 0.;
2424 *(xd + 1) = 1.;
2425
2426 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2427
2428 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
2429
2430 myfree1(x);
2431 myfree1(xd);
2432 myfree1(y);
2433 myfree1(yd);
2434 }
2435
BOOST_AUTO_TEST_CASE(Atan2Operator_FOS_Reverse)2436 BOOST_AUTO_TEST_CASE(Atan2Operator_FOS_Reverse)
2437 {
2438 double a = 12.3, b = 2.1, out;
2439 adouble ad, bd;
2440
2441 trace_on(1, 1);
2442 ad <<= a;
2443 bd <<= b;
2444
2445 ad = atan2(ad, bd);
2446
2447 ad >>= out;
2448 trace_off();
2449
2450 double aDerivative = b / (a*a + b*b);
2451 double bDerivative = -a / (a*a + b*b);
2452
2453 double *u = myalloc1(1);
2454 double *z = myalloc1(2);
2455
2456 *u = 1.;
2457
2458 fos_reverse(1, 1, 2, u, z);
2459
2460 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2461 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
2462
2463 myfree1(u);
2464 myfree1(z);
2465 }
2466
BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_1)2467 BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_1)
2468 {
2469 double a = 2.3, e = 3.5, aout;
2470 adouble ad;
2471
2472 trace_on(1);
2473 ad <<= a;
2474
2475 ad = pow(ad, e);
2476
2477 ad >>= aout;
2478 trace_off();
2479
2480 a = std::pow(a, e);
2481
2482 BOOST_TEST(aout == a, tt::tolerance(tol));
2483
2484 double *x = myalloc1(1);
2485 double *y = myalloc1(1);
2486
2487 *x = 2.3;
2488
2489 zos_forward(1, 1, 1, 0, x, y);
2490
2491 BOOST_TEST(*y == a, tt::tolerance(tol));
2492
2493 myfree1(x);
2494 myfree1(y);
2495 }
2496
BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_1)2497 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_1)
2498 {
2499 double a = 2.3, e = 3.5, aout;
2500 adouble ad;
2501
2502 trace_on(1);
2503 ad <<= a;
2504
2505 ad = pow(ad, e);
2506
2507 ad >>= aout;
2508 trace_off();
2509
2510 double aDerivative = e * std::pow(a, e - 1.);
2511 a = std::pow(a, e);
2512
2513 double *x = myalloc1(1);
2514 double *xd = myalloc1(1);
2515 double *y = myalloc1(1);
2516 double *yd = myalloc1(1);
2517
2518 *x = 2.3;
2519 *xd = 1.;
2520
2521 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2522
2523 BOOST_TEST(*y == a, tt::tolerance(tol));
2524 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2525
2526 myfree1(x);
2527 myfree1(xd);
2528 myfree1(y);
2529 myfree1(yd);
2530 }
2531 /*
2532 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Reverse_1)
2533 {
2534 double a = 2.3, e = 3.5, aout;
2535 adouble ad;
2536
2537 trace_on(1, 1);
2538 ad <<= a;
2539
2540 ad = pow(ad, e);
2541
2542 ad >>= aout;
2543 trace_off();
2544
2545 double aDerivative = e * std::pow(a, e - 1.);
2546 a = std::pow(a, e);
2547
2548 double *u = myalloc1(1);
2549 double *z = myalloc1(1);
2550
2551 *u = 1.;
2552
2553 fos_reverse(1, 1, 1, u, z);
2554
2555 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2556
2557 myfree1(u);
2558 myfree1(z);
2559 }
2560 */
BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_2)2561 BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_2)
2562 {
2563 double a = 2.3, b = 3.5, out;
2564 adouble ad, bd;
2565
2566 trace_on(1);
2567 ad <<= a;
2568 bd <<= b;
2569
2570 ad = pow(ad, bd);
2571
2572 ad >>= out;
2573 trace_off();
2574
2575 a = std::pow(a, b);
2576
2577 BOOST_TEST(out == a, tt::tolerance(tol));
2578
2579 double *x = myalloc1(2);
2580 double *y = myalloc1(1);
2581
2582 *x = 2.3;
2583 *(x + 1) = 3.5;
2584
2585 zos_forward(1, 1, 2, 0, x, y);
2586
2587 BOOST_TEST(*y == a, tt::tolerance(tol));
2588
2589 myfree1(x);
2590 myfree1(y);
2591 }
2592
BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_2)2593 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_2)
2594 {
2595 double a = 2.3, b = 3.5, out;
2596 adouble ad, bd;
2597
2598 trace_on(1);
2599 ad <<= a;
2600 bd <<= b;
2601
2602 ad = pow(ad, bd);
2603
2604 ad >>= out;
2605 trace_off();
2606
2607 double aDerivative = b * std::pow(a, b - 1.);
2608 double bDerivative = std::log(a) * std::pow(a, b);
2609 a = std::pow(a, b);
2610
2611 double *x = myalloc1(2);
2612 double *xd = myalloc1(2);
2613 double *y = myalloc1(1);
2614 double *yd = myalloc1(1);
2615
2616 /* Test partial derivative wrt a. */
2617 *x = 2.3;
2618 *(x + 1) = 3.5;
2619 *xd = 1.;
2620 *(xd + 1) = 0.;
2621
2622 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2623
2624 BOOST_TEST(*y == a, tt::tolerance(tol));
2625 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2626
2627 /* Test partial derivative wrt b. */
2628 *xd = 0.;
2629 *(xd + 1) = 1.;
2630
2631 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2632
2633 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
2634
2635 myfree1(x);
2636 myfree1(xd);
2637 myfree1(y);
2638 myfree1(yd);
2639 }
2640
BOOST_AUTO_TEST_CASE(PowOperator_FOS_Reverse_2)2641 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Reverse_2)
2642 {
2643 double a = 2.3, b = 3.5, out;
2644 adouble ad, bd;
2645
2646 trace_on(1, 1);
2647 ad <<= a;
2648 bd <<= b;
2649
2650 ad = pow(ad, bd);
2651
2652 ad >>= out;
2653 trace_off();
2654
2655 double aDerivative = b * std::pow(a, b - 1.);
2656 double bDerivative = std::log(a) * std::pow(a, b);
2657
2658 double *u = myalloc1(1);
2659 double *z = myalloc1(2);
2660
2661 *u = 1.;
2662
2663 fos_reverse(1, 1, 2, u, z);
2664
2665 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2666 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
2667
2668 myfree1(u);
2669 myfree1(z);
2670 }
2671
BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_3)2672 BOOST_AUTO_TEST_CASE(PowOperator_ZOS_Forward_3)
2673 {
2674 double a = 2.3, e = 3.5, eout;
2675 adouble ed;
2676
2677 trace_on(1);
2678 ed <<= e;
2679
2680 ed = pow(a, ed);
2681
2682 ed >>= eout;
2683 trace_off();
2684
2685 e = std::pow(a, e);
2686
2687 BOOST_TEST(eout == e, tt::tolerance(tol));
2688
2689 double *x = myalloc1(1);
2690 double *y = myalloc1(1);
2691
2692 *x = 3.5;
2693
2694 zos_forward(1, 1, 1, 0, x, y);
2695
2696 BOOST_TEST(*y == e, tt::tolerance(tol));
2697
2698 myfree1(x);
2699 myfree1(y);
2700 }
2701
BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_3)2702 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Forward_3)
2703 {
2704 double a = 2.3, e = 3.5, eout;
2705 adouble ed;
2706
2707 trace_on(1);
2708 ed <<= e;
2709
2710 ed = pow(a, ed);
2711
2712 ed >>= eout;
2713 trace_off();
2714
2715 double eDerivative = std::log(a) * std::pow(a, e);
2716 e = std::pow(a, e);
2717
2718 double *x = myalloc1(1);
2719 double *xd = myalloc1(1);
2720 double *y = myalloc1(1);
2721 double *yd = myalloc1(1);
2722
2723 *x = 3.5;
2724 *xd = 1.;
2725
2726 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2727
2728 BOOST_TEST(*y == e, tt::tolerance(tol));
2729 BOOST_TEST(*yd == eDerivative, tt::tolerance(tol));
2730
2731 myfree1(x);
2732 myfree1(xd);
2733 myfree1(y);
2734 myfree1(yd);
2735 }
2736
BOOST_AUTO_TEST_CASE(PowOperator_FOS_Reverse_3)2737 BOOST_AUTO_TEST_CASE(PowOperator_FOS_Reverse_3)
2738 {
2739 double a = 2.3, e = 3.5, eout;
2740 adouble ed;
2741
2742 trace_on(1, 1);
2743 ed <<= e;
2744
2745 ed = pow(a, ed);
2746
2747 ed >>= eout;
2748 trace_off();
2749
2750 double eDerivative = std::log(a) * std::pow(a, e);
2751 e = std::pow(a, e);
2752
2753 double *u = myalloc1(1);
2754 double *z = myalloc1(1);
2755
2756 *u = 1.;
2757
2758 fos_reverse(1, 1, 1, u, z);
2759
2760 BOOST_TEST(*z == eDerivative, tt::tolerance(tol));
2761
2762 myfree1(u);
2763 myfree1(z);
2764 }
2765
2766 /* Frexp does not need to be tested, because it is non-differentiable. */
2767 /*
2768 BOOST_AUTO_TEST_CASE(LdexpOperator_ZOS_Forward_1)
2769 {
2770 double a = 4., b = 3., out;
2771 adouble ad, bd;
2772
2773 trace_on(1);
2774 ad <<= a;
2775 bd <<= b;
2776
2777 ad = ldexp(ad, bd);
2778
2779 ad >>= out;
2780 trace_off();
2781
2782 a = a * std::pow(2., b);
2783
2784 BOOST_TEST(out == a, tt::tolerance(tol));
2785
2786 double *x = myalloc1(2);
2787 double *y = myalloc1(1);
2788
2789 *x = 4.;
2790 *(x + 1) = 3.;
2791
2792 zos_forward(1, 1, 2, 0, x, y);
2793
2794 BOOST_TEST(*y == a, tt::tolerance(tol));
2795
2796 myfree1(x);
2797 myfree1(y);
2798 }
2799
2800 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Forward_1)
2801 {
2802 double a = 4., b = 3., out;
2803 adouble ad, bd;
2804
2805 trace_on(1);
2806 ad <<= a;
2807 bd <<= b;
2808
2809 ad = ldexp(ad, bd);
2810
2811 ad >>= out;
2812 trace_off();
2813
2814 double aDerivative = std::pow(2., b);
2815 double bDerivative = a * std::log(2.) * std::pow(2., b);
2816 a = a * std::pow(2., b);
2817
2818 double *x = myalloc1(2);
2819 double *xd = myalloc1(2);
2820 double *y = myalloc1(1);
2821 double *yd = myalloc1(1);
2822
2823 *x = 4.;
2824 *(x + 1) = 3.;
2825 *xd = 1.;
2826 *(xd + 1) = 0.;
2827
2828 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2829
2830 BOOST_TEST(*y == a, tt::tolerance(tol));
2831 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2832
2833 *xd = 0.;
2834 *(xd + 1) = 1.;
2835
2836 fos_forward(1, 1, 2, 0, x, xd, y, yd);
2837
2838 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
2839
2840 myfree1(x);
2841 myfree1(xd);
2842 myfree1(y);
2843 myfree1(yd);
2844 }
2845
2846 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Reverse_1)
2847 {
2848 double a = 4., b = 3., out;
2849 adouble ad, bd;
2850
2851 trace_on(1, 1);
2852 ad <<= a;
2853 bd <<= b;
2854
2855 ad = ldexp(ad, bd);
2856
2857 ad >>= out;
2858 trace_off();
2859
2860 double aDerivative = std::pow(2., b);
2861 double bDerivative = a * std::log(2.) * std::pow(2., b);
2862
2863 double *u = myalloc1(1);
2864 double *z = myalloc1(2);
2865
2866 *u = 1.;
2867
2868 fos_reverse(1, 1, 2, u, z);
2869
2870 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2871 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
2872
2873 myfree1(u);
2874 myfree1(z);
2875 }
2876 */
BOOST_AUTO_TEST_CASE(LdexpOperator_ZOS_Forward_2)2877 BOOST_AUTO_TEST_CASE(LdexpOperator_ZOS_Forward_2)
2878 {
2879 double a = 4., e = 3., aout;
2880 adouble ad;
2881
2882 trace_on(1);
2883 ad <<= a;
2884
2885 ad = ldexp(ad, e);
2886
2887 ad >>= aout;
2888 trace_off();
2889
2890 a = a * std::pow(2., e);
2891
2892 BOOST_TEST(aout == a, tt::tolerance(tol));
2893
2894 double *x = myalloc1(1);
2895 double *y = myalloc1(1);
2896
2897 *x = 4.;
2898
2899 zos_forward(1, 1, 1, 0, x, y);
2900
2901 BOOST_TEST(*y == a, tt::tolerance(tol));
2902
2903 myfree1(x);
2904 myfree1(y);
2905 }
2906
BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Forward_2)2907 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Forward_2)
2908 {
2909 double a = 4., e = 3., aout;
2910 adouble ad;
2911
2912 trace_on(1);
2913 ad <<= a;
2914
2915 ad = ldexp(ad, e);
2916
2917 ad >>= aout;
2918 trace_off();
2919
2920 double aDerivative = std::pow(2., e);
2921 a = a * std::pow(2., e);
2922
2923 double *x = myalloc1(1);
2924 double *xd = myalloc1(1);
2925 double *y = myalloc1(1);
2926 double *yd = myalloc1(1);
2927
2928 *x = 4.;
2929 *xd = 1.;
2930
2931 fos_forward(1, 1, 1, 0, x, xd, y, yd);
2932
2933 BOOST_TEST(*y == a, tt::tolerance(tol));
2934 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
2935
2936 myfree1(x);
2937 myfree1(xd);
2938 myfree1(y);
2939 myfree1(yd);
2940 }
2941
BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Reverse_2)2942 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Reverse_2)
2943 {
2944 double a = 4., e = 3., aout;
2945 adouble ad;
2946
2947 trace_on(1, 1);
2948 ad <<= a;
2949
2950 ad = ldexp(ad, e);
2951
2952 ad >>= aout;
2953 trace_off();
2954
2955 double aDerivative = std::pow(2., e);
2956 a = a * std::pow(2., e);
2957
2958 double *u = myalloc1(1);
2959 double *z = myalloc1(1);
2960
2961 *u = 1.;
2962
2963 fos_reverse(1, 1, 1, u, z);
2964
2965 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
2966
2967 myfree1(u);
2968 myfree1(z);
2969 }
2970 /*
2971 BOOST_AUTO_TEST_CASE(LdexpOperator_ZOS_Forward_3)
2972 {
2973 double a = 4., e = 3., eout;
2974 adouble ed;
2975
2976 trace_on(1);
2977 ed <<= e;
2978
2979 ed = ldexp(a, ed);
2980
2981 ed >>= eout;
2982 trace_off();
2983
2984 e = a * std::pow(2., e);
2985
2986 BOOST_TEST(eout == e, tt::tolerance(tol));
2987
2988 double *x = myalloc1(1);
2989 double *y = myalloc1(1);
2990
2991 *x = 3.;
2992
2993 zos_forward(1, 1, 1, 0, x, y);
2994
2995 BOOST_TEST(*y == e, tt::tolerance(tol));
2996
2997 myfree1(x);
2998 myfree1(y);
2999 }
3000
3001 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Forward_3)
3002 {
3003 double a = 4., e = 3., eout;
3004 adouble ed;
3005
3006 trace_on(1);
3007 ed <<= e;
3008
3009 ed = ldexp(a, ed);
3010
3011 ed >>= eout;
3012 trace_off();
3013
3014 double eDerivative = a * std::log(2.) * std::pow(2., e);
3015 e = std::pow(a, e);
3016
3017 double *x = myalloc1(1);
3018 double *xd = myalloc1(1);
3019 double *y = myalloc1(1);
3020 double *yd = myalloc1(1);
3021
3022 *x = 3.;
3023 *xd = 1.;
3024
3025 fos_forward(1, 1, 1, 0, x, xd, y, yd);
3026
3027 BOOST_TEST(*y == e, tt::tolerance(tol));
3028 BOOST_TEST(*yd == eDerivative, tt::tolerance(tol));
3029
3030 myfree1(x);
3031 myfree1(xd);
3032 myfree1(y);
3033 myfree1(yd);
3034 }
3035
3036 BOOST_AUTO_TEST_CASE(LdexpOperator_FOS_Reverse_3)
3037 {
3038 double a = 4., e = 3., eout;
3039 adouble ed;
3040
3041 trace_on(1, 1);
3042 ed <<= e;
3043
3044 ed = ldexp(a, ed);
3045
3046 ed >>= eout;
3047 trace_off();
3048
3049 double eDerivative = a * std::log(2.) * std::pow(2., e);
3050 e = a * std::pow(2., e);
3051
3052 double *u = myalloc1(1);
3053 double *z = myalloc1(1);
3054
3055 *u = 1.;
3056
3057 fos_reverse(1, 1, 1, u, z);
3058
3059 BOOST_TEST(*z == eDerivative, tt::tolerance(tol));
3060
3061 myfree1(u);
3062 myfree1(z);
3063 }
3064 */
3065
BOOST_AUTO_TEST_CASE(FabsOperator_ZOS_Forward)3066 BOOST_AUTO_TEST_CASE(FabsOperator_ZOS_Forward)
3067 {
3068 double a = 1.4, b = -5., c = 0., aout;
3069 adouble ad;
3070
3071 trace_on(1);
3072 ad <<= a;
3073
3074 ad = fabs(ad);
3075
3076 ad >>= aout;
3077 trace_off();
3078
3079 a = std::fabs(a);
3080 b = std::fabs(b);
3081 c = std::fabs(c);
3082
3083 BOOST_TEST(aout == a, tt::tolerance(tol));
3084
3085 double *x1 = myalloc1(1);
3086 double *y1 = myalloc1(1);
3087 double *x2 = myalloc1(1);
3088 double *y2 = myalloc1(1);
3089 double *x3 = myalloc1(1);
3090 double *y3 = myalloc1(1);
3091
3092 *x1 = 1.4;
3093 *x2 = -5.;
3094 *x3 = 0.;
3095
3096 zos_forward(1, 1, 1, 0, x1, y1);
3097 zos_forward(1, 1, 1, 0, x2, y2);
3098 zos_forward(1, 1, 1, 0, x3, y3);
3099
3100 BOOST_TEST(*y1 == a, tt::tolerance(tol));
3101 BOOST_TEST(*y2 == b, tt::tolerance(tol));
3102 BOOST_TEST(*y3 == c, tt::tolerance(tol));
3103
3104 myfree1(x1);
3105 myfree1(y1);
3106 myfree1(x2);
3107 myfree1(y2);
3108 myfree1(x3);
3109 myfree1(y3);
3110 }
3111
BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Forward)3112 BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Forward)
3113 {
3114 double a = 1.4, b = -5., c = 0., aout, bout, cout;
3115 adouble ad;
3116
3117 trace_on(1);
3118 ad <<= a;
3119
3120 ad = fabs(ad);
3121
3122 ad >>= aout;
3123 trace_off();
3124
3125 double aDerivative = 1.;
3126 double bDerivative = -1.;
3127 a = std::fabs(a);
3128 b = std::fabs(b);
3129
3130 double *x1 = myalloc1(1);
3131 double *xd1 = myalloc1(1);
3132 double *y1 = myalloc1(1);
3133 double *yd1 = myalloc1(1);
3134 double *x2 = myalloc1(1);
3135 double *xd2 = myalloc1(1);
3136 double *y2 = myalloc1(1);
3137 double *yd2 = myalloc1(1);
3138
3139 *x1 = 1.4;
3140 *xd1 = 1.;
3141 *x2 = -5.;
3142 *xd2 = 1.;
3143
3144 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
3145 fos_forward(1, 1, 1, 0, x2, xd2, y2, yd2);
3146
3147 BOOST_TEST(*y1 == a, tt::tolerance(tol));
3148 BOOST_TEST(*yd1 == aDerivative, tt::tolerance(tol));
3149 BOOST_TEST(*y2 == b, tt::tolerance(tol));
3150 BOOST_TEST(*yd2 == bDerivative, tt::tolerance(tol));
3151
3152 double *x3 = myalloc1(1);
3153 double *xd3_1 = myalloc1(1);
3154 double *xd3_2 = myalloc1(1);
3155 double *y3 = myalloc1(1);
3156 double *yd3 = myalloc1(1);
3157
3158 *x3 = 0.0;
3159 *xd3_1 = 2.5;
3160 *xd3_2 = -3.5;
3161
3162 fos_forward(1, 1, 1, 0, x3, xd3_1, y3, yd3);
3163
3164 BOOST_TEST(*y3 == 0.0, tt::tolerance(tol));
3165 BOOST_TEST(*yd3 == 2.5, tt::tolerance(tol));
3166
3167 fos_forward(1, 1, 1, 0, x3, xd3_2, y3, yd3);
3168
3169 BOOST_TEST(*y3 == 0.0, tt::tolerance(tol));
3170 BOOST_TEST(*yd3 == 3.5, tt::tolerance(tol));
3171
3172 myfree1(x1);
3173 myfree1(xd1);
3174 myfree1(y1);
3175 myfree1(yd1);
3176 myfree1(x2);
3177 myfree1(xd2);
3178 myfree1(y2);
3179 myfree1(yd2);
3180 myfree1(x3);
3181 myfree1(xd3_1);
3182 myfree1(xd3_2);
3183 myfree1(y3);
3184 myfree1(yd3);
3185 }
3186
BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Pos)3187 BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Pos)
3188 {
3189 double a = 1.4, aout;
3190 adouble ad;
3191
3192 trace_on(1, 1);
3193 ad <<= a;
3194
3195 ad = fabs(ad);
3196
3197 ad >>= aout;
3198 trace_off();
3199
3200 double aDerivative = 1.;
3201
3202 double *u = myalloc1(1);
3203 double *z = myalloc1(1);
3204
3205 *u = 1.;
3206
3207 fos_reverse(1, 1, 1, u, z);
3208
3209 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3210
3211 myfree1(u);
3212 myfree1(z);
3213 }
3214
BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Neg)3215 BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Neg)
3216 {
3217 double a = -5., aout;
3218 adouble ad;
3219
3220 trace_on(1, 1);
3221 ad <<= a;
3222
3223 ad = fabs(ad);
3224
3225 ad >>= aout;
3226 trace_off();
3227
3228 double aDerivative = -1.;
3229
3230 double *u = myalloc1(1);
3231 double *z = myalloc1(1);
3232
3233 *u = 1.;
3234
3235 fos_reverse(1, 1, 1, u, z);
3236
3237 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3238
3239 myfree1(u);
3240 myfree1(z);
3241 }
3242
BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Zero)3243 BOOST_AUTO_TEST_CASE(FabsOperator_FOS_Reverse_Zero)
3244 {
3245 double a = 0., aout;
3246 adouble ad;
3247
3248 trace_on(1, 1);
3249 ad <<= a;
3250
3251 ad = fabs(ad);
3252
3253 ad >>= aout;
3254 trace_off();
3255
3256 /* In reverse mode, the derivative at zero is calculated to be zero. */
3257 double aDerivative = 0.;
3258
3259 double *u = myalloc1(1);
3260 double *z = myalloc1(1);
3261
3262 *u = 1.;
3263
3264 fos_reverse(1, 1, 1, u, z);
3265
3266 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3267
3268 myfree1(u);
3269 myfree1(z);
3270 }
3271
BOOST_AUTO_TEST_CASE(CeilOperator_ZOS_Forward)3272 BOOST_AUTO_TEST_CASE(CeilOperator_ZOS_Forward)
3273 {
3274 double a = 3.573, aout;
3275 adouble ad;
3276
3277 trace_on(1);
3278 ad <<= a;
3279
3280 ad = ceil(ad);
3281
3282 ad >>= aout;
3283 trace_off();
3284
3285 a = std::ceil(a);
3286
3287 BOOST_TEST(aout == a, tt::tolerance(tol));
3288
3289 double *x = myalloc1(1);
3290 double *y = myalloc1(1);
3291
3292 *x = 3.573;
3293
3294 zos_forward(1, 1, 1, 0, x, y);
3295
3296 BOOST_TEST(*y == a, tt::tolerance(tol));
3297
3298 myfree1(x);
3299 myfree1(y);
3300 }
3301
BOOST_AUTO_TEST_CASE(CeilOperator_FOS_Forward)3302 BOOST_AUTO_TEST_CASE(CeilOperator_FOS_Forward)
3303 {
3304 double a = 3.573, aout;
3305 adouble ad;
3306
3307 trace_on(1);
3308 ad <<= a;
3309
3310 ad = ceil(ad);
3311
3312 ad >>= aout;
3313 trace_off();
3314
3315 double aDerivative = 0.;
3316 a = std::ceil(a);
3317
3318 double *x = myalloc1(1);
3319 double *xd = myalloc1(1);
3320 double *y = myalloc1(1);
3321 double *yd = myalloc1(1);
3322
3323 *x = 3.573;
3324 *xd = 1.;
3325
3326 fos_forward(1, 1, 1, 0, x, xd, y, yd);
3327
3328 BOOST_TEST(*y == a, tt::tolerance(tol));
3329 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
3330
3331 myfree1(x);
3332 myfree1(xd);
3333 myfree1(y);
3334 myfree1(yd);
3335 }
3336
BOOST_AUTO_TEST_CASE(CeilOperator_FOS_Reverse)3337 BOOST_AUTO_TEST_CASE(CeilOperator_FOS_Reverse)
3338 {
3339 double a = 3.573, aout;
3340 adouble ad;
3341
3342 trace_on(1, 1);
3343 ad <<= a;
3344
3345 ad = ceil(ad);
3346
3347 ad >>= aout;
3348 trace_off();
3349
3350 double aDerivative = 0.;
3351
3352 double *u = myalloc1(1);
3353 double *z = myalloc1(1);
3354
3355 *u = 1.;
3356
3357 fos_reverse(1, 1, 1, u, z);
3358
3359 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3360
3361 myfree1(u);
3362 myfree1(z);
3363 }
3364
BOOST_AUTO_TEST_CASE(FloorOperator_ZOS_Forward)3365 BOOST_AUTO_TEST_CASE(FloorOperator_ZOS_Forward)
3366 {
3367 double a = 4.483, aout;
3368 adouble ad;
3369
3370 trace_on(1);
3371 ad <<= a;
3372
3373 ad = floor(ad);
3374
3375 ad >>= aout;
3376 trace_off();
3377
3378 a = std::floor(a);
3379
3380 BOOST_TEST(aout == a, tt::tolerance(tol));
3381
3382 double *x = myalloc1(1);
3383 double *y = myalloc1(1);
3384
3385 *x = 4.483;
3386
3387 zos_forward(1, 1, 1, 0, x, y);
3388
3389 BOOST_TEST(*y == a, tt::tolerance(tol));
3390
3391 myfree1(x);
3392 myfree1(y);
3393 }
3394
BOOST_AUTO_TEST_CASE(FloorOperator_FOS_Forward)3395 BOOST_AUTO_TEST_CASE(FloorOperator_FOS_Forward)
3396 {
3397 double a = 4.483, aout;
3398 adouble ad;
3399
3400 trace_on(1);
3401 ad <<= a;
3402
3403 ad = floor(ad);
3404
3405 ad >>= aout;
3406 trace_off();
3407
3408 double aDerivative = 0.;
3409 a = std::floor(a);
3410
3411 double *x = myalloc1(1);
3412 double *xd = myalloc1(1);
3413 double *y = myalloc1(1);
3414 double *yd = myalloc1(1);
3415
3416 *x = 4.483;
3417 *xd = 1.;
3418
3419 fos_forward(1, 1, 1, 0, x, xd, y, yd);
3420
3421 BOOST_TEST(*y == a, tt::tolerance(tol));
3422 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
3423
3424 myfree1(x);
3425 myfree1(xd);
3426 myfree1(y);
3427 myfree1(yd);
3428 }
3429
BOOST_AUTO_TEST_CASE(FloorOperator_FOS_Reverse)3430 BOOST_AUTO_TEST_CASE(FloorOperator_FOS_Reverse)
3431 {
3432 double a = 4.483, aout;
3433 adouble ad;
3434
3435 trace_on(1, 1);
3436 ad <<= a;
3437
3438 ad = ceil(ad);
3439
3440 ad >>= aout;
3441 trace_off();
3442
3443 double aDerivative = 0.;
3444
3445 double *u = myalloc1(1);
3446 double *z = myalloc1(1);
3447
3448 *u = 1.;
3449
3450 fos_reverse(1, 1, 1, u, z);
3451
3452 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3453
3454 myfree1(u);
3455 myfree1(z);
3456 }
3457
BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_1)3458 BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_1)
3459 {
3460 double a = 4., b = 3.2, out;
3461 adouble ad, bd;
3462
3463 trace_on(1);
3464 ad <<= a;
3465 bd <<= b;
3466
3467 ad = fmax(ad, bd);
3468
3469 ad >>= out;
3470 trace_off();
3471
3472 a = std::fmax(a, b);
3473
3474 BOOST_TEST(out == a, tt::tolerance(tol));
3475
3476 double *x = myalloc1(2);
3477 double *y = myalloc1(1);
3478
3479 *x = 4.;
3480 *(x + 1) = 3.2;
3481
3482 zos_forward(1, 1, 2, 0, x, y);
3483
3484 BOOST_TEST(*y == a, tt::tolerance(tol));
3485
3486 myfree1(x);
3487 myfree1(y);
3488 }
3489
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_1)3490 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_1)
3491 {
3492 double a = 4., b = 3.2, out;
3493 adouble ad, bd;
3494
3495 trace_on(1);
3496 ad <<= a;
3497 bd <<= b;
3498
3499 ad = fmax(ad, bd);
3500
3501 ad >>= out;
3502 trace_off();
3503
3504 double aDerivative = 1.;
3505 double bDerivative = 0.;
3506 a = std::fmax(a, b);
3507
3508 double *x = myalloc1(2);
3509 double *xd = myalloc1(2);
3510 double *y = myalloc1(1);
3511 double *yd = myalloc1(1);
3512
3513 /* Test partial derivative wrt a. */
3514 *x = 4.;
3515 *(x + 1) = 3.2;
3516 *xd = 1.;
3517 *(xd + 1) = 0.;
3518
3519 fos_forward(1, 1, 2, 0, x, xd, y, yd);
3520
3521 BOOST_TEST(*y == a, tt::tolerance(tol));
3522 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
3523
3524 /* Test partial derivative wrt b. */
3525 *xd = 0.;
3526 *(xd + 1) = 1.;
3527
3528 fos_forward(1, 1, 2, 0, x, xd, y, yd);
3529
3530 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
3531
3532 myfree1(x);
3533 myfree1(xd);
3534 myfree1(y);
3535 myfree1(yd);
3536
3537 /* Test derivative value for a = b. */
3538 double *x1 = myalloc1(2);
3539 double *xd1 = myalloc1(2);
3540 double *y1 = myalloc1(1);
3541 double *yd1 = myalloc1(1);
3542
3543 *x1 = 2.5;
3544 *(x1 + 1) = 2.5;
3545 *xd1 = 1.3;
3546 *(xd1 + 1) = 3.7;
3547
3548 fos_forward(1, 1, 2, 0, x1, xd1, y1, yd1);
3549
3550 BOOST_TEST(*y1 == 2.5, tt::tolerance(tol));
3551 BOOST_TEST(*yd1 == 3.7, tt::tolerance(tol));
3552
3553 myfree1(x1);
3554 myfree1(xd1);
3555 myfree1(y1);
3556 myfree1(yd1);
3557 }
3558
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_1)3559 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_1)
3560 {
3561 double a = 4., b = 3.2, out;
3562 adouble ad, bd;
3563
3564 trace_on(1, 1);
3565 ad <<= a;
3566 bd <<= b;
3567
3568 ad = fmax(ad, bd);
3569
3570 ad >>= out;
3571 trace_off();
3572
3573 double aDerivative = 1.;
3574 double bDerivative = 0.;
3575
3576 double *u = myalloc1(1);
3577 double *z = myalloc1(2);
3578
3579 *u = 1.;
3580
3581 fos_reverse(1, 1, 2, u, z);
3582
3583 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3584 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
3585
3586 myfree1(u);
3587 myfree1(z);
3588
3589 /* Test reverse derivative value for a = b. */
3590 double a1 = 2.5, b1 = 2.5, out1;
3591 adouble ad1, bd1;
3592
3593 trace_on(1, 1);
3594 ad1 <<= a1;
3595 bd1 <<= b1;
3596
3597 ad1 = fmax(ad1, bd1);
3598
3599 ad1 >>= out1;
3600 trace_off();
3601
3602 double *u1 = myalloc1(1);
3603 double *z1 = myalloc1(2);
3604
3605 *u1 = 1.;
3606
3607 fos_reverse(1, 1, 2, u1, z1);
3608
3609 BOOST_TEST(*z1 == 0.5, tt::tolerance(tol));
3610 BOOST_TEST(*(z1 + 1) == 0.5, tt::tolerance(tol));
3611
3612 myfree1(u1);
3613 myfree1(z1);
3614 }
3615
BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_2)3616 BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_2)
3617 {
3618 double a = 4., b = 3.2, bout;
3619 adouble bd;
3620
3621 trace_on(1);
3622 bd <<= b;
3623
3624 bd = fmax(a, bd);
3625
3626 bd >>= bout;
3627 trace_off();
3628
3629 b = std::fmax(a, b);
3630
3631 BOOST_TEST(bout == b, tt::tolerance(tol));
3632
3633 double *x = myalloc1(1);
3634 double *y = myalloc1(1);
3635
3636 *x = 3.2;
3637
3638 zos_forward(1, 1, 1, 0, x, y);
3639
3640 BOOST_TEST(*y == b, tt::tolerance(tol));
3641
3642 myfree1(x);
3643 myfree1(y);
3644 }
3645
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_2)3646 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_2)
3647 {
3648 double a = 4., b = 3.2, bout;
3649 adouble bd;
3650
3651 trace_on(1);
3652 bd <<= b;
3653
3654 bd = fmax(a, bd);
3655
3656 bd >>= bout;
3657 trace_off();
3658
3659 /* Derivative value is 0.0, as the active variable is smaller than the passive one. */
3660 double bDerivative = 0.;
3661 b = std::fmax(a, b);
3662
3663 double *x = myalloc1(1);
3664 double *xd = myalloc1(1);
3665 double *y = myalloc1(1);
3666 double *yd = myalloc1(1);
3667
3668 *x = 3.2;
3669 *xd = 1.;
3670
3671 fos_forward(1, 1, 1, 0, x, xd, y, yd);
3672
3673 BOOST_TEST(*y == b, tt::tolerance(tol));
3674 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
3675
3676 myfree1(x);
3677 myfree1(xd);
3678 myfree1(y);
3679 myfree1(yd);
3680
3681 /* Test derivative calculation for a = b. */
3682 double a1 = 2.5, b1 = 2.5, bout1;
3683 adouble bd1;
3684
3685 trace_on(1);
3686 bd1 <<= b1;
3687
3688 bd1 = fmax(a1, bd1);
3689
3690 bd1 >>= bout1;
3691 trace_off();
3692
3693 double b1Derivative = 0.;
3694 b1 = std::fmax(a1, b1);
3695
3696 double *x1 = myalloc1(1);
3697 double *xd1 = myalloc1(1);
3698 double *y1 = myalloc1(1);
3699 double *yd1 = myalloc1(1);
3700
3701 *x1 = 2.5;
3702 *xd1 = -1.3;
3703
3704 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
3705
3706 BOOST_TEST(*y1 == b1, tt::tolerance(tol));
3707 BOOST_TEST(*yd1 == b1Derivative, tt::tolerance(tol));
3708
3709 *xd1 = 3.7;
3710 b1Derivative = 3.7;
3711
3712 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
3713
3714 BOOST_TEST(*y1 == b1, tt::tolerance(tol));
3715 BOOST_TEST(*yd1 == b1Derivative, tt::tolerance(tol));
3716
3717 myfree1(x1);
3718 myfree1(xd1);
3719 myfree1(y1);
3720 myfree1(yd1);
3721 }
3722
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_2)3723 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_2)
3724 {
3725 double a = 4., b = 3.2, bout;
3726 adouble bd;
3727
3728 trace_on(1, 1);
3729 bd <<= b;
3730
3731 bd = fmax(a, bd);
3732
3733 bd >>= bout;
3734 trace_off();
3735
3736 double bDerivative = 0.;
3737 b = std::fmax(a, b);
3738
3739 double *u = myalloc1(1);
3740 double *z = myalloc1(1);
3741
3742 *u = 1.;
3743
3744 fos_reverse(1, 1, 1, u, z);
3745
3746 BOOST_TEST(*z == bDerivative, tt::tolerance(tol));
3747
3748 myfree1(u);
3749 myfree1(z);
3750
3751 /* Test derivative calculation for a = b. */
3752 double a1 = 2.5, b1 = 2.5, bout1;
3753 adouble bd1;
3754
3755 trace_on(1, 1);
3756 bd1 <<= b1;
3757
3758 bd1 = fmax(a1, bd1);
3759
3760 bd1 >>= bout1;
3761 trace_off();
3762
3763 double b1Derivative = 0.5;
3764 b1 = std::fmax(a1, b1);
3765
3766 double *u1 = myalloc1(1);
3767 double *z1 = myalloc1(1);
3768
3769 *u1 = 1.;
3770
3771 fos_reverse(1, 1, 1, u1, z1);
3772
3773 BOOST_TEST(*z1 == b1Derivative, tt::tolerance(tol));
3774
3775 myfree1(u1);
3776 myfree1(z1);
3777 }
3778
BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_3)3779 BOOST_AUTO_TEST_CASE(FmaxOperator_ZOS_Forward_3)
3780 {
3781 double a = 4., b = 3.2, aout;
3782 adouble ad;
3783
3784 trace_on(1);
3785 ad <<= a;
3786
3787 ad = fmax(ad, b);
3788
3789 ad >>= aout;
3790 trace_off();
3791
3792 a = std::fmax(a, b);
3793
3794 BOOST_TEST(aout == a, tt::tolerance(tol));
3795
3796 double *x = myalloc1(1);
3797 double *y = myalloc1(1);
3798
3799 *x = 4.;
3800
3801 zos_forward(1, 1, 1, 0, x, y);
3802
3803 BOOST_TEST(*y == a, tt::tolerance(tol));
3804
3805 myfree1(x);
3806 myfree1(y);
3807 }
3808
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_3)3809 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Forward_3)
3810 {
3811 double a = 4., b = 3.2, aout;
3812 adouble ad;
3813
3814 trace_on(1);
3815 ad <<= a;
3816
3817 ad = fmax(ad, b);
3818
3819 ad >>= aout;
3820 trace_off();
3821
3822 /* Derivative value is 1.0, as the active variable is grater than the passive one. */
3823 double aDerivative = 1.;
3824 a = std::fmax(a, b);
3825
3826 double *x = myalloc1(1);
3827 double *xd = myalloc1(1);
3828 double *y = myalloc1(1);
3829 double *yd = myalloc1(1);
3830
3831 *x = 4.;
3832 *xd = 1.;
3833
3834 fos_forward(1, 1, 1, 0, x, xd, y, yd);
3835
3836 BOOST_TEST(*y == a, tt::tolerance(tol));
3837 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
3838
3839 myfree1(x);
3840 myfree1(xd);
3841 myfree1(y);
3842 myfree1(yd);
3843
3844 /* Test derivative calculation for a = b. */
3845 double a1 = 2.5, b1 = 2.5, aout1;
3846 adouble ad1;
3847
3848 trace_on(1);
3849 ad1 <<= a1;
3850
3851 ad1 = fmax(ad1, b1);
3852
3853 ad1 >>= aout1;
3854 trace_off();
3855
3856 double a1Derivative = 0.;
3857 a1 = std::fmax(a1, b1);
3858
3859 double *x1 = myalloc1(1);
3860 double *xd1 = myalloc1(1);
3861 double *y1 = myalloc1(1);
3862 double *yd1 = myalloc1(1);
3863
3864 *x1 = 2.5;
3865 *xd1 = -1.3;
3866
3867 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
3868
3869 BOOST_TEST(*y1 == a1, tt::tolerance(tol));
3870 BOOST_TEST(*yd1 == a1Derivative, tt::tolerance(tol));
3871
3872 *xd1 = 3.7;
3873 a1Derivative = 3.7;
3874
3875 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
3876
3877 BOOST_TEST(*y1 == a1, tt::tolerance(tol));
3878 BOOST_TEST(*yd1 == a1Derivative, tt::tolerance(tol));
3879
3880 myfree1(x1);
3881 myfree1(xd1);
3882 myfree1(y1);
3883 myfree1(yd1);
3884 }
3885
BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_3)3886 BOOST_AUTO_TEST_CASE(FmaxOperator_FOS_Reverse_3)
3887 {
3888 double a = 4., b = 3.2, aout;
3889 adouble ad;
3890
3891 trace_on(1, 1);
3892 ad <<= a;
3893
3894 ad = fmax(ad, b);
3895
3896 ad >>= aout;
3897 trace_off();
3898
3899 double aDerivative = 1.;
3900 a = std::fmax(a, b);
3901
3902 double *u = myalloc1(1);
3903 double *z = myalloc1(1);
3904
3905 *u = 1.;
3906
3907 fos_reverse(1, 1, 1, u, z);
3908
3909 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
3910
3911 myfree1(u);
3912 myfree1(z);
3913
3914 /* Test derivative calculation for a = b. */
3915 double a1 = 2.5, b1 = 2.5, aout1;
3916 adouble ad1;
3917
3918 trace_on(1, 1);
3919 ad1 <<= a1;
3920
3921 ad1 = fmax(ad1, b1);
3922
3923 ad1 >>= aout1;
3924 trace_off();
3925
3926 double a1Derivative = 0.5;
3927 a1 = std::fmax(a1, b1);
3928
3929 double *u1 = myalloc1(1);
3930 double *z1 = myalloc1(1);
3931
3932 *u1 = 1.;
3933
3934 fos_reverse(1, 1, 1, u1, z1);
3935
3936 BOOST_TEST(*z1 == a1Derivative, tt::tolerance(tol));
3937
3938 myfree1(u1);
3939 myfree1(z1);
3940 }
3941
BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_1)3942 BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_1)
3943 {
3944 double a = 4., b = 3.2, out;
3945 adouble ad, bd;
3946
3947 trace_on(1);
3948 ad <<= a;
3949 bd <<= b;
3950
3951 ad = fmin(ad, bd);
3952
3953 ad >>= out;
3954 trace_off();
3955
3956 a = std::fmin(a, b);
3957
3958 BOOST_TEST(out == a, tt::tolerance(tol));
3959
3960 double *x = myalloc1(2);
3961 double *y = myalloc1(1);
3962
3963 *x = 4.;
3964 *(x + 1) = 3.2;
3965
3966 zos_forward(1, 1, 2, 0, x, y);
3967
3968 BOOST_TEST(*y == a, tt::tolerance(tol));
3969
3970 myfree1(x);
3971 myfree1(y);
3972 }
3973
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_1)3974 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_1)
3975 {
3976 double a = 4., b = 3.2, out;
3977 adouble ad, bd;
3978
3979 trace_on(1);
3980 ad <<= a;
3981 bd <<= b;
3982
3983 ad = fmin(ad, bd);
3984
3985 ad >>= out;
3986 trace_off();
3987
3988 double aDerivative = 0.;
3989 double bDerivative = 1.;
3990 a = std::fmin(a, b);
3991
3992 double *x = myalloc1(2);
3993 double *xd = myalloc1(2);
3994 double *y = myalloc1(1);
3995 double *yd = myalloc1(1);
3996
3997 /* Test partial derivative wrt a. */
3998 *x = 4.;
3999 *(x + 1) = 3.2;
4000 *xd = 1.;
4001 *(xd + 1) = 0.;
4002
4003 fos_forward(1, 1, 2, 0, x, xd, y, yd);
4004
4005 BOOST_TEST(*y == a, tt::tolerance(tol));
4006 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4007
4008 /* Test partial derivative wrt b. */
4009 *xd = 0.;
4010 *(xd + 1) = 1.;
4011
4012 fos_forward(1, 1, 2, 0, x, xd, y, yd);
4013
4014 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
4015
4016 myfree1(x);
4017 myfree1(xd);
4018 myfree1(y);
4019 myfree1(yd);
4020
4021 /* Test derivative value for a = b. */
4022 double *x1 = myalloc1(2);
4023 double *xd1 = myalloc1(2);
4024 double *y1 = myalloc1(1);
4025 double *yd1 = myalloc1(1);
4026
4027 *x1 = 2.5;
4028 *(x1 + 1) = 2.5;
4029 *xd1 = 1.3;
4030 *(xd1 + 1) = 3.7;
4031
4032 fos_forward(1, 1, 2, 0, x1, xd1, y1, yd1);
4033
4034 BOOST_TEST(*y1 == 2.5, tt::tolerance(tol));
4035 BOOST_TEST(*yd1 == 1.3, tt::tolerance(tol));
4036
4037 myfree1(x1);
4038 myfree1(xd1);
4039 myfree1(y1);
4040 myfree1(yd1);
4041 }
4042
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_1)4043 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_1)
4044 {
4045 double a = 4., b = 3.2, out;
4046 adouble ad, bd;
4047
4048 trace_on(1, 1);
4049 ad <<= a;
4050 bd <<= b;
4051
4052 ad = fmin(ad, bd);
4053
4054 ad >>= out;
4055 trace_off();
4056
4057 double aDerivative = 0.;
4058 double bDerivative = 1.;
4059
4060 double *u = myalloc1(1);
4061 double *z = myalloc1(2);
4062
4063 *u = 1.;
4064
4065 fos_reverse(1, 1, 2, u, z);
4066
4067 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4068 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
4069
4070 myfree1(u);
4071 myfree1(z);
4072
4073 /* Test reverse derivative value for a = b. */
4074 double a1 = 2.5, b1 = 2.5, out1;
4075 adouble ad1, bd1;
4076
4077 trace_on(1, 1);
4078 ad1 <<= a1;
4079 bd1 <<= b1;
4080
4081 ad1 = fmin(ad1, bd1);
4082
4083 ad1 >>= out1;
4084 trace_off();
4085
4086 double *u1 = myalloc1(1);
4087 double *z1 = myalloc1(2);
4088
4089 *u1 = 1.;
4090
4091 fos_reverse(1, 1, 2, u1, z1);
4092
4093 BOOST_TEST(*z1 == 0.5, tt::tolerance(tol));
4094 BOOST_TEST(*(z1 + 1) == 0.5, tt::tolerance(tol));
4095
4096 myfree1(u1);
4097 myfree1(z1);
4098 }
4099
BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_2)4100 BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_2)
4101 {
4102 double a = 4., b = 3.2, bout;
4103 adouble bd;
4104
4105 trace_on(1);
4106 bd <<= b;
4107
4108 bd = fmin(a, bd);
4109
4110 bd >>= bout;
4111 trace_off();
4112
4113 b = std::fmin(a, b);
4114
4115 BOOST_TEST(bout == b, tt::tolerance(tol));
4116
4117 double *x = myalloc1(1);
4118 double *y = myalloc1(1);
4119
4120 *x = 3.2;
4121
4122 zos_forward(1, 1, 1, 0, x, y);
4123
4124 BOOST_TEST(*y == b, tt::tolerance(tol));
4125
4126 myfree1(x);
4127 myfree1(y);
4128 }
4129
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_2)4130 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_2)
4131 {
4132 double a = 4., b = 3.2, bout;
4133 adouble bd;
4134
4135 trace_on(1);
4136 bd <<= b;
4137
4138 bd = fmin(a, bd);
4139
4140 bd >>= bout;
4141 trace_off();
4142
4143 /* Derivative value is 1.0, as the active variable is smaller than the passive one. */
4144 double bDerivative = 1.;
4145 b = std::fmin(a, b);
4146
4147 double *x = myalloc1(1);
4148 double *xd = myalloc1(1);
4149 double *y = myalloc1(1);
4150 double *yd = myalloc1(1);
4151
4152 *x = 3.2;
4153 *xd = 1.;
4154
4155 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4156
4157 BOOST_TEST(*y == b, tt::tolerance(tol));
4158 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
4159
4160 myfree1(x);
4161 myfree1(xd);
4162 myfree1(y);
4163 myfree1(yd);
4164
4165 /* Test derivative calculation for a = b. */
4166 double a1 = 2.5, b1 = 2.5, bout1;
4167 adouble bd1;
4168
4169 trace_on(1);
4170 bd1 <<= b1;
4171
4172 bd1 = fmin(a1, bd1);
4173
4174 bd1 >>= bout1;
4175 trace_off();
4176
4177 double b1Derivative = -1.3;
4178 b1 = std::fmin(a1, b1);
4179
4180 double *x1 = myalloc1(1);
4181 double *xd1 = myalloc1(1);
4182 double *y1 = myalloc1(1);
4183 double *yd1 = myalloc1(1);
4184
4185 *x1 = 2.5;
4186 *xd1 = -1.3;
4187
4188 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
4189
4190 BOOST_TEST(*y1 == b1, tt::tolerance(tol));
4191 BOOST_TEST(*yd1 == b1Derivative, tt::tolerance(tol));
4192
4193 *xd1 = 3.7;
4194 b1Derivative = 0.;
4195
4196 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
4197
4198 BOOST_TEST(*y1 == b1, tt::tolerance(tol));
4199 BOOST_TEST(*yd1 == b1Derivative, tt::tolerance(tol));
4200
4201 myfree1(x1);
4202 myfree1(xd1);
4203 myfree1(y1);
4204 myfree1(yd1);
4205 }
4206
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_2)4207 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_2)
4208 {
4209 double a = 4., b = 3.2, bout;
4210 adouble bd;
4211
4212 trace_on(1, 1);
4213 bd <<= b;
4214
4215 bd = fmin(a, bd);
4216
4217 bd >>= bout;
4218 trace_off();
4219
4220 double bDerivative = 1.;
4221 b = std::fmin(a, b);
4222
4223 double *u = myalloc1(1);
4224 double *z = myalloc1(1);
4225
4226 *u = 1.;
4227
4228 fos_reverse(1, 1, 1, u, z);
4229
4230 BOOST_TEST(*z == bDerivative, tt::tolerance(tol));
4231
4232 myfree1(u);
4233 myfree1(z);
4234
4235 /* Test derivative calculation for a = b. */
4236 double a1 = 2.5, b1 = 2.5, bout1;
4237 adouble bd1;
4238
4239 trace_on(1, 1);
4240 bd1 <<= b1;
4241
4242 bd1 = fmin(a1, bd1);
4243
4244 bd1 >>= bout1;
4245 trace_off();
4246
4247 double b1Derivative = 0.5;
4248 b1 = std::fmin(a1, b1);
4249
4250 double *u1 = myalloc1(1);
4251 double *z1 = myalloc1(1);
4252
4253 *u1 = 1.;
4254
4255 fos_reverse(1, 1, 1, u1, z1);
4256
4257 BOOST_TEST(*z1 == b1Derivative, tt::tolerance(tol));
4258
4259 myfree1(u1);
4260 myfree1(z1);
4261 }
4262
BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_3)4263 BOOST_AUTO_TEST_CASE(FminOperator_ZOS_Forward_3)
4264 {
4265 double a = 4., b = 3.2, aout;
4266 adouble ad;
4267
4268 trace_on(1);
4269 ad <<= a;
4270
4271 ad = fmin(ad, b);
4272
4273 ad >>= aout;
4274 trace_off();
4275
4276 a = std::fmin(a, b);
4277
4278 BOOST_TEST(aout == a, tt::tolerance(tol));
4279
4280 double *x = myalloc1(1);
4281 double *y = myalloc1(1);
4282
4283 *x = 4.;
4284
4285 zos_forward(1, 1, 1, 0, x, y);
4286
4287 BOOST_TEST(*y == a, tt::tolerance(tol));
4288
4289 myfree1(x);
4290 myfree1(y);
4291 }
4292
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_3)4293 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Forward_3)
4294 {
4295 double a = 4., b = 3.2, aout;
4296 adouble ad;
4297
4298 trace_on(1);
4299 ad <<= a;
4300
4301 ad = fmin(ad, b);
4302
4303 ad >>= aout;
4304 trace_off();
4305
4306 /* Derivative value is 0.0, as the active variable is grater than the passive one. */
4307 double aDerivative = 0.;
4308 a = std::fmin(a, b);
4309
4310 double *x = myalloc1(1);
4311 double *xd = myalloc1(1);
4312 double *y = myalloc1(1);
4313 double *yd = myalloc1(1);
4314
4315 *x = 4.;
4316 *xd = 1.;
4317
4318 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4319
4320 BOOST_TEST(*y == a, tt::tolerance(tol));
4321 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4322
4323 myfree1(x);
4324 myfree1(xd);
4325 myfree1(y);
4326 myfree1(yd);
4327
4328 /* Test derivative calculation for a = b. */
4329 double a1 = 2.5, b1 = 2.5, aout1;
4330 adouble ad1;
4331
4332 trace_on(1);
4333 ad1 <<= a1;
4334
4335 ad1 = fmin(ad1, b1);
4336
4337 ad1 >>= aout1;
4338 trace_off();
4339
4340 double a1Derivative = -1.3;
4341 a1 = std::fmin(a1, b1);
4342
4343 double *x1 = myalloc1(1);
4344 double *xd1 = myalloc1(1);
4345 double *y1 = myalloc1(1);
4346 double *yd1 = myalloc1(1);
4347
4348 *x1 = 2.5;
4349 *xd1 = -1.3;
4350
4351 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
4352
4353 BOOST_TEST(*y1 == a1, tt::tolerance(tol));
4354 BOOST_TEST(*yd1 == a1Derivative, tt::tolerance(tol));
4355
4356 *xd1 = 3.7;
4357 a1Derivative = 0.;
4358
4359 fos_forward(1, 1, 1, 0, x1, xd1, y1, yd1);
4360
4361 BOOST_TEST(*y1 == a1, tt::tolerance(tol));
4362 BOOST_TEST(*yd1 == a1Derivative, tt::tolerance(tol));
4363
4364 myfree1(x1);
4365 myfree1(xd1);
4366 myfree1(y1);
4367 myfree1(yd1);
4368 }
4369
BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_3)4370 BOOST_AUTO_TEST_CASE(FminOperator_FOS_Reverse_3)
4371 {
4372 double a = 4., b = 3.2, aout;
4373 adouble ad;
4374
4375 trace_on(1, 1);
4376 ad <<= a;
4377
4378 ad = fmin(ad, b);
4379
4380 ad >>= aout;
4381 trace_off();
4382
4383 double aDerivative = 0.;
4384 a = std::fmin(a, b);
4385
4386 double *u = myalloc1(1);
4387 double *z = myalloc1(1);
4388
4389 *u = 1.;
4390
4391 fos_reverse(1, 1, 1, u, z);
4392
4393 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4394
4395 myfree1(u);
4396 myfree1(z);
4397
4398 /* Test derivative calculation for a = b. */
4399 double a1 = 2.5, b1 = 2.5, aout1;
4400 adouble ad1;
4401
4402 trace_on(1, 1);
4403 ad1 <<= a1;
4404
4405 ad1 = fmin(ad1, b1);
4406
4407 ad1 >>= aout1;
4408 trace_off();
4409
4410 double a1Derivative = 0.5;
4411 a1 = std::fmin(a1, b1);
4412
4413 double *u1 = myalloc1(1);
4414 double *z1 = myalloc1(1);
4415
4416 *u1 = 1.;
4417
4418 fos_reverse(1, 1, 1, u1, z1);
4419
4420 BOOST_TEST(*z1 == a1Derivative, tt::tolerance(tol));
4421
4422 myfree1(u1);
4423 myfree1(z1);
4424 }
4425
4426 #if defined(ATRIG_ERF)
BOOST_AUTO_TEST_CASE(ErfOperator_ZOS_Forward)4427 BOOST_AUTO_TEST_CASE(ErfOperator_ZOS_Forward)
4428 {
4429 double a = 7.1, aout;
4430 adouble ad;
4431
4432 trace_on(1);
4433 ad <<= a;
4434
4435 ad = erf(ad);
4436
4437 ad >>= aout;
4438 trace_off();
4439
4440 a = std::erf(a);
4441
4442 BOOST_TEST(aout == a, tt::tolerance(tol));
4443
4444 double *x = myalloc1(1);
4445 double *y = myalloc1(1);
4446
4447 *x = 7.1;
4448
4449 zos_forward(1, 1, 1, 0, x, y);
4450
4451 BOOST_TEST(*y == a, tt::tolerance(tol));
4452
4453 myfree1(x);
4454 myfree1(y);
4455 }
4456
BOOST_AUTO_TEST_CASE(ErfOperator_FOS_Forward)4457 BOOST_AUTO_TEST_CASE(ErfOperator_FOS_Forward)
4458 {
4459 double a = 7.1, aout;
4460 adouble ad;
4461
4462 trace_on(1);
4463 ad <<= a;
4464
4465 ad = erf(ad);
4466
4467 ad >>= aout;
4468 trace_off();
4469
4470 double aDerivative = 2. / std::sqrt(std::acos(-1.)) * std::exp(-a * a);
4471 a = std::erf(a);
4472
4473 double *x = myalloc1(1);
4474 double *xd = myalloc1(1);
4475 double *y = myalloc1(1);
4476 double *yd = myalloc1(1);
4477
4478 *x = 7.1;
4479 *xd = 1.;
4480
4481 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4482
4483 BOOST_TEST(*y == a, tt::tolerance(tol));
4484 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4485
4486 myfree1(x);
4487 myfree1(xd);
4488 myfree1(y);
4489 myfree1(yd);
4490 }
4491
BOOST_AUTO_TEST_CASE(ErfOperator_FOS_Reverse)4492 BOOST_AUTO_TEST_CASE(ErfOperator_FOS_Reverse)
4493 {
4494 double a = 7.1, aout;
4495 adouble ad;
4496
4497 trace_on(1, 1);
4498 ad <<= a;
4499
4500 ad = erf(ad);
4501
4502 ad >>= aout;
4503 trace_off();
4504
4505 double aDerivative = 2. / std::sqrt(std::acos(-1.)) * std::exp(-a * a);
4506
4507 double *u = myalloc1(1);
4508 double *z = myalloc1(1);
4509
4510 *u = 1.;
4511
4512 fos_reverse(1, 1, 1, u, z);
4513
4514 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4515
4516 myfree1(u);
4517 myfree1(z);
4518 }
4519 #endif
4520
BOOST_AUTO_TEST_CASE(EqOperator_ZOS_Forward)4521 BOOST_AUTO_TEST_CASE(EqOperator_ZOS_Forward)
4522 {
4523 double a = 10.01, aout;
4524 adouble ad, bd;
4525
4526 trace_on(1);
4527 ad <<= a;
4528
4529 bd = ad;
4530
4531 bd >>= aout;
4532 trace_off();
4533
4534 BOOST_TEST(aout == a, tt::tolerance(tol));
4535
4536 double *x = myalloc1(1);
4537 double *y = myalloc1(1);
4538
4539 *x = 10.01;
4540
4541 zos_forward(1, 1, 1, 0, x, y);
4542
4543 BOOST_TEST(*y == a, tt::tolerance(tol));
4544
4545 myfree1(x);
4546 myfree1(y);
4547 }
4548
BOOST_AUTO_TEST_CASE(EqOperator_FOS_Forward)4549 BOOST_AUTO_TEST_CASE(EqOperator_FOS_Forward)
4550 {
4551 double a = 10.01, aout;
4552 adouble ad, bd;
4553
4554 trace_on(1);
4555 ad <<= a;
4556
4557 bd = ad;
4558
4559 bd >>= aout;
4560 trace_off();
4561
4562 double aDerivative = 1.;
4563
4564 double *x = myalloc1(1);
4565 double *xd = myalloc1(1);
4566 double *y = myalloc1(1);
4567 double *yd = myalloc1(1);
4568
4569 *x = 10.01;
4570 *xd = 1.;
4571
4572 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4573
4574 BOOST_TEST(*y == a, tt::tolerance(tol));
4575 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4576
4577 myfree1(x);
4578 myfree1(xd);
4579 myfree1(y);
4580 myfree1(yd);
4581 }
4582
BOOST_AUTO_TEST_CASE(EqOperator_FOS_Reverse)4583 BOOST_AUTO_TEST_CASE(EqOperator_FOS_Reverse)
4584 {
4585 double a = 10.01, aout;
4586 adouble ad, bd;
4587
4588 trace_on(1, 1);
4589 ad <<= a;
4590
4591 bd = ad;
4592
4593 bd >>= aout;
4594 trace_off();
4595
4596 double aDerivative = 1.;
4597
4598 double *u = myalloc1(1);
4599 double *z = myalloc1(1);
4600
4601 *u = 1.;
4602
4603 fos_reverse(1, 1, 1, u, z);
4604
4605 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4606
4607 myfree1(u);
4608 myfree1(z);
4609 }
4610
BOOST_AUTO_TEST_CASE(EqPlusOperator_ZOS_Forward)4611 BOOST_AUTO_TEST_CASE(EqPlusOperator_ZOS_Forward)
4612 {
4613 double a = 5.132, aout;
4614 adouble ad;
4615
4616 trace_on(1);
4617 ad <<= a;
4618
4619 ad += 5.2;
4620
4621 ad >>= aout;
4622 trace_off();
4623
4624 a += 5.2;
4625
4626 BOOST_TEST(aout == a, tt::tolerance(tol));
4627
4628 double *x = myalloc1(1);
4629 double *y = myalloc1(1);
4630
4631 *x = 5.132;
4632
4633 zos_forward(1, 1, 1, 0, x, y);
4634
4635 BOOST_TEST(*y == a, tt::tolerance(tol));
4636
4637 myfree1(x);
4638 myfree1(y);
4639 }
4640
BOOST_AUTO_TEST_CASE(EqPlusOperator_FOS_Forward)4641 BOOST_AUTO_TEST_CASE(EqPlusOperator_FOS_Forward)
4642 {
4643 double a = 5.132, aout;
4644 adouble ad;
4645
4646 trace_on(1);
4647 ad <<= a;
4648
4649 ad += 5.2;
4650
4651 ad >>= aout;
4652 trace_off();
4653
4654 a += 5.2;
4655 double aDerivative = 1.;
4656
4657 double *x = myalloc1(1);
4658 double *xd = myalloc1(1);
4659 double *y = myalloc1(1);
4660 double *yd = myalloc1(1);
4661
4662 *x = 5.132;
4663 *xd = 1.;
4664
4665 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4666
4667 BOOST_TEST(*y == a, tt::tolerance(tol));
4668 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4669
4670 myfree1(x);
4671 myfree1(xd);
4672 myfree1(y);
4673 myfree1(yd);
4674 }
4675
BOOST_AUTO_TEST_CASE(EqPlusOperator_FOS_Reverse)4676 BOOST_AUTO_TEST_CASE(EqPlusOperator_FOS_Reverse)
4677 {
4678 double a = 5.132, aout;
4679 adouble ad;
4680
4681 trace_on(1, 1);
4682 ad <<= a;
4683
4684 ad += 5.2;
4685
4686 ad >>= aout;
4687 trace_off();
4688
4689 a += 5.2;
4690 double aDerivative = 1.;
4691
4692 double *u = myalloc1(1);
4693 double *z = myalloc1(1);
4694
4695 *u = 1.;
4696
4697 fos_reverse(1, 1, 1, u, z);
4698
4699 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4700
4701 myfree1(u);
4702 myfree1(z);
4703 }
4704
BOOST_AUTO_TEST_CASE(EqMinusOperator_ZOS_Forward)4705 BOOST_AUTO_TEST_CASE(EqMinusOperator_ZOS_Forward)
4706 {
4707 double a = 5.132, aout;
4708 adouble ad;
4709
4710 trace_on(1);
4711 ad <<= a;
4712
4713 ad -= 5.2;
4714
4715 ad >>= aout;
4716 trace_off();
4717
4718 a -= 5.2;
4719
4720 BOOST_TEST(aout == a, tt::tolerance(tol));
4721
4722 double *x = myalloc1(1);
4723 double *y = myalloc1(1);
4724
4725 *x = 5.132;
4726
4727 zos_forward(1, 1, 1, 0, x, y);
4728
4729 BOOST_TEST(*y == a, tt::tolerance(tol));
4730
4731 myfree1(x);
4732 myfree1(y);
4733 }
4734
BOOST_AUTO_TEST_CASE(EqMinusOperator_FOS_Forward)4735 BOOST_AUTO_TEST_CASE(EqMinusOperator_FOS_Forward)
4736 {
4737 double a = 5.132, aout;
4738 adouble ad;
4739
4740 trace_on(1);
4741 ad <<= a;
4742
4743 ad -= 5.2;
4744
4745 ad >>= aout;
4746 trace_off();
4747
4748 a -= 5.2;
4749 double aDerivative = 1.;
4750
4751 double *x = myalloc1(1);
4752 double *xd = myalloc1(1);
4753 double *y = myalloc1(1);
4754 double *yd = myalloc1(1);
4755
4756 *x = 5.132;
4757 *xd = 1.;
4758
4759 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4760
4761 BOOST_TEST(*y == a, tt::tolerance(tol));
4762 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4763
4764 myfree1(x);
4765 myfree1(xd);
4766 myfree1(y);
4767 myfree1(yd);
4768 }
4769
BOOST_AUTO_TEST_CASE(EqMinusOperator_FOS_Reverse)4770 BOOST_AUTO_TEST_CASE(EqMinusOperator_FOS_Reverse)
4771 {
4772 double a = 5.132, aout;
4773 adouble ad;
4774
4775 trace_on(1, 1);
4776 ad <<= a;
4777
4778 ad -= 5.2;
4779
4780 ad >>= aout;
4781 trace_off();
4782
4783 a -= 5.2;
4784 double aDerivative = 1.;
4785
4786 double *u = myalloc1(1);
4787 double *z = myalloc1(1);
4788
4789 *u = 1.;
4790
4791 fos_reverse(1, 1, 1, u, z);
4792
4793 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4794
4795 myfree1(u);
4796 myfree1(z);
4797 }
4798
BOOST_AUTO_TEST_CASE(EqTimesOperator_ZOS_Forward_1)4799 BOOST_AUTO_TEST_CASE(EqTimesOperator_ZOS_Forward_1)
4800 {
4801 double a = 5.132, aout;
4802 adouble ad;
4803
4804 trace_on(1);
4805 ad <<= a;
4806
4807 ad *= 5.2;
4808
4809 ad >>= aout;
4810 trace_off();
4811
4812 a *= 5.2;
4813
4814 BOOST_TEST(aout == a, tt::tolerance(tol));
4815
4816 double *x = myalloc1(1);
4817 double *y = myalloc1(1);
4818
4819 *x = 5.132;
4820
4821 zos_forward(1, 1, 1, 0, x, y);
4822
4823 BOOST_TEST(*y == a, tt::tolerance(tol));
4824
4825 myfree1(x);
4826 myfree1(y);
4827 }
4828
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Forward_1)4829 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Forward_1)
4830 {
4831 double a = 5.132, aout;
4832 adouble ad;
4833
4834 trace_on(1);
4835 ad <<= a;
4836
4837 ad *= 5.2;
4838
4839 ad >>= aout;
4840 trace_off();
4841
4842 a *= 5.2;
4843 double aDerivative = 5.2;
4844
4845 double *x = myalloc1(1);
4846 double *xd = myalloc1(1);
4847 double *y = myalloc1(1);
4848 double *yd = myalloc1(1);
4849
4850 *x = 5.132;
4851 *xd = 1.;
4852
4853 fos_forward(1, 1, 1, 0, x, xd, y, yd);
4854
4855 BOOST_TEST(*y == a, tt::tolerance(tol));
4856 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4857
4858 myfree1(x);
4859 myfree1(xd);
4860 myfree1(y);
4861 myfree1(yd);
4862 }
4863
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Reverse_1)4864 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Reverse_1)
4865 {
4866 double a = 5.132, aout;
4867 adouble ad;
4868
4869 trace_on(1, 1);
4870 ad <<= a;
4871
4872 ad *= 5.2;
4873
4874 ad >>= aout;
4875 trace_off();
4876
4877 a *= 5.2;
4878 double aDerivative = 5.2;
4879
4880 double *u = myalloc1(1);
4881 double *z = myalloc1(1);
4882
4883 *u = 1.;
4884
4885 fos_reverse(1, 1, 1, u, z);
4886
4887 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4888
4889 myfree1(u);
4890 myfree1(z);
4891 }
4892
BOOST_AUTO_TEST_CASE(EqTimesOperator_ZOS_Forward_2)4893 BOOST_AUTO_TEST_CASE(EqTimesOperator_ZOS_Forward_2)
4894 {
4895 double a = 5.132, b = 11.1, out;
4896 adouble ad, bd;
4897
4898 trace_on(1);
4899 ad <<= a;
4900 bd <<= b;
4901
4902 ad *= bd;
4903
4904 ad >>= out;
4905 trace_off();
4906
4907 a *= b;
4908
4909 BOOST_TEST(out == a, tt::tolerance(tol));
4910
4911 double *x = myalloc1(2);
4912 double *y = myalloc1(1);
4913
4914 *x = 5.132;
4915 *(x + 1) = 11.1;
4916
4917 zos_forward(1, 1, 2, 0, x, y);
4918
4919 BOOST_TEST(*y == a, tt::tolerance(tol));
4920
4921 myfree1(x);
4922 myfree1(y);
4923 }
4924
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Forward_2)4925 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Forward_2)
4926 {
4927 double a = 5.132, b = 11.1, out;
4928 adouble ad, bd;
4929
4930 trace_on(1);
4931 ad <<= a;
4932 bd <<= b;
4933
4934 ad *= bd;
4935
4936 ad >>= out;
4937 trace_off();
4938
4939 double aDerivative = b;
4940 double bDerivative = a;
4941 a *= b;
4942
4943 double *x = myalloc1(2);
4944 double *xd = myalloc1(2);
4945 double *y = myalloc1(1);
4946 double *yd = myalloc1(1);
4947
4948 /* Test partial derivative wrt a. */
4949 *x = 5.132;
4950 *(x + 1) = 11.1;
4951 *xd = 1.;
4952 *(xd + 1) = 0.;
4953
4954 fos_forward(1, 1, 2, 0, x, xd, y, yd);
4955
4956 BOOST_TEST(*y == a, tt::tolerance(tol));
4957 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
4958
4959 /* Test partial derivative wrt b. */
4960 *xd = 0.;
4961 *(xd + 1) = 1.;
4962
4963 fos_forward(1, 1, 2, 0, x, xd, y, yd);
4964
4965 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
4966
4967 myfree1(x);
4968 myfree1(xd);
4969 myfree1(y);
4970 myfree1(yd);
4971 }
4972
BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Reverse_2)4973 BOOST_AUTO_TEST_CASE(EqTimesOperator_FOS_Reverse_2)
4974 {
4975 double a = 5.132, b = 11.1, out;
4976 adouble ad, bd;
4977
4978 trace_on(1, 1);
4979 ad <<= a;
4980 bd <<= b;
4981
4982 ad *= bd;
4983
4984 ad >>= out;
4985 trace_off();
4986
4987 double aDerivative = b;
4988 double bDerivative = a;
4989
4990 double *u = myalloc1(1);
4991 double *z = myalloc1(2);
4992
4993 *u = 1.;
4994
4995 fos_reverse(1, 1, 2, u, z);
4996
4997 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
4998 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
4999
5000 myfree1(u);
5001 myfree1(z);
5002 }
5003
BOOST_AUTO_TEST_CASE(EqDivOperator_ZOS_Forward_1)5004 BOOST_AUTO_TEST_CASE(EqDivOperator_ZOS_Forward_1)
5005 {
5006 double a = 5.132, aout;
5007 adouble ad;
5008
5009 trace_on(1);
5010 ad <<= a;
5011
5012 ad /= 5.2;
5013
5014 ad >>= aout;
5015 trace_off();
5016
5017 a /= 5.2;
5018
5019 BOOST_TEST(aout == a, tt::tolerance(tol));
5020
5021 double *x = myalloc1(1);
5022 double *y = myalloc1(1);
5023
5024 *x = 5.132;
5025
5026 zos_forward(1, 1, 1, 0, x, y);
5027
5028 BOOST_TEST(*y == a, tt::tolerance(tol));
5029
5030 myfree1(x);
5031 myfree1(y);
5032 }
5033
BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Forward_1)5034 BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Forward_1)
5035 {
5036 double a = 5.132, aout;
5037 adouble ad;
5038
5039 trace_on(1);
5040 ad <<= a;
5041
5042 ad /= 5.2;
5043
5044 ad >>= aout;
5045 trace_off();
5046
5047 a /= 5.2;
5048 double aDerivative = 1. / 5.2;
5049
5050 double *x = myalloc1(1);
5051 double *xd = myalloc1(1);
5052 double *y = myalloc1(1);
5053 double *yd = myalloc1(1);
5054
5055 *x = 5.132;
5056 *xd = 1.;
5057
5058 fos_forward(1, 1, 1, 0, x, xd, y, yd);
5059
5060 BOOST_TEST(*y == a, tt::tolerance(tol));
5061 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
5062
5063 myfree1(x);
5064 myfree1(xd);
5065 myfree1(y);
5066 myfree1(yd);
5067 }
5068
BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Reverse_1)5069 BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Reverse_1)
5070 {
5071 double a = 5.132, aout;
5072 adouble ad;
5073
5074 trace_on(1, 1);
5075 ad <<= a;
5076
5077 ad /= 5.2;
5078
5079 ad >>= aout;
5080 trace_off();
5081
5082 a /= 5.2;
5083 double aDerivative = 1. / 5.2;
5084
5085 double *u = myalloc1(1);
5086 double *z = myalloc1(1);
5087
5088 *u = 1.;
5089
5090 fos_reverse(1, 1, 1, u, z);
5091
5092 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
5093
5094 myfree1(u);
5095 myfree1(z);
5096 }
5097
BOOST_AUTO_TEST_CASE(EqDivOperator_ZOS_Forward_2)5098 BOOST_AUTO_TEST_CASE(EqDivOperator_ZOS_Forward_2)
5099 {
5100 double a = 5.132, b = 11.1, out;
5101 adouble ad, bd;
5102
5103 trace_on(1);
5104 ad <<= a;
5105 bd <<= b;
5106
5107 ad /= bd;
5108
5109 ad >>= out;
5110 trace_off();
5111
5112 a /= b;
5113
5114 BOOST_TEST(out == a, tt::tolerance(tol));
5115
5116 double *x = myalloc1(2);
5117 double *y = myalloc1(1);
5118
5119 *x = 5.132;
5120 *(x + 1) = 11.1;
5121
5122 zos_forward(1, 1, 2, 0, x, y);
5123
5124 BOOST_TEST(*y == a, tt::tolerance(tol));
5125
5126 myfree1(x);
5127 myfree1(y);
5128 }
5129
BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Forward_2)5130 BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Forward_2)
5131 {
5132 double a = 5.132, b = 11.1, out;
5133 adouble ad, bd;
5134
5135 trace_on(1);
5136 ad <<= a;
5137 bd <<= b;
5138
5139 ad /= bd;
5140
5141 ad >>= out;
5142 trace_off();
5143
5144 double aDerivative = 1. / b;
5145 double bDerivative = -a / (b*b);
5146 a /= b;
5147
5148 double *x = myalloc1(2);
5149 double *xd = myalloc1(2);
5150 double *y = myalloc1(1);
5151 double *yd = myalloc1(1);
5152
5153 /* Test partial derivative wrt a. */
5154 *x = 5.132;
5155 *(x + 1) = 11.1;
5156 *xd = 1.;
5157 *(xd + 1) = 0.;
5158
5159 fos_forward(1, 1, 2, 0, x, xd, y, yd);
5160
5161 BOOST_TEST(*y == a, tt::tolerance(tol));
5162 BOOST_TEST(*yd == aDerivative, tt::tolerance(tol));
5163
5164 /* Test partial derivative wrt b. */
5165 *xd = 0.;
5166 *(xd + 1) = 1.;
5167
5168 fos_forward(1, 1, 2, 0, x, xd, y, yd);
5169
5170 BOOST_TEST(*yd == bDerivative, tt::tolerance(tol));
5171
5172 myfree1(x);
5173 myfree1(xd);
5174 myfree1(y);
5175 myfree1(yd);
5176 }
5177
BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Reverse_2)5178 BOOST_AUTO_TEST_CASE(EqDivOperator_FOS_Reverse_2)
5179 {
5180 double a = 5.132, b = 11.1, out;
5181 adouble ad, bd;
5182
5183 trace_on(1, 1);
5184 ad <<= a;
5185 bd <<= b;
5186
5187 ad /= bd;
5188
5189 ad >>= out;
5190 trace_off();
5191
5192 double aDerivative = 1. / b;
5193 double bDerivative = -a / (b*b);
5194
5195 double *u = myalloc1(1);
5196 double *z = myalloc1(2);
5197
5198 *u = 1.;
5199
5200 fos_reverse(1, 1, 2, u, z);
5201
5202 BOOST_TEST(*z == aDerivative, tt::tolerance(tol));
5203 BOOST_TEST(*(z + 1) == bDerivative, tt::tolerance(tol));
5204
5205 myfree1(u);
5206 myfree1(z);
5207 }
5208
BOOST_AUTO_TEST_CASE(CondassignOperator_ZOS_Forward)5209 BOOST_AUTO_TEST_CASE(CondassignOperator_ZOS_Forward)
5210 {
5211 double out;
5212 adouble cond, arg1, arg2;
5213 adouble p;
5214
5215 trace_on(1);
5216 cond <<= 1.;
5217 arg1 <<= 3.5;
5218 arg2 <<= 5.3;
5219
5220 condassign(p, cond, arg1, arg2);
5221
5222 p >>= out;
5223 trace_off();
5224
5225 BOOST_TEST(out == 3.5, tt::tolerance(tol));
5226
5227 double *x = myalloc1(3);
5228 double *y = myalloc1(1);
5229
5230 *x = 1.;
5231 *(x + 1) = 3.5;
5232 *(x + 2) = 5.3;
5233
5234 zos_forward(1, 1, 3, 0, x, y);
5235
5236 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
5237
5238 myfree1(x);
5239 myfree1(y);
5240 }
5241
BOOST_AUTO_TEST_CASE(CondassignOperator_FOS_Forward)5242 BOOST_AUTO_TEST_CASE(CondassignOperator_FOS_Forward)
5243 {
5244 double out;
5245 adouble cond, arg1, arg2;
5246 adouble p;
5247
5248 trace_on(1);
5249 cond <<= 1.;
5250 arg1 <<= 3.5;
5251 arg2 <<= 5.3;
5252
5253 condassign(p, cond, arg1, arg2);
5254
5255 p >>= out;
5256 trace_off();
5257
5258 BOOST_TEST(out == 3.5, tt::tolerance(tol));
5259
5260 double *x = myalloc1(3);
5261 double *xd = myalloc1(3);
5262 double *y = myalloc1(1);
5263 double *yd = myalloc1(1);
5264
5265 *x = 1.;
5266 *(x + 1) = 3.5;
5267 *(x + 2) = 5.3;
5268 *xd = 0.;
5269 *(xd + 1) = 0.1;
5270 *(xd + 2) = 0.2;
5271
5272 fos_forward(1, 1, 3, 0, x, xd, y, yd);
5273
5274 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
5275 BOOST_TEST(*yd == 0.1, tt::tolerance(tol));
5276
5277 myfree1(x);
5278 myfree1(xd);
5279 myfree1(y);
5280 myfree1(yd);
5281 }
5282 /*
5283 BOOST_AUTO_TEST_CASE(CondassignOperator_FOS_Reverse)
5284 {
5285 double out;
5286 adouble cond, arg1, arg2;
5287 adouble p;
5288
5289 trace_on(1);
5290 cond <<= 1.;
5291 arg1 <<= 3.5;
5292 arg2 <<= 5.3;
5293
5294 condassign(p, cond, arg1, arg2);
5295
5296 p >>= out;
5297 trace_off();
5298
5299 double aDerivative = 1.;
5300 double bDerivative = 0.;
5301
5302 double *u = myalloc1(1);
5303 double *z = myalloc1(3);
5304
5305 *u = 1.;
5306
5307 fos_reverse(1, 1, 3, u, z);
5308
5309 BOOST_TEST(*z == 0., tt::tolerance(tol));
5310 BOOST_TEST(*(z + 1) == aDerivative, tt::tolerance(tol));
5311 BOOST_TEST(*(z + 2) == bDerivative, tt::tolerance(tol));
5312
5313 myfree1(u);
5314 myfree1(z);
5315 }
5316 */
BOOST_AUTO_TEST_CASE(CondeqassignOperator_ZOS_Forward)5317 BOOST_AUTO_TEST_CASE(CondeqassignOperator_ZOS_Forward)
5318 {
5319 double out;
5320 adouble cond, arg1, arg2;
5321 adouble p;
5322
5323 trace_on(1);
5324 cond <<= 1.;
5325 arg1 <<= 3.5;
5326 arg2 <<= 5.3;
5327
5328 condeqassign(p, cond, arg1, arg2);
5329
5330 p >>= out;
5331 trace_off();
5332
5333 BOOST_TEST(out == 3.5, tt::tolerance(tol));
5334
5335 double *x = myalloc1(3);
5336 double *y = myalloc1(1);
5337
5338 *x = 1.;
5339 *(x + 1) = 3.5;
5340 *(x + 2) = 5.3;
5341
5342 zos_forward(1, 1, 3, 0, x, y);
5343
5344 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
5345
5346 myfree1(x);
5347 myfree1(y);
5348 }
5349
BOOST_AUTO_TEST_CASE(CondeqassignOperator_FOS_Forward)5350 BOOST_AUTO_TEST_CASE(CondeqassignOperator_FOS_Forward)
5351 {
5352 double out;
5353 adouble cond, arg1, arg2;
5354 adouble p;
5355
5356 trace_on(1);
5357 cond <<= 1.;
5358 arg1 <<= 3.5;
5359 arg2 <<= 5.3;
5360
5361 condeqassign(p, cond, arg1, arg2);
5362
5363 p >>= out;
5364 trace_off();
5365
5366 BOOST_TEST(out == 3.5, tt::tolerance(tol));
5367
5368 double *x = myalloc1(3);
5369 double *xd = myalloc1(3);
5370 double *y = myalloc1(1);
5371 double *yd = myalloc1(1);
5372
5373 *x = 1.;
5374 *(x + 1) = 3.5;
5375 *(x + 2) = 5.3;
5376 *xd = 0.;
5377 *(xd + 1) = 0.1;
5378 *(xd + 2) = 0.2;
5379
5380 fos_forward(1, 1, 3, 0, x, xd, y, yd);
5381
5382 BOOST_TEST(*y == 3.5, tt::tolerance(tol));
5383 BOOST_TEST(*yd == 0.1, tt::tolerance(tol));
5384
5385 myfree1(x);
5386 myfree1(xd);
5387 myfree1(y);
5388 myfree1(yd);
5389 }
5390 /*
5391 BOOST_AUTO_TEST_CASE(CondeqassignOperator_FOS_Reverse)
5392 {
5393 double out;
5394 adouble cond, arg1, arg2;
5395 adouble p;
5396
5397 trace_on(1);
5398 cond <<= 1.;
5399 arg1 <<= 3.5;
5400 arg2 <<= 5.3;
5401
5402 condeqassign(p, cond, arg1, arg2);
5403
5404 p >>= out;
5405 trace_off();
5406
5407 double aDerivative = 1.;
5408 double bDerivative = 0.;
5409
5410 double *u = myalloc1(1);
5411 double *z = myalloc1(3);
5412
5413 *u = 1.;
5414
5415 fos_reverse(1, 1, 3, u, z);
5416
5417 BOOST_TEST(*z == 0., tt::tolerance(tol));
5418 BOOST_TEST(*(z + 1) == aDerivative, tt::tolerance(tol));
5419 BOOST_TEST(*(z + 2) == bDerivative, tt::tolerance(tol));
5420
5421 myfree1(u);
5422 myfree1(z);
5423 }
5424 */
5425
5426 /* Boolean operations only alter the trace, if advanced branching is
5427 * activated. This advanced branching is not tested here.
5428 */
5429
BOOST_AUTO_TEST_CASE(TraceNotOperatorPrimal)5430 BOOST_AUTO_TEST_CASE(TraceNotOperatorPrimal)
5431 {
5432 double a = 1.0;
5433 adouble ad = a;
5434
5435 BOOST_TEST(!a == 0.0, tt::tolerance(tol));
5436 }
5437
BOOST_AUTO_TEST_CASE(TraceCompNeqOperatorPrimal)5438 BOOST_AUTO_TEST_CASE(TraceCompNeqOperatorPrimal)
5439 {
5440 double a = 1.5, b = 0.5;
5441 adouble ad = a, bd = b;
5442
5443 int n = (ad != bd);
5444 int m = (a != b);
5445
5446 BOOST_TEST(n == m, tt::tolerance(tol));
5447
5448 int k = (ad != a);
5449 int l = (a != a);
5450
5451 BOOST_TEST(k == l, tt::tolerance(tol));
5452 }
5453
BOOST_AUTO_TEST_CASE(TraceCompEqOperatorPrimal)5454 BOOST_AUTO_TEST_CASE(TraceCompEqOperatorPrimal)
5455 {
5456 double a = 0.5, b = 1.5;
5457 adouble ad = a, bd = b;
5458
5459 int n = (ad == bd);
5460 int m = (a == b);
5461
5462 BOOST_TEST(n == m, tt::tolerance(tol));
5463
5464 int k = (ad == a);
5465 int l = (a == a);
5466
5467 BOOST_TEST(k == l, tt::tolerance(tol));
5468 }
5469
BOOST_AUTO_TEST_CASE(TraceCompLeqOperatorPrimal)5470 BOOST_AUTO_TEST_CASE(TraceCompLeqOperatorPrimal)
5471 {
5472 double a = 1.0, b = 0.99;
5473 adouble ad = a, bd = b;
5474
5475 int n = (ad <= bd);
5476 int m = (a <= b);
5477
5478 BOOST_TEST(n == m, tt::tolerance(tol));
5479
5480 int k = (ad <= a);
5481 int l = (a <= a);
5482
5483 BOOST_TEST(k == l, tt::tolerance(tol));
5484 }
5485
BOOST_AUTO_TEST_CASE(TraceCompGeqOperatorPrimal)5486 BOOST_AUTO_TEST_CASE(TraceCompGeqOperatorPrimal)
5487 {
5488 double a = 1.2, b = 2.5;
5489 adouble ad = a, bd = b;
5490
5491 int n = (ad >= bd);
5492 int m = (a >= b);
5493
5494 BOOST_TEST(n == m, tt::tolerance(tol));
5495
5496 int k = (ad >= a);
5497 int l = (a >= a);
5498
5499 BOOST_TEST(k == l, tt::tolerance(tol));
5500 }
5501
BOOST_AUTO_TEST_CASE(TraceCompLeOperatorPrimal)5502 BOOST_AUTO_TEST_CASE(TraceCompLeOperatorPrimal)
5503 {
5504 double a = 1.1, b = 1.1;
5505 adouble ad = a, bd = b;
5506
5507 int n = (ad < bd);
5508 int m = (a < b);
5509
5510 BOOST_TEST(n == m, tt::tolerance(tol));
5511
5512 int k = (ad < a);
5513 int l = (a < a);
5514
5515 BOOST_TEST(k == l, tt::tolerance(tol));
5516 }
5517
BOOST_AUTO_TEST_CASE(TraceCompGeOperatorPrimal)5518 BOOST_AUTO_TEST_CASE(TraceCompGeOperatorPrimal)
5519 {
5520 double a = 1.7, b = 7.5;
5521 adouble ad = a, bd = b;
5522
5523 int n = (ad > bd);
5524 int m = (a > b);
5525
5526 BOOST_TEST(n == m, tt::tolerance(tol));
5527
5528 int k = (ad > a);
5529 int l = (a > a);
5530
5531 BOOST_TEST(k == l, tt::tolerance(tol));
5532 }
5533
5534 /* Implementation of PowOperator_FOS_Reverse_1 does not work. Why?
5535 * Apparently, PowOperator_FOS_Reverse_3 works fine (for some reason...).
5536 * Also, the implementations for LdexpOperator_1 and LdexpOperator_3 do
5537 * not work. It seems, that no implementations of ldexp(double, adouble)
5538 * and ldexp(adouble, adouble) exist.
5539 * Implementation for CondeqassignOperator_FOS_Reverse and
5540 * CondassignOperator_FOS_Reverse do not work either (same error message)
5541 * as for PowOperator_FOS_Reverse_1...).
5542 */
5543
5544 /* What does reverse mode do for fmax(), fmin() with a = b? */
5545
5546
5547 BOOST_AUTO_TEST_SUITE_END()
5548
5549
5550
5551
5552