Sacado Package Browser (Single Doxygen Collection)  Version of the Day
Sacado_Fad_SimpleFadOps.hpp
Go to the documentation of this file.
1 // $Id$
2 // $Source$
3 // @HEADER
4 // ***********************************************************************
5 //
6 // Sacado Package
7 // Copyright (2006) Sandia Corporation
8 //
9 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
10 // the U.S. Government retains certain rights in this software.
11 //
12 // This library is free software; you can redistribute it and/or modify
13 // it under the terms of the GNU Lesser General Public License as
14 // published by the Free Software Foundation; either version 2.1 of the
15 // License, or (at your option) any later version.
16 //
17 // This library is distributed in the hope that it will be useful, but
18 // WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 // Lesser General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License along with this library; if not, write to the Free Software
24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
25 // USA
26 // Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
27 // (etphipp@sandia.gov).
28 //
29 // ***********************************************************************
30 // @HEADER
31 
32 #ifndef SACADO_FAD_SIMPLEFADOPS_HPP
33 #define SACADO_FAD_SIMPLEFADOPS_HPP
34 
35 #include "Sacado_cmath.hpp"
36 #include <ostream> // for std::ostream
37 
38 namespace Sacado {
39 
40  namespace Fad {
41 
42  template <typename ValueT>
43  SimpleFad<ValueT>
45  return a;
46  }
47 
48  template <typename ValueT>
49  SimpleFad<ValueT>
51  return SimpleFad<ValueT>(a, -a.val(), -1.0);
52  }
53 
54  template <typename ValueT>
55  SimpleFad<ValueT>
57  ValueT t1 = std::exp(a.val());
58  return SimpleFad<ValueT>(a, t1, t1);
59  }
60 
61  template <typename ValueT>
62  SimpleFad<ValueT>
64  return SimpleFad<ValueT>(a, std::log(a.val()), 1.0/a.val());
65  }
66 
67  template <typename ValueT>
68  SimpleFad<ValueT>
70  return SimpleFad<ValueT>(a, std::log10(a.val()),
71  1.0/(std::log(10.0)*a.val()));
72  }
73 
74  template <typename ValueT>
75  SimpleFad<ValueT>
77  ValueT t1 = std::sqrt(a.val());
78  ValueT t2 = 1.0/(2.0*t1);
79  return SimpleFad<ValueT>(a, t1, t2);
80  }
81 
82 #ifdef HAVE_SACADO_CXX11
83  template <typename ValueT>
84  SimpleFad<ValueT>
85  cbrt(const SimpleFad<ValueT>& a) {
86  ValueT t1 = std::cbrt(a.val());
87  ValueT t2 = 1.0/(3.0*t1*t1);
88  return SimpleFad<ValueT>(a, t1, t2);
89  }
90 #endif
91 
92  template <typename ValueT>
93  SimpleFad<ValueT>
95  return SimpleFad<ValueT>(a, std::cos(a.val()), -std::sin(a.val()));
96  }
97 
98  template <typename ValueT>
99  SimpleFad<ValueT>
101  return SimpleFad<ValueT>(a, std::sin(a.val()), std::cos(a.val()));
102  }
103 
104  template <typename ValueT>
105  SimpleFad<ValueT>
107  ValueT t1 = std::tan(a.val());
108  ValueT t2 = 1.0 + t1*t1;
109  return SimpleFad<ValueT>(a, t1, t2);
110  }
111 
112  template <typename ValueT>
113  SimpleFad<ValueT>
115  return SimpleFad<ValueT>(a, std::acos(a.val()),
116  -1.0/std::sqrt(1.0 - a.val()*a.val()));
117  }
118 
119  template <typename ValueT>
120  SimpleFad<ValueT>
122  return SimpleFad<ValueT>(a, std::asin(a.val()),
123  1.0/std::sqrt(1.0 - a.val()*a.val()));
124  }
125 
126  template <typename ValueT>
127  SimpleFad<ValueT>
129  return SimpleFad<ValueT>(a, std::atan(a.val()),
130  1.0/(1.0 + a.val()*a.val()));
131  }
132 
133  template <typename ValueT>
134  SimpleFad<ValueT>
136  return SimpleFad<ValueT>(a, std::cosh(a.val()), std::sinh(a.val()));
137  }
138 
139  template <typename ValueT>
140  SimpleFad<ValueT>
142  return SimpleFad<ValueT>(a, std::sinh(a.val()), std::cosh(a.val()));
143  }
144 
145  template <typename ValueT>
146  SimpleFad<ValueT>
148  ValueT t = std::tanh(a.val());
149  return SimpleFad<ValueT>(a, t, 1.0-t*t);
150  }
151 
152  template <typename ValueT>
153  SimpleFad<ValueT>
155  return SimpleFad<ValueT>(a, std::acosh(a.val()),
156  1.0/std::sqrt(a.val()*a.val()-1.0));
157  }
158 
159  template <typename ValueT>
160  SimpleFad<ValueT>
162  return SimpleFad<ValueT>(a, std::asinh(a.val()),
163  1.0/std::sqrt(1.0 + a.val()*a.val()));
164  }
165 
166  template <typename ValueT>
167  SimpleFad<ValueT>
169  return SimpleFad<ValueT>(a, std::atanh(a.val()),
170  1.0 /(1.0 - a.val()*a.val()));
171  }
172 
173  template <typename ValueT>
174  SimpleFad<ValueT>
176  ValueT t = 1.0;
177  if (a.val() < 0)
178  t = -1.0;
179  return SimpleFad<ValueT>(a, std::abs(a.val()), t);
180  }
181 
182  template <typename ValueT>
183  SimpleFad<ValueT>
185  ValueT t = 1.0;
186  if (a.val() < 0)
187  t = -1.0;
188  return SimpleFad<ValueT>(a, std::fabs(a.val()), t);
189  }
190 
191  template <typename ValueT>
192  SimpleFad<ValueT>
194  const SimpleFad<ValueT>& b) {
195  int sz = a.size() >= b.size() ? a.size() : b.size();
196  SimpleFad<ValueT> c(sz, a.val() + b.val());
197  if (a.hasFastAccess() && b.hasFastAccess())
198  for (int i=0; i<sz; i++)
199  c.fastAccessDx(i) = a.fastAccessDx(i) + b.fastAccessDx(i);
200  else if (a.hasFastAccess())
201  for (int i=0; i<sz; i++)
202  c.fastAccessDx(i) = a.fastAccessDx(i);
203  else if (b.hasFastAccess())
204  for (int i=0; i<sz; i++)
205  c.fastAccessDx(i) = b.fastAccessDx(i);
206 
207  return c;
208  }
209 
210  template <typename ValueT>
211  SimpleFad<ValueT>
213  const SimpleFad<ValueT>& b) {
214  return SimpleFad<ValueT>(b, a+b.val(), 1.0);
215  }
216 
217  template <typename ValueT>
218  SimpleFad<ValueT>
220  const typename SimpleFad<ValueT>::value_type& b) {
221  return SimpleFad<ValueT>(a, a.val()+b, 1.0);
222  }
223 
224  template <typename ValueT>
225  SimpleFad<ValueT>
227  const SimpleFad<ValueT>& b) {
228  int sz = a.size() >= b.size() ? a.size() : b.size();
229  SimpleFad<ValueT> c(sz, a.val() - b.val());
230  if (a.hasFastAccess() && b.hasFastAccess())
231  for (int i=0; i<sz; i++)
232  c.fastAccessDx(i) = a.fastAccessDx(i) - b.fastAccessDx(i);
233  else if (a.hasFastAccess())
234  for (int i=0; i<sz; i++)
235  c.fastAccessDx(i) = a.fastAccessDx(i);
236  else if (b.hasFastAccess())
237  for (int i=0; i<sz; i++)
238  c.fastAccessDx(i) = -b.fastAccessDx(i);
239 
240  return c;
241  }
242 
243  template <typename ValueT>
244  SimpleFad<ValueT>
246  const SimpleFad<ValueT>& b) {
247  return SimpleFad<ValueT>(b, a-b.val(), -1.0);
248  }
249 
250  template <typename ValueT>
251  SimpleFad<ValueT>
253  const typename SimpleFad<ValueT>::value_type& b) {
254  return SimpleFad<ValueT>(a, a.val()-b, 1.0);
255  }
256 
257  template <typename ValueT>
258  SimpleFad<ValueT>
260  const SimpleFad<ValueT>& b) {
261  int sz = a.size() >= b.size() ? a.size() : b.size();
262  SimpleFad<ValueT> c(sz, a.val() * b.val());
263  if (a.hasFastAccess() && b.hasFastAccess())
264  for (int i=0; i<sz; i++)
265  c.fastAccessDx(i) =
266  a.fastAccessDx(i)*b.val() + b.fastAccessDx(i)*a.val();
267  else if (a.hasFastAccess())
268  for (int i=0; i<sz; i++)
269  c.fastAccessDx(i) = a.fastAccessDx(i)*b.val();
270  else if (b.hasFastAccess())
271  for (int i=0; i<sz; i++)
272  c.fastAccessDx(i) = b.fastAccessDx(i)*a.val();
273 
274  return c;
275  }
276 
277  template <typename ValueT>
278  SimpleFad<ValueT>
280  const SimpleFad<ValueT>& b) {
281  return SimpleFad<ValueT>(b, a*b.val(), a);
282  }
283 
284  template <typename ValueT>
285  SimpleFad<ValueT>
287  const typename SimpleFad<ValueT>::value_type& b) {
288  return SimpleFad<ValueT>(a, a.val()*b, b);
289  }
290 
291  template <typename ValueT>
292  SimpleFad<ValueT>
294  const SimpleFad<ValueT>& b) {
295  int sz = a.size() >= b.size() ? a.size() : b.size();
296  SimpleFad<ValueT> c(sz, a.val() / b.val());
297  if (a.hasFastAccess() && b.hasFastAccess()) {
298  ValueT t = b.val()*b.val();
299  for (int i=0; i<sz; i++)
300  c.fastAccessDx(i) =
301  (a.fastAccessDx(i)*b.val() - b.fastAccessDx(i)*a.val()) / t;
302  }
303  else if (a.hasFastAccess())
304  for (int i=0; i<sz; i++)
305  c.fastAccessDx(i) = a.fastAccessDx(i)/b.val();
306  else if (b.hasFastAccess()) {
307  ValueT t = -a.val()/(b.val()*b.val());
308  for (int i=0; i<sz; i++)
309  c.fastAccessDx(i) = b.fastAccessDx(i)*t;
310  }
311 
312  return c;
313  }
314 
315  template <typename ValueT>
316  SimpleFad<ValueT>
318  const SimpleFad<ValueT>& b) {
319  return SimpleFad<ValueT>(b, a/b.val(), -a/(b.val()*b.val()));
320  }
321 
322  template <typename ValueT>
323  SimpleFad<ValueT>
325  const typename SimpleFad<ValueT>::value_type& b) {
326  return SimpleFad<ValueT>(a, a.val()/b, 1.0/b);
327  }
328 
329  template <typename ValueT>
330  SimpleFad<ValueT>
332  const SimpleFad<ValueT>& b) {
333  int sz = a.size() >= b.size() ? a.size() : b.size();
334  SimpleFad<ValueT> c(sz, std::pow(a.val(), b.val()));
335  typedef typename SimpleFad<ValueT>::value_type value_type;
336  if (a.hasFastAccess() && b.hasFastAccess()) {
337  if (a.val() != value_type(0)) {
338  ValueT t1 = c.val()*b.val()/a.val();
339  ValueT t2 = c.val()*std::log(a.val());
340  for (int i=0; i<sz; i++)
341  c.fastAccessDx(i) =
342  a.fastAccessDx(i)*t1 + b.fastAccessDx(i)*t2;
343  }
344  }
345  else if (a.hasFastAccess()) {
346  if (b.val() == value_type(1)) {
347  for (int i=0; i<sz; i++)
348  c.fastAccessDx(i) = a.fastAccessDx(i);
349  }
350  else if (a.val() != value_type(0)) {
351  ValueT t1 = c.val()*b.val()/a.val();
352  for (int i=0; i<sz; i++)
353  c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
354  }
355  }
356  else if (b.hasFastAccess()) {
357  if (a.val() != value_type(0)) {
358  ValueT t2 = c.val()*std::log(a.val());
359  for (int i=0; i<sz; i++)
360  c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
361  }
362  }
363 
364  return c;
365  }
366 
367  template <typename ValueT>
368  SimpleFad<ValueT>
370  const SimpleFad<ValueT>& b) {
371  typedef typename SimpleFad<ValueT>::value_type value_type;
372  ValueT t = std::pow(a,b.val());
373  if (a != value_type(0))
374  return SimpleFad<ValueT>(b, t, t*std::log(a));
375  else
376  return SimpleFad<ValueT>(b, t, value_type(0));
377  }
378 
379  template <typename ValueT>
380  SimpleFad<ValueT>
382  const typename SimpleFad<ValueT>::value_type& b) {
383  typedef typename SimpleFad<ValueT>::value_type value_type;
384  ValueT t = std::pow(a.val(),b);
385  if (b == value_type(1))
386  return a;
387  else if (a.val() != value_type(0))
388  return SimpleFad<ValueT>(a, t, t*b/a.val());
389  else
390  return SimpleFad<ValueT>(a, t, value_type(0));
391  }
392 
393  template <typename ValueT>
394  SimpleFad<ValueT>
396  const SimpleFad<ValueT>& b) {
397  int sz = a.size() >= b.size() ? a.size() : b.size();
398  SimpleFad<ValueT> c(sz, std::atan2(a.val(), b.val()));
399  if (a.hasFastAccess() && b.hasFastAccess()) {
400  ValueT t = a.val()*a.val() + b.val()*b.val();
401  ValueT t1 = b.val()/t;
402  ValueT t2 = a.val()/t;
403  for (int i=0; i<sz; i++)
404  c.fastAccessDx(i) =
405  a.fastAccessDx(i)*t1 - b.fastAccessDx(i)*t2;
406  }
407  else if (a.hasFastAccess()) {
408  ValueT t1 = b.val()/(a.val()*a.val() + b.val()*b.val());
409  for (int i=0; i<sz; i++)
410  c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
411  }
412  else if (b.hasFastAccess()) {
413  ValueT t2 = -a.val()/(a.val()*a.val() + b.val()*b.val());
414  for (int i=0; i<sz; i++)
415  c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
416  }
417 
418  return c;
419  }
420 
421  template <typename ValueT>
422  SimpleFad<ValueT>
424  const SimpleFad<ValueT>& b) {
425  return SimpleFad<ValueT>(b, std::atan2(a,b.val()),
426  -a/(a*a + b.val()*b.val()));
427  }
428 
429  template <typename ValueT>
430  SimpleFad<ValueT>
432  const typename SimpleFad<ValueT>::value_type& b) {
433  return SimpleFad<ValueT>(a, std::atan2(a.val(),b),
434  b/(a.val()*a.val() + b*b));
435  }
436 
437  template <typename ValueT>
438  SimpleFad<ValueT>
440  const SimpleFad<ValueT>& b) {
441  int sz = a.size() >= b.size() ? a.size() : b.size();
442  SimpleFad<ValueT> c(sz, std::max(a.val(), b.val()));
443  if (a.hasFastAccess() && b.hasFastAccess()) {
444  if (a.val() >= b.val())
445  for (int i=0; i<sz; i++)
446  c.fastAccessDx(i) = a.fastAccessDx(i);
447  else
448  for (int i=0; i<sz; i++)
449  c.fastAccessDx(i) = b.fastAccessDx(i);
450  }
451  else if (a.hasFastAccess()) {
452  if (a.val() >= b.val())
453  for (int i=0; i<sz; i++)
454  c.fastAccessDx(i) = a.fastAccessDx(i);
455  else
456  for (int i=0; i<sz; i++)
457  c.fastAccessDx(i) = 0.0;
458  }
459  else if (b.hasFastAccess()) {
460  if (a.val() >= b.val())
461  for (int i=0; i<sz; i++)
462  c.fastAccessDx(i) = 0.0;
463  else
464  for (int i=0; i<sz; i++)
465  c.fastAccessDx(i) = b.fastAccessDx(i);
466  }
467 
468  return c;
469  }
470 
471  template <typename ValueT>
472  SimpleFad<ValueT>
474  const SimpleFad<ValueT>& b) {
475  SimpleFad<ValueT> c(b.size(), std::max(a, b.val()));
476  if (a >= b.val())
477  for (int i=0; i<c.size(); i++)
478  c.fastAccessDx(i) = 0.0;
479  else
480  for (int i=0; i<c.size(); i++)
481  c.fastAccessDx(i) = b.fastAccessDx(i);
482 
483  return c;
484  }
485 
486  template <typename ValueT>
487  SimpleFad<ValueT>
489  const typename SimpleFad<ValueT>::value_type& b) {
490  SimpleFad<ValueT> c(a.size(), std::max(a.val(), b));
491  if (a.val() >= b)
492  for (int i=0; i<c.size(); i++)
493  c.fastAccessDx(i) = a.fastAccessDx(i);
494  else
495  for (int i=0; i<c.size(); i++)
496  c.fastAccessDx(i) = 0.0;
497 
498  return c;
499  }
500 
501  template <typename ValueT>
502  SimpleFad<ValueT>
504  const SimpleFad<ValueT>& b) {
505  int sz = a.size() >= b.size() ? a.size() : b.size();
506  SimpleFad<ValueT> c(sz, std::min(a.val(), b.val()));
507  if (a.hasFastAccess() && b.hasFastAccess()) {
508  if (a.val() <= b.val())
509  for (int i=0; i<sz; i++)
510  c.fastAccessDx(i) = a.fastAccessDx(i);
511  else
512  for (int i=0; i<sz; i++)
513  c.fastAccessDx(i) = b.fastAccessDx(i);
514  }
515  else if (a.hasFastAccess()) {
516  if (a.val() <= b.val())
517  for (int i=0; i<sz; i++)
518  c.fastAccessDx(i) = a.fastAccessDx(i);
519  else
520  for (int i=0; i<sz; i++)
521  c.fastAccessDx(i) = 0.0;
522  }
523  else if (b.hasFastAccess()) {
524  if (a.val() <= b.val())
525  for (int i=0; i<sz; i++)
526  c.fastAccessDx(i) = 0.0;
527  else
528  for (int i=0; i<sz; i++)
529  c.fastAccessDx(i) = b.fastAccessDx(i);
530  }
531 
532  return c;
533  }
534 
535  template <typename ValueT>
536  SimpleFad<ValueT>
538  const SimpleFad<ValueT>& b) {
539  SimpleFad<ValueT> c(b.size(), std::min(a, b.val()));
540  if (a <= b.val())
541  for (int i=0; i<c.size(); i++)
542  c.fastAccessDx(i) = 0.0;
543  else
544  for (int i=0; i<c.size(); i++)
545  c.fastAccessDx(i) = b.fastAccessDx(i);
546 
547  return c;
548  }
549 
550  template <typename ValueT>
551  SimpleFad<ValueT>
553  const typename SimpleFad<ValueT>::value_type& b) {
554  SimpleFad<ValueT> c(a.size(), std::min(a.val(), b));
555  if (a.val() <= b)
556  for (int i=0; i<c.size(); i++)
557  c.fastAccessDx(i) = a.fastAccessDx(i);
558  else
559  for (int i=0; i<c.size(); i++)
560  c.fastAccessDx(i) = 0.0;
561 
562  return c;
563  }
564 
565  } // namespace Fad
566 
567 } // namespace Sacado
568 
569  //-------------------------- Relational Operators -----------------------
570 
571 #define FAD_RELOP_MACRO(OP) \
572 namespace Sacado { \
573  namespace Fad { \
574  template <typename ValueT> \
575  inline bool \
576  operator OP (const SimpleFad<ValueT>& a, \
577  const SimpleFad<ValueT>& b) \
578  { \
579  return a.val() OP b.val(); \
580  } \
581  \
582  template <typename ValueT> \
583  inline bool \
584  operator OP (const ValueT& a, \
585  const SimpleFad<ValueT>& b) \
586  { \
587  return a OP b.val(); \
588  } \
589  \
590  template <typename ValueT> \
591  inline bool \
592  operator OP (const SimpleFad<ValueT>& a, \
593  const ValueT& b) \
594  { \
595  return a.val() OP b; \
596  } \
597  } \
598 }
599 
600 FAD_RELOP_MACRO(==)
601 FAD_RELOP_MACRO(!=)
604 FAD_RELOP_MACRO(<=)
605 FAD_RELOP_MACRO(>=)
606 FAD_RELOP_MACRO(<<=)
607 FAD_RELOP_MACRO(>>=)
610 
611 #undef FAD_RELOP_MACRO
612 
613 namespace Sacado {
614 
615  namespace Fad {
616 
617  template <typename ValueT>
618  inline bool operator ! (const SimpleFad<ValueT>& a)
619  {
620  return ! a.val();
621  }
622 
623  } // namespace Fad
624 
625 } // namespace Sacado
626 
627 //-------------------------- Boolean Operators -----------------------
628 namespace Sacado {
629 
630  namespace Fad {
631 
632  template <typename T>
633  bool toBool(const SimpleFad<T>& x) {
634  bool is_zero = (x.val() == 0.0);
635  for (int i=0; i<x.size(); i++)
636  is_zero = is_zero && (x.dx(i) == 0.0);
637  return !is_zero;
638  }
639 
640  } // namespace Fad
641 
642 } // namespace Sacado
643 
644 #define FAD_BOOL_MACRO(OP) \
645 namespace Sacado { \
646  namespace Fad { \
647  template <typename T1, typename T2> \
648  inline bool \
649  operator OP (const SimpleFad<T1>& expr1, \
650  const SimpleFad<T2>& expr2) \
651  { \
652  return toBool(expr1) OP toBool(expr2); \
653  } \
654  \
655  template <typename T2> \
656  inline bool \
657  operator OP (const typename SimpleFad<T2>::value_type& a, \
658  const SimpleFad<T2>& expr2) \
659  { \
660  return a OP toBool(expr2); \
661  } \
662  \
663  template <typename T1> \
664  inline bool \
665  operator OP (const SimpleFad<T1>& expr1, \
666  const typename SimpleFad<T1>::value_type& b) \
667  { \
668  return toBool(expr1) OP b; \
669  } \
670  } \
671 }
672 
673 FAD_BOOL_MACRO(&&)
674 FAD_BOOL_MACRO(||)
675 
676 #undef FAD_BOOL_MACRO
677 
678 //-------------------------- I/O Operators -----------------------
679 
680 namespace Sacado {
681 
682  namespace Fad {
683 
684  template <typename ValueT>
685  std::ostream& operator << (std::ostream& os,
686  const SimpleFad<ValueT>& x) {
687  os << x.val() << " [";
688 
689  for (int i=0; i< x.size(); i++) {
690  os << " " << x.dx(i);
691  }
692 
693  os << " ]";
694  return os;
695  }
696 
697  } // namespace Fad
698 
699 } // namespace Sacado
700 
701 #endif // SACADO_FAD_SIMPLEFADOPS_HPP
cbrt(expr.val())
SimpleFad< ValueT > atan2(const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
float acosh(float x)
SimpleFad< ValueT > atan2(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
SACADO_INLINE_FUNCTION int size() const
Returns number of derivative components.
SimpleFad< ValueT > abs(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > sqrt(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > asin(const SimpleFad< ValueT > &a)
SACADO_INLINE_FUNCTION const ValueT & val() const
Returns value.
Forward-mode AD class using dynamic memory allocation but no expression templates.
SimpleFad< ValueT > acosh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > log(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
SimpleFad< ValueT > min(const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
SACADO_INLINE_FUNCTION bool toBool(const Expr< ExprT > &x)
SimpleFad< ValueT > exp(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > atan(const SimpleFad< ValueT > &a)
expr expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c *expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 expr1 expr1 c
float asinh(float x)
SimpleFad< ValueT > fabs(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > pow(const SimpleFad< ValueT > &a, const typename SimpleFad< ValueT >::value_type &b)
SimpleFad< ValueT > log10(const SimpleFad< ValueT > &a)
#define FAD_RELOP_MACRO(OP)
SimpleFad< ValueT > min(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
SACADO_INLINE_FUNCTION ValueT & fastAccessDx(int i)
Returns derivative component i without bounds checking.
tan(expr.val())
SimpleFad< ValueT > sin(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > atanh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > sinh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > operator/(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
#define FAD_BOOL_MACRO(OP)
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Returns true if derivative array is not empty.
std::ostream & operator<<(std::ostream &os, const Expr< ExprT > &x)
GeneralFadType::value_type value_type
Typename of values.
SimpleFad< ValueT > tan(const SimpleFad< ValueT > &a)
SACADO_INLINE_FUNCTION bool operator!(const Expr< ExprT > &expr)
SimpleFad< ValueT > cos(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > cosh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > operator*(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
float atanh(float x)
SimpleFad< ValueT > operator-(const SimpleFad< ValueT > &a)
SACADO_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)
SimpleFad< ValueT > acos(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > tanh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > asinh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > operator+(const SimpleFad< ValueT > &a)