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