Sacado Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
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) \
45namespace 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 \
107namespace 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
118UNARYFUNC_MACRO(exp, ExpOp)
119UNARYFUNC_MACRO(log, LogOp)
120UNARYFUNC_MACRO(log10, Log10Op)
121UNARYFUNC_MACRO(sqrt, SqrtOp)
122UNARYFUNC_MACRO(cos, CosOp)
123UNARYFUNC_MACRO(sin, SinOp)
124UNARYFUNC_MACRO(tan, TanOp)
125UNARYFUNC_MACRO(acos, ACosOp)
126UNARYFUNC_MACRO(asin, ASinOp)
127UNARYFUNC_MACRO(atan, ATanOp)
128UNARYFUNC_MACRO(cosh, CoshOp)
129UNARYFUNC_MACRO(sinh, SinhOp)
130UNARYFUNC_MACRO(tanh, TanhOp)
131UNARYFUNC_MACRO(acosh, ACoshOp)
132UNARYFUNC_MACRO(asinh, ASinhOp)
133UNARYFUNC_MACRO(atanh, ATanhOp)
134UNARYFUNC_MACRO(abs, AbsOp)
135UNARYFUNC_MACRO(fabs, FAbsOp)
136UNARYFUNC_MACRO(cbrt, CbrtOp)
137
138#undef UNARYFUNC_MACRO
139
140namespace 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) \
170namespace 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 \
443namespace 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
454BINARYFUNC_MACRO(atan2, Atan2Op)
455BINARYFUNC_MACRO(pow, PowerOp)
456BINARYFUNC_MACRO(max, MaxOp)
457BINARYFUNC_MACRO(min, MinOp)
458
459#undef BINARYFUNC_MACRO
460
461#if defined(HAVE_SACADO_KOKKOS)
462
463namespace 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
544namespace 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
Sacado_Base.hpp
Sacado_ConfigDefs.h
SACADO_INLINE_FUNCTION
#define SACADO_INLINE_FUNCTION
Definition Sacado_ConfigDefs.h:110
Sacado_Fad_Exp_MathFunctions.hpp
fabs
fabs(expr.val())
asinh
asinh(expr.val())
log
log(expr.val())
tan
tan(expr.val())
abs
abs(expr.val())
SinOp
expr expr SinOp
Definition Sacado_Fad_Exp_Ops.hpp:198
SinhOp
expr expr SinhOp
Definition Sacado_Fad_Exp_Ops.hpp:238
cos
cos(expr.val())
SqrtOp
expr expr SqrtOp
Definition Sacado_Fad_Exp_Ops.hpp:186
MinOp
MinOp
Definition Sacado_Fad_Exp_Ops.hpp:854
ACosOp
expr expr ACosOp
Definition Sacado_Fad_Exp_Ops.hpp:212
MaxOp
expr2 expr1 expr2 expr2 c *expr2 c *expr1 c *expr2 c *expr1 MaxOp
Definition Sacado_Fad_Exp_Ops.hpp:840
ATanOp
expr expr ATanOp
Definition Sacado_Fad_Exp_Ops.hpp:226
cosh
cosh(expr.val())
ACoshOp
expr expr ACoshOp
Definition Sacado_Fad_Exp_Ops.hpp:250
acos
acos(expr.val())
sin
sin(expr.val())
sinh
sinh(expr.val())
ASinOp
expr expr ASinOp
Definition Sacado_Fad_Exp_Ops.hpp:219
cbrt
cbrt(expr.val())
log10
log10(expr.val())
TanhOp
expr expr TanhOp
Definition Sacado_Fad_Exp_Ops.hpp:244
TanOp
expr expr TanOp
Definition Sacado_Fad_Exp_Ops.hpp:204
CoshOp
expr expr CoshOp
Definition Sacado_Fad_Exp_Ops.hpp:232
ASinhOp
expr expr ASinhOp
Definition Sacado_Fad_Exp_Ops.hpp:258
FAbsOp
FAbsOp
Definition Sacado_Fad_Exp_Ops.hpp:278
exp
exp(expr.val())
atan
atan(expr.val())
Log10Op
expr expr Log10Op
Definition Sacado_Fad_Exp_Ops.hpp:180
acosh
acosh(expr.val())
ExpOp
expr expr expr ExpOp
Definition Sacado_Fad_Exp_Ops.hpp:168
AbsOp
expr expr AbsOp
Definition Sacado_Fad_Exp_Ops.hpp:272
atan2
atan2(expr1.val(), expr2.val())
sqrt
sqrt(expr.val())
ATanhOp
expr expr ATanhOp
Definition Sacado_Fad_Exp_Ops.hpp:265
CbrtOp
CbrtOp
Definition Sacado_Fad_Exp_Ops.hpp:284
tanh
tanh(expr.val())
atanh
atanh(expr.val())
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
CosOp
expr expr CosOp
Definition Sacado_Fad_Exp_Ops.hpp:192
LogOp
LogOp
Definition Sacado_Fad_Exp_Ops.hpp:174
asin
asin(expr.val())
Sacado_Fad_ExpressionFwd.hpp
Sacado_Fad_Ops_Fwd.hpp
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
UNARYFUNC_MACRO
#define UNARYFUNC_MACRO(OP, FADOP)
Definition Sacado_MathFunctions.hpp:44
BINARYFUNC_MACRO
#define BINARYFUNC_MACRO(OP, FADOP)
Definition Sacado_MathFunctions.hpp:169
Sacado_SFINAE_Macros.hpp
max
adouble max(const adouble &a, const adouble &b)
Definition TayUnitTests.hpp:42
min
adouble min(const adouble &a, const adouble &b)
Definition TayUnitTests.hpp:45
Sacado::CacheFad::Expr
Wrapper for a generic expression template.
Definition Sacado_CacheFad_Expression.hpp:77
Sacado::ELRCacheFad::Expr
Wrapper for a generic expression template.
Definition Sacado_ELRCacheFad_Expression.hpp:77
Sacado::ELRFad::Expr
Wrapper for a generic expression template.
Definition Sacado_ELRFad_Expression.hpp:77
Sacado::Fad::Expr
Wrapper for a generic expression template.
Definition Sacado_Fad_Expression.hpp:83
Sacado::CacheFad
Namespace for forward-mode AD classes w/caching.
Definition Sacado_CacheFad_DFadTraits.hpp:56
Sacado::CacheFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
Sacado::ELRCacheFad
Namespace for expression-level reverse forward-mode AD classes.
Definition Sacado_ELRCacheFad_DFadTraits.hpp:56
Sacado::ELRCacheFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
Sacado::ELRFad
Namespace for expression-level reverse forward-mode AD classes.
Definition Sacado_ELRFad_DFadTraits.hpp:56
Sacado::ELRFad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
Sacado::Fad::safe_sqrt
SACADO_INLINE_FUNCTION Expr< SafeSqrtOp< Expr< T > > > safe_sqrt(const Expr< T > &)
Generated by doxygen 1.17.0