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