Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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  template <typename ValueT>
83  SimpleFad<ValueT>
85  ValueT t1 = std::cbrt(a.val());
86  ValueT t2 = 1.0/(3.0*t1*t1);
87  return SimpleFad<ValueT>(a, t1, t2);
88  }
89 
90  template <typename ValueT>
91  SimpleFad<ValueT>
93  return SimpleFad<ValueT>(a, std::cos(a.val()), -std::sin(a.val()));
94  }
95 
96  template <typename ValueT>
97  SimpleFad<ValueT>
99  return SimpleFad<ValueT>(a, std::sin(a.val()), std::cos(a.val()));
100  }
101 
102  template <typename ValueT>
103  SimpleFad<ValueT>
105  ValueT t1 = std::tan(a.val());
106  ValueT t2 = 1.0 + t1*t1;
107  return SimpleFad<ValueT>(a, t1, t2);
108  }
109 
110  template <typename ValueT>
111  SimpleFad<ValueT>
113  return SimpleFad<ValueT>(a, std::acos(a.val()),
114  -1.0/std::sqrt(1.0 - a.val()*a.val()));
115  }
116 
117  template <typename ValueT>
118  SimpleFad<ValueT>
120  return SimpleFad<ValueT>(a, std::asin(a.val()),
121  1.0/std::sqrt(1.0 - a.val()*a.val()));
122  }
123 
124  template <typename ValueT>
125  SimpleFad<ValueT>
127  return SimpleFad<ValueT>(a, std::atan(a.val()),
128  1.0/(1.0 + a.val()*a.val()));
129  }
130 
131  template <typename ValueT>
132  SimpleFad<ValueT>
134  return SimpleFad<ValueT>(a, std::cosh(a.val()), std::sinh(a.val()));
135  }
136 
137  template <typename ValueT>
138  SimpleFad<ValueT>
140  return SimpleFad<ValueT>(a, std::sinh(a.val()), std::cosh(a.val()));
141  }
142 
143  template <typename ValueT>
144  SimpleFad<ValueT>
146  ValueT t = std::tanh(a.val());
147  return SimpleFad<ValueT>(a, t, 1.0-t*t);
148  }
149 
150  template <typename ValueT>
151  SimpleFad<ValueT>
153  return SimpleFad<ValueT>(a, std::acosh(a.val()),
154  1.0/std::sqrt(a.val()*a.val()-1.0));
155  }
156 
157  template <typename ValueT>
158  SimpleFad<ValueT>
160  return SimpleFad<ValueT>(a, std::asinh(a.val()),
161  1.0/std::sqrt(1.0 + a.val()*a.val()));
162  }
163 
164  template <typename ValueT>
165  SimpleFad<ValueT>
167  return SimpleFad<ValueT>(a, std::atanh(a.val()),
168  1.0 /(1.0 - a.val()*a.val()));
169  }
170 
171  template <typename ValueT>
172  SimpleFad<ValueT>
174  ValueT t = 1.0;
175  if (a.val() < 0)
176  t = -1.0;
177  return SimpleFad<ValueT>(a, std::abs(a.val()), t);
178  }
179 
180  template <typename ValueT>
181  SimpleFad<ValueT>
183  ValueT t = 1.0;
184  if (a.val() < 0)
185  t = -1.0;
186  return SimpleFad<ValueT>(a, std::fabs(a.val()), t);
187  }
188 
189  template <typename ValueT>
190  SimpleFad<ValueT>
192  const SimpleFad<ValueT>& b) {
193  int sz = a.size() >= b.size() ? a.size() : b.size();
194  SimpleFad<ValueT> c(sz, a.val() + b.val());
195  if (a.hasFastAccess() && b.hasFastAccess())
196  for (int i=0; i<sz; i++)
197  c.fastAccessDx(i) = a.fastAccessDx(i) + b.fastAccessDx(i);
198  else if (a.hasFastAccess())
199  for (int i=0; i<sz; i++)
200  c.fastAccessDx(i) = a.fastAccessDx(i);
201  else if (b.hasFastAccess())
202  for (int i=0; i<sz; i++)
203  c.fastAccessDx(i) = b.fastAccessDx(i);
204 
205  return c;
206  }
207 
208  template <typename ValueT>
209  SimpleFad<ValueT>
211  const SimpleFad<ValueT>& b) {
212  return SimpleFad<ValueT>(b, a+b.val(), 1.0);
213  }
214 
215  template <typename ValueT>
216  SimpleFad<ValueT>
218  const typename SimpleFad<ValueT>::value_type& b) {
219  return SimpleFad<ValueT>(a, a.val()+b, 1.0);
220  }
221 
222  template <typename ValueT>
223  SimpleFad<ValueT>
225  const SimpleFad<ValueT>& b) {
226  int sz = a.size() >= b.size() ? a.size() : b.size();
227  SimpleFad<ValueT> c(sz, a.val() - b.val());
228  if (a.hasFastAccess() && b.hasFastAccess())
229  for (int i=0; i<sz; i++)
230  c.fastAccessDx(i) = a.fastAccessDx(i) - b.fastAccessDx(i);
231  else if (a.hasFastAccess())
232  for (int i=0; i<sz; i++)
233  c.fastAccessDx(i) = a.fastAccessDx(i);
234  else if (b.hasFastAccess())
235  for (int i=0; i<sz; i++)
236  c.fastAccessDx(i) = -b.fastAccessDx(i);
237 
238  return c;
239  }
240 
241  template <typename ValueT>
242  SimpleFad<ValueT>
244  const SimpleFad<ValueT>& b) {
245  return SimpleFad<ValueT>(b, a-b.val(), -1.0);
246  }
247 
248  template <typename ValueT>
249  SimpleFad<ValueT>
251  const typename SimpleFad<ValueT>::value_type& b) {
252  return SimpleFad<ValueT>(a, a.val()-b, 1.0);
253  }
254 
255  template <typename ValueT>
256  SimpleFad<ValueT>
258  const SimpleFad<ValueT>& b) {
259  int sz = a.size() >= b.size() ? a.size() : b.size();
260  SimpleFad<ValueT> c(sz, a.val() * b.val());
261  if (a.hasFastAccess() && b.hasFastAccess())
262  for (int i=0; i<sz; i++)
263  c.fastAccessDx(i) =
264  a.fastAccessDx(i)*b.val() + b.fastAccessDx(i)*a.val();
265  else if (a.hasFastAccess())
266  for (int i=0; i<sz; i++)
267  c.fastAccessDx(i) = a.fastAccessDx(i)*b.val();
268  else if (b.hasFastAccess())
269  for (int i=0; i<sz; i++)
270  c.fastAccessDx(i) = b.fastAccessDx(i)*a.val();
271 
272  return c;
273  }
274 
275  template <typename ValueT>
276  SimpleFad<ValueT>
278  const SimpleFad<ValueT>& b) {
279  return SimpleFad<ValueT>(b, a*b.val(), a);
280  }
281 
282  template <typename ValueT>
283  SimpleFad<ValueT>
285  const typename SimpleFad<ValueT>::value_type& b) {
286  return SimpleFad<ValueT>(a, a.val()*b, b);
287  }
288 
289  template <typename ValueT>
290  SimpleFad<ValueT>
292  const SimpleFad<ValueT>& b) {
293  int sz = a.size() >= b.size() ? a.size() : b.size();
294  SimpleFad<ValueT> c(sz, a.val() / b.val());
295  if (a.hasFastAccess() && b.hasFastAccess()) {
296  ValueT t = b.val()*b.val();
297  for (int i=0; i<sz; i++)
298  c.fastAccessDx(i) =
299  (a.fastAccessDx(i)*b.val() - b.fastAccessDx(i)*a.val()) / t;
300  }
301  else if (a.hasFastAccess())
302  for (int i=0; i<sz; i++)
303  c.fastAccessDx(i) = a.fastAccessDx(i)/b.val();
304  else if (b.hasFastAccess()) {
305  ValueT t = -a.val()/(b.val()*b.val());
306  for (int i=0; i<sz; i++)
307  c.fastAccessDx(i) = b.fastAccessDx(i)*t;
308  }
309 
310  return c;
311  }
312 
313  template <typename ValueT>
314  SimpleFad<ValueT>
316  const SimpleFad<ValueT>& b) {
317  return SimpleFad<ValueT>(b, a/b.val(), -a/(b.val()*b.val()));
318  }
319 
320  template <typename ValueT>
321  SimpleFad<ValueT>
323  const typename SimpleFad<ValueT>::value_type& b) {
324  return SimpleFad<ValueT>(a, a.val()/b, 1.0/b);
325  }
326 
327  template <typename ValueT>
328  SimpleFad<ValueT>
330  const SimpleFad<ValueT>& b) {
331  int sz = a.size() >= b.size() ? a.size() : b.size();
332  SimpleFad<ValueT> c(sz, std::pow(a.val(), b.val()));
333  typedef typename SimpleFad<ValueT>::value_type value_type;
334  if (a.hasFastAccess() && b.hasFastAccess()) {
335  if (a.val() != value_type(0)) {
336  ValueT t1 = c.val()*b.val()/a.val();
337  ValueT t2 = c.val()*std::log(a.val());
338  for (int i=0; i<sz; i++)
339  c.fastAccessDx(i) =
340  a.fastAccessDx(i)*t1 + b.fastAccessDx(i)*t2;
341  }
342  }
343  else if (a.hasFastAccess()) {
344  if (b.val() == value_type(1)) {
345  for (int i=0; i<sz; i++)
346  c.fastAccessDx(i) = a.fastAccessDx(i);
347  }
348  else if (a.val() != value_type(0)) {
349  ValueT t1 = c.val()*b.val()/a.val();
350  for (int i=0; i<sz; i++)
351  c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
352  }
353  }
354  else if (b.hasFastAccess()) {
355  if (a.val() != value_type(0)) {
356  ValueT t2 = c.val()*std::log(a.val());
357  for (int i=0; i<sz; i++)
358  c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
359  }
360  }
361 
362  return c;
363  }
364 
365  template <typename ValueT>
366  SimpleFad<ValueT>
368  const SimpleFad<ValueT>& b) {
369  typedef typename SimpleFad<ValueT>::value_type value_type;
370  ValueT t = std::pow(a,b.val());
371  if (a != value_type(0))
372  return SimpleFad<ValueT>(b, t, t*std::log(a));
373  else
374  return SimpleFad<ValueT>(b, t, value_type(0));
375  }
376 
377  template <typename ValueT>
378  SimpleFad<ValueT>
380  const typename SimpleFad<ValueT>::value_type& b) {
381  typedef typename SimpleFad<ValueT>::value_type value_type;
382  ValueT t = std::pow(a.val(),b);
383  if (b == value_type(1))
384  return a;
385  else if (a.val() != value_type(0))
386  return SimpleFad<ValueT>(a, t, t*b/a.val());
387  else
388  return SimpleFad<ValueT>(a, t, value_type(0));
389  }
390 
391  template <typename ValueT>
392  SimpleFad<ValueT>
394  const SimpleFad<ValueT>& b) {
395  int sz = a.size() >= b.size() ? a.size() : b.size();
396  SimpleFad<ValueT> c(sz, std::atan2(a.val(), b.val()));
397  if (a.hasFastAccess() && b.hasFastAccess()) {
398  ValueT t = a.val()*a.val() + b.val()*b.val();
399  ValueT t1 = b.val()/t;
400  ValueT t2 = a.val()/t;
401  for (int i=0; i<sz; i++)
402  c.fastAccessDx(i) =
403  a.fastAccessDx(i)*t1 - b.fastAccessDx(i)*t2;
404  }
405  else if (a.hasFastAccess()) {
406  ValueT t1 = b.val()/(a.val()*a.val() + b.val()*b.val());
407  for (int i=0; i<sz; i++)
408  c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
409  }
410  else if (b.hasFastAccess()) {
411  ValueT t2 = -a.val()/(a.val()*a.val() + b.val()*b.val());
412  for (int i=0; i<sz; i++)
413  c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
414  }
415 
416  return c;
417  }
418 
419  template <typename ValueT>
420  SimpleFad<ValueT>
422  const SimpleFad<ValueT>& b) {
423  return SimpleFad<ValueT>(b, std::atan2(a,b.val()),
424  -a/(a*a + b.val()*b.val()));
425  }
426 
427  template <typename ValueT>
428  SimpleFad<ValueT>
430  const typename SimpleFad<ValueT>::value_type& b) {
431  return SimpleFad<ValueT>(a, std::atan2(a.val(),b),
432  b/(a.val()*a.val() + b*b));
433  }
434 
435  template <typename ValueT>
436  SimpleFad<ValueT>
438  const SimpleFad<ValueT>& b) {
439  int sz = a.size() >= b.size() ? a.size() : b.size();
440  SimpleFad<ValueT> c(sz, std::max(a.val(), b.val()));
441  if (a.hasFastAccess() && b.hasFastAccess()) {
442  if (a.val() >= b.val())
443  for (int i=0; i<sz; i++)
444  c.fastAccessDx(i) = a.fastAccessDx(i);
445  else
446  for (int i=0; i<sz; i++)
447  c.fastAccessDx(i) = b.fastAccessDx(i);
448  }
449  else if (a.hasFastAccess()) {
450  if (a.val() >= b.val())
451  for (int i=0; i<sz; i++)
452  c.fastAccessDx(i) = a.fastAccessDx(i);
453  else
454  for (int i=0; i<sz; i++)
455  c.fastAccessDx(i) = 0.0;
456  }
457  else if (b.hasFastAccess()) {
458  if (a.val() >= b.val())
459  for (int i=0; i<sz; i++)
460  c.fastAccessDx(i) = 0.0;
461  else
462  for (int i=0; i<sz; i++)
463  c.fastAccessDx(i) = b.fastAccessDx(i);
464  }
465 
466  return c;
467  }
468 
469  template <typename ValueT>
470  SimpleFad<ValueT>
472  const SimpleFad<ValueT>& b) {
473  SimpleFad<ValueT> c(b.size(), std::max(a, b.val()));
474  if (a >= b.val())
475  for (int i=0; i<c.size(); i++)
476  c.fastAccessDx(i) = 0.0;
477  else
478  for (int i=0; i<c.size(); i++)
479  c.fastAccessDx(i) = b.fastAccessDx(i);
480 
481  return c;
482  }
483 
484  template <typename ValueT>
485  SimpleFad<ValueT>
487  const typename SimpleFad<ValueT>::value_type& b) {
488  SimpleFad<ValueT> c(a.size(), std::max(a.val(), b));
489  if (a.val() >= b)
490  for (int i=0; i<c.size(); i++)
491  c.fastAccessDx(i) = a.fastAccessDx(i);
492  else
493  for (int i=0; i<c.size(); i++)
494  c.fastAccessDx(i) = 0.0;
495 
496  return c;
497  }
498 
499  template <typename ValueT>
500  SimpleFad<ValueT>
502  const SimpleFad<ValueT>& b) {
503  int sz = a.size() >= b.size() ? a.size() : b.size();
504  SimpleFad<ValueT> c(sz, std::min(a.val(), b.val()));
505  if (a.hasFastAccess() && b.hasFastAccess()) {
506  if (a.val() <= b.val())
507  for (int i=0; i<sz; i++)
508  c.fastAccessDx(i) = a.fastAccessDx(i);
509  else
510  for (int i=0; i<sz; i++)
511  c.fastAccessDx(i) = b.fastAccessDx(i);
512  }
513  else if (a.hasFastAccess()) {
514  if (a.val() <= b.val())
515  for (int i=0; i<sz; i++)
516  c.fastAccessDx(i) = a.fastAccessDx(i);
517  else
518  for (int i=0; i<sz; i++)
519  c.fastAccessDx(i) = 0.0;
520  }
521  else if (b.hasFastAccess()) {
522  if (a.val() <= b.val())
523  for (int i=0; i<sz; i++)
524  c.fastAccessDx(i) = 0.0;
525  else
526  for (int i=0; i<sz; i++)
527  c.fastAccessDx(i) = b.fastAccessDx(i);
528  }
529 
530  return c;
531  }
532 
533  template <typename ValueT>
534  SimpleFad<ValueT>
536  const SimpleFad<ValueT>& b) {
537  SimpleFad<ValueT> c(b.size(), std::min(a, b.val()));
538  if (a <= b.val())
539  for (int i=0; i<c.size(); i++)
540  c.fastAccessDx(i) = 0.0;
541  else
542  for (int i=0; i<c.size(); i++)
543  c.fastAccessDx(i) = b.fastAccessDx(i);
544 
545  return c;
546  }
547 
548  template <typename ValueT>
549  SimpleFad<ValueT>
551  const typename SimpleFad<ValueT>::value_type& b) {
552  SimpleFad<ValueT> c(a.size(), std::min(a.val(), b));
553  if (a.val() <= b)
554  for (int i=0; i<c.size(); i++)
555  c.fastAccessDx(i) = a.fastAccessDx(i);
556  else
557  for (int i=0; i<c.size(); i++)
558  c.fastAccessDx(i) = 0.0;
559 
560  return c;
561  }
562 
563  } // namespace Fad
564 
565 } // namespace Sacado
566 
567  //-------------------------- Relational Operators -----------------------
568 
569 #define FAD_RELOP_MACRO(OP) \
570 namespace Sacado { \
571  namespace Fad { \
572  template <typename ValueT> \
573  inline bool \
574  operator OP (const SimpleFad<ValueT>& a, \
575  const SimpleFad<ValueT>& b) \
576  { \
577  return a.val() OP b.val(); \
578  } \
579  \
580  template <typename ValueT> \
581  inline bool \
582  operator OP (const ValueT& a, \
583  const SimpleFad<ValueT>& b) \
584  { \
585  return a OP b.val(); \
586  } \
587  \
588  template <typename ValueT> \
589  inline bool \
590  operator OP (const SimpleFad<ValueT>& a, \
591  const ValueT& b) \
592  { \
593  return a.val() OP b; \
594  } \
595  } \
596 }
597 
598 FAD_RELOP_MACRO(==)
599 FAD_RELOP_MACRO(!=)
602 FAD_RELOP_MACRO(<=)
603 FAD_RELOP_MACRO(>=)
604 FAD_RELOP_MACRO(<<=)
605 FAD_RELOP_MACRO(>>=)
608 
609 #undef FAD_RELOP_MACRO
610 
611 namespace Sacado {
612 
613  namespace Fad {
614 
615  template <typename ValueT>
616  inline bool operator ! (const SimpleFad<ValueT>& a)
617  {
618  return ! a.val();
619  }
620 
621  } // namespace Fad
622 
623 } // namespace Sacado
624 
625 //-------------------------- Boolean Operators -----------------------
626 namespace Sacado {
627 
628  namespace Fad {
629 
630  template <typename T>
631  bool toBool(const SimpleFad<T>& x) {
632  bool is_zero = (x.val() == 0.0);
633  for (int i=0; i<x.size(); i++)
634  is_zero = is_zero && (x.dx(i) == 0.0);
635  return !is_zero;
636  }
637 
638  } // namespace Fad
639 
640 } // namespace Sacado
641 
642 #define FAD_BOOL_MACRO(OP) \
643 namespace Sacado { \
644  namespace Fad { \
645  template <typename T1, typename T2> \
646  inline bool \
647  operator OP (const SimpleFad<T1>& expr1, \
648  const SimpleFad<T2>& expr2) \
649  { \
650  return toBool(expr1) OP toBool(expr2); \
651  } \
652  \
653  template <typename T2> \
654  inline bool \
655  operator OP (const typename SimpleFad<T2>::value_type& a, \
656  const SimpleFad<T2>& expr2) \
657  { \
658  return a OP toBool(expr2); \
659  } \
660  \
661  template <typename T1> \
662  inline bool \
663  operator OP (const SimpleFad<T1>& expr1, \
664  const typename SimpleFad<T1>::value_type& b) \
665  { \
666  return toBool(expr1) OP b; \
667  } \
668  } \
669 }
670 
671 FAD_BOOL_MACRO(&&)
672 FAD_BOOL_MACRO(||)
673 
674 #undef FAD_BOOL_MACRO
675 
676 //-------------------------- I/O Operators -----------------------
677 
678 namespace Sacado {
679 
680  namespace Fad {
681 
682  template <typename ValueT>
683  std::ostream& operator << (std::ostream& os,
684  const SimpleFad<ValueT>& x) {
685  os << x.val() << " [";
686 
687  for (int i=0; i< x.size(); i++) {
688  os << " " << x.dx(i);
689  }
690 
691  os << " ]";
692  return os;
693  }
694 
695  } // namespace Fad
696 
697 } // namespace Sacado
698 
699 #endif // SACADO_FAD_SIMPLEFADOPS_HPP
cbrt(expr.val())
asinh(expr.val())
asin(expr.val())
cosh(expr.val())
abs(expr.val())
atanh(expr.val())
SimpleFad< ValueT > atan2(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
SimpleFad< ValueT > abs(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > sqrt(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > asin(const SimpleFad< ValueT > &a)
atan(expr.val())
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)
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Returns true if derivative array is not empty.
SACADO_INLINE_FUNCTION bool toBool(const Expr< ExprT > &x)
SimpleFad< ValueT > exp(const SimpleFad< ValueT > &a)
tanh(expr.val())
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
SimpleFad< ValueT > fabs(const SimpleFad< ValueT > &a)
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.
sqrt(expr.val())
sinh(expr.val())
tan(expr.val())
SimpleFad< ValueT > sin(const SimpleFad< ValueT > &a)
SACADO_INLINE_FUNCTION const ValueT & val() const
Returns value.
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)
atan2(expr1.val(), expr2.val())
SimpleFad< ValueT > cbrt(const SimpleFad< ValueT > &a)
#define FAD_BOOL_MACRO(OP)
sin(expr.val())
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 int size() const
Returns number of derivative components.
log(expr.val())
SACADO_INLINE_FUNCTION bool operator!(const Expr< ExprT > &expr)
SimpleFad< ValueT > cos(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > cosh(const SimpleFad< ValueT > &a)
acosh(expr.val())
SimpleFad< ValueT > operator*(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
acos(expr.val())
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
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)
exp(expr.val())
fabs(expr.val())
SimpleFad< ValueT > acos(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > tanh(const SimpleFad< ValueT > &a)
SACADO_INLINE_FUNCTION const ValueT * dx() const
Returns derivative array.
log10(expr.val())
cos(expr.val())
SimpleFad< ValueT > asinh(const SimpleFad< ValueT > &a)
SimpleFad< ValueT > operator+(const SimpleFad< ValueT > &a)