Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Sacado_CacheFad_Ops.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 // ***********************************************************************
9 //
10 // The forward-mode AD classes in Sacado are a derivative work of the
11 // expression template classes in the Fad package by Nicolas Di Cesare.
12 // The following banner is included in the original Fad source code:
13 //
14 // ************ DO NOT REMOVE THIS BANNER ****************
15 //
16 // Nicolas Di Cesare <Nicolas.Dicesare@ann.jussieu.fr>
17 // http://www.ann.jussieu.fr/~dicesare
18 //
19 // CEMRACS 98 : C++ courses,
20 // templates : new C++ techniques
21 // for scientific computing
22 //
23 //********************************************************
24 //
25 // A short implementation ( not all operators and
26 // functions are overloaded ) of 1st order Automatic
27 // Differentiation in forward mode (FAD) using
28 // EXPRESSION TEMPLATES.
29 //
30 //********************************************************
31 // @HEADER
32 
33 #ifndef SACADO_CACHEFAD_OPS_HPP
34 #define SACADO_CACHEFAD_OPS_HPP
35 
36 #include "Sacado_CacheFad_Expression.hpp"
37 #include "Sacado_cmath.hpp"
38 #include "Sacado_dummy_arg.hpp"
39 #include <ostream> // for std::ostream
40 
41 namespace Sacado {
42  namespace CacheFad {
43 
44  //
45  // UnaryPlusOp
46  //
47 
48  template <typename ExprT>
49  class UnaryPlusOp {};
50 
51  template <typename ExprT>
52  class Expr< UnaryPlusOp<ExprT> > {
53  public:
54 
55  typedef typename ExprT::value_type value_type;
56  typedef typename ExprT::scalar_type scalar_type;
57  typedef typename ExprT::base_expr_type base_expr_type;
58 
59  SACADO_INLINE_FUNCTION
60  explicit Expr(const ExprT& expr_) : expr(expr_) {}
61 
62  SACADO_INLINE_FUNCTION
63  int size() const { return expr.size(); }
64 
65  SACADO_INLINE_FUNCTION
66  bool updateValue() const { return expr.updateValue(); }
67 
68  SACADO_INLINE_FUNCTION
69  void cache() const {
70  expr.cache();
71  }
72 
73  SACADO_INLINE_FUNCTION
74  value_type val() const {
75  return expr.val();
76  }
77 
78  SACADO_INLINE_FUNCTION
79  bool isLinear() const {
80  return expr.isLinear();
81  }
82 
83  SACADO_INLINE_FUNCTION
84  bool hasFastAccess() const {
85  return expr.hasFastAccess();
86  }
87 
88  SACADO_INLINE_FUNCTION
89  const value_type dx(int i) const {
90  return expr.dx(i);
91  }
92 
93  SACADO_INLINE_FUNCTION
94  const value_type fastAccessDx(int i) const {
95  return expr.fastAccessDx(i);
96  }
97 
98  protected:
99 
100  const ExprT& expr;
101  };
102 
103  template <typename T>
104  SACADO_INLINE_FUNCTION
105  Expr< UnaryPlusOp< Expr<T> > >
106  operator+ (const Expr<T>& expr)
107  {
108  typedef UnaryPlusOp< Expr<T> > expr_t;
109 
110  return Expr<expr_t>(expr);
111  }
112 
113  //
114  // UnaryMinusOp
115  //
116  template <typename ExprT>
117  class UnaryMinusOp {};
118 
119  template <typename ExprT>
120  class Expr< UnaryMinusOp<ExprT> > {
121  public:
122 
123  typedef typename ExprT::value_type value_type;
124  typedef typename ExprT::scalar_type scalar_type;
125  typedef typename ExprT::base_expr_type base_expr_type;
126 
127  SACADO_INLINE_FUNCTION
128  explicit Expr(const ExprT& expr_) : expr(expr_) {}
129 
130  SACADO_INLINE_FUNCTION
131  int size() const { return expr.size(); }
132 
133  SACADO_INLINE_FUNCTION
134  bool updateValue() const { return expr.updateValue(); }
135 
136  SACADO_INLINE_FUNCTION
137  void cache() const {
138  expr.cache();
139  }
140 
141  SACADO_INLINE_FUNCTION
142  value_type val() const {
143  return -expr.val();
144  }
145 
146  SACADO_INLINE_FUNCTION
147  bool isLinear() const {
148  return expr.isLinear();
149  }
150 
151  SACADO_INLINE_FUNCTION
152  bool hasFastAccess() const {
153  return expr.hasFastAccess();
154  }
155 
156  SACADO_INLINE_FUNCTION
157  const value_type dx(int i) const {
158  return -expr.dx(i);
159  }
160 
161  SACADO_INLINE_FUNCTION
162  const value_type fastAccessDx(int i) const {
163  return -expr.fastAccessDx(i);
164  }
165 
166  protected:
167 
168  const ExprT& expr;
169  };
170 
171  template <typename T>
172  SACADO_INLINE_FUNCTION
173  Expr< UnaryMinusOp< Expr<T> > >
174  operator- (const Expr<T>& expr)
175  {
176  typedef UnaryMinusOp< Expr<T> > expr_t;
177 
178  return Expr<expr_t>(expr);
179  }
180 
181  //
182  // AbsOp
183  //
184 
185  template <typename ExprT>
186  class AbsOp {};
187 
188  template <typename ExprT>
189  class Expr< AbsOp<ExprT> > {
190  public:
191 
192  typedef typename ExprT::value_type value_type;
193  typedef typename ExprT::scalar_type scalar_type;
194  typedef typename ExprT::base_expr_type base_expr_type;
195 
196  SACADO_INLINE_FUNCTION
197  explicit Expr(const ExprT& expr_) : expr(expr_) {}
198 
199  SACADO_INLINE_FUNCTION
200  int size() const { return expr.size(); }
201 
202  SACADO_INLINE_FUNCTION
203  bool updateValue() const { return expr.updateValue(); }
204 
205  SACADO_INLINE_FUNCTION
206  void cache() const {
207  expr.cache();
208  v = expr.val();
209  v_pos = (v >= 0);
210  }
211 
212  SACADO_INLINE_FUNCTION
213  value_type val() const {
214  return std::abs(v);
215  }
216 
217  SACADO_INLINE_FUNCTION
218  bool isLinear() const {
219  return false;
220  }
221 
222  SACADO_INLINE_FUNCTION
223  bool hasFastAccess() const {
224  return expr.hasFastAccess();
225  }
226 
227  SACADO_INLINE_FUNCTION
228  const value_type dx(int i) const {
229  return v_pos ? expr.dx(i) : value_type(-expr.dx(i));
230  }
231 
232  SACADO_INLINE_FUNCTION
233  const value_type fastAccessDx(int i) const {
234  return v_pos ? expr.fastAccessDx(i) : value_type(-expr.fastAccessDx(i));
235  }
236 
237  protected:
238 
239  const ExprT& expr;
240  mutable value_type v;
241  mutable bool v_pos;
242  };
243 
244  template <typename T>
245  SACADO_INLINE_FUNCTION
246  Expr< AbsOp< Expr<T> > >
247  abs (const Expr<T>& expr)
248  {
249  typedef AbsOp< Expr<T> > expr_t;
250 
251  return Expr<expr_t>(expr);
252  }
253 
254  //
255  // FAbsOp
256  //
257 
258  template <typename ExprT>
259  class FAbsOp {};
260 
261  template <typename ExprT>
262  class Expr< FAbsOp<ExprT> > {
263  public:
264 
265  typedef typename ExprT::value_type value_type;
266  typedef typename ExprT::scalar_type scalar_type;
267  typedef typename ExprT::base_expr_type base_expr_type;
268 
269  SACADO_INLINE_FUNCTION
270  explicit Expr(const ExprT& expr_) : expr(expr_) {}
271 
272  SACADO_INLINE_FUNCTION
273  int size() const { return expr.size(); }
274 
275  SACADO_INLINE_FUNCTION
276  bool updateValue() const { return expr.updateValue(); }
277 
278  SACADO_INLINE_FUNCTION
279  void cache() const {
280  expr.cache();
281  v = expr.val();
282  v_pos = (v >= 0);
283  }
284 
285  SACADO_INLINE_FUNCTION
286  value_type val() const {
287  return std::fabs(v);
288  }
289 
290  SACADO_INLINE_FUNCTION
291  bool isLinear() const {
292  return false;
293  }
294 
295  SACADO_INLINE_FUNCTION
296  bool hasFastAccess() const {
297  return expr.hasFastAccess();
298  }
299 
300  SACADO_INLINE_FUNCTION
301  const value_type dx(int i) const {
302  return v_pos ? expr.dx(i) : value_type(-expr.dx(i));
303  }
304 
305  SACADO_INLINE_FUNCTION
306  const value_type fastAccessDx(int i) const {
307  return v_pos ? expr.fastAccessDx(i) : value_type(-expr.fastAccessDx(i));
308  }
309 
310  protected:
311 
312  const ExprT& expr;
313  mutable value_type v;
314  mutable bool v_pos;
315  };
316 
317  template <typename T>
318  SACADO_INLINE_FUNCTION
319  Expr< FAbsOp< Expr<T> > >
320  fabs (const Expr<T>& expr)
321  {
322  typedef FAbsOp< Expr<T> > expr_t;
323 
324  return Expr<expr_t>(expr);
325  }
326 
327  }
328 }
329 
330 #define FAD_UNARYOP_MACRO(OPNAME,OP,PARTIAL,VALUE) \
331 namespace Sacado { \
332  namespace CacheFad { \
333  \
334  template <typename ExprT> \
335  class OP {}; \
336  \
337  template <typename ExprT> \
338  class Expr< OP<ExprT> > { \
339  public: \
340  \
341  typedef typename ExprT::value_type value_type; \
342  typedef typename ExprT::scalar_type scalar_type; \
343  typedef typename ExprT::base_expr_type base_expr_type; \
344  \
345  SACADO_INLINE_FUNCTION \
346  explicit Expr(const ExprT& expr_) : expr(expr_) {} \
347  \
348  SACADO_INLINE_FUNCTION \
349  int size() const { return expr.size(); } \
350  \
351  SACADO_INLINE_FUNCTION \
352  bool hasFastAccess() const { return expr.hasFastAccess(); } \
353  \
354  SACADO_INLINE_FUNCTION \
355  bool isPassive() const { return expr.isPassive();} \
356  \
357  SACADO_INLINE_FUNCTION \
358  bool updateValue() const { return expr.updateValue(); } \
359  \
360  SACADO_INLINE_FUNCTION \
361  void cache() const { \
362  expr.cache(); \
363  v = expr.val(); \
364  PARTIAL; \
365  } \
366  \
367  SACADO_INLINE_FUNCTION \
368  value_type val() const { \
369  return VALUE; \
370  } \
371  \
372  SACADO_INLINE_FUNCTION \
373  value_type dx(int i) const { \
374  return expr.dx(i)*a; \
375  } \
376  \
377  SACADO_INLINE_FUNCTION \
378  value_type fastAccessDx(int i) const { \
379  return expr.fastAccessDx(i)*a; \
380  } \
381  \
382  protected: \
383  \
384  const ExprT& expr; \
385  mutable value_type v; \
386  mutable value_type a; \
387  }; \
388  \
389  template <typename T> \
390  SACADO_INLINE_FUNCTION \
391  Expr< OP< Expr<T> > > \
392  OPNAME (const Expr<T>& expr) \
393  { \
394  typedef OP< Expr<T> > expr_t; \
395  \
396  return Expr<expr_t>(expr); \
397  } \
398  } \
399 }
400 
401 FAD_UNARYOP_MACRO(exp,
402  ExpOp,
403  a = std::exp(v),
404  a)
405 FAD_UNARYOP_MACRO(log,
406  LogOp,
407  a=value_type(1)/v,
408  std::log(v))
409 FAD_UNARYOP_MACRO(log10,
410  Log10Op,
411  a = value_type(1)/(std::log(value_type(10))*v),
412  std::log10(v))
413 FAD_UNARYOP_MACRO(sqrt,
414  SqrtOp,
415  a = value_type(1)/(value_type(2)*std::sqrt(v)),
416  std::sqrt(v))
417 FAD_UNARYOP_MACRO(safe_sqrt,
418  SafeSqrtOp,
419  a = (v == value_type(0.0) ? value_type(0.0) : value_type(value_type(1)/(value_type(2)*std::sqrt(v)))),
420  std::sqrt(v))
421 FAD_UNARYOP_MACRO(cos,
422  CosOp,
423  a = -std::sin(v),
424  std::cos(v))
425 FAD_UNARYOP_MACRO(sin,
426  SinOp,
427  a = std::cos(v),
428  std::sin(v))
429 FAD_UNARYOP_MACRO(tan,
430  TanOp,
431  a = value_type(1)+std::tan(v)*std::tan(v),
432  std::tan(v))
433 FAD_UNARYOP_MACRO(acos,
434  ACosOp,
435  a = value_type(-1)/std::sqrt(value_type(1)-v*v),
436  std::acos(v))
437 FAD_UNARYOP_MACRO(asin,
438  ASinOp,
439  a = value_type(1)/std::sqrt(value_type(1)-v*v),
440  std::asin(v))
441 FAD_UNARYOP_MACRO(atan,
442  ATanOp,
443  a = value_type(1)/(value_type(1)+v*v),
444  std::atan(v))
445 FAD_UNARYOP_MACRO(cosh,
446  CoshOp,
447  a = std::sinh(v),
448  std::cosh(v))
449 FAD_UNARYOP_MACRO(sinh,
450  SinhOp,
451  a = std::cosh(v),
452  std::sinh(v))
453 FAD_UNARYOP_MACRO(tanh,
454  TanhOp,
455  a = value_type(1)-std::tanh(v)*std::tanh(v),
456  std::tanh(v))
457 FAD_UNARYOP_MACRO(acosh,
458  ACoshOp,
459  a = value_type(1)/std::sqrt((v-value_type(1))*(v+value_type(1))),
460  std::acosh(v))
461 FAD_UNARYOP_MACRO(asinh,
462  ASinhOp,
463  a = value_type(1)/std::sqrt(value_type(1)+v*v),
464  std::asinh(v))
465 FAD_UNARYOP_MACRO(atanh,
466  ATanhOp,
467  a = value_type(1)/(value_type(1)-v*v),
468  std::atanh(v))
469 FAD_UNARYOP_MACRO(cbrt,
470  CbrtOp,
471  a = value_type(1)/(value_type(3)*std::cbrt(v*v)),
472  std::cbrt(v))
473 
474 #undef FAD_UNARYOP_MACRO
475 
476 //
477 // Binary operators
478 //
479 namespace Sacado {
480  namespace CacheFad {
481 
482  //
483  // AdditionOp
484  //
485 
486  template <typename ExprT1, typename ExprT2>
487  class AdditionOp {};
488 
489  template <typename ExprT1, typename ExprT2>
490  class Expr< AdditionOp<ExprT1,ExprT2> > {
491 
492  public:
493 
494  typedef typename ExprT1::value_type value_type_1;
495  typedef typename ExprT2::value_type value_type_2;
496  typedef typename Sacado::Promote<value_type_1,
497  value_type_2>::type value_type;
498 
499  typedef typename ExprT1::scalar_type scalar_type_1;
500  typedef typename ExprT2::scalar_type scalar_type_2;
501  typedef typename Sacado::Promote<scalar_type_1,
502  scalar_type_2>::type scalar_type;
503 
504  typedef typename ExprT1::base_expr_type base_expr_type_1;
505  typedef typename ExprT2::base_expr_type base_expr_type_2;
506  typedef typename Sacado::Promote<base_expr_type_1,
507  base_expr_type_2>::type base_expr_type;
508 
509  SACADO_INLINE_FUNCTION
510  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
511  expr1(expr1_), expr2(expr2_) {}
512 
513  SACADO_INLINE_FUNCTION
514  int size() const {
515  int sz1 = expr1.size(), sz2 = expr2.size();
516  return sz1 > sz2 ? sz1 : sz2;
517  }
518 
519  SACADO_INLINE_FUNCTION
520  bool updateValue() const {
521  return expr1.updateValue() && expr2.updateValue();
522  }
523 
524  SACADO_INLINE_FUNCTION
525  void cache() const {
526  expr1.cache();
527  expr2.cache();
528  }
529 
530  SACADO_INLINE_FUNCTION
531  value_type val() const {
532  return expr1.val()+expr2.val();
533  }
534 
535  SACADO_INLINE_FUNCTION
536  bool isLinear() const {
537  return expr1.isLinear() && expr2.isLinear();
538  }
539 
540  SACADO_INLINE_FUNCTION
541  bool hasFastAccess() const {
542  return expr1.hasFastAccess() && expr2.hasFastAccess();
543  }
544 
545  SACADO_INLINE_FUNCTION
546  const value_type dx(int i) const {
547  return expr1.dx(i) + expr2.dx(i);
548  }
549 
550  SACADO_INLINE_FUNCTION
551  const value_type fastAccessDx(int i) const {
552  return expr1.fastAccessDx(i) + expr2.fastAccessDx(i);
553  }
554 
555  protected:
556 
557  const ExprT1& expr1;
558  const ExprT2& expr2;
559 
560  };
561 
562  template <typename ExprT1, typename T2>
563  class Expr< AdditionOp<ExprT1, ConstExpr<T2> > > {
564 
565  public:
566 
567  typedef ConstExpr<T2> ExprT2;
568  typedef typename ExprT1::value_type value_type_1;
569  typedef typename ExprT2::value_type value_type_2;
570  typedef typename Sacado::Promote<value_type_1,
571  value_type_2>::type value_type;
572 
573  typedef typename ExprT1::scalar_type scalar_type_1;
574  typedef typename ExprT2::scalar_type scalar_type_2;
575  typedef typename Sacado::Promote<scalar_type_1,
576  scalar_type_2>::type scalar_type;
577 
578  typedef typename ExprT1::base_expr_type base_expr_type_1;
579  typedef typename ExprT2::base_expr_type base_expr_type_2;
580  typedef typename Sacado::Promote<base_expr_type_1,
581  base_expr_type_2>::type base_expr_type;
582 
583  SACADO_INLINE_FUNCTION
584  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
585  expr1(expr1_), expr2(expr2_) {}
586 
587  SACADO_INLINE_FUNCTION
588  int size() const {
589  return expr1.size();
590  }
591 
592  SACADO_INLINE_FUNCTION
593  bool updateValue() const {
594  return expr1.updateValue();
595  }
596 
597  SACADO_INLINE_FUNCTION
598  void cache() const {
599  expr1.cache();
600  }
601 
602  SACADO_INLINE_FUNCTION
603  value_type val() const {
604  return expr1.val() + expr2.val();
605  }
606 
607  SACADO_INLINE_FUNCTION
608  bool isLinear() const {
609  return expr1.isLinear();
610  }
611 
612  SACADO_INLINE_FUNCTION
613  bool hasFastAccess() const {
614  return expr1.hasFastAccess();
615  }
616 
617  SACADO_INLINE_FUNCTION
618  const value_type dx(int i) const {
619  return expr1.dx(i);
620  }
621 
622  SACADO_INLINE_FUNCTION
623  const value_type fastAccessDx(int i) const {
624  return expr1.fastAccessDx(i);
625  }
626 
627  protected:
628 
629  const ExprT1& expr1;
630  ExprT2 expr2;
631 
632  };
633 
634  template <typename T1, typename ExprT2>
635  class Expr< AdditionOp< ConstExpr<T1>,ExprT2> > {
636 
637  public:
638 
639  typedef ConstExpr<T1> ExprT1;
640  typedef typename ExprT1::value_type value_type_1;
641  typedef typename ExprT2::value_type value_type_2;
642  typedef typename Sacado::Promote<value_type_1,
643  value_type_2>::type value_type;
644 
645  typedef typename ExprT1::scalar_type scalar_type_1;
646  typedef typename ExprT2::scalar_type scalar_type_2;
647  typedef typename Sacado::Promote<scalar_type_1,
648  scalar_type_2>::type scalar_type;
649 
650  typedef typename ExprT1::base_expr_type base_expr_type_1;
651  typedef typename ExprT2::base_expr_type base_expr_type_2;
652  typedef typename Sacado::Promote<base_expr_type_1,
653  base_expr_type_2>::type base_expr_type;
654 
655  SACADO_INLINE_FUNCTION
656  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
657  expr1(expr1_), expr2(expr2_) {}
658 
659  SACADO_INLINE_FUNCTION
660  int size() const {
661  return expr2.size();
662  }
663 
664  SACADO_INLINE_FUNCTION
665  bool updateValue() const {
666  return expr2.updateValue();
667  }
668 
669  SACADO_INLINE_FUNCTION
670  void cache() const {
671  expr2.cache();
672  }
673 
674  SACADO_INLINE_FUNCTION
675  value_type val() const {
676  return expr1.val() + expr2.val();
677  }
678 
679  SACADO_INLINE_FUNCTION
680  bool isLinear() const {
681  return expr2.isLinear();
682  }
683 
684  SACADO_INLINE_FUNCTION
685  bool hasFastAccess() const {
686  return expr2.hasFastAccess();
687  }
688 
689  SACADO_INLINE_FUNCTION
690  const value_type dx(int i) const {
691  return expr2.dx(i);
692  }
693 
694  SACADO_INLINE_FUNCTION
695  const value_type fastAccessDx(int i) const {
696  return expr2.fastAccessDx(i);
697  }
698 
699  protected:
700 
701  ExprT1 expr1;
702  const ExprT2& expr2;
703 
704  };
705 
706  //
707  // SubtractionOp
708  //
709 
710  template <typename ExprT1, typename ExprT2>
711  class SubtractionOp {};
712 
713  template <typename ExprT1, typename ExprT2>
714  class Expr< SubtractionOp<ExprT1,ExprT2> > {
715 
716  public:
717 
718  typedef typename ExprT1::value_type value_type_1;
719  typedef typename ExprT2::value_type value_type_2;
720  typedef typename Sacado::Promote<value_type_1,
721  value_type_2>::type value_type;
722 
723  typedef typename ExprT1::scalar_type scalar_type_1;
724  typedef typename ExprT2::scalar_type scalar_type_2;
725  typedef typename Sacado::Promote<scalar_type_1,
726  scalar_type_2>::type scalar_type;
727 
728  typedef typename ExprT1::base_expr_type base_expr_type_1;
729  typedef typename ExprT2::base_expr_type base_expr_type_2;
730  typedef typename Sacado::Promote<base_expr_type_1,
731  base_expr_type_2>::type base_expr_type;
732 
733  SACADO_INLINE_FUNCTION
734  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
735  expr1(expr1_), expr2(expr2_) {}
736 
737  SACADO_INLINE_FUNCTION
738  int size() const {
739  int sz1 = expr1.size(), sz2 = expr2.size();
740  return sz1 > sz2 ? sz1 : sz2;
741  }
742 
743  SACADO_INLINE_FUNCTION
744  bool updateValue() const {
745  return expr1.updateValue() && expr2.updateValue();
746  }
747 
748  SACADO_INLINE_FUNCTION
749  void cache() const {
750  expr1.cache();
751  expr2.cache();
752  }
753 
754  SACADO_INLINE_FUNCTION
755  value_type val() const {
756  return expr1.val()-expr2.val();
757  }
758 
759  SACADO_INLINE_FUNCTION
760  bool isLinear() const {
761  return expr1.isLinear() && expr2.isLinear();
762  }
763 
764  SACADO_INLINE_FUNCTION
765  bool hasFastAccess() const {
766  return expr1.hasFastAccess() && expr2.hasFastAccess();
767  }
768 
769  SACADO_INLINE_FUNCTION
770  const value_type dx(int i) const {
771  return expr1.dx(i) - expr2.dx(i);
772  }
773 
774  SACADO_INLINE_FUNCTION
775  const value_type fastAccessDx(int i) const {
776  return expr1.fastAccessDx(i) - expr2.fastAccessDx(i);
777  }
778 
779  protected:
780 
781  const ExprT1& expr1;
782  const ExprT2& expr2;
783 
784  };
785 
786  template <typename ExprT1, typename T2>
787  class Expr< SubtractionOp<ExprT1, ConstExpr<T2> > > {
788 
789  public:
790 
791  typedef ConstExpr<T2> ExprT2;
792  typedef typename ExprT1::value_type value_type_1;
793  typedef typename ExprT2::value_type value_type_2;
794  typedef typename Sacado::Promote<value_type_1,
795  value_type_2>::type value_type;
796 
797  typedef typename ExprT1::scalar_type scalar_type_1;
798  typedef typename ExprT2::scalar_type scalar_type_2;
799  typedef typename Sacado::Promote<scalar_type_1,
800  scalar_type_2>::type scalar_type;
801 
802  typedef typename ExprT1::base_expr_type base_expr_type_1;
803  typedef typename ExprT2::base_expr_type base_expr_type_2;
804  typedef typename Sacado::Promote<base_expr_type_1,
805  base_expr_type_2>::type base_expr_type;
806 
807  SACADO_INLINE_FUNCTION
808  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
809  expr1(expr1_), expr2(expr2_) {}
810 
811  SACADO_INLINE_FUNCTION
812  int size() const {
813  return expr1.size();
814  }
815 
816  SACADO_INLINE_FUNCTION
817  bool updateValue() const {
818  return expr1.updateValue();
819  }
820 
821  SACADO_INLINE_FUNCTION
822  void cache() const {
823  expr1.cache();
824  }
825 
826  SACADO_INLINE_FUNCTION
827  value_type val() const {
828  return expr1.val() - expr2.val();
829  }
830 
831  SACADO_INLINE_FUNCTION
832  bool isLinear() const {
833  return expr1.isLinear();
834  }
835 
836  SACADO_INLINE_FUNCTION
837  bool hasFastAccess() const {
838  return expr1.hasFastAccess();
839  }
840 
841  SACADO_INLINE_FUNCTION
842  const value_type dx(int i) const {
843  return expr1.dx(i);
844  }
845 
846  SACADO_INLINE_FUNCTION
847  const value_type fastAccessDx(int i) const {
848  return expr1.fastAccessDx(i);
849  }
850 
851  protected:
852 
853  const ExprT1& expr1;
854  ExprT2 expr2;
855 
856  };
857 
858  template <typename T1, typename ExprT2>
859  class Expr< SubtractionOp< ConstExpr<T1>,ExprT2> > {
860 
861  public:
862 
863  typedef ConstExpr<T1> ExprT1;
864  typedef typename ExprT1::value_type value_type_1;
865  typedef typename ExprT2::value_type value_type_2;
866  typedef typename Sacado::Promote<value_type_1,
867  value_type_2>::type value_type;
868 
869  typedef typename ExprT1::scalar_type scalar_type_1;
870  typedef typename ExprT2::scalar_type scalar_type_2;
871  typedef typename Sacado::Promote<scalar_type_1,
872  scalar_type_2>::type scalar_type;
873 
874  typedef typename ExprT1::base_expr_type base_expr_type_1;
875  typedef typename ExprT2::base_expr_type base_expr_type_2;
876  typedef typename Sacado::Promote<base_expr_type_1,
877  base_expr_type_2>::type base_expr_type;
878 
879  SACADO_INLINE_FUNCTION
880  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
881  expr1(expr1_), expr2(expr2_) {}
882 
883  SACADO_INLINE_FUNCTION
884  int size() const {
885  return expr2.size();
886  }
887 
888  SACADO_INLINE_FUNCTION
889  bool updateValue() const {
890  return expr2.updateValue();
891  }
892 
893  SACADO_INLINE_FUNCTION
894  void cache() const {
895  expr2.cache();
896  }
897 
898  SACADO_INLINE_FUNCTION
899  value_type val() const {
900  return expr1.val() - expr2.val();
901  }
902 
903  SACADO_INLINE_FUNCTION
904  bool isLinear() const {
905  return expr2.isLinear();
906  }
907 
908  SACADO_INLINE_FUNCTION
909  bool hasFastAccess() const {
910  return expr2.hasFastAccess();
911  }
912 
913  SACADO_INLINE_FUNCTION
914  const value_type dx(int i) const {
915  return -expr2.dx(i);
916  }
917 
918  SACADO_INLINE_FUNCTION
919  const value_type fastAccessDx(int i) const {
920  return -expr2.fastAccessDx(i);
921  }
922 
923  protected:
924 
925  ExprT1 expr1;
926  const ExprT2& expr2;
927 
928  };
929 
930  //
931  // MultiplicationOp
932  //
933 
934  template <typename ExprT1, typename ExprT2>
935  class MultiplicationOp {};
936 
937  template <typename ExprT1, typename ExprT2>
938  class Expr< MultiplicationOp<ExprT1,ExprT2> > {
939 
940  public:
941 
942  typedef typename ExprT1::value_type value_type_1;
943  typedef typename ExprT2::value_type value_type_2;
944  typedef typename Sacado::Promote<value_type_1,
945  value_type_2>::type value_type;
946 
947  typedef typename ExprT1::scalar_type scalar_type_1;
948  typedef typename ExprT2::scalar_type scalar_type_2;
949  typedef typename Sacado::Promote<scalar_type_1,
950  scalar_type_2>::type scalar_type;
951 
952  typedef typename ExprT1::base_expr_type base_expr_type_1;
953  typedef typename ExprT2::base_expr_type base_expr_type_2;
954  typedef typename Sacado::Promote<base_expr_type_1,
955  base_expr_type_2>::type base_expr_type;
956 
957  SACADO_INLINE_FUNCTION
958  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
959  expr1(expr1_), expr2(expr2_) {}
960 
961  SACADO_INLINE_FUNCTION
962  int size() const {
963  int sz1 = expr1.size(), sz2 = expr2.size();
964  return sz1 > sz2 ? sz1 : sz2;
965  }
966 
967  SACADO_INLINE_FUNCTION
968  bool updateValue() const {
969  return expr1.updateValue() && expr2.updateValue();
970  }
971 
972  SACADO_INLINE_FUNCTION
973  void cache() const {
974  expr1.cache();
975  expr2.cache();
976  v1 = expr1.val();
977  v2 = expr2.val();
978  }
979 
980  SACADO_INLINE_FUNCTION
981  value_type val() const {
982  return v1*v2;
983  }
984 
985  SACADO_INLINE_FUNCTION
986  bool isLinear() const {
987  return false;
988  }
989 
990  SACADO_INLINE_FUNCTION
991  bool hasFastAccess() const {
992  return expr1.hasFastAccess() && expr2.hasFastAccess();
993  }
994 
995  SACADO_INLINE_FUNCTION
996  const value_type dx(int i) const {
997  if (expr1.size() > 0 && expr2.size() > 0)
998  return v1*expr2.dx(i) + expr1.dx(i)*v2;
999  else if (expr1.size() > 0)
1000  return expr1.dx(i)*v2;
1001  else
1002  return v1*expr2.dx(i);
1003  }
1004 
1005  SACADO_INLINE_FUNCTION
1006  const value_type fastAccessDx(int i) const {
1007  return v1*expr2.fastAccessDx(i) + expr1.fastAccessDx(i)*v2;
1008  }
1009 
1010  protected:
1011 
1012  const ExprT1& expr1;
1013  const ExprT2& expr2;
1014  mutable value_type_1 v1;
1015  mutable value_type_2 v2;
1016 
1017  };
1018 
1019  template <typename ExprT1, typename T2>
1020  class Expr< MultiplicationOp<ExprT1, ConstExpr<T2> > > {
1021 
1022  public:
1023 
1024  typedef ConstExpr<T2> ExprT2;
1025  typedef typename ExprT1::value_type value_type_1;
1026  typedef typename ExprT2::value_type value_type_2;
1027  typedef typename Sacado::Promote<value_type_1,
1028  value_type_2>::type value_type;
1029 
1030  typedef typename ExprT1::scalar_type scalar_type_1;
1031  typedef typename ExprT2::scalar_type scalar_type_2;
1032  typedef typename Sacado::Promote<scalar_type_1,
1033  scalar_type_2>::type scalar_type;
1034 
1035  typedef typename ExprT1::base_expr_type base_expr_type_1;
1036  typedef typename ExprT2::base_expr_type base_expr_type_2;
1037  typedef typename Sacado::Promote<base_expr_type_1,
1038  base_expr_type_2>::type base_expr_type;
1039 
1040  SACADO_INLINE_FUNCTION
1041  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1042  expr1(expr1_), expr2(expr2_) {}
1043 
1044  SACADO_INLINE_FUNCTION
1045  int size() const {
1046  return expr1.size();
1047  }
1048 
1049  SACADO_INLINE_FUNCTION
1050  bool updateValue() const {
1051  return expr1.updateValue();
1052  }
1053 
1054  SACADO_INLINE_FUNCTION
1055  void cache() const {
1056  expr1.cache();
1057  }
1058 
1059  SACADO_INLINE_FUNCTION
1060  value_type val() const {
1061  return expr1.val()*expr2.val();
1062  }
1063 
1064  SACADO_INLINE_FUNCTION
1065  bool isLinear() const {
1066  return expr1.isLinear();
1067  }
1068 
1069  SACADO_INLINE_FUNCTION
1070  bool hasFastAccess() const {
1071  return expr1.hasFastAccess();
1072  }
1073 
1074  SACADO_INLINE_FUNCTION
1075  const value_type dx(int i) const {
1076  return expr1.dx(i)*expr2.val();
1077  }
1078 
1079  SACADO_INLINE_FUNCTION
1080  const value_type fastAccessDx(int i) const {
1081  return expr1.fastAccessDx(i)*expr2.val();
1082  }
1083 
1084  protected:
1085 
1086  const ExprT1& expr1;
1087  ExprT2 expr2;
1088 
1089  };
1090 
1091  template <typename T1, typename ExprT2>
1092  class Expr< MultiplicationOp< ConstExpr<T1>,ExprT2> > {
1093 
1094  public:
1095 
1096  typedef ConstExpr<T1> ExprT1;
1097  typedef typename ExprT1::value_type value_type_1;
1098  typedef typename ExprT2::value_type value_type_2;
1099  typedef typename Sacado::Promote<value_type_1,
1100  value_type_2>::type value_type;
1101 
1102  typedef typename ExprT1::scalar_type scalar_type_1;
1103  typedef typename ExprT2::scalar_type scalar_type_2;
1104  typedef typename Sacado::Promote<scalar_type_1,
1105  scalar_type_2>::type scalar_type;
1106 
1107  typedef typename ExprT1::base_expr_type base_expr_type_1;
1108  typedef typename ExprT2::base_expr_type base_expr_type_2;
1109  typedef typename Sacado::Promote<base_expr_type_1,
1110  base_expr_type_2>::type base_expr_type;
1111 
1112  SACADO_INLINE_FUNCTION
1113  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1114  expr1(expr1_), expr2(expr2_) {}
1115 
1116  SACADO_INLINE_FUNCTION
1117  int size() const {
1118  return expr2.size();
1119  }
1120 
1121  SACADO_INLINE_FUNCTION
1122  bool updateValue() const {
1123  return expr2.updateValue();
1124  }
1125 
1126  SACADO_INLINE_FUNCTION
1127  void cache() const {
1128  expr2.cache();
1129  }
1130 
1131  SACADO_INLINE_FUNCTION
1132  value_type val() const {
1133  return expr1.val()*expr2.val();
1134  }
1135 
1136  SACADO_INLINE_FUNCTION
1137  bool isLinear() const {
1138  return expr2.isLinear();
1139  }
1140 
1141  SACADO_INLINE_FUNCTION
1142  bool hasFastAccess() const {
1143  return expr2.hasFastAccess();
1144  }
1145 
1146  SACADO_INLINE_FUNCTION
1147  const value_type dx(int i) const {
1148  return expr1.val()*expr2.dx(i);
1149  }
1150 
1151  SACADO_INLINE_FUNCTION
1152  const value_type fastAccessDx(int i) const {
1153  return expr1.val()*expr2.fastAccessDx(i);
1154  }
1155 
1156  protected:
1157 
1158  ExprT1 expr1;
1159  const ExprT2& expr2;
1160 
1161  };
1162 
1163  //
1164  // DivisionOp
1165  //
1166 
1167  template <typename ExprT1, typename ExprT2>
1168  class DivisionOp {};
1169 
1170  template <typename ExprT1, typename ExprT2>
1171  class Expr< DivisionOp<ExprT1,ExprT2> > {
1172 
1173  public:
1174 
1175  typedef typename ExprT1::value_type value_type_1;
1176  typedef typename ExprT2::value_type value_type_2;
1177  typedef typename Sacado::Promote<value_type_1,
1178  value_type_2>::type value_type;
1179 
1180  typedef typename ExprT1::scalar_type scalar_type_1;
1181  typedef typename ExprT2::scalar_type scalar_type_2;
1182  typedef typename Sacado::Promote<scalar_type_1,
1183  scalar_type_2>::type scalar_type;
1184 
1185  typedef typename ExprT1::base_expr_type base_expr_type_1;
1186  typedef typename ExprT2::base_expr_type base_expr_type_2;
1187  typedef typename Sacado::Promote<base_expr_type_1,
1188  base_expr_type_2>::type base_expr_type;
1189 
1190  SACADO_INLINE_FUNCTION
1191  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1192  expr1(expr1_), expr2(expr2_) {}
1193 
1194  SACADO_INLINE_FUNCTION
1195  int size() const {
1196  int sz1 = expr1.size(), sz2 = expr2.size();
1197  return sz1 > sz2 ? sz1 : sz2;
1198  }
1199 
1200  SACADO_INLINE_FUNCTION
1201  bool updateValue() const {
1202  return expr1.updateValue() && expr2.updateValue();
1203  }
1204 
1205  SACADO_INLINE_FUNCTION
1206  void cache() const {
1207  expr1.cache();
1208  expr2.cache();
1209  const value_type_1 v1 = expr1.val();
1210  const value_type_2 v2 = expr2.val();
1211  a = value_type(1)/v2;
1212  v = v1*a;
1213  b = -v/v2;
1214  }
1215 
1216  SACADO_INLINE_FUNCTION
1217  value_type val() const {
1218  return v;
1219  }
1220 
1221  SACADO_INLINE_FUNCTION
1222  bool isLinear() const {
1223  return false;
1224  }
1225 
1226  SACADO_INLINE_FUNCTION
1227  bool hasFastAccess() const {
1228  return expr1.hasFastAccess() && expr2.hasFastAccess();
1229  }
1230 
1231  SACADO_INLINE_FUNCTION
1232  const value_type dx(int i) const {
1233  if (expr1.size() > 0 && expr2.size() > 0)
1234  return expr1.dx(i)*a + expr2.dx(i)*b;
1235  else if (expr1.size() > 0)
1236  return expr1.dx(i)*a;
1237  else
1238  return expr1.val()*b;
1239  }
1240 
1241  SACADO_INLINE_FUNCTION
1242  const value_type fastAccessDx(int i) const {
1243  return expr1.fastAccessDx(i)*a + expr2.fastAccessDx(i)*b;
1244  }
1245 
1246  protected:
1247 
1248  const ExprT1& expr1;
1249  const ExprT2& expr2;
1250  mutable value_type v;
1251  mutable value_type a;
1252  mutable value_type b;
1253 
1254  };
1255 
1256  template <typename ExprT1, typename T2>
1257  class Expr< DivisionOp<ExprT1, ConstExpr<T2> > > {
1258 
1259  public:
1260 
1261  typedef ConstExpr<T2> ExprT2;
1262  typedef typename ExprT1::value_type value_type_1;
1263  typedef typename ExprT2::value_type value_type_2;
1264  typedef typename Sacado::Promote<value_type_1,
1265  value_type_2>::type value_type;
1266 
1267  typedef typename ExprT1::scalar_type scalar_type_1;
1268  typedef typename ExprT2::scalar_type scalar_type_2;
1269  typedef typename Sacado::Promote<scalar_type_1,
1270  scalar_type_2>::type scalar_type;
1271 
1272  typedef typename ExprT1::base_expr_type base_expr_type_1;
1273  typedef typename ExprT2::base_expr_type base_expr_type_2;
1274  typedef typename Sacado::Promote<base_expr_type_1,
1275  base_expr_type_2>::type base_expr_type;
1276 
1277  SACADO_INLINE_FUNCTION
1278  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1279  expr1(expr1_), expr2(expr2_) {}
1280 
1281  SACADO_INLINE_FUNCTION
1282  int size() const {
1283  return expr1.size();
1284  }
1285 
1286  SACADO_INLINE_FUNCTION
1287  bool updateValue() const {
1288  return expr1.updateValue();
1289  }
1290 
1291  SACADO_INLINE_FUNCTION
1292  void cache() const {
1293  expr1.cache();
1294  const value_type_1 v1 = expr1.val();
1295  a = value_type(1)/expr2.val();
1296  v = v1*a;
1297  }
1298 
1299  SACADO_INLINE_FUNCTION
1300  value_type val() const {
1301  return v;
1302  }
1303 
1304  SACADO_INLINE_FUNCTION
1305  bool isLinear() const {
1306  return expr1.isLinear();
1307  }
1308 
1309  SACADO_INLINE_FUNCTION
1310  bool hasFastAccess() const {
1311  return expr1.hasFastAccess();
1312  }
1313 
1314  SACADO_INLINE_FUNCTION
1315  const value_type dx(int i) const {
1316  return expr1.dx(i)*a;
1317  }
1318 
1319  SACADO_INLINE_FUNCTION
1320  const value_type fastAccessDx(int i) const {
1321  return expr1.fastAccessDx(i)*a;
1322  }
1323 
1324  protected:
1325 
1326  const ExprT1& expr1;
1327  ExprT2 expr2;
1328  mutable value_type v;
1329  mutable value_type a;
1330 
1331  };
1332 
1333  template <typename T1, typename ExprT2>
1334  class Expr< DivisionOp< ConstExpr<T1>,ExprT2> > {
1335 
1336  public:
1337 
1338  typedef ConstExpr<T1> ExprT1;
1339  typedef typename ExprT1::value_type value_type_1;
1340  typedef typename ExprT2::value_type value_type_2;
1341  typedef typename Sacado::Promote<value_type_1,
1342  value_type_2>::type value_type;
1343 
1344  typedef typename ExprT1::scalar_type scalar_type_1;
1345  typedef typename ExprT2::scalar_type scalar_type_2;
1346  typedef typename Sacado::Promote<scalar_type_1,
1347  scalar_type_2>::type scalar_type;
1348 
1349  typedef typename ExprT1::base_expr_type base_expr_type_1;
1350  typedef typename ExprT2::base_expr_type base_expr_type_2;
1351  typedef typename Sacado::Promote<base_expr_type_1,
1352  base_expr_type_2>::type base_expr_type;
1353 
1354  SACADO_INLINE_FUNCTION
1355  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1356  expr1(expr1_), expr2(expr2_) {}
1357 
1358  SACADO_INLINE_FUNCTION
1359  int size() const {
1360  return expr2.size();
1361  }
1362 
1363  SACADO_INLINE_FUNCTION
1364  bool updateValue() const {
1365  return expr2.updateValue();
1366  }
1367 
1368  SACADO_INLINE_FUNCTION
1369  void cache() const {
1370  expr2.cache();
1371  const value_type_2 v2 = expr2.val();
1372  v = expr1.val()/v2;
1373  b = -v/v2;
1374  }
1375 
1376  SACADO_INLINE_FUNCTION
1377  value_type val() const {
1378  return v;
1379  }
1380 
1381  SACADO_INLINE_FUNCTION
1382  bool isLinear() const {
1383  return false;
1384  }
1385 
1386  SACADO_INLINE_FUNCTION
1387  bool hasFastAccess() const {
1388  return expr2.hasFastAccess();
1389  }
1390 
1391  SACADO_INLINE_FUNCTION
1392  const value_type dx(int i) const {
1393  return expr2.dx(i)*b;
1394  }
1395 
1396  SACADO_INLINE_FUNCTION
1397  const value_type fastAccessDx(int i) const {
1398  return expr2.fastAccessDx(i)*b;
1399  }
1400 
1401  protected:
1402 
1403  ExprT1 expr1;
1404  const ExprT2& expr2;
1405  mutable value_type v;
1406  mutable value_type b;
1407 
1408  };
1409 
1410  //
1411  // Atan2Op
1412  //
1413 
1414  template <typename ExprT1, typename ExprT2>
1415  class Atan2Op {};
1416 
1417  template <typename ExprT1, typename ExprT2>
1418  class Expr< Atan2Op<ExprT1,ExprT2> > {
1419 
1420  public:
1421 
1422  typedef typename ExprT1::value_type value_type_1;
1423  typedef typename ExprT2::value_type value_type_2;
1424  typedef typename Sacado::Promote<value_type_1,
1425  value_type_2>::type value_type;
1426 
1427  typedef typename ExprT1::scalar_type scalar_type_1;
1428  typedef typename ExprT2::scalar_type scalar_type_2;
1429  typedef typename Sacado::Promote<scalar_type_1,
1430  scalar_type_2>::type scalar_type;
1431 
1432  typedef typename ExprT1::base_expr_type base_expr_type_1;
1433  typedef typename ExprT2::base_expr_type base_expr_type_2;
1434  typedef typename Sacado::Promote<base_expr_type_1,
1435  base_expr_type_2>::type base_expr_type;
1436 
1437  SACADO_INLINE_FUNCTION
1438  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1439  expr1(expr1_), expr2(expr2_) {}
1440 
1441  SACADO_INLINE_FUNCTION
1442  int size() const {
1443  int sz1 = expr1.size(), sz2 = expr2.size();
1444  return sz1 > sz2 ? sz1 : sz2;
1445  }
1446 
1447  SACADO_INLINE_FUNCTION
1448  bool updateValue() const {
1449  return expr1.updateValue() && expr2.updateValue();
1450  }
1451 
1452  SACADO_INLINE_FUNCTION
1453  void cache() const {
1454  expr1.cache();
1455  expr2.cache();
1456  const value_type_1 v1 = expr1.val();
1457  const value_type_2 v2 = expr2.val();
1458  a = value_type(1)/(v1*v1 + v2*v2);
1459  b = -v1*a;
1460  a = v2*a;
1461  v = std::atan2(v1,v2);
1462  }
1463 
1464  SACADO_INLINE_FUNCTION
1465  value_type val() const {
1466  return v;
1467  }
1468 
1469  SACADO_INLINE_FUNCTION
1470  bool isLinear() const {
1471  return false;
1472  }
1473 
1474  SACADO_INLINE_FUNCTION
1475  bool hasFastAccess() const {
1476  return expr1.hasFastAccess() && expr2.hasFastAccess();
1477  }
1478 
1479  SACADO_INLINE_FUNCTION
1480  const value_type dx(int i) const {
1481  if (expr1.size() > 0 && expr2.size() > 0)
1482  return expr1.dx(i)*a + expr2.dx(i)*b;
1483  else if (expr1.size() > 0)
1484  return expr1.dx(i)*a;
1485  else
1486  return expr1.val()*b;
1487  }
1488 
1489  SACADO_INLINE_FUNCTION
1490  const value_type fastAccessDx(int i) const {
1491  return expr1.fastAccessDx(i)*a + expr2.fastAccessDx(i)*b;
1492  }
1493 
1494  protected:
1495 
1496  const ExprT1& expr1;
1497  const ExprT2& expr2;
1498  mutable value_type v;
1499  mutable value_type a;
1500  mutable value_type b;
1501 
1502  };
1503 
1504  template <typename ExprT1, typename T2>
1505  class Expr< Atan2Op<ExprT1, ConstExpr<T2> > > {
1506 
1507  public:
1508 
1509  typedef ConstExpr<T2> ExprT2;
1510  typedef typename ExprT1::value_type value_type_1;
1511  typedef typename ExprT2::value_type value_type_2;
1512  typedef typename Sacado::Promote<value_type_1,
1513  value_type_2>::type value_type;
1514 
1515  typedef typename ExprT1::scalar_type scalar_type_1;
1516  typedef typename ExprT2::scalar_type scalar_type_2;
1517  typedef typename Sacado::Promote<scalar_type_1,
1518  scalar_type_2>::type scalar_type;
1519 
1520  typedef typename ExprT1::base_expr_type base_expr_type_1;
1521  typedef typename ExprT2::base_expr_type base_expr_type_2;
1522  typedef typename Sacado::Promote<base_expr_type_1,
1523  base_expr_type_2>::type base_expr_type;
1524 
1525  SACADO_INLINE_FUNCTION
1526  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1527  expr1(expr1_), expr2(expr2_) {}
1528 
1529  SACADO_INLINE_FUNCTION
1530  int size() const {
1531  return expr1.size();
1532  }
1533 
1534  SACADO_INLINE_FUNCTION
1535  bool updateValue() const {
1536  return expr1.updateValue();
1537  }
1538 
1539  SACADO_INLINE_FUNCTION
1540  void cache() const {
1541  expr1.cache();
1542  const value_type_1 v1 = expr1.val();
1543  const value_type_2 v2 = expr2.val();
1544  a = v2/(v1*v1 + v2*v2);
1545  v = std::atan2(v1,v2);
1546  }
1547 
1548  SACADO_INLINE_FUNCTION
1549  value_type val() const {
1550  return v;
1551  }
1552 
1553  SACADO_INLINE_FUNCTION
1554  bool isLinear() const {
1555  return false;
1556  }
1557 
1558  SACADO_INLINE_FUNCTION
1559  bool hasFastAccess() const {
1560  return expr1.hasFastAccess();
1561  }
1562 
1563  SACADO_INLINE_FUNCTION
1564  const value_type dx(int i) const {
1565  return expr1.dx(i)*a;
1566  }
1567 
1568  SACADO_INLINE_FUNCTION
1569  const value_type fastAccessDx(int i) const {
1570  return expr1.fastAccessDx(i)*a;
1571  }
1572 
1573  protected:
1574 
1575  const ExprT1& expr1;
1576  ExprT2 expr2;
1577  mutable value_type v;
1578  mutable value_type a;
1579 
1580  };
1581 
1582  template <typename T1, typename ExprT2>
1583  class Expr< Atan2Op< ConstExpr<T1>,ExprT2> > {
1584 
1585  public:
1586 
1587  typedef ConstExpr<T1> ExprT1;
1588  typedef typename ExprT1::value_type value_type_1;
1589  typedef typename ExprT2::value_type value_type_2;
1590  typedef typename Sacado::Promote<value_type_1,
1591  value_type_2>::type value_type;
1592 
1593  typedef typename ExprT1::scalar_type scalar_type_1;
1594  typedef typename ExprT2::scalar_type scalar_type_2;
1595  typedef typename Sacado::Promote<scalar_type_1,
1596  scalar_type_2>::type scalar_type;
1597 
1598  typedef typename ExprT1::base_expr_type base_expr_type_1;
1599  typedef typename ExprT2::base_expr_type base_expr_type_2;
1600  typedef typename Sacado::Promote<base_expr_type_1,
1601  base_expr_type_2>::type base_expr_type;
1602 
1603  SACADO_INLINE_FUNCTION
1604  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1605  expr1(expr1_), expr2(expr2_) {}
1606 
1607  SACADO_INLINE_FUNCTION
1608  int size() const {
1609  return expr2.size();
1610  }
1611 
1612  SACADO_INLINE_FUNCTION
1613  bool updateValue() const {
1614  return expr2.updateValue();
1615  }
1616 
1617  SACADO_INLINE_FUNCTION
1618  void cache() const {
1619  expr2.cache();
1620  const value_type_1 v1 = expr1.val();
1621  const value_type_2 v2 = expr2.val();
1622  b = -v1/(v1*v1 + v2*v2);
1623  v = std::atan2(v1,v2);
1624  }
1625 
1626  SACADO_INLINE_FUNCTION
1627  value_type val() const {
1628  return v;
1629  }
1630 
1631  SACADO_INLINE_FUNCTION
1632  bool isLinear() const {
1633  return false;
1634  }
1635 
1636  SACADO_INLINE_FUNCTION
1637  bool hasFastAccess() const {
1638  return expr2.hasFastAccess();
1639  }
1640 
1641  SACADO_INLINE_FUNCTION
1642  const value_type dx(int i) const {
1643  return expr2.dx(i)*b;
1644  }
1645 
1646  SACADO_INLINE_FUNCTION
1647  const value_type fastAccessDx(int i) const {
1648  return expr2.fastAccessDx(i)*b;
1649  }
1650 
1651  protected:
1652 
1653  ExprT1 expr1;
1654  const ExprT2& expr2;
1655  mutable value_type v;
1656  mutable value_type b;
1657 
1658  };
1659 
1660  //
1661  // PowerOp
1662  //
1663 
1664  template <typename ExprT1, typename ExprT2>
1665  class PowerOp {};
1666 
1667  template <typename ExprT1, typename ExprT2>
1668  class Expr< PowerOp<ExprT1,ExprT2> > {
1669 
1670  public:
1671 
1672  typedef typename ExprT1::value_type value_type_1;
1673  typedef typename ExprT2::value_type value_type_2;
1674  typedef typename Sacado::Promote<value_type_1,
1675  value_type_2>::type value_type;
1676 
1677  typedef typename ExprT1::scalar_type scalar_type_1;
1678  typedef typename ExprT2::scalar_type scalar_type_2;
1679  typedef typename Sacado::Promote<scalar_type_1,
1680  scalar_type_2>::type scalar_type;
1681 
1682  typedef typename ExprT1::base_expr_type base_expr_type_1;
1683  typedef typename ExprT2::base_expr_type base_expr_type_2;
1684  typedef typename Sacado::Promote<base_expr_type_1,
1685  base_expr_type_2>::type base_expr_type;
1686 
1687  SACADO_INLINE_FUNCTION
1688  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1689  expr1(expr1_), expr2(expr2_) {}
1690 
1691  SACADO_INLINE_FUNCTION
1692  int size() const {
1693  int sz1 = expr1.size(), sz2 = expr2.size();
1694  return sz1 > sz2 ? sz1 : sz2;
1695  }
1696 
1697  SACADO_INLINE_FUNCTION
1698  bool updateValue() const {
1699  return expr1.updateValue() && expr2.updateValue();
1700  }
1701 
1702  SACADO_INLINE_FUNCTION
1703  void cache() const {
1704  expr1.cache();
1705  expr2.cache();
1706  const value_type_1 v1 = expr1.val();
1707  const value_type_2 v2 = expr2.val();
1708  v = std::pow(v1,v2);
1709  if (expr2.size() == 0 && v2 == value_type(1)) {
1710  a = value_type(1);
1711  b = value_type(0);
1712  }
1713  else if (v1 == value_type(0)) {
1714  a = value_type(0);
1715  b = value_type(0);
1716  }
1717  else {
1718  a = v*v2/v1;
1719  b = v*std::log(v1);
1720  }
1721  }
1722 
1723  SACADO_INLINE_FUNCTION
1724  value_type val() const {
1725  return v;
1726  }
1727 
1728  SACADO_INLINE_FUNCTION
1729  bool isLinear() const {
1730  return false;
1731  }
1732 
1733  SACADO_INLINE_FUNCTION
1734  bool hasFastAccess() const {
1735  return expr1.hasFastAccess() && expr2.hasFastAccess();
1736  }
1737 
1738  SACADO_INLINE_FUNCTION
1739  const value_type dx(int i) const {
1740  if (expr1.size() > 0 && expr2.size() > 0)
1741  return expr1.dx(i)*a + expr2.dx(i)*b;
1742  else if (expr1.size() > 0)
1743  return expr1.dx(i)*a;
1744  else
1745  return expr1.val()*b;
1746  }
1747 
1748  SACADO_INLINE_FUNCTION
1749  const value_type fastAccessDx(int i) const {
1750  return expr1.fastAccessDx(i)*a + expr2.fastAccessDx(i)*b;
1751  }
1752 
1753  protected:
1754 
1755  const ExprT1& expr1;
1756  const ExprT2& expr2;
1757  mutable value_type v;
1758  mutable value_type a;
1759  mutable value_type b;
1760 
1761  };
1762 
1763  template <typename ExprT1, typename T2>
1764  class Expr< PowerOp<ExprT1, ConstExpr<T2> > > {
1765 
1766  public:
1767 
1768  typedef ConstExpr<T2> ExprT2;
1769  typedef typename ExprT1::value_type value_type_1;
1770  typedef typename ExprT2::value_type value_type_2;
1771  typedef typename Sacado::Promote<value_type_1,
1772  value_type_2>::type value_type;
1773 
1774  typedef typename ExprT1::scalar_type scalar_type_1;
1775  typedef typename ExprT2::scalar_type scalar_type_2;
1776  typedef typename Sacado::Promote<scalar_type_1,
1777  scalar_type_2>::type scalar_type;
1778 
1779  typedef typename ExprT1::base_expr_type base_expr_type_1;
1780  typedef typename ExprT2::base_expr_type base_expr_type_2;
1781  typedef typename Sacado::Promote<base_expr_type_1,
1782  base_expr_type_2>::type base_expr_type;
1783 
1784  SACADO_INLINE_FUNCTION
1785  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1786  expr1(expr1_), expr2(expr2_) {}
1787 
1788  SACADO_INLINE_FUNCTION
1789  int size() const {
1790  return expr1.size();
1791  }
1792 
1793  SACADO_INLINE_FUNCTION
1794  bool updateValue() const {
1795  return expr1.updateValue();
1796  }
1797 
1798  SACADO_INLINE_FUNCTION
1799  void cache() const {
1800  expr1.cache();
1801  const value_type_1 v1 = expr1.val();
1802  const value_type_2 v2 = expr2.val();
1803  v = std::pow(v1,v2);
1804  if (v2 == value_type_1(1)) {
1805  a = value_type(1);
1806  }
1807  else if (v1 == value_type_1(0)) {
1808  a = value_type(0);
1809  }
1810  else {
1811  a = v*v2/v1;
1812  }
1813  }
1814 
1815  SACADO_INLINE_FUNCTION
1816  value_type val() const {
1817  return v;
1818  }
1819 
1820  SACADO_INLINE_FUNCTION
1821  bool isLinear() const {
1822  return false;
1823  }
1824 
1825  SACADO_INLINE_FUNCTION
1826  bool hasFastAccess() const {
1827  return expr1.hasFastAccess();
1828  }
1829 
1830  SACADO_INLINE_FUNCTION
1831  const value_type dx(int i) const {
1832  return expr1.dx(i)*a;
1833  }
1834 
1835  SACADO_INLINE_FUNCTION
1836  const value_type fastAccessDx(int i) const {
1837  return expr1.fastAccessDx(i)*a;
1838  }
1839 
1840  protected:
1841 
1842  const ExprT1& expr1;
1843  ExprT2 expr2;
1844  mutable value_type v;
1845  mutable value_type a;
1846 
1847  };
1848 
1849  template <typename T1, typename ExprT2>
1850  class Expr< PowerOp< ConstExpr<T1>,ExprT2> > {
1851 
1852  public:
1853 
1854  typedef ConstExpr<T1> ExprT1;
1855  typedef typename ExprT1::value_type value_type_1;
1856  typedef typename ExprT2::value_type value_type_2;
1857  typedef typename Sacado::Promote<value_type_1,
1858  value_type_2>::type value_type;
1859 
1860  typedef typename ExprT1::scalar_type scalar_type_1;
1861  typedef typename ExprT2::scalar_type scalar_type_2;
1862  typedef typename Sacado::Promote<scalar_type_1,
1863  scalar_type_2>::type scalar_type;
1864 
1865  typedef typename ExprT1::base_expr_type base_expr_type_1;
1866  typedef typename ExprT2::base_expr_type base_expr_type_2;
1867  typedef typename Sacado::Promote<base_expr_type_1,
1868  base_expr_type_2>::type base_expr_type;
1869 
1870  SACADO_INLINE_FUNCTION
1871  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1872  expr1(expr1_), expr2(expr2_) {}
1873 
1874  SACADO_INLINE_FUNCTION
1875  int size() const {
1876  return expr2.size();
1877  }
1878 
1879  SACADO_INLINE_FUNCTION
1880  bool updateValue() const {
1881  return expr2.updateValue();
1882  }
1883 
1884  SACADO_INLINE_FUNCTION
1885  void cache() const {
1886  expr2.cache();
1887  const value_type_1 v1 = expr1.val();
1888  const value_type_2 v2 = expr2.val();
1889  v = std::pow(v1,v2);
1890  if (v1 == value_type(0)) {
1891  b = value_type(0);
1892  }
1893  else {
1894  b = v*std::log(v1);
1895  }
1896  }
1897 
1898  SACADO_INLINE_FUNCTION
1899  value_type val() const {
1900  return v;
1901  }
1902 
1903  SACADO_INLINE_FUNCTION
1904  bool isLinear() const {
1905  return false;
1906  }
1907 
1908  SACADO_INLINE_FUNCTION
1909  bool hasFastAccess() const {
1910  return expr2.hasFastAccess();
1911  }
1912 
1913  SACADO_INLINE_FUNCTION
1914  const value_type dx(int i) const {
1915  return expr2.dx(i)*b;
1916  }
1917 
1918  SACADO_INLINE_FUNCTION
1919  const value_type fastAccessDx(int i) const {
1920  return expr2.fastAccessDx(i)*b;
1921  }
1922 
1923  protected:
1924 
1925  ExprT1 expr1;
1926  const ExprT2& expr2;
1927  mutable value_type v;
1928  mutable value_type b;
1929 
1930  };
1931 
1932  //
1933  // MaxOp
1934  //
1935 
1936  template <typename ExprT1, typename ExprT2>
1937  class MaxOp {};
1938 
1939  template <typename ExprT1, typename ExprT2>
1940  class Expr< MaxOp<ExprT1,ExprT2> > {
1941 
1942  public:
1943 
1944  typedef typename ExprT1::value_type value_type_1;
1945  typedef typename ExprT2::value_type value_type_2;
1946  typedef typename Sacado::Promote<value_type_1,
1947  value_type_2>::type value_type;
1948 
1949  typedef typename ExprT1::scalar_type scalar_type_1;
1950  typedef typename ExprT2::scalar_type scalar_type_2;
1951  typedef typename Sacado::Promote<scalar_type_1,
1952  scalar_type_2>::type scalar_type;
1953 
1954  typedef typename ExprT1::base_expr_type base_expr_type_1;
1955  typedef typename ExprT2::base_expr_type base_expr_type_2;
1956  typedef typename Sacado::Promote<base_expr_type_1,
1957  base_expr_type_2>::type base_expr_type;
1958 
1959  SACADO_INLINE_FUNCTION
1960  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
1961  expr1(expr1_), expr2(expr2_) {}
1962 
1963  SACADO_INLINE_FUNCTION
1964  int size() const {
1965  int sz1 = expr1.size(), sz2 = expr2.size();
1966  return sz1 > sz2 ? sz1 : sz2;
1967  }
1968 
1969  SACADO_INLINE_FUNCTION
1970  bool updateValue() const {
1971  return expr1.updateValue() && expr2.updateValue();
1972  }
1973 
1974  SACADO_INLINE_FUNCTION
1975  void cache() const {
1976  expr1.cache();
1977  expr2.cache();
1978  const value_type_1 v1 = expr1.val();
1979  const value_type_2 v2 = expr2.val();
1980  max_v1 = (v1 >= v2);
1981  v = max_v1 ? v1 : v2;
1982  }
1983 
1984  SACADO_INLINE_FUNCTION
1985  value_type val() const {
1986  return v;
1987  }
1988 
1989  SACADO_INLINE_FUNCTION
1990  bool isLinear() const {
1991  return false;
1992  }
1993 
1994  SACADO_INLINE_FUNCTION
1995  bool hasFastAccess() const {
1996  return expr1.hasFastAccess() && expr2.hasFastAccess();
1997  }
1998 
1999  SACADO_INLINE_FUNCTION
2000  const value_type dx(int i) const {
2001  return max_v1 ? expr1.dx(i) : expr2.dx(i);
2002  }
2003 
2004  SACADO_INLINE_FUNCTION
2005  const value_type fastAccessDx(int i) const {
2006  return max_v1 ? expr1.fastAccessDx(i) : expr2.fastAccessDx(i);
2007  }
2008 
2009  protected:
2010 
2011  const ExprT1& expr1;
2012  const ExprT2& expr2;
2013  mutable value_type v;
2014  mutable bool max_v1;
2015 
2016  };
2017 
2018  template <typename ExprT1, typename T2>
2019  class Expr< MaxOp<ExprT1, ConstExpr<T2> > > {
2020 
2021  public:
2022 
2023  typedef ConstExpr<T2> ExprT2;
2024  typedef typename ExprT1::value_type value_type_1;
2025  typedef typename ExprT2::value_type value_type_2;
2026  typedef typename Sacado::Promote<value_type_1,
2027  value_type_2>::type value_type;
2028 
2029  typedef typename ExprT1::scalar_type scalar_type_1;
2030  typedef typename ExprT2::scalar_type scalar_type_2;
2031  typedef typename Sacado::Promote<scalar_type_1,
2032  scalar_type_2>::type scalar_type;
2033 
2034  typedef typename ExprT1::base_expr_type base_expr_type_1;
2035  typedef typename ExprT2::base_expr_type base_expr_type_2;
2036  typedef typename Sacado::Promote<base_expr_type_1,
2037  base_expr_type_2>::type base_expr_type;
2038 
2039  SACADO_INLINE_FUNCTION
2040  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
2041  expr1(expr1_), expr2(expr2_) {}
2042 
2043  SACADO_INLINE_FUNCTION
2044  int size() const {
2045  return expr1.size();
2046  }
2047 
2048  SACADO_INLINE_FUNCTION
2049  bool updateValue() const {
2050  return expr1.updateValue();
2051  }
2052 
2053  SACADO_INLINE_FUNCTION
2054  void cache() const {
2055  expr1.cache();
2056  const value_type_1 v1 = expr1.val();
2057  const value_type_2 v2 = expr2.val();
2058  max_v1 = (v1 >= v2);
2059  v = max_v1 ? v1 : v2;
2060  }
2061 
2062  SACADO_INLINE_FUNCTION
2063  value_type val() const {
2064  return v;
2065  }
2066 
2067  SACADO_INLINE_FUNCTION
2068  bool isLinear() const {
2069  return false;
2070  }
2071 
2072  SACADO_INLINE_FUNCTION
2073  bool hasFastAccess() const {
2074  return expr1.hasFastAccess();
2075  }
2076 
2077  SACADO_INLINE_FUNCTION
2078  const value_type dx(int i) const {
2079  return max_v1 ? expr1.dx(i) : value_type(0);
2080  }
2081 
2082  SACADO_INLINE_FUNCTION
2083  const value_type fastAccessDx(int i) const {
2084  return max_v1 ? expr1.fastAccessDx(i) : value_type(0);
2085  }
2086 
2087  protected:
2088 
2089  const ExprT1& expr1;
2090  ExprT2 expr2;
2091  mutable value_type v;
2092  mutable bool max_v1;
2093 
2094  };
2095 
2096  template <typename T1, typename ExprT2>
2097  class Expr< MaxOp< ConstExpr<T1>,ExprT2> > {
2098 
2099  public:
2100 
2101  typedef ConstExpr<T1> ExprT1;
2102  typedef typename ExprT1::value_type value_type_1;
2103  typedef typename ExprT2::value_type value_type_2;
2104  typedef typename Sacado::Promote<value_type_1,
2105  value_type_2>::type value_type;
2106 
2107  typedef typename ExprT1::scalar_type scalar_type_1;
2108  typedef typename ExprT2::scalar_type scalar_type_2;
2109  typedef typename Sacado::Promote<scalar_type_1,
2110  scalar_type_2>::type scalar_type;
2111 
2112  typedef typename ExprT1::base_expr_type base_expr_type_1;
2113  typedef typename ExprT2::base_expr_type base_expr_type_2;
2114  typedef typename Sacado::Promote<base_expr_type_1,
2115  base_expr_type_2>::type base_expr_type;
2116 
2117  SACADO_INLINE_FUNCTION
2118  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
2119  expr1(expr1_), expr2(expr2_) {}
2120 
2121  SACADO_INLINE_FUNCTION
2122  int size() const {
2123  return expr2.size();
2124  }
2125 
2126  SACADO_INLINE_FUNCTION
2127  bool updateValue() const {
2128  return expr2.updateValue();
2129  }
2130 
2131  SACADO_INLINE_FUNCTION
2132  void cache() const {
2133  expr2.cache();
2134  const value_type_1 v1 = expr1.val();
2135  const value_type_2 v2 = expr2.val();
2136  max_v1 = (v1 >= v2);
2137  v = max_v1 ? v1 : v2;
2138  }
2139 
2140  SACADO_INLINE_FUNCTION
2141  value_type val() const {
2142  return v;
2143  }
2144 
2145  SACADO_INLINE_FUNCTION
2146  bool isLinear() const {
2147  return false;
2148  }
2149 
2150  SACADO_INLINE_FUNCTION
2151  bool hasFastAccess() const {
2152  return expr2.hasFastAccess();
2153  }
2154 
2155  SACADO_INLINE_FUNCTION
2156  const value_type dx(int i) const {
2157  return max_v1 ? value_type(0) : expr2.dx(i);
2158  }
2159 
2160  SACADO_INLINE_FUNCTION
2161  const value_type fastAccessDx(int i) const {
2162  return max_v1 ? value_type(0) : expr2.fastAccessDx(i);
2163  }
2164 
2165  protected:
2166 
2167  ExprT1 expr1;
2168  const ExprT2& expr2;
2169  mutable value_type v;
2170  mutable bool max_v1;
2171 
2172  };
2173 
2174  //
2175  // MinOp
2176  //
2177 
2178  template <typename ExprT1, typename ExprT2>
2179  class MinOp {};
2180 
2181  template <typename ExprT1, typename ExprT2>
2182  class Expr< MinOp<ExprT1,ExprT2> > {
2183 
2184  public:
2185 
2186  typedef typename ExprT1::value_type value_type_1;
2187  typedef typename ExprT2::value_type value_type_2;
2188  typedef typename Sacado::Promote<value_type_1,
2189  value_type_2>::type value_type;
2190 
2191  typedef typename ExprT1::scalar_type scalar_type_1;
2192  typedef typename ExprT2::scalar_type scalar_type_2;
2193  typedef typename Sacado::Promote<scalar_type_1,
2194  scalar_type_2>::type scalar_type;
2195 
2196  typedef typename ExprT1::base_expr_type base_expr_type_1;
2197  typedef typename ExprT2::base_expr_type base_expr_type_2;
2198  typedef typename Sacado::Promote<base_expr_type_1,
2199  base_expr_type_2>::type base_expr_type;
2200 
2201  SACADO_INLINE_FUNCTION
2202  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
2203  expr1(expr1_), expr2(expr2_) {}
2204 
2205  SACADO_INLINE_FUNCTION
2206  int size() const {
2207  int sz1 = expr1.size(), sz2 = expr2.size();
2208  return sz1 > sz2 ? sz1 : sz2;
2209  }
2210 
2211  SACADO_INLINE_FUNCTION
2212  bool updateValue() const {
2213  return expr1.updateValue() && expr2.updateValue();
2214  }
2215 
2216  SACADO_INLINE_FUNCTION
2217  void cache() const {
2218  expr1.cache();
2219  expr2.cache();
2220  const value_type_1 v1 = expr1.val();
2221  const value_type_2 v2 = expr2.val();
2222  min_v1 = (v1 <= v2);
2223  v = min_v1 ? v1 : v2;
2224  }
2225 
2226  SACADO_INLINE_FUNCTION
2227  value_type val() const {
2228  return v;
2229  }
2230 
2231  SACADO_INLINE_FUNCTION
2232  bool isLinear() const {
2233  return false;
2234  }
2235 
2236  SACADO_INLINE_FUNCTION
2237  bool hasFastAccess() const {
2238  return expr1.hasFastAccess() && expr2.hasFastAccess();
2239  }
2240 
2241  SACADO_INLINE_FUNCTION
2242  const value_type dx(int i) const {
2243  return min_v1 ? expr1.dx(i) : expr2.dx(i);
2244  }
2245 
2246  SACADO_INLINE_FUNCTION
2247  const value_type fastAccessDx(int i) const {
2248  return min_v1 ? expr1.fastAccessDx(i) : expr2.fastAccessDx(i);
2249  }
2250 
2251  protected:
2252 
2253  const ExprT1& expr1;
2254  const ExprT2& expr2;
2255  mutable value_type v;
2256  mutable bool min_v1;
2257 
2258  };
2259 
2260  template <typename ExprT1, typename T2>
2261  class Expr< MinOp<ExprT1, ConstExpr<T2> > > {
2262 
2263  public:
2264 
2265  typedef ConstExpr<T2> ExprT2;
2266  typedef typename ExprT1::value_type value_type_1;
2267  typedef typename ExprT2::value_type value_type_2;
2268  typedef typename Sacado::Promote<value_type_1,
2269  value_type_2>::type value_type;
2270 
2271  typedef typename ExprT1::scalar_type scalar_type_1;
2272  typedef typename ExprT2::scalar_type scalar_type_2;
2273  typedef typename Sacado::Promote<scalar_type_1,
2274  scalar_type_2>::type scalar_type;
2275 
2276  typedef typename ExprT1::base_expr_type base_expr_type_1;
2277  typedef typename ExprT2::base_expr_type base_expr_type_2;
2278  typedef typename Sacado::Promote<base_expr_type_1,
2279  base_expr_type_2>::type base_expr_type;
2280 
2281  SACADO_INLINE_FUNCTION
2282  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
2283  expr1(expr1_), expr2(expr2_) {}
2284 
2285  SACADO_INLINE_FUNCTION
2286  int size() const {
2287  return expr1.size();
2288  }
2289 
2290  SACADO_INLINE_FUNCTION
2291  bool updateValue() const {
2292  return expr1.updateValue();
2293  }
2294 
2295  SACADO_INLINE_FUNCTION
2296  void cache() const {
2297  expr1.cache();
2298  const value_type_1 v1 = expr1.val();
2299  const value_type_2 v2 = expr2.val();
2300  min_v1 = (v1 <= v2);
2301  v = min_v1 ? v1 : v2;
2302  }
2303 
2304  SACADO_INLINE_FUNCTION
2305  value_type val() const {
2306  return v;
2307  }
2308 
2309  SACADO_INLINE_FUNCTION
2310  bool isLinear() const {
2311  return false;
2312  }
2313 
2314  SACADO_INLINE_FUNCTION
2315  bool hasFastAccess() const {
2316  return expr1.hasFastAccess();
2317  }
2318 
2319  SACADO_INLINE_FUNCTION
2320  const value_type dx(int i) const {
2321  return min_v1 ? expr1.dx(i) : value_type(0);
2322  }
2323 
2324  SACADO_INLINE_FUNCTION
2325  const value_type fastAccessDx(int i) const {
2326  return min_v1 ? expr1.fastAccessDx(i) : value_type(0);
2327  }
2328 
2329  protected:
2330 
2331  const ExprT1& expr1;
2332  ExprT2 expr2;
2333  mutable value_type v;
2334  mutable bool min_v1;
2335 
2336  };
2337 
2338  template <typename T1, typename ExprT2>
2339  class Expr< MinOp< ConstExpr<T1>,ExprT2> > {
2340 
2341  public:
2342 
2343  typedef ConstExpr<T1> ExprT1;
2344  typedef typename ExprT1::value_type value_type_1;
2345  typedef typename ExprT2::value_type value_type_2;
2346  typedef typename Sacado::Promote<value_type_1,
2347  value_type_2>::type value_type;
2348 
2349  typedef typename ExprT1::scalar_type scalar_type_1;
2350  typedef typename ExprT2::scalar_type scalar_type_2;
2351  typedef typename Sacado::Promote<scalar_type_1,
2352  scalar_type_2>::type scalar_type;
2353 
2354  typedef typename ExprT1::base_expr_type base_expr_type_1;
2355  typedef typename ExprT2::base_expr_type base_expr_type_2;
2356  typedef typename Sacado::Promote<base_expr_type_1,
2357  base_expr_type_2>::type base_expr_type;
2358 
2359  SACADO_INLINE_FUNCTION
2360  Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
2361  expr1(expr1_), expr2(expr2_) {}
2362 
2363  SACADO_INLINE_FUNCTION
2364  int size() const {
2365  return expr2.size();
2366  }
2367 
2368  SACADO_INLINE_FUNCTION
2369  bool updateValue() const {
2370  return expr2.updateValue();
2371  }
2372 
2373  SACADO_INLINE_FUNCTION
2374  void cache() const {
2375  expr2.cache();
2376  const value_type_1 v1 = expr1.val();
2377  const value_type_2 v2 = expr2.val();
2378  min_v1 = (v1 <= v2);
2379  v = min_v1 ? v1 : v2;
2380  }
2381 
2382  SACADO_INLINE_FUNCTION
2383  value_type val() const {
2384  return v;
2385  }
2386 
2387  SACADO_INLINE_FUNCTION
2388  bool isLinear() const {
2389  return false;
2390  }
2391 
2392  SACADO_INLINE_FUNCTION
2393  bool hasFastAccess() const {
2394  return expr2.hasFastAccess();
2395  }
2396 
2397  SACADO_INLINE_FUNCTION
2398  const value_type dx(int i) const {
2399  return min_v1 ? value_type(0) : expr2.dx(i);
2400  }
2401 
2402  SACADO_INLINE_FUNCTION
2403  const value_type fastAccessDx(int i) const {
2404  return min_v1 ? value_type(0) : expr2.fastAccessDx(i);
2405  }
2406 
2407  protected:
2408 
2409  ExprT1 expr1;
2410  const ExprT2& expr2;
2411  mutable value_type v;
2412  mutable bool min_v1;
2413 
2414  };
2415 
2416  }
2417 
2418 }
2419 
2420 #define FAD_BINARYOP_MACRO(OPNAME,OP) \
2421 namespace Sacado { \
2422  namespace CacheFad { \
2423  \
2424  template <typename T1, typename T2> \
2425  SACADO_INLINE_FUNCTION \
2426  SACADO_FAD_OP_ENABLE_EXPR_EXPR(OP) \
2427  OPNAME (const T1& expr1, const T2& expr2) \
2428  { \
2429  typedef OP< T1, T2 > expr_t; \
2430  \
2431  return Expr<expr_t>(expr1, expr2); \
2432  } \
2433  \
2434  template <typename T> \
2435  SACADO_INLINE_FUNCTION \
2436  Expr< OP< Expr<T>, Expr<T> > > \
2437  OPNAME (const Expr<T>& expr1, const Expr<T>& expr2) \
2438  { \
2439  typedef OP< Expr<T>, Expr<T> > expr_t; \
2440  \
2441  return Expr<expr_t>(expr1, expr2); \
2442  } \
2443  \
2444  template <typename T> \
2445  SACADO_INLINE_FUNCTION \
2446  Expr< OP< ConstExpr<typename Expr<T>::value_type>, \
2447  Expr<T> > > \
2448  OPNAME (const typename Expr<T>::value_type& c, \
2449  const Expr<T>& expr) \
2450  { \
2451  typedef ConstExpr<typename Expr<T>::value_type> ConstT; \
2452  typedef OP< ConstT, Expr<T> > expr_t; \
2453  \
2454  return Expr<expr_t>(ConstT(c), expr); \
2455  } \
2456  \
2457  template <typename T> \
2458  SACADO_INLINE_FUNCTION \
2459  Expr< OP< Expr<T>, \
2460  ConstExpr<typename Expr<T>::value_type> > > \
2461  OPNAME (const Expr<T>& expr, \
2462  const typename Expr<T>::value_type& c) \
2463  { \
2464  typedef ConstExpr<typename Expr<T>::value_type> ConstT; \
2465  typedef OP< Expr<T>, ConstT > expr_t; \
2466  \
2467  return Expr<expr_t>(expr, ConstT(c)); \
2468  } \
2469  \
2470  template <typename T> \
2471  SACADO_INLINE_FUNCTION \
2472  SACADO_FAD_OP_ENABLE_SCALAR_EXPR(OP) \
2473  OPNAME (const typename Expr<T>::scalar_type& c, \
2474  const Expr<T>& expr) \
2475  { \
2476  typedef ConstExpr<typename Expr<T>::scalar_type> ConstT; \
2477  typedef OP< ConstT, Expr<T> > expr_t; \
2478  \
2479  return Expr<expr_t>(ConstT(c), expr); \
2480  } \
2481  \
2482  template <typename T> \
2483  SACADO_INLINE_FUNCTION \
2484  SACADO_FAD_OP_ENABLE_EXPR_SCALAR(OP) \
2485  OPNAME (const Expr<T>& expr, \
2486  const typename Expr<T>::scalar_type& c) \
2487  { \
2488  typedef ConstExpr<typename Expr<T>::scalar_type> ConstT; \
2489  typedef OP< Expr<T>, ConstT > expr_t; \
2490  \
2491  return Expr<expr_t>(expr, ConstT(c)); \
2492  } \
2493  } \
2494 }
2495 
2496 
2497 FAD_BINARYOP_MACRO(operator+, AdditionOp)
2498 FAD_BINARYOP_MACRO(operator-, SubtractionOp)
2499 FAD_BINARYOP_MACRO(operator*, MultiplicationOp)
2500 FAD_BINARYOP_MACRO(operator/, DivisionOp)
2501 FAD_BINARYOP_MACRO(atan2, Atan2Op)
2502 FAD_BINARYOP_MACRO(pow, PowerOp)
2503 FAD_BINARYOP_MACRO(max, MaxOp)
2504 FAD_BINARYOP_MACRO(min, MinOp)
2505 
2506 #undef FAD_BINARYOP_MACRO
2507 
2508 //-------------------------- Relational Operators -----------------------
2509 
2510 #define FAD_RELOP_MACRO(OP) \
2511 namespace Sacado { \
2512  namespace CacheFad { \
2513  template <typename ExprT1, typename ExprT2> \
2514  SACADO_INLINE_FUNCTION \
2515  bool \
2516  operator OP (const Expr<ExprT1>& expr1, \
2517  const Expr<ExprT2>& expr2) \
2518  { \
2519  expr1.cache(); \
2520  expr2.cache(); \
2521  return expr1.val() OP expr2.val(); \
2522  } \
2523  \
2524  template <typename ExprT2> \
2525  SACADO_INLINE_FUNCTION \
2526  bool \
2527  operator OP (const typename Expr<ExprT2>::value_type& a, \
2528  const Expr<ExprT2>& expr2) \
2529  { \
2530  expr2.cache(); \
2531  return a OP expr2.val(); \
2532  } \
2533  \
2534  template <typename ExprT1> \
2535  SACADO_INLINE_FUNCTION \
2536  bool \
2537  operator OP (const Expr<ExprT1>& expr1, \
2538  const typename Expr<ExprT1>::value_type& b) \
2539  { \
2540  expr1.cache(); \
2541  return expr1.val() OP b; \
2542  } \
2543  } \
2544 }
2545 
2546 FAD_RELOP_MACRO(==)
2547 FAD_RELOP_MACRO(!=)
2548 FAD_RELOP_MACRO(<)
2549 FAD_RELOP_MACRO(>)
2550 FAD_RELOP_MACRO(<=)
2551 FAD_RELOP_MACRO(>=)
2552 FAD_RELOP_MACRO(<<=)
2553 FAD_RELOP_MACRO(>>=)
2554 FAD_RELOP_MACRO(&)
2555 FAD_RELOP_MACRO(|)
2556 
2557 #undef FAD_RELOP_MACRO
2558 
2559 namespace Sacado {
2560 
2561  namespace CacheFad {
2562 
2563  template <typename ExprT>
2564  SACADO_INLINE_FUNCTION
2565  bool operator ! (const Expr<ExprT>& expr)
2566  {
2567  expr.cache();
2568  return ! expr.val();
2569  }
2570 
2571  } // namespace CacheFad
2572 
2573 } // namespace Sacado
2574 
2575 //-------------------------- Boolean Operators -----------------------
2576 namespace Sacado {
2577 
2578  namespace CacheFad {
2579 
2580  template <typename ExprT>
2581  SACADO_INLINE_FUNCTION
2582  bool toBool(const Expr<ExprT>& x) {
2583  x.cache();
2584  bool is_zero = (x.val() == 0.0);
2585  for (int i=0; i<x.size(); i++)
2586  is_zero = is_zero && (x.dx(i) == 0.0);
2587  return !is_zero;
2588  }
2589 
2590  } // namespace Fad
2591 
2592 } // namespace Sacado
2593 
2594 #define FAD_BOOL_MACRO(OP) \
2595 namespace Sacado { \
2596  namespace CacheFad { \
2597  template <typename ExprT1, typename ExprT2> \
2598  SACADO_INLINE_FUNCTION \
2599  bool \
2600  operator OP (const Expr<ExprT1>& expr1, \
2601  const Expr<ExprT2>& expr2) \
2602  { \
2603  return toBool(expr1) OP toBool(expr2); \
2604  } \
2605  \
2606  template <typename ExprT2> \
2607  SACADO_INLINE_FUNCTION \
2608  bool \
2609  operator OP (const typename Expr<ExprT2>::value_type& a, \
2610  const Expr<ExprT2>& expr2) \
2611  { \
2612  return a OP toBool(expr2); \
2613  } \
2614  \
2615  template <typename ExprT1> \
2616  SACADO_INLINE_FUNCTION \
2617  bool \
2618  operator OP (const Expr<ExprT1>& expr1, \
2619  const typename Expr<ExprT1>::value_type& b) \
2620  { \
2621  return toBool(expr1) OP b; \
2622  } \
2623  } \
2624 }
2625 
2626 FAD_BOOL_MACRO(&&)
2627 FAD_BOOL_MACRO(||)
2628 
2629 #undef FAD_BOOL_MACRO
2630 
2631 //-------------------------- I/O Operators -----------------------
2632 
2633 namespace Sacado {
2634 
2635  namespace CacheFad {
2636 
2637  template <typename ExprT>
2638  std::ostream& operator << (std::ostream& os, const Expr<ExprT>& x) {
2639  x.cache();
2640  os << x.val() << " [";
2641 
2642  for (int i=0; i< x.size(); i++) {
2643  os << " " << x.dx(i);
2644  }
2645 
2646  os << " ]";
2647  return os;
2648  }
2649 
2650  } // namespace CacheFad
2651 
2652 } // namespace Sacado
2653 
2654 #endif // SACADO_CACHEFAD_OPS_HPP
cbrt
cbrt(expr.val())
FAD_RELOP_MACRO
#define FAD_RELOP_MACRO(OP)
Definition: Sacado_CacheFad_Ops.hpp:2510
Sacado_cmath.hpp
Sacado::CacheFad::abs
SACADO_INLINE_FUNCTION Expr< AbsOp< Expr< T > > > abs(const Expr< T > &expr)
Definition: Sacado_CacheFad_Ops.hpp:247
SinOp
expr expr SinOp
Definition: Sacado_Fad_Exp_Ops.hpp:177
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::isLinear
SACADO_INLINE_FUNCTION bool isLinear() const
Definition: Sacado_CacheFad_Ops.hpp:291
MaxOp
expr2 expr1 expr2 expr2 c *expr2 c *expr1 c *expr2 c *expr1 MaxOp
Definition: Sacado_Fad_Exp_Ops.hpp:819
asinh
asinh(expr.val())
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::Expr
SACADO_INLINE_FUNCTION Expr(const ExprT &expr_)
Definition: Sacado_CacheFad_Ops.hpp:60
FAD_UNARYOP_MACRO
#define FAD_UNARYOP_MACRO(OPNAME, OP, USING, VALUE, DX, FASTACCESSDX)
Definition: Sacado_Fad_Exp_Ops.hpp:28
asin
asin(expr.val())
cosh
cosh(expr.val())
dx
expr expr dx(i)
Definition: Sacado_ELRFad_Ops.hpp:186
abs
abs(expr.val())
Sacado::CacheFad::operator!
SACADO_INLINE_FUNCTION bool operator!(const Expr< ExprT > &expr)
Definition: Sacado_CacheFad_Ops.hpp:2565
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::updateValue
SACADO_INLINE_FUNCTION bool updateValue() const
Definition: Sacado_CacheFad_Ops.hpp:66
AdditionOp
expr AdditionOp
Definition: Sacado_LFad_LogicalSparseOps.hpp:358
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::Expr
SACADO_INLINE_FUNCTION Expr(const ExprT &expr_)
Definition: Sacado_CacheFad_Ops.hpp:270
atanh
atanh(expr.val())
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::hasFastAccess
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Definition: Sacado_CacheFad_Ops.hpp:152
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::cache
SACADO_INLINE_FUNCTION void cache() const
Definition: Sacado_CacheFad_Ops.hpp:279
Sacado_CacheFad_Expression.hpp
CoshOp
expr expr CoshOp
Definition: Sacado_Fad_Exp_Ops.hpp:211
ATanhOp
expr expr ATanhOp
Definition: Sacado_Fad_Exp_Ops.hpp:244
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::val
SACADO_INLINE_FUNCTION value_type val() const
Definition: Sacado_CacheFad_Ops.hpp:286
TanhOp
expr expr TanhOp
Definition: Sacado_Fad_Exp_Ops.hpp:223
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::isLinear
SACADO_INLINE_FUNCTION bool isLinear() const
Definition: Sacado_CacheFad_Ops.hpp:147
SqrtOp
expr expr SqrtOp
Definition: Sacado_Fad_Exp_Ops.hpp:165
ASinhOp
expr expr ASinhOp
Definition: Sacado_Fad_Exp_Ops.hpp:237
atan
atan(expr.val())
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::cache
SACADO_INLINE_FUNCTION void cache() const
Definition: Sacado_CacheFad_Ops.hpp:137
SafeSqrtOp
SafeSqrtOp
Definition: Sacado_CacheFad_Ops.hpp:418
FAD_BOOL_MACRO
#define FAD_BOOL_MACRO(OP)
Definition: Sacado_CacheFad_Ops.hpp:2594
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::cache
SACADO_INLINE_FUNCTION void cache() const
Definition: Sacado_CacheFad_Ops.hpp:69
i
int i
Definition: gmock-matchers_test.cc:718
MultiplicationOp
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 MultiplicationOp
Definition: Sacado_Fad_Exp_Ops.hpp:755
Sacado::CacheFad::Expr< AbsOp< ExprT > >::dx
SACADO_INLINE_FUNCTION const value_type dx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:228
Sacado::CacheFad::Expr< AbsOp< ExprT > >::isLinear
SACADO_INLINE_FUNCTION bool isLinear() const
Definition: Sacado_CacheFad_Ops.hpp:218
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::hasFastAccess
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Definition: Sacado_CacheFad_Ops.hpp:84
a
a
Definition: Sacado_CacheFad_Ops.hpp:407
Atan2Op
expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 expr1 expr1 c *expr2 expr1 c *expr2 expr1 c *expr2 expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 Atan2Op
Definition: Sacado_Fad_Exp_Ops.hpp:787
val
expr val()
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::Expr
SACADO_INLINE_FUNCTION Expr(const ExprT &expr_)
Definition: Sacado_CacheFad_Ops.hpp:128
tanh
tanh(expr.val())
CosOp
expr expr CosOp
Definition: Sacado_Fad_Exp_Ops.hpp:171
CbrtOp
CbrtOp
Definition: Sacado_Fad_Exp_Ops.hpp:263
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::dx
SACADO_INLINE_FUNCTION const value_type dx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:301
FAD_BINARYOP_MACRO
#define FAD_BINARYOP_MACRO(OPNAME, OP, USING, VALUE, DX, CDX1, CDX2, FASTACCESSDX, VAL_CONST_DX_1, VAL_CONST_DX_2, CONST_DX_1, CONST_DX_2, CONST_FASTACCESSDX_1, CONST_FASTACCESSDX_2)
Definition: Sacado_Fad_Exp_Ops.hpp:437
ATanOp
expr expr ATanOp
Definition: Sacado_Fad_Exp_Ops.hpp:205
Sacado::CacheFad::Expr< AbsOp< ExprT > >::hasFastAccess
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Definition: Sacado_CacheFad_Ops.hpp:223
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::fastAccessDx
SACADO_INLINE_FUNCTION const value_type fastAccessDx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:162
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::val
SACADO_INLINE_FUNCTION value_type val() const
Definition: Sacado_CacheFad_Ops.hpp:74
Sacado::Fad::min
SimpleFad< ValueT > min(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:479
ACosOp
expr expr ACosOp
Definition: Sacado_Fad_Exp_Ops.hpp:191
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::fastAccessDx
SACADO_INLINE_FUNCTION const value_type fastAccessDx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:94
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::fastAccessDx
SACADO_INLINE_FUNCTION const value_type fastAccessDx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:306
sqrt
sqrt(expr.val())
sinh
sinh(expr.val())
tan
tan(expr.val())
DivisionOp
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 DivisionOp
Definition: Sacado_Fad_Exp_Ops.hpp:770
Sacado::CacheFad::fabs
SACADO_INLINE_FUNCTION Expr< FAbsOp< Expr< T > > > fabs(const Expr< T > &expr)
Definition: Sacado_CacheFad_Ops.hpp:320
atan2
atan2(expr1.val(), expr2.val())
Sacado::CacheFad::Expr< AbsOp< ExprT > >::Expr
SACADO_INLINE_FUNCTION Expr(const ExprT &expr_)
Definition: Sacado_CacheFad_Ops.hpp:197
Sacado::CacheFad::toBool
SACADO_INLINE_FUNCTION bool toBool(const Expr< ExprT > &x)
Definition: Sacado_CacheFad_Ops.hpp:2582
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::updateValue
SACADO_INLINE_FUNCTION bool updateValue() const
Definition: Sacado_CacheFad_Ops.hpp:134
sin
sin(expr.val())
fastAccessDx
expr expr expr fastAccessDx(i)) FAD_UNARYOP_MACRO(exp
Definition: Sacado_Fad_Exp_Ops.hpp:267
MinOp
MinOp
Definition: Sacado_Fad_Exp_Ops.hpp:833
Sacado::CacheFad::Expr< AbsOp< ExprT > >::size
SACADO_INLINE_FUNCTION int size() const
Definition: Sacado_CacheFad_Ops.hpp:200
x
int x
Definition: gmock-matchers_test.cc:3775
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::hasFastAccess
SACADO_INLINE_FUNCTION bool hasFastAccess() const
Definition: Sacado_CacheFad_Ops.hpp:296
Sacado::CacheFad::Expr< AbsOp< ExprT > >::fastAccessDx
SACADO_INLINE_FUNCTION const value_type fastAccessDx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:233
Sacado::safe_sqrt
SACADO_INLINE_FUNCTION T safe_sqrt(const T &x)
Definition: Sacado_cmath.hpp:32
SubtractionOp
SubtractionOp
Definition: Sacado_Fad_Exp_Ops.hpp:741
Sacado::CacheFad::Expr< AbsOp< ExprT > >::updateValue
SACADO_INLINE_FUNCTION bool updateValue() const
Definition: Sacado_CacheFad_Ops.hpp:203
Sacado_dummy_arg.hpp
log
log(expr.val())
Sacado::CacheFad::operator+
SACADO_INLINE_FUNCTION Expr< UnaryPlusOp< Expr< T > > > operator+(const Expr< T > &expr)
Definition: Sacado_CacheFad_Ops.hpp:106
ACoshOp
expr expr ACoshOp
Definition: Sacado_Fad_Exp_Ops.hpp:229
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::size
SACADO_INLINE_FUNCTION int size() const
Definition: Sacado_CacheFad_Ops.hpp:63
Log10Op
expr expr Log10Op
Definition: Sacado_Fad_Exp_Ops.hpp:159
SinhOp
expr expr SinhOp
Definition: Sacado_Fad_Exp_Ops.hpp:217
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::updateValue
SACADO_INLINE_FUNCTION bool updateValue() const
Definition: Sacado_CacheFad_Ops.hpp:276
acosh
acosh(expr.val())
LogOp
LogOp
Definition: Sacado_Fad_Exp_Ops.hpp:153
acos
acos(expr.val())
Sacado::Fad::max
SimpleFad< ValueT > max(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
Definition: Sacado_Fad_SimpleFadOps.hpp:415
ASinOp
expr expr ASinOp
Definition: Sacado_Fad_Exp_Ops.hpp:198
Sacado::Fad::pow
SACADO_INLINE_FUNCTION mpl::enable_if_c< ExprLevel< Expr< T1 > >::value==ExprLevel< Expr< T2 > >::value, Expr< PowerOp< Expr< T1 >, Expr< T2 > > > >::type pow(const Expr< T1 > &expr1, const Expr< T2 > &expr2)
Definition: Sacado_Fad_Ops.hpp:2079
Sacado::CacheFad::Expr< FAbsOp< ExprT > >::size
SACADO_INLINE_FUNCTION int size() const
Definition: Sacado_CacheFad_Ops.hpp:273
Sacado::CacheFad::Expr< AbsOp< ExprT > >::val
SACADO_INLINE_FUNCTION value_type val() const
Definition: Sacado_CacheFad_Ops.hpp:213
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::isLinear
SACADO_INLINE_FUNCTION bool isLinear() const
Definition: Sacado_CacheFad_Ops.hpp:79
Sacado::CacheFad::Expr< AbsOp< ExprT > >::cache
SACADO_INLINE_FUNCTION void cache() const
Definition: Sacado_CacheFad_Ops.hpp:206
SACADO_INLINE_FUNCTION
#define SACADO_INLINE_FUNCTION
Definition: Sacado_ConfigDefs.h:88
exp
exp(expr.val())
Sacado::CacheFad::operator-
SACADO_INLINE_FUNCTION Expr< UnaryMinusOp< Expr< T > > > operator-(const Expr< T > &expr)
Definition: Sacado_CacheFad_Ops.hpp:174
ExpOp
expr expr expr ExpOp
Definition: Sacado_Fad_Exp_Ops.hpp:147
fabs
fabs(expr.val())
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::dx
SACADO_INLINE_FUNCTION const value_type dx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:157
Sacado::CacheFad::Expr
Wrapper for a generic expression template.
Definition: Sacado_CacheFad_Expression.hpp:58
Sacado::CacheFad::Expr< UnaryMinusOp< ExprT > >::val
SACADO_INLINE_FUNCTION value_type val() const
Definition: Sacado_CacheFad_Ops.hpp:142
TanOp
expr expr TanOp
Definition: Sacado_Fad_Exp_Ops.hpp:183
log10
log10(expr.val())
Sacado::Promote
Base template specification for Promote.
Definition: Sacado_Traits.hpp:87
cos
cos(expr.val())
Sacado::CacheFad::Expr< UnaryPlusOp< ExprT > >::dx
SACADO_INLINE_FUNCTION const value_type dx(int i) const
Definition: Sacado_CacheFad_Ops.hpp:89
PowerOp
expr expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c *expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 PowerOp
Definition: Sacado_LFad_LogicalSparseOps.hpp:413
Generated on Tue Nov 12 2024 09:21:50 for Sacado Package Browser (Single Doxygen Collection) by   doxygen 1.8.5