Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
FadUnitTests2.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Sacado Package
5 // Copyright (2006) Sandia Corporation
6 //
7 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8 // the U.S. Government retains certain rights in this software.
9 //
10 // This library is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU Lesser General Public License as
12 // published by the Free Software Foundation; either version 2.1 of the
13 // License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
23 // USA
24 // Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
25 // (etphipp@sandia.gov).
26 //
27 // ***********************************************************************
28 // @HEADER
29 
30 #ifndef FADUNITTESTS2_HPP
31 #define FADUNITTESTS2_HPP
32 
33 // Sacado includes
34 #include "Sacado_No_Kokkos.hpp"
35 #include "Sacado_Random.hpp"
36 
37 // Cppunit includes
38 #include <cppunit/extensions/HelperMacros.h>
39 
40 #define COMPARE_VALUES(a, b) \
41  CPPUNIT_ASSERT( std::abs(a-b) < this->tol_a + this->tol_r*std::abs(a) );
42 
43 #define COMPARE_FADS(a, b) \
44 CPPUNIT_ASSERT(a.size() == b.size()); \
45 CPPUNIT_ASSERT(a.hasFastAccess() == b.hasFastAccess()); \
46 COMPARE_VALUES(a.val(), b.val()); \
47 for (int i=0; i<a.size(); i++) { \
48  COMPARE_VALUES(a.dx(i), b.dx(i)); \
49  COMPARE_VALUES(a.fastAccessDx(i), b.fastAccessDx(i)); \
50  } \
51  ;
52 
53 // A class for testing each Fad operation based on hand-coded derivatives.
54 // Only those operations that are defined for both real and complex
55 // types are tested here. The others are tested below
56 template <class FadType, class ScalarType>
57 class FadOpsUnitTest2 : public CppUnit::TestFixture {
58 
59  CPPUNIT_TEST_SUITE( FadOpsUnitTest2 );
60 
61  CPPUNIT_TEST(testAddition);
62  CPPUNIT_TEST(testSubtraction);
63  CPPUNIT_TEST(testMultiplication);
64  CPPUNIT_TEST(testDivision);
65 
66  CPPUNIT_TEST(testEquals);
67  CPPUNIT_TEST(testNotEquals);
68 
69  CPPUNIT_TEST(testPow);
70 
71  CPPUNIT_TEST(testUnaryPlus);
72  CPPUNIT_TEST(testUnaryMinus);
73 
74  CPPUNIT_TEST(testExp);
75  CPPUNIT_TEST(testLog);
76  CPPUNIT_TEST(testLog10);
77  CPPUNIT_TEST(testSqrt);
78  CPPUNIT_TEST(testCos);
79  CPPUNIT_TEST(testSin);
80  CPPUNIT_TEST(testTan);
81  CPPUNIT_TEST(testCosh);
82  CPPUNIT_TEST(testSinh);
83  CPPUNIT_TEST(testTanh);
84 
85  CPPUNIT_TEST(testPlusEquals);
86  CPPUNIT_TEST(testMinusEquals);
87  CPPUNIT_TEST(testTimesEquals);
88  CPPUNIT_TEST(testDivideEquals);
89 
90  CPPUNIT_TEST(testEqualsLR);
91  CPPUNIT_TEST(testPlusEqualsLR);
92  CPPUNIT_TEST(testMinusEqualsLR);
93  CPPUNIT_TEST(testTimesEqualsLR);
94  CPPUNIT_TEST(testDivideEqualsLR);
95 
96  CPPUNIT_TEST(testResizeBug6135);
97 
98  CPPUNIT_TEST(testEquality);
99  CPPUNIT_TEST(testEqualityConstL);
100  CPPUNIT_TEST(testEqualityConstR);
101 
102  CPPUNIT_TEST_SUITE_END();
103 
104 public:
105 
106  FadOpsUnitTest2();
107 
108  FadOpsUnitTest2(int numComponents, double absolute_tolerance,
109  double relative_tolerance);
110 
111  void setUp();
112 
113  void tearDown();
114 
115  void testAddition();
116  void testSubtraction();
117  void testMultiplication ();
118  void testDivision();
119 
120  void testEquals();
121  void testNotEquals();
122 
123  void testPow();
124 
125  void testUnaryPlus();
126  void testUnaryMinus();
127 
128  void testExp();
129  void testLog();
130  void testLog10();
131  void testSqrt();
132  void testCos();
133  void testSin();
134  void testTan();
135  void testCosh();
136  void testSinh();
137  void testTanh();
138 
139  void testPlusEquals();
140  void testMinusEquals();
141  void testTimesEquals();
142  void testDivideEquals();
143 
144  void testEqualsLR();
145  void testPlusEqualsLR();
146  void testMinusEqualsLR();
147  void testTimesEqualsLR();
148  void testDivideEqualsLR();
149 
150  void testResizeBug6135();
151 
152  void testEquality();
153  void testEqualityConstL();
154  void testEqualityConstR();
155 
156 protected:
157 
158  // DFad variables
159  FadType a_fad, b_fad, c_fad;
160 
161  // Random number generator
162  Sacado::Random<ScalarType> urand;
163 
164  // Number of derivative components
165  int n;
166 
167  // Tolerances to which fad objects should be the same
168  double tol_a, tol_r;
169 
170 }; // class FadOpsUnitTest2
171 
172 template <class FadType, class ScalarType>
173 FadOpsUnitTest2<FadType,ScalarType>::
174 FadOpsUnitTest2() :
175  urand(), n(5), tol_a(1.0e-15), tol_r(1.0e-14) {}
176 
177 template <class FadType, class ScalarType>
178 FadOpsUnitTest2<FadType,ScalarType>::
179 FadOpsUnitTest2(int numComponents, double absolute_tolerance,
180  double relative_tolerance) :
181  urand(),
182  n(numComponents),
183  tol_a(absolute_tolerance),
184  tol_r(relative_tolerance) {}
185 
186 template <class FadType, class ScalarType>
187 void FadOpsUnitTest2<FadType,ScalarType>::setUp() {
188  ScalarType val;
189 
190  val = urand.number();
191  a_fad = FadType(n,val);
192 
193  val = urand.number();
194  b_fad = FadType(n,val);
195 
196  for (int i=0; i<n; i++) {
197  val = urand.number();
198  a_fad.fastAccessDx(i) = val;
199 
200  val = urand.number();
201  b_fad.fastAccessDx(i) = val;
202  }
203 }
204 
205 template <class FadType, class ScalarType>
206 void FadOpsUnitTest2<FadType,ScalarType>::
207 tearDown() {}
208 
209 template <class FadType, class ScalarType>
210 void
211 FadOpsUnitTest2<FadType,ScalarType>::
212 testAddition() {
213  c_fad = a_fad + b_fad;
214  FadType t1(n, a_fad.val()+b_fad.val());
215  for (int i=0; i<n; i++)
216  t1.fastAccessDx(i) = a_fad.dx(i) + b_fad.dx(i);
217  COMPARE_FADS(c_fad, t1);
218 
219  ScalarType val = urand.number();
220  c_fad = a_fad + val;
221  FadType t2(n, a_fad.val()+val);
222  for (int i=0; i<n; i++)
223  t2.fastAccessDx(i) = a_fad.dx(i);
224  COMPARE_FADS(c_fad, t2);
225 
226  c_fad = val + b_fad;
227  FadType t3(n, val+b_fad.val());
228  for (int i=0; i<n; i++)
229  t3.fastAccessDx(i) = b_fad.dx(i);
230  COMPARE_FADS(c_fad, t3);
231 }
232 
233 template <class FadType, class ScalarType>
234 void
235 FadOpsUnitTest2<FadType,ScalarType>::
236 testSubtraction() {
237  c_fad = a_fad - b_fad;
238  FadType t1(n, a_fad.val()-b_fad.val());
239  for (int i=0; i<n; i++)
240  t1.fastAccessDx(i) = a_fad.dx(i) - b_fad.dx(i);
241  COMPARE_FADS(c_fad, t1);
242 
243  ScalarType val = urand.number();
244  c_fad = a_fad - val;
245  FadType t2(n, a_fad.val()-val);
246  for (int i=0; i<n; i++)
247  t2.fastAccessDx(i) = a_fad.dx(i);
248  COMPARE_FADS(c_fad, t2);
249 
250  c_fad = val - b_fad;
251  FadType t3(n, val-b_fad.val());
252  for (int i=0; i<n; i++)
253  t3.fastAccessDx(i) = -b_fad.dx(i);
254  COMPARE_FADS(c_fad, t3);
255 }
256 
257 template <class FadType, class ScalarType>
258 void
259 FadOpsUnitTest2<FadType,ScalarType>::
260 testMultiplication() {
261  c_fad = a_fad * b_fad;
262  FadType t1(n, a_fad.val()*b_fad.val());
263  for (int i=0; i<n; i++)
264  t1.fastAccessDx(i) = a_fad.dx(i)*b_fad.val() + a_fad.val()*b_fad.dx(i);
265  COMPARE_FADS(c_fad, t1);
266 
267  ScalarType val = urand.number();
268  c_fad = a_fad * val;
269  FadType t2(n, a_fad.val()*val);
270  for (int i=0; i<n; i++)
271  t2.fastAccessDx(i) = a_fad.dx(i)*val;
272  COMPARE_FADS(c_fad, t2);
273 
274  c_fad = val * b_fad;
275  FadType t3(n, val*b_fad.val());
276  for (int i=0; i<n; i++)
277  t3.fastAccessDx(i) = val*b_fad.dx(i);
278  COMPARE_FADS(c_fad, t3);
279 }
280 
281 template <class FadType, class ScalarType>
282 void
283 FadOpsUnitTest2<FadType,ScalarType>::
284 testDivision() {
285  c_fad = a_fad / b_fad;
286  FadType t1(n, a_fad.val()/b_fad.val());
287  for (int i=0; i<n; i++)
288  t1.fastAccessDx(i) =
289  (a_fad.dx(i)*b_fad.val() - a_fad.val()*b_fad.dx(i)) /
290  (b_fad.val()*b_fad.val());
291  COMPARE_FADS(c_fad, t1);
292 
293  ScalarType val = urand.number();
294  c_fad = a_fad / val;
295  FadType t2(n, a_fad.val()/val);
296  for (int i=0; i<n; i++)
297  t2.fastAccessDx(i) = a_fad.dx(i)/val;
298  COMPARE_FADS(c_fad, t2);
299 
300  c_fad = val / b_fad;
301  FadType t3(n, val/b_fad.val());
302  for (int i=0; i<n; i++)
303  t3.fastAccessDx(i) = -val*b_fad.dx(i)/(b_fad.val()*b_fad.val());
304  COMPARE_FADS(c_fad, t3);
305 }
306 
307 template <class FadType, class ScalarType>
308 void
309 FadOpsUnitTest2<FadType,ScalarType>::
310 testEquals() {
311  bool r1 = a_fad == b_fad;
312  bool r2 = a_fad.val() == b_fad.val();
313  CPPUNIT_ASSERT(r1 == r2);
314 
315  ScalarType val = urand.number();
316  r1 = a_fad == val;
317  r2 = a_fad.val() == val;
318  CPPUNIT_ASSERT(r1 == r2);
319 
320  r1 = val == b_fad;
321  r2 = val == b_fad.val();
322  CPPUNIT_ASSERT(r1 == r2);
323 }
324 
325 template <class FadType, class ScalarType>
326 void
327 FadOpsUnitTest2<FadType,ScalarType>::
328 testNotEquals() {
329  bool r1 = a_fad != b_fad;
330  bool r2 = a_fad.val() != b_fad.val();
331  CPPUNIT_ASSERT(r1 == r2);
332 
333  ScalarType val = urand.number();
334  r1 = a_fad != val;
335  r2 = a_fad.val() != val;
336  CPPUNIT_ASSERT(r1 == r2);
337 
338  r1 = val != b_fad;
339  r2 = val != b_fad.val();
340  CPPUNIT_ASSERT(r1 == r2);
341 }
342 
343 template <class FadType, class ScalarType>
344 void
345 FadOpsUnitTest2<FadType,ScalarType>::
346 testUnaryPlus() {
347  c_fad = +(a_fad);
348  FadType t1(n, a_fad.val());
349  for (int i=0; i<n; i++)
350  t1.fastAccessDx(i) = a_fad.dx(i);
351  COMPARE_FADS(c_fad, t1);
352 }
353 
354 template <class FadType, class ScalarType>
355 void
356 FadOpsUnitTest2<FadType,ScalarType>::
357 testUnaryMinus() {
358  c_fad = -(a_fad);
359  FadType t1(n, -a_fad.val());
360  for (int i=0; i<n; i++)
361  t1.fastAccessDx(i) = -a_fad.dx(i);
362  COMPARE_FADS(c_fad, t1);
363 }
364 
365 template <class FadType, class ScalarType>
366 void
367 FadOpsUnitTest2<FadType,ScalarType>::
368 testExp() {
369  c_fad = std::exp(a_fad);
370  FadType t1(n, std::exp(a_fad.val()));
371  for (int i=0; i<n; i++)
372  t1.fastAccessDx(i) = std::exp(a_fad.val())*a_fad.dx(i);
373  COMPARE_FADS(c_fad, t1);
374 }
375 
376 template <class FadType, class ScalarType>
377 void
378 FadOpsUnitTest2<FadType,ScalarType>::
379 testLog() {
380  c_fad = std::log(a_fad);
381  FadType t1(n, std::log(a_fad.val()));
382  for (int i=0; i<n; i++)
383  t1.fastAccessDx(i) = a_fad.dx(i)/a_fad.val();
384  COMPARE_FADS(c_fad, t1);
385 }
386 
387 template <class FadType, class ScalarType>
388 void
389 FadOpsUnitTest2<FadType,ScalarType>::
390 testLog10() {
391  c_fad = std::log10(a_fad);
392  FadType t1(n, std::log10(a_fad.val()));
393  for (int i=0; i<n; i++)
394  t1.fastAccessDx(i) = a_fad.dx(i)/(a_fad.val()*std::log(10));
395  COMPARE_FADS(c_fad, t1);
396 }
397 
398 template <class FadType, class ScalarType>
399 void
400 FadOpsUnitTest2<FadType,ScalarType>::
401 testSqrt() {
402  c_fad = std::sqrt(a_fad);
403  FadType t1(n, std::sqrt(a_fad.val()));
404  for (int i=0; i<n; i++)
405  t1.fastAccessDx(i) = a_fad.dx(i)/(2.*std::sqrt(a_fad.val()));
406  COMPARE_FADS(c_fad, t1);
407 }
408 
409 template <class FadType, class ScalarType>
410 void
411 FadOpsUnitTest2<FadType,ScalarType>::
412 testCos() {
413  c_fad = std::cos(a_fad);
414  FadType t1(n, std::cos(a_fad.val()));
415  for (int i=0; i<n; i++)
416  t1.fastAccessDx(i) = -std::sin(a_fad.val())*a_fad.dx(i);
417  COMPARE_FADS(c_fad, t1);
418 }
419 
420 template <class FadType, class ScalarType>
421 void
422 FadOpsUnitTest2<FadType,ScalarType>::
423 testSin() {
424  c_fad = std::sin(a_fad);
425  FadType t1(n, std::sin(a_fad.val()));
426  for (int i=0; i<n; i++)
427  t1.fastAccessDx(i) = std::cos(a_fad.val())*a_fad.dx(i);
428  COMPARE_FADS(c_fad, t1);
429 }
430 
431 template <class FadType, class ScalarType>
432 void
433 FadOpsUnitTest2<FadType,ScalarType>::
434 testTan() {
435  c_fad = std::tan(a_fad);
436  FadType t1(n, std::tan(a_fad.val()));
437  for (int i=0; i<n; i++)
438  t1.fastAccessDx(i) =
439  a_fad.dx(i)/(std::cos(a_fad.val())*std::cos(a_fad.val()));;
440  COMPARE_FADS(c_fad, t1);
441 }
442 
443 template <class FadType, class ScalarType>
444 void
445 FadOpsUnitTest2<FadType,ScalarType>::
446 testCosh() {
447  c_fad = std::cosh(a_fad);
448  FadType t1(n, std::cosh(a_fad.val()));
449  for (int i=0; i<n; i++)
450  t1.fastAccessDx(i) = std::sinh(a_fad.val())*a_fad.dx(i);
451  COMPARE_FADS(c_fad, t1);
452 }
453 
454 template <class FadType, class ScalarType>
455 void
456 FadOpsUnitTest2<FadType,ScalarType>::
457 testSinh() {
458  c_fad = std::sinh(a_fad);
459  FadType t1(n, std::sinh(a_fad.val()));
460  for (int i=0; i<n; i++)
461  t1.fastAccessDx(i) = std::cosh(a_fad.val())*a_fad.dx(i);
462  COMPARE_FADS(c_fad, t1);
463 }
464 
465 template <class FadType, class ScalarType>
466 void
467 FadOpsUnitTest2<FadType,ScalarType>::
468 testTanh() {
469  c_fad = std::tanh(a_fad);
470  FadType t1(n, std::tanh(a_fad.val()));
471  for (int i=0; i<n; i++)
472  t1.fastAccessDx(i) =
473  a_fad.dx(i)/(std::cosh(a_fad.val())*std::cosh(a_fad.val()));
474  COMPARE_FADS(c_fad, t1);
475 }
476 
477 template <class FadType, class ScalarType>
478 void
479 FadOpsUnitTest2<FadType,ScalarType>::
480 testPlusEquals() {
481  FadType t1(n, c_fad.val()+a_fad.val());
482  for (int i=0; i<n; i++)
483  t1.fastAccessDx(i) = c_fad.dx(i) + a_fad.dx(i);
484  c_fad += a_fad;
485  COMPARE_FADS(c_fad, t1);
486 
487  ScalarType val = urand.number();
488  FadType t2(n, c_fad.val()+val);
489  for (int i=0; i<n; i++)
490  t2.fastAccessDx(i) = c_fad.dx(i);
491  c_fad += val;
492  COMPARE_FADS(c_fad, t2);
493 }
494 
495 template <class FadType, class ScalarType>
496 void
497 FadOpsUnitTest2<FadType,ScalarType>::
498 testMinusEquals() {
499  FadType t1(n, c_fad.val()-a_fad.val());
500  for (int i=0; i<n; i++)
501  t1.fastAccessDx(i) = c_fad.dx(i) - a_fad.dx(i);
502  c_fad -= a_fad;
503  COMPARE_FADS(c_fad, t1);
504 
505  ScalarType val = urand.number();
506  FadType t2(n, c_fad.val()-val);
507  for (int i=0; i<n; i++)
508  t2.fastAccessDx(i) = c_fad.dx(i);
509  c_fad -= val;
510  COMPARE_FADS(c_fad, t2);
511 }
512 
513 template <class FadType, class ScalarType>
514 void
515 FadOpsUnitTest2<FadType,ScalarType>::
516 testTimesEquals() {
517  FadType t1(n, c_fad.val()*a_fad.val());
518  for (int i=0; i<n; i++)
519  t1.fastAccessDx(i) = c_fad.dx(i)*a_fad.val() + a_fad.dx(i)*c_fad.val();
520  c_fad *= a_fad;
521  COMPARE_FADS(c_fad, t1);
522 
523  ScalarType val = urand.number();
524  FadType t2(n, c_fad.val()*val);
525  for (int i=0; i<n; i++)
526  t2.fastAccessDx(i) = c_fad.dx(i)*val;
527  c_fad *= val;
528  COMPARE_FADS(c_fad, t2);
529 }
530 
531 template <class FadType, class ScalarType>
532 void
533 FadOpsUnitTest2<FadType,ScalarType>::
534 testDivideEquals() {
535  FadType t1(n, c_fad.val()/a_fad.val());
536  for (int i=0; i<n; i++)
537  t1.fastAccessDx(i) =
538  (a_fad.dx(i)*c_fad.val() - c_fad.dx(i)*a_fad.val()) /
539  (a_fad.val()*a_fad.val());
540  c_fad /= a_fad;
541  COMPARE_FADS(c_fad, t1);
542 
543  ScalarType val = urand.number();
544  FadType t2(n, c_fad.val()/val);
545  for (int i=0; i<n; i++)
546  t2.fastAccessDx(i) = c_fad.dx(i)/val;
547  c_fad /= val;
548  COMPARE_FADS(c_fad, t2);
549 }
550 
551 template <class FadType, class ScalarType>
552 void
553 FadOpsUnitTest2<FadType,ScalarType>::
554 testPow() {
555  c_fad = std::pow(a_fad, b_fad);
556  FadType t1(n, std::pow(a_fad.val(),b_fad.val()));
557  for (int i=0; i<n; i++)
558  t1.fastAccessDx(i) =
559  std::pow(a_fad.val(),b_fad.val())*(b_fad.val()*a_fad.dx(i)/a_fad.val() +
560  std::log(a_fad.val())*b_fad.dx(i));
561  COMPARE_FADS(c_fad, t1);
562 
563  ScalarType val = urand.number();
564  c_fad = std::pow(a_fad, val);
565  FadType t2(n, std::pow(a_fad.val(), val));
566  for (int i=0; i<n; i++)
567  t2.fastAccessDx(i) =
568  std::pow(a_fad.val(), val)*(val*a_fad.dx(i)/a_fad.val());
569  COMPARE_FADS(c_fad, t2);
570 
571  c_fad = std::pow(val, b_fad);
572  FadType t3(n, std::pow(val, b_fad.val()));
573  for (int i=0; i<n; i++)
574  t3.fastAccessDx(i) =
575  std::pow(val, b_fad.val())*std::log(val)*b_fad.dx(i);
576  COMPARE_FADS(c_fad, t3);
577 
578  val = 0.0;
579  c_fad = std::pow(a_fad, val);
580  FadType t4(n, std::pow(a_fad.val(), val));
581  for (int i=0; i<n; i++)
582  t4.fastAccessDx(i) = 0.0;
583  COMPARE_FADS(c_fad, t4);
584 
585  c_fad = std::pow(val, b_fad);
586  FadType t5(n, std::pow(val, b_fad.val()));
587  for (int i=0; i<n; i++)
588  t5.fastAccessDx(i) = 0.0;
589  COMPARE_FADS(c_fad, t5);
590 
591  FadType aa_fad = a_fad;
592  aa_fad.val() = 0.0;
593  c_fad = std::pow(aa_fad, b_fad);
594  FadType t6(n, std::pow(aa_fad.val(),b_fad.val()));
595  for (int i=0; i<n; i++)
596  t6.fastAccessDx(i) = 0.0;
597  COMPARE_FADS(c_fad, t6);
598 
599  FadType bb_fad = b_fad;
600  bb_fad.val() = 0.0;
601  c_fad = std::pow(a_fad, bb_fad);
602  FadType t7(n, std::pow(a_fad.val(),bb_fad.val()));
603  for (int i=0; i<n; i++)
604  t7.fastAccessDx(i) =
605  std::pow(a_fad.val(),bb_fad.val())*(bb_fad.val()*a_fad.dx(i)/a_fad.val()
606  + std::log(a_fad.val())*b_fad.dx(i));
607  COMPARE_FADS(c_fad, t7);
608 }
609 
610 template <class FadType, class ScalarType>
611 void
612 FadOpsUnitTest2<FadType,ScalarType>::
613 testEqualsLR() {
614  FadType aa_fad = a_fad;
615  aa_fad = 1.0;
616  aa_fad = aa_fad + b_fad;
617  c_fad = 1.0 + b_fad;
618  COMPARE_FADS(aa_fad, c_fad);
619 }
620 
621 template <class FadType, class ScalarType>
622 void
623 FadOpsUnitTest2<FadType,ScalarType>::
624 testPlusEqualsLR() {
625  FadType aa_fad = a_fad;
626  aa_fad = 1.0;
627  aa_fad += aa_fad + b_fad;
628  c_fad = 1.0 + 1.0 + b_fad;
629  COMPARE_FADS(aa_fad, c_fad);
630 }
631 
632 template <class FadType, class ScalarType>
633 void
634 FadOpsUnitTest2<FadType,ScalarType>::
635 testMinusEqualsLR() {
636  FadType aa_fad = a_fad;
637  aa_fad = 1.0;
638  aa_fad -= aa_fad + b_fad;
639  c_fad = 1.0 - 1.0 - b_fad;
640  COMPARE_FADS(aa_fad, c_fad);
641 }
642 
643 template <class FadType, class ScalarType>
644 void
645 FadOpsUnitTest2<FadType,ScalarType>::
646 testTimesEqualsLR() {
647  FadType aa_fad = a_fad;
648  aa_fad = 2.0;
649  aa_fad *= aa_fad + b_fad;
650  c_fad = 2.0 * (2.0 + b_fad);
651  COMPARE_FADS(aa_fad, c_fad);
652 }
653 
654 template <class FadType, class ScalarType>
655 void
656 FadOpsUnitTest2<FadType,ScalarType>::
657 testDivideEqualsLR() {
658  FadType aa_fad = a_fad;
659  aa_fad = 2.0;
660  aa_fad /= aa_fad + b_fad;
661  c_fad = 2.0 / (2.0 + b_fad);
662  COMPARE_FADS(aa_fad, c_fad);
663 }
664 
665 template <class FadType, class ScalarType>
666 void
667 FadOpsUnitTest2<FadType,ScalarType>::
668 testResizeBug6135() {
669  FadType d_fad = ScalarType(1.0);
670  d_fad = d_fad + a_fad;
671  c_fad = 1.0 + a_fad;
672  COMPARE_FADS(d_fad, c_fad);
673 }
674 
675 template <class FadType, class ScalarType>
676 void
677 FadOpsUnitTest2<FadType,ScalarType>::
678 testEquality() {
679  FadType aa_fad = a_fad;
680  FadType bb_fad = b_fad;
681  aa_fad.val() = 9.0;
682  bb_fad.val() = 3.0;
683  FadType d_fad;
684  if (aa_fad == bb_fad*bb_fad)
685  d_fad = aa_fad;
686  c_fad = aa_fad;
687  COMPARE_FADS(d_fad, c_fad);
688 }
689 
690 template <class FadType, class ScalarType>
691 void
692 FadOpsUnitTest2<FadType,ScalarType>::
693 testEqualityConstL() {
694  FadType bb_fad = b_fad;
695  bb_fad.val() = 3.0;
696  FadType d_fad;
697  if (ScalarType(9.0) == bb_fad*bb_fad)
698  d_fad = a_fad;
699  c_fad = a_fad;
700  COMPARE_FADS(d_fad, c_fad);
701 }
702 
703 template <class FadType, class ScalarType>
704 void
705 FadOpsUnitTest2<FadType,ScalarType>::
706 testEqualityConstR() {
707  FadType bb_fad = b_fad;
708  bb_fad.val() = 3.0;
709  FadType d_fad;
710  if (bb_fad*bb_fad == ScalarType(9.0))
711  d_fad = a_fad;
712  c_fad = a_fad;
713  COMPARE_FADS(d_fad, c_fad);
714 }
715 
716 // A class for testing each real Fad operation
717 // This class tests additional functions that aren't define for complex
718 // types
719 template <class FadType, class ScalarType>
720 class RealFadOpsUnitTest2 : public FadOpsUnitTest2<FadType,ScalarType> {
721 
722  CPPUNIT_TEST_SUITE( RealFadOpsUnitTest2 );
723 
724  CPPUNIT_TEST(testAddition);
725  CPPUNIT_TEST(testSubtraction);
726  CPPUNIT_TEST(testMultiplication);
727  CPPUNIT_TEST(testDivision);
728 
729  CPPUNIT_TEST(testEquals);
730  CPPUNIT_TEST(testNotEquals);
731  CPPUNIT_TEST(testLessThanOrEquals);
732  CPPUNIT_TEST(testGreaterThanOrEquals);
733  CPPUNIT_TEST(testLessThan);
734  CPPUNIT_TEST(testGreaterThan);
735 
736  CPPUNIT_TEST(testPow);
737  CPPUNIT_TEST(testATan2);
738  CPPUNIT_TEST(testMax);
739  CPPUNIT_TEST(testMin);
740 
741  CPPUNIT_TEST(testUnaryPlus);
742  CPPUNIT_TEST(testUnaryMinus);
743 
744  CPPUNIT_TEST(testExp);
745  CPPUNIT_TEST(testLog);
746  CPPUNIT_TEST(testLog10);
747  CPPUNIT_TEST(testSqrt);
748  CPPUNIT_TEST(testCos);
749  CPPUNIT_TEST(testSin);
750  CPPUNIT_TEST(testTan);
751  CPPUNIT_TEST(testACos);
752  CPPUNIT_TEST(testASin);
753  CPPUNIT_TEST(testATan);
754  CPPUNIT_TEST(testCosh);
755  CPPUNIT_TEST(testSinh);
756  CPPUNIT_TEST(testTanh);
757  CPPUNIT_TEST(testACosh);
758  CPPUNIT_TEST(testASinh);
759  CPPUNIT_TEST(testATanh);
760  CPPUNIT_TEST(testAbs);
761  CPPUNIT_TEST(testFAbs);
762 #ifdef HAVE_SACADO_CXX11
763  CPPUNIT_TEST(testCbrt);
764 #endif
765 
766  CPPUNIT_TEST(testPlusEquals);
767  CPPUNIT_TEST(testMinusEquals);
768  CPPUNIT_TEST(testTimesEquals);
769  CPPUNIT_TEST(testDivideEquals);
770 
771  CPPUNIT_TEST(testEqualsLR);
772  CPPUNIT_TEST(testPlusEqualsLR);
773  CPPUNIT_TEST(testMinusEqualsLR);
774  CPPUNIT_TEST(testTimesEqualsLR);
775  CPPUNIT_TEST(testDivideEqualsLR);
776 
777  CPPUNIT_TEST(testResizeBug6135);
778 
779  CPPUNIT_TEST(testEquality);
780  CPPUNIT_TEST(testEqualityConstL);
781  CPPUNIT_TEST(testEqualityConstR);
782 
783  CPPUNIT_TEST_SUITE_END();
784 
785 public:
786 
787  RealFadOpsUnitTest2() {}
788 
789  RealFadOpsUnitTest2(int numComponents, double absolute_tolerance,
790  double relative_tolerance) :
791  FadOpsUnitTest2<FadType,ScalarType>(numComponents, absolute_tolerance, relative_tolerance) {}
792 
793  void testLessThanOrEquals();
794  void testGreaterThanOrEquals();
795  void testLessThan();
796  void testGreaterThan();
797 
798  void testACos();
799  void testASin();
800  void testATan();
801  void testACosh();
802  void testASinh();
803  void testATanh();
804  void testAbs();
805  void testFAbs();
806 #ifdef HAVE_SACADO_CXX11
807  void testCbrt();
808 #endif
809 
810  void testATan2();
811  void testMax();
812  void testMin();
813 };
814 
815 template <class FadType, class ScalarType>
816 void
817 RealFadOpsUnitTest2<FadType,ScalarType>::
818 testLessThanOrEquals() {
819  bool r1 = this->a_fad <= this->b_fad;
820  bool r2 = this->a_fad.val() <= this->b_fad.val();
821  CPPUNIT_ASSERT(r1 == r2);
822 
823  ScalarType val = this->urand.number();
824  r1 = this->a_fad <= val;
825  r2 = this->a_fad.val() <= val;
826  CPPUNIT_ASSERT(r1 == r2);
827 
828  r1 = val <= this->b_fad;
829  r2 = val <= this->b_fad.val();
830  CPPUNIT_ASSERT(r1 == r2);
831 }
832 
833 template <class FadType, class ScalarType>
834 void
835 RealFadOpsUnitTest2<FadType,ScalarType>::
836 testGreaterThanOrEquals() {
837  bool r1 = this->a_fad >= this->b_fad;
838  bool r2 = this->a_fad.val() >= this->b_fad.val();
839  CPPUNIT_ASSERT(r1 == r2);
840 
841  ScalarType val = this->urand.number();
842  r1 = this->a_fad >= val;
843  r2 = this->a_fad.val() >= val;
844  CPPUNIT_ASSERT(r1 == r2);
845 
846  r1 = val >= this->b_fad;
847  r2 = val >= this->b_fad.val();
848  CPPUNIT_ASSERT(r1 == r2);
849 }
850 
851 template <class FadType, class ScalarType>
852 void
853 RealFadOpsUnitTest2<FadType,ScalarType>::
854 testLessThan() {
855  bool r1 = this->a_fad < this->b_fad;
856  bool r2 = this->a_fad.val() < this->b_fad.val();
857  CPPUNIT_ASSERT(r1 == r2);
858 
859  ScalarType val = this->urand.number();
860  r1 = this->a_fad < val;
861  r2 = this->a_fad.val() < val;
862  CPPUNIT_ASSERT(r1 == r2);
863 
864  r1 = val < this->b_fad;
865  r2 = val < this->b_fad.val();
866  CPPUNIT_ASSERT(r1 == r2);
867 }
868 
869 template <class FadType, class ScalarType>
870 void
871 RealFadOpsUnitTest2<FadType,ScalarType>::
872 testGreaterThan() {
873  bool r1 = this->a_fad > this->b_fad;
874  bool r2 = this->a_fad.val() > this->b_fad.val();
875  CPPUNIT_ASSERT(r1 == r2);
876 
877  ScalarType val = this->urand.number();
878  r1 = this->a_fad > val;
879  r2 = this->a_fad.val() > val;
880  CPPUNIT_ASSERT(r1 == r2);
881 
882  r1 = val > this->b_fad;
883  r2 = val > this->b_fad.val();
884  CPPUNIT_ASSERT(r1 == r2);
885 }
886 
887 template <class FadType, class ScalarType>
888 void
889 RealFadOpsUnitTest2<FadType,ScalarType>::
890 testACos() {
891  this->c_fad = std::acos(this->a_fad);
892  FadType t1(this->n, std::acos(this->a_fad.val()));
893  for (int i=0; i<this->n; i++)
894  t1.fastAccessDx(i) = -this->a_fad.dx(i)/std::sqrt(1.0 - this->a_fad.val()*this->a_fad.val());
895  COMPARE_FADS(this->c_fad, t1);
896 }
897 
898 template <class FadType, class ScalarType>
899 void
900 RealFadOpsUnitTest2<FadType,ScalarType>::
901 testASin() {
902  this->c_fad = std::asin(this->a_fad);
903  FadType t1(this->n, std::asin(this->a_fad.val()));
904  for (int i=0; i<this->n; i++)
905  t1.fastAccessDx(i) = this->a_fad.dx(i)/std::sqrt(1.0 - this->a_fad.val()*this->a_fad.val());
906  COMPARE_FADS(this->c_fad, t1);
907 }
908 
909 template <class FadType, class ScalarType>
910 void
911 RealFadOpsUnitTest2<FadType,ScalarType>::
912 testATan() {
913  this->c_fad = std::atan(this->a_fad);
914  FadType t1(this->n, std::atan(this->a_fad.val()));
915  for (int i=0; i<this->n; i++)
916  t1.fastAccessDx(i) = this->a_fad.dx(i)/(1.0 + this->a_fad.val()*this->a_fad.val());
917  COMPARE_FADS(this->c_fad, t1);
918 }
919 
920 template <class FadType, class ScalarType>
921 void
922 RealFadOpsUnitTest2<FadType,ScalarType>::
923 testACosh() {
924  FadType aa_fad = this->a_fad;
925  if (this->a_fad.val() < 1.0)
926  aa_fad.val() = 1.0 / this->a_fad.val();
927  this->c_fad = std::acosh(aa_fad);
928  FadType t1(this->n, std::acosh(aa_fad.val()));
929  for (int i=0; i<this->n; i++)
930  t1.fastAccessDx(i) = aa_fad.dx(i)/std::sqrt(aa_fad.val()*aa_fad.val()-1.0);
931  COMPARE_FADS(this->c_fad, t1);
932 }
933 
934 template <class FadType, class ScalarType>
935 void
936 RealFadOpsUnitTest2<FadType,ScalarType>::
937 testASinh() {
938  this->c_fad = std::asinh(this->a_fad);
939  FadType t1(this->n, std::asinh(this->a_fad.val()));
940  for (int i=0; i<this->n; i++)
941  t1.fastAccessDx(i) = this->a_fad.dx(i)/std::sqrt(this->a_fad.val()*this->a_fad.val()+1.0);
942  COMPARE_FADS(this->c_fad, t1);
943 }
944 
945 template <class FadType, class ScalarType>
946 void
947 RealFadOpsUnitTest2<FadType,ScalarType>::
948 testATanh() {
949  this->c_fad = std::atanh(this->a_fad);
950  FadType t1(this->n, std::atanh(this->a_fad.val()));
951  for (int i=0; i<this->n; i++)
952  t1.fastAccessDx(i) = this->a_fad.dx(i)/(1.0 - this->a_fad.val()*this->a_fad.val());
953  COMPARE_FADS(this->c_fad, t1);
954 }
955 
956 template <class FadType, class ScalarType>
957 void
958 RealFadOpsUnitTest2<FadType,ScalarType>::
959 testAbs() {
960  this->c_fad = std::abs(this->a_fad);
961  FadType t1(this->n, std::abs(this->a_fad.val()));
962  for (int i=0; i<this->n; i++) {
963  if (this->a_fad.val() >= 0)
964  t1.fastAccessDx(i) = this->a_fad.dx(i);
965  else
966  t1.fastAccessDx(i) = -this->a_fad.dx(i);
967  }
968  COMPARE_FADS(this->c_fad, t1);
969 }
970 
971 template <class FadType, class ScalarType>
972 void
973 RealFadOpsUnitTest2<FadType,ScalarType>::
974 testFAbs() {
975  this->c_fad = std::fabs(this->a_fad);
976  FadType t1(this->n, std::fabs(this->a_fad.val()));
977  for (int i=0; i<this->n; i++) {
978  if (this->a_fad.val() >= 0)
979  t1.fastAccessDx(i) = this->a_fad.dx(i);
980  else
981  t1.fastAccessDx(i) = -this->a_fad.dx(i);
982  }
983  COMPARE_FADS(this->c_fad, t1);
984 }
985 
986 #ifdef HAVE_SACADO_CXX11
987 template <class FadType, class ScalarType>
988 void
989 RealFadOpsUnitTest2<FadType,ScalarType>::
990 testCbrt() {
991  this->c_fad = std::cbrt(this->a_fad);
992  FadType t1(this->n, std::cbrt(this->a_fad.val()));
993  for (int i=0; i<this->n; i++)
994  t1.fastAccessDx(i) =
995  this->a_fad.dx(i)/(3.*std::cbrt(this->a_fad.val()*this->a_fad.val()));
996  COMPARE_FADS(this->c_fad, t1);
997 }
998 #endif
999 
1000 template <class FadType, class ScalarType>
1001 void
1002 RealFadOpsUnitTest2<FadType,ScalarType>::
1003 testATan2() {
1004  this->c_fad = std::atan2(this->a_fad, this->b_fad);
1005  FadType t1(this->n, std::atan2(this->a_fad.val(),this->b_fad.val()));
1006  ScalarType t = this->a_fad.val()*this->a_fad.val() +
1007  this->b_fad.val()*this->b_fad.val();
1008  for (int i=0; i<this->n; i++)
1009  t1.fastAccessDx(i) = (this->b_fad.val()*this->a_fad.dx(i) -
1010  this->a_fad.val()*this->b_fad.dx(i))/t;
1011  COMPARE_FADS(this->c_fad, t1);
1012 
1013  ScalarType val = this->urand.number();
1014  this->c_fad = std::atan2(this->a_fad, val);
1015  FadType t2(this->n, std::atan2(this->a_fad.val(), val));
1016  t = this->a_fad.val()*this->a_fad.val() + val*val;
1017  for (int i=0; i<this->n; i++)
1018  t2.fastAccessDx(i) = val*this->a_fad.dx(i)/t;
1019  COMPARE_FADS(this->c_fad, t2);
1020 
1021  this->c_fad = std::atan2(val, this->b_fad);
1022  FadType t3(this->n, std::atan2(val, this->b_fad.val()));
1023  t = val*val + this->b_fad.val()*this->b_fad.val();
1024  for (int i=0; i<this->n; i++)
1025  t3.fastAccessDx(i) = -val*this->b_fad.dx(i)/t;
1026  COMPARE_FADS(this->c_fad, t3);
1027 }
1028 
1029 template <class FadType, class ScalarType>
1030 void
1031 RealFadOpsUnitTest2<FadType,ScalarType>::
1032 testMax() {
1033  ScalarType val;
1034 
1035  // Fad, Fad
1036  FadType aa_fad = this->a_fad + 1.0;
1037  this->c_fad = max(aa_fad, this->a_fad);
1038  COMPARE_FADS(this->c_fad, aa_fad);
1039  this->c_fad = max(this->a_fad, aa_fad);
1040  COMPARE_FADS(this->c_fad, aa_fad);
1041 
1042  // Expr, Fad
1043  this->c_fad = max(this->a_fad+1.0, this->a_fad);
1044  COMPARE_FADS(this->c_fad, aa_fad);
1045  this->c_fad = max(this->a_fad, this->a_fad+1.0);
1046  COMPARE_FADS(this->c_fad, aa_fad);
1047 
1048  // Expr, Expr (same)
1049  this->c_fad = max(this->a_fad+1.0, this->a_fad+1.0);
1050  COMPARE_FADS(this->c_fad, aa_fad);
1051 
1052  // Expr, Expr (different)
1053  this->c_fad = max(this->a_fad+1.0, this->a_fad-1.0);
1054  COMPARE_FADS(this->c_fad, aa_fad);
1055  this->c_fad = max(this->a_fad-1.0, this->a_fad+1.0);
1056  COMPARE_FADS(this->c_fad, aa_fad);
1057 
1058  // Fad, const
1059  val = this->a_fad.val() + 1;
1060  this->c_fad = max(this->a_fad, val);
1061  COMPARE_VALUES(this->c_fad.val(), val);
1062  for (int i=0; i<this->n; i++)
1063  COMPARE_VALUES(this->c_fad.dx(i), 0.0);
1064  val = this->a_fad.val() - 1;
1065  this->c_fad = max(this->a_fad, val);
1066  COMPARE_FADS(this->c_fad, this->a_fad);
1067  val = this->b_fad.val() + 1;
1068  this->c_fad = max(val, this->b_fad);
1069  COMPARE_VALUES(this->c_fad.val(), val);
1070  for (int i=0; i<this->n; i++)
1071  COMPARE_VALUES(this->c_fad.dx(i), 0.0);
1072  val = this->b_fad.val() - 1;
1073  this->c_fad = max(val, this->b_fad);
1074  COMPARE_FADS(this->c_fad, this->b_fad);
1075 
1076  // Expr, const
1077  val = this->a_fad.val();
1078  this->c_fad = max(this->a_fad+1.0, val);
1079  COMPARE_FADS(this->c_fad, aa_fad);
1080  this->c_fad = max(val, this->a_fad+1.0);
1081  COMPARE_FADS(this->c_fad, aa_fad);
1082 }
1083 
1084 template <class FadType, class ScalarType>
1085 void
1086 RealFadOpsUnitTest2<FadType,ScalarType>::
1087 testMin() {
1088  ScalarType val;
1089 
1090  // Fad, Fad
1091  FadType aa_fad = this->a_fad - 1.0;
1092  this->c_fad = min(aa_fad, this->a_fad);
1093  COMPARE_FADS(this->c_fad, aa_fad);
1094  this->c_fad = min(this->a_fad, aa_fad);
1095  COMPARE_FADS(this->c_fad, aa_fad);
1096 
1097  // Expr, Fad
1098  this->c_fad = min(this->a_fad-1.0, this->a_fad);
1099  COMPARE_FADS(this->c_fad, aa_fad);
1100  this->c_fad = min(this->a_fad, this->a_fad-1.0);
1101  COMPARE_FADS(this->c_fad, aa_fad);
1102 
1103  // Expr, Expr (same)
1104  this->c_fad = min(this->a_fad-1.0, this->a_fad-1.0);
1105  COMPARE_FADS(this->c_fad, aa_fad);
1106 
1107  // Expr, Expr (different)
1108  this->c_fad = min(this->a_fad+1.0, this->a_fad-1.0);
1109  COMPARE_FADS(this->c_fad, aa_fad);
1110  this->c_fad = min(this->a_fad-1.0, this->a_fad+1.0);
1111  COMPARE_FADS(this->c_fad, aa_fad);
1112 
1113  // Fad, const
1114  val = this->a_fad.val() - 1;
1115  this->c_fad = min(this->a_fad, val);
1116  COMPARE_VALUES(this->c_fad.val(), val);
1117  for (int i=0; i<this->n; i++)
1118  COMPARE_VALUES(this->c_fad.dx(i), 0.0);
1119  val = this->a_fad.val() + 1;
1120  this->c_fad = min(this->a_fad, val);
1121  COMPARE_FADS(this->c_fad, this->a_fad);
1122  val = this->b_fad.val() - 1;
1123  this->c_fad = min(val, this->b_fad);
1124  COMPARE_VALUES(this->c_fad.val(), val);
1125  for (int i=0; i<this->n; i++)
1126  COMPARE_VALUES(this->c_fad.dx(i), 0.0);
1127  val = this->b_fad.val() + 1;
1128  this->c_fad = min(val, this->b_fad);
1129  COMPARE_FADS(this->c_fad, this->b_fad);
1130 
1131  // Expr, const
1132  val = this->a_fad.val();
1133  this->c_fad = min(this->a_fad-1.0, val);
1134  COMPARE_FADS(this->c_fad, aa_fad);
1135  this->c_fad = min(val, this->a_fad-1.0);
1136  COMPARE_FADS(this->c_fad, aa_fad);
1137 }
1138 
1139 #undef COMPARE_VALUES
1140 #undef COMPARE_FADS
1141 
1142 #endif // FADUNITTESTS2_HPP
cbrt
cbrt(expr.val())
asin
asin(expr.val())
COMPARE_FADS
#define COMPARE_FADS(a, b)
Definition: FadUnitTests2.hpp:43
cosh
cosh(expr.val())
abs
abs(expr.val())
FadOpsUnitTest2::CPPUNIT_TEST
CPPUNIT_TEST(testAddition)
FadType
Sacado::Fad::DFad< double > FadType
Definition: blas_example.cpp:49
atan
atan(expr.val())
Sacado::Fad::pow
KOKKOS_INLINE_FUNCTION mpl::enable_if_c< ExprLevel< Expr< T1 > >::value==ExprLevel< Expr< T2 > >::value, Expr< PowerOp< Expr< T1 >, Expr< T2 > > > >::type pow(const Expr< T1 > &expr1, const Expr< T2 > &expr2)
Definition: Sacado_Fad_Ops.hpp:1619
val
expr val()
RealFadOpsUnitTest2::CPPUNIT_TEST_SUITE
CPPUNIT_TEST_SUITE(RealFadOpsUnitTest2)
tanh
tanh(expr.val())
Sacado_Random.hpp
Sacado::Fad::min
SimpleFad< ValueT > min(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:497
FadOpsUnitTest2::CPPUNIT_TEST_SUITE
CPPUNIT_TEST_SUITE(FadOpsUnitTest2)
sqrt
sqrt(expr.val())
sinh
sinh(expr.val())
tan
tan(expr.val())
FadOpsUnitTest2::urand
Sacado::Random< ScalarType > urand
Definition: FadUnitTests2.hpp:162
atan2
atan2(expr1.val(), expr2.val())
sin
sin(expr.val())
Sacado_No_Kokkos.hpp
log
log(expr.val())
RealFadOpsUnitTest2::CPPUNIT_TEST
CPPUNIT_TEST(testAddition)
acos
acos(expr.val())
Sacado::Fad::max
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:433
exp
exp(expr.val())
fabs
fabs(expr.val())
RealFadOpsUnitTest2::RealFadOpsUnitTest2
RealFadOpsUnitTest2(int numComponents, double absolute_tolerance, double relative_tolerance)
Definition: FadUnitTests2.hpp:789
n
int n
log10
log10(expr.val())
cos
cos(expr.val())
COMPARE_VALUES
#define COMPARE_VALUES(a, b)
Definition: FadUnitTests2.hpp:40
Generated by   doxygen 1.8.5