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_Exp_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_FAD_EXP_MATHFUNCTIONS_HPP
11 #define SACADO_FAD_EXP_MATHFUNCTIONS_HPP
12 
13 #include "Sacado_cmath.hpp"
14 #include "Sacado_SFINAE_Macros.hpp"
15 
16 // Note: Sacado::Fad::Ops are forward-declared here, instead of in macros
17 // below.
18 #include "Sacado_Fad_Exp_Ops_Fwd.hpp"
19 
20 #define UNARYFUNC_MACRO(OP,FADOP) \
21 namespace Sacado { \
22  \
23  namespace Fad { \
24  namespace Exp { \
25  template <typename T> class Expr; \
26  template <typename T> \
27  SACADO_INLINE_FUNCTION \
28  FADOP< typename Expr<T>::derived_type, \
29  typename T::expr_spec_type > \
30  OP (const Expr<T>&); \
31  } \
32  } \
33  \
34 } \
35  \
36 namespace std { \
37  using Sacado::Fad::Exp::OP; \
38 }
39 
40 UNARYFUNC_MACRO(exp, ExpOp)
41 UNARYFUNC_MACRO(log, LogOp)
42 UNARYFUNC_MACRO(log10, Log10Op)
43 UNARYFUNC_MACRO(sqrt, SqrtOp)
44 UNARYFUNC_MACRO(safe_sqrt, SafeSqrtOp)
45 UNARYFUNC_MACRO(cos, CosOp)
46 UNARYFUNC_MACRO(sin, SinOp)
47 UNARYFUNC_MACRO(tan, TanOp)
48 UNARYFUNC_MACRO(acos, ACosOp)
49 UNARYFUNC_MACRO(asin, ASinOp)
50 UNARYFUNC_MACRO(atan, ATanOp)
51 UNARYFUNC_MACRO(cosh, CoshOp)
52 UNARYFUNC_MACRO(sinh, SinhOp)
53 UNARYFUNC_MACRO(tanh, TanhOp)
54 UNARYFUNC_MACRO(acosh, ACoshOp)
55 UNARYFUNC_MACRO(asinh, ASinhOp)
56 UNARYFUNC_MACRO(atanh, ATanhOp)
57 UNARYFUNC_MACRO(abs, AbsOp)
58 UNARYFUNC_MACRO(fabs, FAbsOp)
59 UNARYFUNC_MACRO(cbrt, CbrtOp)
60 
61 #undef UNARYFUNC_MACRO
62 
63 #define BINARYFUNC_MACRO(OP,FADOP) \
64 namespace Sacado { \
65  \
66  namespace Fad { \
67  namespace Exp { \
68  template <typename T> class Expr; \
69  template <typename T> struct IsFadExpr; \
70  template <typename T> struct ExprLevel; \
71  template <typename T1, typename T2> \
72  SACADO_INLINE_FUNCTION \
73  SACADO_FAD_EXP_OP_ENABLE_EXPR_EXPR(FADOP) \
74  OP (const T1&, const T2&); \
75  \
76  template <typename T> \
77  SACADO_INLINE_FUNCTION \
78  FADOP< typename T::value_type, typename Expr<T>::derived_type, \
79  true, false, typename T::expr_spec_type > \
80  OP (const typename T::value_type&, const Expr<T>&); \
81  \
82  template <typename T> \
83  SACADO_INLINE_FUNCTION \
84  FADOP< typename Expr<T>::derived_type, typename T::value_type, \
85  false, true, typename T::expr_spec_type > \
86  OP (const Expr<T>&, const typename T::value_type&); \
87  \
88  template <typename T> \
89  SACADO_INLINE_FUNCTION \
90  SACADO_FAD_EXP_OP_ENABLE_SCALAR_EXPR(FADOP) \
91  OP (const typename T::scalar_type&, const Expr<T>&); \
92  \
93  template <typename T> \
94  SACADO_INLINE_FUNCTION \
95  SACADO_FAD_EXP_OP_ENABLE_EXPR_SCALAR(FADOP) \
96  OP (const Expr<T>&, const typename T::scalar_type&); \
97  } \
98  } \
99  \
100 } \
101  \
102 namespace std { \
103  using Sacado::Fad::Exp::OP; \
104 }
105 
106 BINARYFUNC_MACRO(atan2, Atan2Op)
107 BINARYFUNC_MACRO(pow, PowerOp)
108 BINARYFUNC_MACRO(max, MaxOp)
109 BINARYFUNC_MACRO(min, MinOp)
110 
111 #undef BINARYFUNC_MACRO
112 
113 #if defined(HAVE_SACADO_KOKKOS)
114 
115 namespace Sacado {
116  namespace Fad {
117  namespace Exp {
118  template <typename S> class GeneralFad;
119  template <typename ValT, unsigned sl, unsigned ss, typename U>
120  class ViewFadPtr;
121 
122  template <typename S>
123  SACADO_INLINE_FUNCTION
124  void atomic_add(GeneralFad<S>* dst, const GeneralFad<S>& x);
125  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
126  SACADO_INLINE_FUNCTION
127  void atomic_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
128 
129  template <typename S>
130  SACADO_INLINE_FUNCTION GeneralFad<S>
131  atomic_max_fetch(GeneralFad<S>* dest, const GeneralFad<S>& val);
132  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
133  SACADO_INLINE_FUNCTION U
134  atomic_max_fetch(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
135  template <typename S>
136  SACADO_INLINE_FUNCTION GeneralFad<S>
137  atomic_min_fetch(GeneralFad<S>* dest, const GeneralFad<S>& val);
138  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
139  SACADO_INLINE_FUNCTION U
140  atomic_min_fetch(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
141  template <typename S>
142  SACADO_INLINE_FUNCTION GeneralFad<S>
143  atomic_add_fetch(GeneralFad<S>* dst, const GeneralFad<S>& x);
144  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
145  SACADO_INLINE_FUNCTION U
146  atomic_add_fetch(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
147  template <typename S>
148  SACADO_INLINE_FUNCTION GeneralFad<S>
149  atomic_sub_fetch(GeneralFad<S>* dest, const GeneralFad<S>& val);
150  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
151  SACADO_INLINE_FUNCTION U
152  atomic_sub_fetch(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
153  template <typename S>
154  SACADO_INLINE_FUNCTION GeneralFad<S>
155  atomic_mul_fetch(GeneralFad<S>* dest, const GeneralFad<S>& val);
156  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
157  SACADO_INLINE_FUNCTION U
158  atomic_mul_fetch(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
159  template <typename S>
160  SACADO_INLINE_FUNCTION GeneralFad<S>
161  atomic_div_fetch(GeneralFad<S>* dest, const GeneralFad<S>& val);
162  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
163  SACADO_INLINE_FUNCTION U
164  atomic_div_fetch(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
165 
166  template <typename S>
167  SACADO_INLINE_FUNCTION GeneralFad<S>
168  atomic_fetch_max(GeneralFad<S>* dest, const GeneralFad<S>& val);
169  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
170  SACADO_INLINE_FUNCTION U
171  atomic_fetch_max(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
172  template <typename S>
173  SACADO_INLINE_FUNCTION GeneralFad<S>
174  atomic_fetch_min(GeneralFad<S>* dest, const GeneralFad<S>& val);
175  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
176  SACADO_INLINE_FUNCTION U
177  atomic_fetch_min(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
178  template <typename S>
179  SACADO_INLINE_FUNCTION GeneralFad<S>
180  atomic_fetch_add(GeneralFad<S>* dst, const GeneralFad<S>& x);
181  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
182  SACADO_INLINE_FUNCTION U
183  atomic_fetch_add(ViewFadPtr<ValT,sl,ss,U> dst, const Expr<T>& x);
184  template <typename S>
185  SACADO_INLINE_FUNCTION GeneralFad<S>
186  atomic_fetch_sub(GeneralFad<S>* dest, const GeneralFad<S>& val);
187  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
188  SACADO_INLINE_FUNCTION U
189  atomic_fetch_sub(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
190  template <typename S>
191  SACADO_INLINE_FUNCTION GeneralFad<S>
192  atomic_fetch_mul(GeneralFad<S>* dest, const GeneralFad<S>& val);
193  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
194  SACADO_INLINE_FUNCTION U
195  atomic_fetch_mul(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
196  template <typename S>
197  SACADO_INLINE_FUNCTION GeneralFad<S>
198  atomic_fetch_div(GeneralFad<S>* dest, const GeneralFad<S>& val);
199  template <typename ValT, unsigned sl, unsigned ss, typename U, typename T>
200  SACADO_INLINE_FUNCTION U
201  atomic_fetch_div(ViewFadPtr<ValT,sl,ss,U> dest, const Expr<T>& val);
202  }
203  }
204 }
205 
206 namespace Kokkos {
207  using Sacado::Fad::Exp::atomic_add;
208  using Sacado::Fad::Exp::atomic_max_fetch;
209  using Sacado::Fad::Exp::atomic_min_fetch;
210  using Sacado::Fad::Exp::atomic_add_fetch;
211  using Sacado::Fad::Exp::atomic_sub_fetch;
212  using Sacado::Fad::Exp::atomic_mul_fetch;
213  using Sacado::Fad::Exp::atomic_div_fetch;
214  using Sacado::Fad::Exp::atomic_fetch_max;
215  using Sacado::Fad::Exp::atomic_fetch_min;
216  using Sacado::Fad::Exp::atomic_fetch_add;
217  using Sacado::Fad::Exp::atomic_fetch_sub;
218  using Sacado::Fad::Exp::atomic_fetch_mul;
219  using Sacado::Fad::Exp::atomic_fetch_div;
220 }
221 
222 #endif
223 
224 #endif // SACADO_FAD_EXP_MATHFUNCTIONS_HPP
cbrt
cbrt(expr.val())
Sacado_cmath.hpp
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())
cosh
cosh(expr.val())
abs
abs(expr.val())
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
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())
SafeSqrtOp
SafeSqrtOp
Definition: Sacado_CacheFad_Ops.hpp:418
FAbsOp
FAbsOp
Definition: Sacado_Fad_Exp_Ops.hpp:257
BINARYFUNC_MACRO
#define BINARYFUNC_MACRO(OP, FADOP)
Definition: Sacado_Fad_Exp_MathFunctions.hpp:63
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
val
expr val()
Sacado_Fad_Exp_Ops_Fwd.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
UNARYFUNC_MACRO
#define UNARYFUNC_MACRO(OP, FADOP)
Definition: Sacado_Fad_Exp_MathFunctions.hpp:20
ATanOp
expr expr ATanOp
Definition: Sacado_Fad_Exp_Ops.hpp:205
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
sqrt
sqrt(expr.val())
sinh
sinh(expr.val())
tan
tan(expr.val())
atan2
atan2(expr1.val(), expr2.val())
sin
sin(expr.val())
MinOp
MinOp
Definition: Sacado_Fad_Exp_Ops.hpp:833
x
int x
Definition: gmock-matchers_test.cc:3775
Sacado::safe_sqrt
SACADO_INLINE_FUNCTION T safe_sqrt(const T &x)
Definition: Sacado_cmath.hpp:32
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_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
TanOp
expr expr TanOp
Definition: Sacado_Fad_Exp_Ops.hpp:183
log10
log10(expr.val())
cos
cos(expr.val())
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:51 for Sacado Package Browser (Single Doxygen Collection) by   doxygen 1.8.5