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