Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Sacado_MathFunctions.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 SACADO_MATHFUNCTIONS_HPP
31 #define SACADO_MATHFUNCTIONS_HPP
32 
33 #include <cmath>
34 
35 #include "Sacado_ConfigDefs.h"
36 #include "Sacado_Base.hpp"
37 #include "Sacado_Fad_ExpressionFwd.hpp"
38 #include "Sacado_SFINAE_Macros.hpp"
39 
40 // Note: Sacado::Fad::Ops are forward-declared here, instead of in macros
41 // below.
42 #include "Sacado_Fad_Ops_Fwd.hpp"
43 
44 #define UNARYFUNC_MACRO(OP,FADOP) \
45 namespace Sacado { \
46  \
47  namespace Fad { \
48  template <typename T> \
49  SACADO_INLINE_FUNCTION \
50  Expr< FADOP< Expr<T> > > OP (const Expr<T>&); \
51  \
52  template <typename T> class SimpleFad; \
53  template <typename T> \
54  SimpleFad<T> OP (const SimpleFad<T>&); \
55  } \
56  \
57  namespace ELRFad { \
58  template <typename T> class FADOP; \
59  template <typename T> class Expr; \
60  template <typename T> \
61  SACADO_INLINE_FUNCTION \
62  Expr< FADOP< Expr<T> > > OP (const Expr<T>&); \
63  } \
64  \
65  namespace CacheFad { \
66  template <typename T> class FADOP; \
67  template <typename T> class Expr; \
68  template <typename T> \
69  SACADO_INLINE_FUNCTION \
70  Expr< FADOP< Expr<T> > > OP (const Expr<T>&); \
71  } \
72  \
73  namespace ELRCacheFad { \
74  template <typename T> class FADOP; \
75  template <typename T> class Expr; \
76  template <typename T> \
77  SACADO_INLINE_FUNCTION \
78  Expr< FADOP< Expr<T> > > OP (const Expr<T>&); \
79  } \
80  \
81  namespace LFad { \
82  template <typename T> class FADOP; \
83  template <typename T> class Expr; \
84  template <typename T> \
85  Expr< FADOP< Expr<T> > > OP (const Expr<T>&); \
86  } \
87  \
88  namespace Tay { \
89  template <typename T> class Taylor; \
90  template <typename T> Taylor<T> OP (const Base< Taylor<T> >&); \
91  } \
92  \
93  namespace FlopCounterPack { \
94  template <typename T> class ScalarFlopCounter; \
95  template <typename T> \
96  ScalarFlopCounter<T> OP (const Base< ScalarFlopCounter<T> >&); \
97  } \
98  \
99  namespace Rad { \
100  template <typename T> class ADvari; \
101  template <typename T> class IndepADvar; \
102  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&); \
103  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&); \
104  } \
105 } \
106  \
107 namespace std { \
108  using Sacado::Fad::OP; \
109  using Sacado::ELRFad::OP; \
110  using Sacado::CacheFad::OP; \
111  using Sacado::ELRCacheFad::OP; \
112  using Sacado::LFad::OP; \
113  using Sacado::Tay::OP; \
114  using Sacado::FlopCounterPack::OP; \
115  using Sacado::Rad::OP; \
116 }
117 
118 UNARYFUNC_MACRO(exp, ExpOp)
119 UNARYFUNC_MACRO(log, LogOp)
120 UNARYFUNC_MACRO(log10, Log10Op)
121 UNARYFUNC_MACRO(sqrt, SqrtOp)
122 UNARYFUNC_MACRO(cos, CosOp)
123 UNARYFUNC_MACRO(sin, SinOp)
124 UNARYFUNC_MACRO(tan, TanOp)
125 UNARYFUNC_MACRO(acos, ACosOp)
126 UNARYFUNC_MACRO(asin, ASinOp)
127 UNARYFUNC_MACRO(atan, ATanOp)
128 UNARYFUNC_MACRO(cosh, CoshOp)
129 UNARYFUNC_MACRO(sinh, SinhOp)
130 UNARYFUNC_MACRO(tanh, TanhOp)
131 UNARYFUNC_MACRO(acosh, ACoshOp)
132 UNARYFUNC_MACRO(asinh, ASinhOp)
133 UNARYFUNC_MACRO(atanh, ATanhOp)
134 UNARYFUNC_MACRO(abs, AbsOp)
135 UNARYFUNC_MACRO(fabs, FAbsOp)
136 UNARYFUNC_MACRO(cbrt, CbrtOp)
137 
138 #undef UNARYFUNC_MACRO
139 
140 namespace Sacado {
141  namespace Fad {
142  template <typename T>
143  SACADO_INLINE_FUNCTION
144  Expr< SafeSqrtOp< Expr<T> > > safe_sqrt (const Expr<T>&);
145  }
146 
147  namespace ELRFad {
148  template <typename T> class SafeSqrtOp;
149  template <typename T>
150  SACADO_INLINE_FUNCTION
151  Expr< SafeSqrtOp< Expr<T> > > safe_sqrt (const Expr<T>&);
152  }
153 
154  namespace CacheFad {
155  template <typename T> class SafeSqrtOp;
156  template <typename T>
157  SACADO_INLINE_FUNCTION
158  Expr< SafeSqrtOp< Expr<T> > > safe_sqrt (const Expr<T>&);
159  }
160 
161  namespace ELRCacheFad {
162  template <typename T> class SafeSqrtOp;
163  template <typename T>
164  SACADO_INLINE_FUNCTION
165  Expr< SafeSqrtOp< Expr<T> > > safe_sqrt (const Expr<T>&);
166  }
167 }
168 
169 #define BINARYFUNC_MACRO(OP,FADOP) \
170 namespace Sacado { \
171  \
172  namespace Fad { \
173  template <typename T> class ConstExpr; \
174  template <typename T> struct IsFadExpr; \
175  template <typename T> struct ExprLevel; \
176  template <typename T1, typename T2> \
177  SACADO_INLINE_FUNCTION \
178  typename mpl::enable_if_c< \
179  ExprLevel< Expr<T1> >::value == ExprLevel< Expr<T2> >::value, \
180  Expr< FADOP< Expr<T1>, Expr<T2> > > \
181  >::type \
182  /*SACADO_FAD_OP_ENABLE_EXPR_EXPR(FADOP)*/ \
183  OP (const Expr<T1>&, const Expr<T2>&); \
184  \
185  template <typename T> \
186  SACADO_INLINE_FUNCTION \
187  Expr< FADOP< Expr<T>, Expr<T> > > \
188  OP (const Expr<T>&, const Expr<T>&); \
189  \
190  template <typename T> \
191  SACADO_INLINE_FUNCTION \
192  Expr< FADOP< ConstExpr<typename Expr<T>::value_type>, Expr<T> > > \
193  OP (const typename Expr<T>::value_type&, const Expr<T>&); \
194  \
195  template <typename T> \
196  SACADO_INLINE_FUNCTION \
197  Expr< FADOP< Expr<T>, ConstExpr<typename Expr<T>::value_type> > > \
198  OP (const Expr<T>&, const typename Expr<T>::value_type&); \
199  \
200  template <typename T> \
201  SACADO_INLINE_FUNCTION \
202  SACADO_FAD_OP_ENABLE_SCALAR_EXPR(FADOP) \
203  OP (const typename Expr<T>::scalar_type&, const Expr<T>&); \
204  \
205  template <typename T> \
206  SACADO_INLINE_FUNCTION \
207  SACADO_FAD_OP_ENABLE_EXPR_SCALAR(FADOP) \
208  OP (const Expr<T>&, const typename Expr<T>::scalar_type&); \
209  \
210  template <typename T> class SimpleFad; \
211  template <typename T> \
212  SimpleFad<T> \
213  OP (const SimpleFad<T>&, const SimpleFad<T>&); \
214  \
215  template <typename T> \
216  SimpleFad<T> \
217  OP (const SimpleFad<T>&, \
218  const typename SimpleFad<T>::value_type&); \
219  \
220  template <typename T> \
221  SimpleFad<T> \
222  OP (const typename SimpleFad<T>::value_type&, \
223  const SimpleFad<T>&); \
224  } \
225  \
226  namespace ELRFad { \
227  template <typename T1, typename T2> class FADOP; \
228  template <typename T> class Expr; \
229  template <typename T> class ConstExpr; \
230  template <typename T> struct IsFadExpr; \
231  template <typename T> struct ExprLevel; \
232  template <typename T1, typename T2> \
233  SACADO_INLINE_FUNCTION \
234  SACADO_FAD_OP_ENABLE_EXPR_EXPR(FADOP) \
235  OP (const T1&, const T2&); \
236  \
237  template <typename T> \
238  SACADO_INLINE_FUNCTION \
239  Expr< FADOP< Expr<T>, Expr<T> > > \
240  OP (const Expr<T>&, const Expr<T>&); \
241  \
242  template <typename T> \
243  SACADO_INLINE_FUNCTION \
244  Expr< FADOP< ConstExpr<typename Expr<T>::value_type>, Expr<T> > > \
245  OP (const typename Expr<T>::value_type&, const Expr<T>&); \
246  \
247  template <typename T> \
248  SACADO_INLINE_FUNCTION \
249  Expr< FADOP< Expr<T>, ConstExpr<typename Expr<T>::value_type> > > \
250  OP (const Expr<T>&, const typename Expr<T>::value_type&); \
251  \
252  template <typename T> \
253  SACADO_INLINE_FUNCTION \
254  SACADO_FAD_OP_ENABLE_SCALAR_EXPR(FADOP) \
255  OP (const typename Expr<T>::scalar_type&, const Expr<T>&); \
256  \
257  template <typename T> \
258  SACADO_INLINE_FUNCTION \
259  SACADO_FAD_OP_ENABLE_EXPR_SCALAR(FADOP) \
260  OP (const Expr<T>&, const typename Expr<T>::scalar_type&); \
261  } \
262  \
263  namespace CacheFad { \
264  template <typename T1, typename T2> class FADOP; \
265  template <typename T> class Expr; \
266  template <typename T> class ConstExpr; \
267  template <typename T> struct IsFadExpr; \
268  template <typename T> struct ExprLevel; \
269  template <typename T1, typename T2> \
270  SACADO_INLINE_FUNCTION \
271  SACADO_FAD_OP_ENABLE_EXPR_EXPR(FADOP) \
272  OP (const T1&, const T2&); \
273  \
274  template <typename T> \
275  SACADO_INLINE_FUNCTION \
276  Expr< FADOP< Expr<T>, Expr<T> > > \
277  OP (const Expr<T>&, const Expr<T>&); \
278  \
279  template <typename T> \
280  SACADO_INLINE_FUNCTION \
281  Expr< FADOP< ConstExpr<typename Expr<T>::value_type>, Expr<T> > > \
282  OP (const typename Expr<T>::value_type&, const Expr<T>&); \
283  \
284  template <typename T> \
285  SACADO_INLINE_FUNCTION \
286  Expr< FADOP< Expr<T>, ConstExpr<typename Expr<T>::value_type> > > \
287  OP (const Expr<T>&, const typename Expr<T>::value_type&); \
288  \
289  template <typename T> \
290  SACADO_INLINE_FUNCTION \
291  SACADO_FAD_OP_ENABLE_SCALAR_EXPR(FADOP) \
292  OP (const typename Expr<T>::scalar_type&, const Expr<T>&); \
293  \
294  template <typename T> \
295  SACADO_INLINE_FUNCTION \
296  SACADO_FAD_OP_ENABLE_EXPR_SCALAR(FADOP) \
297  OP (const Expr<T>&, const typename Expr<T>::scalar_type&); \
298  } \
299  \
300  namespace ELRCacheFad { \
301  template <typename T1, typename T2> class FADOP; \
302  template <typename T> class Expr; \
303  template <typename T> class ConstExpr; \
304  template <typename T> struct IsFadExpr; \
305  template <typename T> struct ExprLevel; \
306  template <typename T1, typename T2> \
307  SACADO_INLINE_FUNCTION \
308  SACADO_FAD_OP_ENABLE_EXPR_EXPR(FADOP) \
309  OP (const T1&, const T2&); \
310  \
311  template <typename T> \
312  SACADO_INLINE_FUNCTION \
313  Expr< FADOP< Expr<T>, Expr<T> > > \
314  OP (const Expr<T>&, const Expr<T>&); \
315  \
316  template <typename T> \
317  SACADO_INLINE_FUNCTION \
318  Expr< FADOP< ConstExpr<typename Expr<T>::value_type>, Expr<T> > > \
319  OP (const typename Expr<T>::value_type&, const Expr<T>&); \
320  \
321  template <typename T> \
322  SACADO_INLINE_FUNCTION \
323  Expr< FADOP< Expr<T>, ConstExpr<typename Expr<T>::value_type> > > \
324  OP (const Expr<T>&, const typename Expr<T>::value_type&); \
325  \
326  template <typename T> \
327  SACADO_INLINE_FUNCTION \
328  SACADO_FAD_OP_ENABLE_SCALAR_EXPR(FADOP) \
329  OP (const typename Expr<T>::scalar_type&, const Expr<T>&); \
330  \
331  template <typename T> \
332  SACADO_INLINE_FUNCTION \
333  SACADO_FAD_OP_ENABLE_EXPR_SCALAR(FADOP) \
334  OP (const Expr<T>&, const typename Expr<T>::scalar_type&); \
335  } \
336  \
337  namespace LFad { \
338  template <typename T1, typename T2> class FADOP; \
339  template <typename T> class Expr; \
340  \
341  template <typename T1, typename T2> \
342  Expr< FADOP< Expr<T1>, Expr<T2> > > \
343  OP (const Expr<T1>&, const Expr<T2>&); \
344  \
345  template <typename T> \
346  Expr< FADOP< Expr<T>, Expr<T> > > \
347  OP (const Expr<T>&, const Expr<T>&); \
348  \
349  template <typename T> \
350  Expr< FADOP< typename Expr<T>::value_type, Expr<T> > > \
351  OP (const typename Expr<T>::value_type&, const Expr<T>&); \
352  \
353  template <typename T> \
354  Expr< FADOP< Expr<T>, typename Expr<T>::value_type > > \
355  OP (const Expr<T>&, const typename Expr<T>::value_type&); \
356  } \
357  \
358  namespace Tay { \
359  template <typename T> class Taylor; \
360  template <typename T> Taylor<T> OP ( \
361  const Base< Taylor<T> >&, \
362  const Base< Taylor<T> >&); \
363  template <typename T> Taylor<T> OP ( \
364  const typename Taylor<T>::value_type&, \
365  const Base< Taylor<T> >&); \
366  template <typename T> Taylor<T> OP ( \
367  const Base< Taylor<T> >&, \
368  const typename Taylor<T>::value_type&); \
369  } \
370  \
371  namespace FlopCounterPack { \
372  template <typename T> class ScalarFlopCounter; \
373  template <typename T> \
374  ScalarFlopCounter<T> OP ( \
375  const Base< ScalarFlopCounter<T> >&, \
376  const Base< ScalarFlopCounter<T> >&); \
377  template <typename T> \
378  ScalarFlopCounter<T> OP ( \
379  const typename ScalarFlopCounter<T>::value_type&, \
380  const Base< ScalarFlopCounter<T> >&); \
381  template <typename T> \
382  ScalarFlopCounter<T> OP ( \
383  const Base< ScalarFlopCounter<T> >&, \
384  const typename ScalarFlopCounter<T>::value_type&); \
385  template <typename T> \
386  ScalarFlopCounter<T> OP ( \
387  const int&, \
388  const Base< ScalarFlopCounter<T> >&); \
389  template <typename T> \
390  ScalarFlopCounter<T> OP ( \
391  const Base< ScalarFlopCounter<T> >&, \
392  const int&); \
393  } \
394  \
395  namespace Rad { \
396  template <typename T> class ADvari; \
397  template <typename T> class IndepADvar; \
398  template <typename T> class DoubleAvoid; \
399  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
400  const Base< ADvari<T> >&); \
401  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
402  const Base< ADvari<T> >&); \
403  template <typename T> ADvari<T>& OP (T, \
404  const Base< ADvari<T> >&); \
405  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::dtype,\
406  const Base< ADvari<T> >&); \
407  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::itype,\
408  const Base< ADvari<T> >&); \
409  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::ltype,\
410  const Base< ADvari<T> >&); \
411  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
412  const Base< IndepADvar<T> >&); \
413  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
414  T); \
415  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
416  typename DoubleAvoid<T>::dtype);\
417  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
418  typename DoubleAvoid<T>::itype);\
419  template <typename T> ADvari<T>& OP (const Base< ADvari<T> >&, \
420  typename DoubleAvoid<T>::ltype);\
421  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
422  const Base< IndepADvar<T> >&); \
423  template <typename T> ADvari<T>& OP (T, \
424  const Base< IndepADvar<T> >&); \
425  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::dtype,\
426  const Base< IndepADvar<T> >&); \
427  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::itype,\
428  const Base< IndepADvar<T> >&); \
429  template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::ltype,\
430  const Base< IndepADvar<T> >&); \
431  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
432  T); \
433  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
434  typename DoubleAvoid<T>::dtype);\
435  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
436  typename DoubleAvoid<T>::itype);\
437  template <typename T> ADvari<T>& OP (const Base< IndepADvar<T> >&, \
438  typename DoubleAvoid<T>::ltype);\
439  } \
440  \
441 } \
442  \
443 namespace std { \
444  using Sacado::Fad::OP; \
445  using Sacado::ELRFad::OP; \
446  using Sacado::CacheFad::OP; \
447  using Sacado::ELRCacheFad::OP; \
448  using Sacado::LFad::OP; \
449  using Sacado::Tay::OP; \
450  using Sacado::FlopCounterPack::OP; \
451  using Sacado::Rad::OP; \
452 }
453 
454 BINARYFUNC_MACRO(atan2, Atan2Op)
455 BINARYFUNC_MACRO(pow, PowerOp)
456 BINARYFUNC_MACRO(max, MaxOp)
457 BINARYFUNC_MACRO(min, MinOp)
458 
459 #undef BINARYFUNC_MACRO
460 
461 #if defined(HAVE_SACADO_KOKKOS)
462 
463 namespace Sacado {
464 #ifndef SACADO_NEW_FAD_DESIGN_IS_DEFAULT
465  namespace Fad {
466  template <typename ValT, unsigned sl, unsigned ss, typename U>
467  class ViewFadPtr;
468  template <typename T> class DFad;
469  template <typename T, int N> class SFad;
470  template <typename T, int N> class SLFad;
471  template <typename T>
472  SACADO_INLINE_FUNCTION
473  void atomic_add(DFad<T>* dst, const DFad<T>& x);
474  template <typename T, int N>
475  SACADO_INLINE_FUNCTION
476  void atomic_add(SFad<T,N>* dst, const SFad<T,N>& x);
477  template <typename T, int N>
478  SACADO_INLINE_FUNCTION
479  void atomic_add(SLFad<T,N>* dst, const SLFad<T,N>& x);
480  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
481  SACADO_INLINE_FUNCTION
482  void atomic_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
483  }
484 #endif
485  namespace ELRFad {
486  template <typename ValT, unsigned sl, unsigned ss, typename U>
487  class ViewFadPtr;
488  template <typename T> class DFad;
489  template <typename T, int N> class SFad;
490  template <typename T, int N> class SLFad;
491  template <typename T>
492  SACADO_INLINE_FUNCTION
493  void atomic_add(DFad<T>* dst, const DFad<T>& x);
494  template <typename T, int N>
495  SACADO_INLINE_FUNCTION
496  void atomic_add(SFad<T,N>* dst, const SFad<T,N>& x);
497  template <typename T, int N>
498  SACADO_INLINE_FUNCTION
499  void atomic_add(SLFad<T,N>* dst, const SLFad<T,N>& x);
500  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
501  SACADO_INLINE_FUNCTION
502  void atomic_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
503  }
504  namespace CacheFad {
505  template <typename ValT, unsigned sl, unsigned ss, typename U>
506  class ViewFadPtr;
507  template <typename T> class DFad;
508  template <typename T, int N> class SFad;
509  template <typename T, int N> class SLFad;
510  template <typename T>
511  SACADO_INLINE_FUNCTION
512  void atomic_add(DFad<T>* dst, const DFad<T>& x);
513  template <typename T, int N>
514  SACADO_INLINE_FUNCTION
515  void atomic_add(SFad<T,N>* dst, const SFad<T,N>& x);
516  template <typename T, int N>
517  SACADO_INLINE_FUNCTION
518  void atomic_add(SLFad<T,N>* dst, const SLFad<T,N>& x);
519  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
520  SACADO_INLINE_FUNCTION
521  void atomic_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
522  }
523  namespace ELRCacheFad {
524  template <typename ValT, unsigned sl, unsigned ss, typename U>
525  class ViewFadPtr;
526  template <typename T> class DFad;
527  template <typename T, int N> class SFad;
528  template <typename T, int N> class SLFad;
529  template <typename T>
530  SACADO_INLINE_FUNCTION
531  void atomic_add(DFad<T>* dst, const DFad<T>& x);
532  template <typename T, int N>
533  SACADO_INLINE_FUNCTION
534  void atomic_add(SFad<T,N>* dst, const SFad<T,N>& x);
535  template <typename T, int N>
536  SACADO_INLINE_FUNCTION
537  void atomic_add(SLFad<T,N>* dst, const SLFad<T,N>& x);
538  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
539  SACADO_INLINE_FUNCTION
540  void atomic_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
541  }
542 }
543 
544 namespace Kokkos {
545 #ifndef SACADO_NEW_FAD_DESIGN_IS_DEFAULT
546  using Sacado::Fad::atomic_add;
547 #endif
548  using Sacado::ELRFad::atomic_add;
549  using Sacado::CacheFad::atomic_add;
550  using Sacado::ELRCacheFad::atomic_add;
551 }
552 
553 #endif
554 
555 #ifdef SACADO_ENABLE_NEW_DESIGN
556 #include "Sacado_Fad_Exp_MathFunctions.hpp"
557 #endif
558 
559 #endif // SACADO_MATHFUNCTIONS_HPP
cbrt
cbrt(expr.val())
SinOp
expr expr SinOp
Definition: Sacado_Fad_Exp_Ops.hpp:198
MaxOp
expr2 expr1 expr2 expr2 c *expr2 c *expr1 c *expr2 c *expr1 MaxOp
Definition: Sacado_Fad_Exp_Ops.hpp:840
asinh
asinh(expr.val())
asin
asin(expr.val())
Sacado::CacheFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
cosh
cosh(expr.val())
abs
abs(expr.val())
Sacado::Fad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
atanh
atanh(expr.val())
CoshOp
expr expr CoshOp
Definition: Sacado_Fad_Exp_Ops.hpp:232
ATanhOp
expr expr ATanhOp
Definition: Sacado_Fad_Exp_Ops.hpp:265
Sacado_SFINAE_Macros.hpp
Sacado::Fad::Exp::SLFad
GeneralFad< StaticStorage< T, Num > > SLFad
Definition: Sacado_Fad_Exp_SLFad.hpp:42
TanhOp
expr expr TanhOp
Definition: Sacado_Fad_Exp_Ops.hpp:244
SqrtOp
expr expr SqrtOp
Definition: Sacado_Fad_Exp_Ops.hpp:186
ASinhOp
expr expr ASinhOp
Definition: Sacado_Fad_Exp_Ops.hpp:258
atan
atan(expr.val())
FAbsOp
FAbsOp
Definition: Sacado_Fad_Exp_Ops.hpp:278
Atan2Op
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 expr1 expr1 c *expr2 expr1 c *expr2 expr1 c *expr2 expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 Atan2Op
Definition: Sacado_Fad_Exp_Ops.hpp:808
Sacado_Fad_Exp_MathFunctions.hpp
Sacado_Fad_ExpressionFwd.hpp
tanh
tanh(expr.val())
CosOp
expr expr CosOp
Definition: Sacado_Fad_Exp_Ops.hpp:192
CbrtOp
CbrtOp
Definition: Sacado_Fad_Exp_Ops.hpp:284
BINARYFUNC_MACRO
#define BINARYFUNC_MACRO(OP, FADOP)
Definition: Sacado_MathFunctions.hpp:169
ATanOp
expr expr ATanOp
Definition: Sacado_Fad_Exp_Ops.hpp:226
Sacado::Fad::Exp::DFad
GeneralFad< DynamicStorage< T > > DFad
Definition: Sacado_Fad_Exp_DFad.hpp:42
Sacado::Fad::min
SimpleFad< ValueT > min(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:501
ACosOp
expr expr ACosOp
Definition: Sacado_Fad_Exp_Ops.hpp:212
Sacado_Base.hpp
sqrt
sqrt(expr.val())
Sacado::ELRCacheFad::Expr
Wrapper for a generic expression template.
Definition: Sacado_ELRCacheFad_Expression.hpp:77
sinh
sinh(expr.val())
tan
tan(expr.val())
atan2
atan2(expr1.val(), expr2.val())
sin
sin(expr.val())
Sacado::ELRFad::Expr
Wrapper for a generic expression template.
Definition: Sacado_ELRFad_Expression.hpp:77
MinOp
MinOp
Definition: Sacado_Fad_Exp_Ops.hpp:854
x
int x
Definition: gmock-matchers_test.cc:3775
Sacado_Fad_Ops_Fwd.hpp
log
log(expr.val())
ACoshOp
expr expr ACoshOp
Definition: Sacado_Fad_Exp_Ops.hpp:250
Log10Op
expr expr Log10Op
Definition: Sacado_Fad_Exp_Ops.hpp:180
SinhOp
expr expr SinhOp
Definition: Sacado_Fad_Exp_Ops.hpp:238
acosh
acosh(expr.val())
LogOp
LogOp
Definition: Sacado_Fad_Exp_Ops.hpp:174
acos
acos(expr.val())
Sacado::Fad::max
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:437
ASinOp
expr expr ASinOp
Definition: Sacado_Fad_Exp_Ops.hpp:219
Sacado::Fad::pow
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)
Definition: Sacado_Fad_Ops.hpp:2098
Sacado_ConfigDefs.h
SACADO_INLINE_FUNCTION
#define SACADO_INLINE_FUNCTION
Definition: Sacado_ConfigDefs.h:110
exp
exp(expr.val())
ExpOp
expr expr expr ExpOp
Definition: Sacado_Fad_Exp_Ops.hpp:168
fabs
fabs(expr.val())
AbsOp
expr expr AbsOp
Definition: Sacado_Fad_Exp_Ops.hpp:272
Sacado::CacheFad::Expr
Wrapper for a generic expression template.
Definition: Sacado_CacheFad_Expression.hpp:77
TanOp
expr expr TanOp
Definition: Sacado_Fad_Exp_Ops.hpp:204
Sacado::Fad::Exp::SFad
GeneralFad< StaticFixedStorage< T, Num > > SFad
Definition: Sacado_Fad_Exp_SFad.hpp:43
log10
log10(expr.val())
cos
cos(expr.val())
UNARYFUNC_MACRO
#define UNARYFUNC_MACRO(OP, FADOP)
Definition: Sacado_MathFunctions.hpp:44
Sacado::ELRCacheFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
Sacado::ELRFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
PowerOp
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 PowerOp
Definition: Sacado_LFad_LogicalSparseOps.hpp:432
Generated on Thu Apr 18 2024 09:23:39 for Sacado Package Browser (Single Doxygen Collection) by   doxygen 1.8.5