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