Stokhos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Sacado_Fad_Ops_MP_Vector.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Sacado Package
5// Copyright (2006) Sandia Corporation
6//
7// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8// the U.S. Government retains certain rights in this software.
9//
10// This library is free software; you can redistribute it and/or modify
11// it under the terms of the GNU Lesser General Public License as
12// published by the Free Software Foundation; either version 2.1 of the
13// License, or (at your option) any later version.
14//
15// This library is distributed in the hope that it will be useful, but
16// WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18// Lesser General Public License for more details.
19//
20// You should have received a copy of the GNU Lesser General Public
21// License along with this library; if not, write to the Free Software
22// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
23// USA
24// Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
25// (etphipp@sandia.gov).
26//
27// ***********************************************************************
28//
29// The forward-mode AD classes in Sacado are a derivative work of the
30// expression template classes in the Fad package by Nicolas Di Cesare.
31// The following banner is included in the original Fad source code:
32//
33// ************ DO NOT REMOVE THIS BANNER ****************
34//
35// Nicolas Di Cesare <Nicolas.Dicesare@ann.jussieu.fr>
36// http://www.ann.jussieu.fr/~dicesare
37//
38// CEMRACS 98 : C++ courses,
39// templates : new C++ techniques
40// for scientific computing
41//
42//********************************************************
43//
44// A short implementation ( not all operators and
45// functions are overloaded ) of 1st order Automatic
46// Differentiation in forward mode (FAD) using
47// EXPRESSION TEMPLATES.
48//
49//********************************************************
50// @HEADER
51
52#ifndef SACADO_FAD_OPS_MP_VECTOR_HPP
53#define SACADO_FAD_OPS_MP_VECTOR_HPP
54
55#include "Sacado_Fad_Ops.hpp"
56#include "Sacado_mpl_enable_if.hpp"
57#include "Sacado_Fad_Expr_MP_Vector.hpp"
58
59#define FAD_UNARYOP_MACRO(OPNAME,OP,MPVALUE,VALUE,DX,FASTACCESSDX) \
60namespace Sacado { \
61 namespace Fad { \
62 \
63 template <typename ExprT> \
64 class Expr< OP<ExprT>,ExprSpecMPVector > { \
65 public: \
66 \
67 typedef typename ExprT::value_type value_type; \
68 typedef typename ExprT::scalar_type scalar_type; \
69 typedef typename ExprT::base_expr_type base_expr_type; \
70 \
71 typedef typename value_type::value_type val_type; \
72 \
73 KOKKOS_INLINE_FUNCTION \
74 Expr(const ExprT& expr_) : expr(expr_) {} \
75 \
76 KOKKOS_INLINE_FUNCTION \
77 int size() const { return expr.size(); } \
78 \
79 KOKKOS_INLINE_FUNCTION \
80 bool hasFastAccess() const { return expr.hasFastAccess(); } \
81 \
82 KOKKOS_INLINE_FUNCTION \
83 bool isPassive() const { return expr.isPassive();} \
84 \
85 KOKKOS_INLINE_FUNCTION \
86 bool updateValue() const { return expr.updateValue(); } \
87 \
88 KOKKOS_INLINE_FUNCTION \
89 value_type val() const { \
90 return MPVALUE; \
91 } \
92 \
93 KOKKOS_INLINE_FUNCTION \
94 val_type val(int j) const { \
95 return VALUE; \
96 } \
97 \
98 KOKKOS_INLINE_FUNCTION \
99 val_type dx(int i, int j) const { \
100 return DX; \
101 } \
102 \
103 KOKKOS_INLINE_FUNCTION \
104 val_type fastAccessDx(int i, int j) const { \
105 return FASTACCESSDX; \
106 } \
107 \
108 protected: \
109 \
110 const ExprT& expr; \
111 }; \
112 \
113 } \
114}
115
116FAD_UNARYOP_MACRO(operator+,
117 UnaryPlusOp,
118 expr.val(),
119 expr.val(j),
120 expr.dx(i,j),
121 expr.fastAccessDx(i,j))
122FAD_UNARYOP_MACRO(operator-,
123 UnaryMinusOp,
124 -expr.val(),
125 -expr.val(j),
126 -expr.dx(i,j),
127 -expr.fastAccessDx(i,j))
128FAD_UNARYOP_MACRO(exp,
129 ExpOp,
130 std::exp(expr.val()),
131 std::exp(expr.val(j)),
132 std::exp(expr.val(j))*expr.dx(i,j),
133 std::exp(expr.val(j))*expr.fastAccessDx(i,j))
134FAD_UNARYOP_MACRO(log,
135 LogOp,
136 std::log(expr.val()),
137 std::log(expr.val(j)),
138 expr.dx(i,j)/expr.val(j),
139 expr.fastAccessDx(i,j)/expr.val(j))
140FAD_UNARYOP_MACRO(log10,
141 Log10Op,
142 std::log10(expr.val()),
143 std::log10(expr.val(j)),
144 expr.dx(i,j)/( std::log(val_type(10))*expr.val(j)),
145 expr.fastAccessDx(i,j) / ( std::log(val_type(10))*expr.val(j)))
146FAD_UNARYOP_MACRO(sqrt,
147 SqrtOp,
148 std::sqrt(expr.val()),
149 std::sqrt(expr.val(j)),
150 expr.dx(i,j)/(val_type(2)* std::sqrt(expr.val(j))),
151 expr.fastAccessDx(i,j)/(val_type(2)* std::sqrt(expr.val(j))))
152FAD_UNARYOP_MACRO(cos,
153 CosOp,
154 std::cos(expr.val()),
155 std::cos(expr.val(j)),
156 -expr.dx(i,j)* std::sin(expr.val(j)),
157 -expr.fastAccessDx(i,j)* std::sin(expr.val(j)))
158FAD_UNARYOP_MACRO(sin,
159 SinOp,
160 std::sin(expr.val()),
161 std::sin(expr.val(j)),
162 expr.dx(i,j)* std::cos(expr.val(j)),
163 expr.fastAccessDx(i,j)* std::cos(expr.val(j)))
164FAD_UNARYOP_MACRO(tan,
165 TanOp,
166 std::tan(expr.val()),
167 std::tan(expr.val(j)),
168 expr.dx(i,j)*
169 (val_type(1)+ std::tan(expr.val(j))* std::tan(expr.val(j))),
170 expr.fastAccessDx(i,j)*
171 (val_type(1)+ std::tan(expr.val(j))* std::tan(expr.val(j))))
172FAD_UNARYOP_MACRO(acos,
173 ACosOp,
174 std::acos(expr.val()),
175 std::acos(expr.val(j)),
176 -expr.dx(i,j)/ std::sqrt(val_type(1)-expr.val(j)*expr.val(j)),
177 -expr.fastAccessDx(i,j) /
178 std::sqrt(val_type(1)-expr.val(j)*expr.val(j)))
179FAD_UNARYOP_MACRO(asin,
180 ASinOp,
181 std::asin(expr.val()),
182 std::asin(expr.val(j)),
183 expr.dx(i,j)/ std::sqrt(val_type(1)-expr.val(j)*expr.val(j)),
184 expr.fastAccessDx(i,j) /
185 std::sqrt(val_type(1)-expr.val(j)*expr.val(j)))
186FAD_UNARYOP_MACRO(atan,
187 ATanOp,
188 std::atan(expr.val()),
189 std::atan(expr.val(j)),
190 expr.dx(i,j)/(val_type(1)+expr.val(j)*expr.val(j)),
191 expr.fastAccessDx(i,j)/(val_type(1)+expr.val(j)*expr.val(j)))
192FAD_UNARYOP_MACRO(cosh,
193 CoshOp,
194 std::cosh(expr.val()),
195 std::cosh(expr.val(j)),
196 expr.dx(i,j)* std::sinh(expr.val(j)),
197 expr.fastAccessDx(i,j)* std::sinh(expr.val(j)))
198FAD_UNARYOP_MACRO(sinh,
199 SinhOp,
200 std::sinh(expr.val()),
201 std::sinh(expr.val(j)),
202 expr.dx(i,j)* std::cosh(expr.val(j)),
203 expr.fastAccessDx(i,j)* std::cosh(expr.val(j)))
204FAD_UNARYOP_MACRO(tanh,
205 TanhOp,
206 std::tanh(expr.val()),
207 std::tanh(expr.val(j)),
208 expr.dx(i,j)/( std::cosh(expr.val(j))* std::cosh(expr.val(j))),
209 expr.fastAccessDx(i,j) /
210 ( std::cosh(expr.val(j))* std::cosh(expr.val(j))))
211FAD_UNARYOP_MACRO(acosh,
212 ACoshOp,
213 std::acosh(expr.val()),
214 std::acosh(expr.val(j)),
215 expr.dx(i,j)/ std::sqrt((expr.val(j)-val_type(1)) *
216 (expr.val(j)+val_type(1))),
217 expr.fastAccessDx(i,j)/ std::sqrt((expr.val(j)-val_type(1)) *
218 (expr.val(j)+val_type(1))))
219FAD_UNARYOP_MACRO(asinh,
220 ASinhOp,
221 std::asinh(expr.val()),
222 std::asinh(expr.val(j)),
223 expr.dx(i,j)/ std::sqrt(val_type(1)+expr.val(j)*expr.val(j)),
224 expr.fastAccessDx(i,j)/ std::sqrt(val_type(1)+
225 expr.val(j)*expr.val(j)))
226FAD_UNARYOP_MACRO(atanh,
227 ATanhOp,
228 std::atanh(expr.val()),
229 std::atanh(expr.val(j)),
230 expr.dx(i,j)/(val_type(1)-expr.val(j)*expr.val(j)),
231 expr.fastAccessDx(i,j)/(val_type(1)-
232 expr.val(j)*expr.val(j)))
233FAD_UNARYOP_MACRO(abs,
234 AbsOp,
235 std::abs(expr.val()),
236 std::abs(expr.val(j)),
237 expr.val(j) >= 0 ? val_type(+expr.dx(i,j)) :
238 val_type(-expr.dx(i,j)),
239 expr.val(j) >= 0 ? val_type(+expr.fastAccessDx(i,j)) :
240 val_type(-expr.fastAccessDx(i,j)))
241FAD_UNARYOP_MACRO(fabs,
242 FAbsOp,
243 std::fabs(expr.val()),
244 std::fabs(expr.val(j)),
245 expr.val(j) >= 0 ? val_type(+expr.dx(i,j)) :
246 val_type(-expr.dx(i,j)),
247 expr.val(j) >= 0 ? val_type(+expr.fastAccessDx(i,j)) :
248 val_type(-expr.fastAccessDx(i,j)))
249FAD_UNARYOP_MACRO(cbrt,
250 CbrtOp,
251 std::cbrt(expr.val()),
252 std::cbrt(expr.val(j)),
253 expr.dx(i,j)/(val_type(3)*std::cbrt(expr.val(j)*expr.val(j))),
254 expr.fastAccessDx(i,j)/(val_type(3)*std::cbrt(expr.val(j)*expr.val(j))))
255
256#undef FAD_UNARYOP_MACRO
257
258#define FAD_BINARYOP_MACRO(OPNAME,OP,MPVALUE,VALUE,DX,FASTACCESSDX,MPVAL_CONST_DX_1,MPVAL_CONST_DX_2,VAL_CONST_DX_1,VAL_CONST_DX_2,CONST_DX_1,CONST_DX_2,CONST_FASTACCESSDX_1,CONST_FASTACCESSDX_2) \
259namespace Sacado { \
260 namespace Fad { \
261 \
262 template <typename ExprT1, typename ExprT2> \
263 class Expr< OP< ExprT1, ExprT2 >,ExprSpecMPVector > { \
264 \
265 public: \
266 \
267 typedef typename ExprT1::value_type value_type_1; \
268 typedef typename ExprT2::value_type value_type_2; \
269 typedef typename Sacado::Promote<value_type_1, \
270 value_type_2>::type value_type; \
271 \
272 typedef typename ExprT1::scalar_type scalar_type_1; \
273 typedef typename ExprT2::scalar_type scalar_type_2; \
274 typedef typename Sacado::Promote<scalar_type_1, \
275 scalar_type_2>::type scalar_type; \
276 \
277 typedef typename ExprT1::base_expr_type base_expr_type_1; \
278 typedef typename ExprT2::base_expr_type base_expr_type_2; \
279 typedef typename Sacado::Promote<base_expr_type_1, \
280 base_expr_type_2>::type base_expr_type; \
281 \
282 typedef typename value_type::value_type val_type; \
283 \
284 KOKKOS_INLINE_FUNCTION \
285 Expr(const ExprT1& expr1_, const ExprT2& expr2_) : \
286 expr1(expr1_), expr2(expr2_) {} \
287 \
288 KOKKOS_INLINE_FUNCTION \
289 int size() const { \
290 int sz1 = expr1.size(), sz2 = expr2.size(); \
291 return sz1 > sz2 ? sz1 : sz2; \
292 } \
293 \
294 KOKKOS_INLINE_FUNCTION \
295 bool hasFastAccess() const { \
296 return expr1.hasFastAccess() && expr2.hasFastAccess(); \
297 } \
298 \
299 KOKKOS_INLINE_FUNCTION \
300 bool isPassive() const { \
301 return expr1.isPassive() && expr2.isPassive(); \
302 } \
303 \
304 KOKKOS_INLINE_FUNCTION \
305 bool updateValue() const { \
306 return expr1.updateValue() && expr2.updateValue(); \
307 } \
308 \
309 KOKKOS_INLINE_FUNCTION \
310 const value_type val() const { \
311 return MPVALUE; \
312 } \
313 \
314 KOKKOS_INLINE_FUNCTION \
315 const val_type val(int j) const { \
316 return VALUE; \
317 } \
318 \
319 KOKKOS_INLINE_FUNCTION \
320 const val_type dx(int i, int j) const { \
321 return DX; \
322 } \
323 \
324 KOKKOS_INLINE_FUNCTION \
325 const val_type fastAccessDx(int i, int j) const { \
326 return FASTACCESSDX; \
327 } \
328 \
329 protected: \
330 \
331 const ExprT1& expr1; \
332 const ExprT2& expr2; \
333 \
334 }; \
335 \
336 template <typename ExprT1, typename T2> \
337 class Expr< OP< ExprT1, ConstExpr<T2> >,ExprSpecMPVector > { \
338 \
339 public: \
340 \
341 typedef ConstExpr<T2> ConstT; \
342 typedef ConstExpr<T2> ExprT2; \
343 typedef typename ExprT1::value_type value_type_1; \
344 typedef typename ExprT2::value_type value_type_2; \
345 typedef typename Sacado::Promote<value_type_1, \
346 value_type_2>::type value_type; \
347 \
348 typedef typename ExprT1::scalar_type scalar_type_1; \
349 typedef typename ExprT2::scalar_type scalar_type_2; \
350 typedef typename Sacado::Promote<scalar_type_1, \
351 scalar_type_2>::type scalar_type; \
352 \
353 typedef typename ExprT1::base_expr_type base_expr_type_1; \
354 typedef typename ExprT2::base_expr_type base_expr_type_2; \
355 typedef typename Sacado::Promote<base_expr_type_1, \
356 base_expr_type_2>::type base_expr_type; \
357 \
358 typedef typename value_type::value_type val_type; \
359 \
360 KOKKOS_INLINE_FUNCTION \
361 Expr(const ExprT1& expr1_, const ConstT& c_) : \
362 expr1(expr1_), c(c_) {} \
363 \
364 KOKKOS_INLINE_FUNCTION \
365 int size() const { \
366 return expr1.size(); \
367 } \
368 \
369 KOKKOS_INLINE_FUNCTION \
370 bool hasFastAccess() const { \
371 return expr1.hasFastAccess(); \
372 } \
373 \
374 KOKKOS_INLINE_FUNCTION \
375 bool isPassive() const { \
376 return expr1.isPassive(); \
377 } \
378 \
379 KOKKOS_INLINE_FUNCTION \
380 bool updateValue() const { return expr1.updateValue(); } \
381 \
382 KOKKOS_INLINE_FUNCTION \
383 const value_type val() const { \
384 return MPVAL_CONST_DX_2; \
385 } \
386 \
387 KOKKOS_INLINE_FUNCTION \
388 const val_type val(int j) const { \
389 return VAL_CONST_DX_2; \
390 } \
391 \
392 KOKKOS_INLINE_FUNCTION \
393 const val_type dx(int i, int j) const { \
394 return CONST_DX_2; \
395 } \
396 \
397 KOKKOS_INLINE_FUNCTION \
398 const val_type fastAccessDx(int i, int j) const { \
399 return CONST_FASTACCESSDX_2; \
400 } \
401 \
402 protected: \
403 \
404 const ExprT1& expr1; \
405 ConstT c; \
406 }; \
407 \
408 template <typename T1, typename ExprT2> \
409 class Expr< OP< ConstExpr<T1>, ExprT2 >,ExprSpecMPVector > { \
410 \
411 public: \
412 \
413 typedef ConstExpr<T1> ConstT; \
414 typedef ConstExpr<T1> ExprT1; \
415 typedef typename ExprT1::value_type value_type_1; \
416 typedef typename ExprT2::value_type value_type_2; \
417 typedef typename Sacado::Promote<value_type_1, \
418 value_type_2>::type value_type; \
419 \
420 typedef typename ExprT1::scalar_type scalar_type_1; \
421 typedef typename ExprT2::scalar_type scalar_type_2; \
422 typedef typename Sacado::Promote<scalar_type_1, \
423 scalar_type_2>::type scalar_type; \
424 \
425 typedef typename ExprT1::base_expr_type base_expr_type_1; \
426 typedef typename ExprT2::base_expr_type base_expr_type_2; \
427 typedef typename Sacado::Promote<base_expr_type_1, \
428 base_expr_type_2>::type base_expr_type; \
429 \
430 typedef typename value_type::value_type val_type; \
431 \
432 KOKKOS_INLINE_FUNCTION \
433 Expr(const ConstT& c_, const ExprT2& expr2_) : \
434 c(c_), expr2(expr2_) {} \
435 \
436 KOKKOS_INLINE_FUNCTION \
437 int size() const { \
438 return expr2.size(); \
439 } \
440 \
441 KOKKOS_INLINE_FUNCTION \
442 bool hasFastAccess() const { \
443 return expr2.hasFastAccess(); \
444 } \
445 \
446 KOKKOS_INLINE_FUNCTION \
447 bool isPassive() const { \
448 return expr2.isPassive(); \
449 } \
450 \
451 KOKKOS_INLINE_FUNCTION \
452 bool updateValue() const { return expr2.updateValue(); } \
453 \
454 KOKKOS_INLINE_FUNCTION \
455 const value_type val() const { \
456 return MPVAL_CONST_DX_1; \
457 } \
458 \
459 KOKKOS_INLINE_FUNCTION \
460 const val_type val(int j) const { \
461 return VAL_CONST_DX_1; \
462 } \
463 \
464 KOKKOS_INLINE_FUNCTION \
465 const val_type dx(int i, int j) const { \
466 return CONST_DX_1; \
467 } \
468 \
469 KOKKOS_INLINE_FUNCTION \
470 const val_type fastAccessDx(int i, int j) const { \
471 return CONST_FASTACCESSDX_1; \
472 } \
473 \
474 protected: \
475 \
476 ConstT c; \
477 const ExprT2& expr2; \
478 }; \
479 \
480 } \
481}
482
483
484FAD_BINARYOP_MACRO(operator+,
485 AdditionOp,
486 expr1.val() + expr2.val(),
487 expr1.val(j) + expr2.val(j),
488 expr1.dx(i,j) + expr2.dx(i,j),
489 expr1.fastAccessDx(i,j) + expr2.fastAccessDx(i,j),
490 c.val() + expr2.val(),
491 expr1.val() + c.val(),
492 c.val(j) + expr2.val(j),
493 expr1.val(j) + c.val(j),
494 expr2.dx(i,j),
495 expr1.dx(i,j),
496 expr2.fastAccessDx(i,j),
497 expr1.fastAccessDx(i,j))
498FAD_BINARYOP_MACRO(operator-,
499 SubtractionOp,
500 expr1.val() - expr2.val(),
501 expr1.val(j) - expr2.val(j),
502 expr1.dx(i,j) - expr2.dx(i,j),
503 expr1.fastAccessDx(i,j) - expr2.fastAccessDx(i,j),
504 c.val() - expr2.val(),
505 expr1.val() - c.val(),
506 c.val(j) - expr2.val(j),
507 expr1.val(j) - c.val(j),
508 -expr2.dx(i,j),
509 expr1.dx(i,j),
510 -expr2.fastAccessDx(i,j),
511 expr1.fastAccessDx(i,j))
512// FAD_BINARYOP_MACRO(operator*,
513// MultiplicationOp,
514// expr1.val() * expr2.val(),
515// expr1.val(j) * expr2.val(j),
516// expr1.val(j)*expr2.dx(i,j) + expr1.dx(i,j)*expr2.val(j),
517// expr1.val(j)*expr2.fastAccessDx(i,j) +
518// expr1.fastAccessDx(i,j)*expr2.val(j),
519// c.val() * expr2.val(),
520// expr1.val() * c.val(),
521// c.val(j) * expr2.val(j),
522// expr1.val(j) * c.val(j),
523// c.val(j)*expr2.dx(i,j),
524// expr1.dx(i,j)*c.val(j),
525// c.val(j)*expr2.fastAccessDx(i,j),
526// expr1.fastAccessDx(i,j)*c.val(j))
527FAD_BINARYOP_MACRO(operator/,
528 DivisionOp,
529 expr1.val() / expr2.val(),
530 expr1.val(j) / expr2.val(j),
531 (expr1.dx(i,j)*expr2.val(j) - expr2.dx(i,j)*expr1.val(j)) /
532 (expr2.val(j)*expr2.val(j)),
533 (expr1.fastAccessDx(i,j)*expr2.val(j) -
534 expr2.fastAccessDx(i,j)*expr1.val(j)) /
535 (expr2.val(j)*expr2.val(j)),
536 c.val() / expr2.val(),
537 expr1.val() / c.val(),
538 c.val(j) / expr2.val(j),
539 expr1.val(j) / c.val(j),
540 -expr2.dx(i,j)*c.val(j) / (expr2.val(j)*expr2.val(j)),
541 expr1.dx(i,j)/c.val(j),
542 -expr2.fastAccessDx(i,j)*c.val(j) / (expr2.val(j)*expr2.val(j)),
543 expr1.fastAccessDx(i,j)/c.val(j))
544FAD_BINARYOP_MACRO(atan2,
545 Atan2Op,
546 std::atan2(expr1.val(), expr2.val()),
547 std::atan2(expr1.val(j), expr2.val(j)),
548 (expr2.val(j)*expr1.dx(i,j) - expr1.val(j)*expr2.dx(i,j))/
549 (expr1.val(j)*expr1.val(j) + expr2.val(j)*expr2.val(j)),
550 (expr2.val(j)*expr1.fastAccessDx(i,j) - expr1.val(j)*expr2.fastAccessDx(i,j))/
551 (expr1.val(j)*expr1.val(j) + expr2.val(j)*expr2.val(j)),
552 std::atan2(c.val(), expr2.val()),
553 std::atan2(expr1.val(), c.val()),
554 std::atan2(c.val(j), expr2.val(j)),
555 std::atan2(expr1.val(j), c.val(j)),
556 (-c.val(j)*expr2.dx(i,j)) / (c.val(j)*c.val(j) + expr2.val(j)*expr2.val(j)),
557 (c.val(j)*expr1.dx(i,j))/ (expr1.val(j)*expr1.val(j) + c.val(j)*c.val(j)),
558 (-c.val(j)*expr2.fastAccessDx(i,j))/ (c.val(j)*c.val(j) + expr2.val(j)*expr2.val(j)),
559 (c.val(j)*expr1.fastAccessDx(i,j))/ (expr1.val(j)*expr1.val(j) + c.val(j)*c.val(j)))
560FAD_BINARYOP_MACRO(pow,
561 PowerOp,
562 std::pow(expr1.val(), expr2.val()),
563 std::pow(expr1.val(j), expr2.val(j)),
564 expr1.val(j) == val_type(0) ? val_type(0) : val_type((expr2.dx(i,j)*std::log(expr1.val(j))+expr2.val(j)*expr1.dx(i,j)/expr1.val(j))*std::pow(expr1.val(j),expr2.val(j))),
565 expr1.val(j) == val_type(0) ? val_type(0.0) : val_type((expr2.fastAccessDx(i,j)*std::log(expr1.val(j))+expr2.val(j)*expr1.fastAccessDx(i,j)/expr1.val(j))*std::pow(expr1.val(j),expr2.val(j))),
566 std::pow(c.val(), expr2.val()),
567 std::pow(expr1.val(), c.val()),
568 std::pow(c.val(j), expr2.val(j)),
569 std::pow(expr1.val(j), c.val(j)),
570 c.val(j) == val_type(0) ? val_type(0) : val_type(expr2.dx(i,j)*std::log(c.val(j))*std::pow(c.val(j),expr2.val(j))),
571 expr1.val(j) == val_type(0) ? val_type(0.0) : val_type(c.val(j)*expr1.dx(i,j)/expr1.val(j)*std::pow(expr1.val(j),c.val(j))),
572 c.val(j) == val_type(0) ? val_type(0) : val_type(expr2.fastAccessDx(i,j)*std::log(c.val(j))*std::pow(c.val(j),expr2.val(j))),
573 expr1.val(j) == val_type(0) ? val_type(0.0) : val_type(c.val(j)*expr1.fastAccessDx(i,j)/expr1.val(j)*std::pow(expr1.val(j),c.val(j))))
574FAD_BINARYOP_MACRO(max,
575 MaxOp,
576 std::max(expr1.val(), expr2.val()),
577 std::max(expr1.val(j), expr2.val(j)),
578 expr1.val(j) >= expr2.val(j) ? expr1.dx(i,j) : expr2.dx(i,j),
579 expr1.val(j) >= expr2.val(j) ? expr1.fastAccessDx(i,j) :
580 expr2.fastAccessDx(i,j),
581 std::max(c.val(), expr2.val()),
582 std::max(expr1.val(), c.val()),
583 std::max(c.val(j), expr2.val(j)),
584 std::max(expr1.val(j), c.val(j)),
585 c.val(j) >= expr2.val(j) ? val_type(0) : expr2.dx(i,j),
586 expr1.val(j) >= c.val(j) ? expr1.dx(i,j) : val_type(0),
587 c.val(j) >= expr2.val(j) ? val_type(0) : expr2.fastAccessDx(i,j),
588 expr1.val(j) >= c.val(j) ? expr1.fastAccessDx(i,j) : val_type(0))
589FAD_BINARYOP_MACRO(min,
590 MinOp,
591 std::min(expr1.val(), expr2.val()),
592 std::min(expr1.val(j), expr2.val(j)),
593 expr1.val(j) <= expr2.val(j) ? expr1.dx(i,j) : expr2.dx(i,j),
594 expr1.val(j) <= expr2.val(j) ? expr1.fastAccessDx(i,j) :
595 expr2.fastAccessDx(i,j),
596 std::min(c.val(), expr2.val()),
597 std::min(expr1.val(), c.val()),
598 std::min(c.val(j), expr2.val(j)),
599 std::min(expr1.val(j), c.val(j)),
600 c.val(j) <= expr2.val(j) ? val_type(0) : expr2.dx(i,j),
601 expr1.val(j) <= c.val(j) ? expr1.dx(i,j) : val_type(0),
602 c.val(j) <= expr2.val(j) ? val_type(0) : expr2.fastAccessDx(i,j),
603 expr1.val(j) <= c.val(j) ? expr1.fastAccessDx(i,j) : val_type(0))
604
605
606#undef FAD_BINARYOP_MACRO
607
608namespace Sacado {
609 namespace Fad {
610
611 template <typename ExprT1, typename ExprT2>
612 class Expr< MultiplicationOp< ExprT1, ExprT2 >,ExprSpecMPVector > {
613
614 public:
615
616 typedef typename ExprT1::value_type value_type_1;
617 typedef typename ExprT2::value_type value_type_2;
618 typedef typename Sacado::Promote<value_type_1,
619 value_type_2>::type value_type;
620
621 typedef typename ExprT1::scalar_type scalar_type_1;
622 typedef typename ExprT2::scalar_type scalar_type_2;
623 typedef typename Sacado::Promote<scalar_type_1,
624 scalar_type_2>::type scalar_type;
625
626 typedef typename ExprT1::base_expr_type base_expr_type_1;
627 typedef typename ExprT2::base_expr_type base_expr_type_2;
628 typedef typename Sacado::Promote<base_expr_type_1,
629 base_expr_type_2>::type base_expr_type;
630
631 typedef typename value_type::value_type val_type;
632
633 KOKKOS_INLINE_FUNCTION
634 Expr(const ExprT1& expr1_, const ExprT2& expr2_) :
635 expr1(expr1_), expr2(expr2_) {}
636
637 KOKKOS_INLINE_FUNCTION
638 int size() const {
639 int sz1 = expr1.size(), sz2 = expr2.size();
640 return sz1 > sz2 ? sz1 : sz2;
641 }
642
643 KOKKOS_INLINE_FUNCTION
644 bool hasFastAccess() const {
645 return expr1.hasFastAccess() && expr2.hasFastAccess();
646 }
647
648 KOKKOS_INLINE_FUNCTION
649 bool isPassive() const {
650 return expr1.isPassive() && expr2.isPassive();
651 }
652
653 KOKKOS_INLINE_FUNCTION
654 bool updateValue() const {
655 return expr1.updateValue() && expr2.updateValue();
656 }
657
658 KOKKOS_INLINE_FUNCTION
659 const value_type val() const {
660 return expr1.val()*expr2.val();
661 }
662
663 KOKKOS_INLINE_FUNCTION
664 const val_type val(int j) const {
665 return expr1.val(j)*expr2.val(j);
666 }
667
668 KOKKOS_INLINE_FUNCTION
669 const val_type dx(int i, int j) const {
670 if (expr1.size() > 0 && expr2.size() > 0)
671 return expr1.val(j)*expr2.dx(i,j) + expr1.dx(i,j)*expr2.val(j);
672 else if (expr1.size() > 0)
673 return expr1.dx(i,j)*expr2.val(j);
674 else
675 return expr1.val(j)*expr2.dx(i,j);
676 }
677
678 KOKKOS_INLINE_FUNCTION
679 const val_type fastAccessDx(int i, int j) const {
680 return expr1.val(j)*expr2.fastAccessDx(i,j) +
681 expr1.fastAccessDx(i,j)*expr2.val(j);
682 }
683
684 protected:
685
686 const ExprT1& expr1;
687 const ExprT2& expr2;
688
689 };
690
691 template <typename ExprT1, typename T2>
692 class Expr< MultiplicationOp< ExprT1, ConstExpr<T2> >,ExprSpecMPVector > {
693
694 public:
695
696 typedef ConstExpr<T2> ConstT;
697 typedef ConstExpr<T2> ExprT2;
698 typedef typename ExprT1::value_type value_type_1;
699 typedef typename ExprT2::value_type value_type_2;
700 typedef typename Sacado::Promote<value_type_1,
701 value_type_2>::type value_type;
702
703 typedef typename ExprT1::scalar_type scalar_type_1;
704 typedef typename ExprT2::scalar_type scalar_type_2;
705 typedef typename Sacado::Promote<scalar_type_1,
706 scalar_type_2>::type scalar_type;
707
708 typedef typename ExprT1::base_expr_type base_expr_type_1;
709 typedef typename ExprT2::base_expr_type base_expr_type_2;
710 typedef typename Sacado::Promote<base_expr_type_1,
711 base_expr_type_2>::type base_expr_type;
712
713 typedef typename value_type::value_type val_type;
714
715 KOKKOS_INLINE_FUNCTION
716 Expr(const ExprT1& expr1_, const ConstT& c_) :
717 expr1(expr1_), c(c_) {}
718
719 KOKKOS_INLINE_FUNCTION
720 int size() const {
721 return expr1.size();
722 }
723
724 KOKKOS_INLINE_FUNCTION
725 bool hasFastAccess() const {
726 return expr1.hasFastAccess();
727 }
728
729 KOKKOS_INLINE_FUNCTION
730 bool isPassive() const {
731 return expr1.isPassive();
732 }
733
734 KOKKOS_INLINE_FUNCTION
735 bool updateValue() const { return expr1.updateValue(); }
736
737 KOKKOS_INLINE_FUNCTION
738 const value_type val() const {
739 return expr1.val()*c.val();
740 }
741
742 KOKKOS_INLINE_FUNCTION
743 const val_type val(int j) const {
744 return expr1.val(j)*c.val(j);
745 }
746
747 KOKKOS_INLINE_FUNCTION
748 const val_type dx(int i, int j) const {
749 return expr1.dx(i,j)*c.val(j);
750 }
751
752 KOKKOS_INLINE_FUNCTION
753 const val_type fastAccessDx(int i, int j) const {
754 return expr1.fastAccessDx(i,j)*c.val(j);
755 }
756
757 protected:
758
759 const ExprT1& expr1;
760 ConstT c;
761 };
762
763 template <typename T1, typename ExprT2>
764 class Expr< MultiplicationOp< ConstExpr<T1>, ExprT2 >,ExprSpecMPVector > {
765
766 public:
767
768 typedef ConstExpr<T1> ConstT;
769 typedef ConstExpr<T1> ExprT1;
770 typedef typename ExprT1::value_type value_type_1;
771 typedef typename ExprT2::value_type value_type_2;
772 typedef typename Sacado::Promote<value_type_1,
773 value_type_2>::type value_type;
774
775 typedef typename ExprT1::scalar_type scalar_type_1;
776 typedef typename ExprT2::scalar_type scalar_type_2;
777 typedef typename Sacado::Promote<scalar_type_1,
778 scalar_type_2>::type scalar_type;
779
780 typedef typename ExprT1::base_expr_type base_expr_type_1;
781 typedef typename ExprT2::base_expr_type base_expr_type_2;
782 typedef typename Sacado::Promote<base_expr_type_1,
783 base_expr_type_2>::type base_expr_type;
784
785 typedef typename value_type::value_type val_type;
786
787 KOKKOS_INLINE_FUNCTION
788 Expr(const ConstT& c_, const ExprT2& expr2_) :
789 c(c_), expr2(expr2_) {}
790
791 KOKKOS_INLINE_FUNCTION
792 int size() const {
793 return expr2.size();
794 }
795
796 KOKKOS_INLINE_FUNCTION
797 bool hasFastAccess() const {
798 return expr2.hasFastAccess();
799 }
800
801 KOKKOS_INLINE_FUNCTION
802 bool isPassive() const {
803 return expr2.isPassive();
804 }
805
806 KOKKOS_INLINE_FUNCTION
807 bool updateValue() const { return expr2.updateValue(); }
808
809 KOKKOS_INLINE_FUNCTION
810 const value_type val() const {
811 return c.val()*expr2.val();
812 }
813
814 KOKKOS_INLINE_FUNCTION
815 const val_type val(int j) const {
816 return c.val(j)*expr2.val(j);
817 }
818
819 KOKKOS_INLINE_FUNCTION
820 const val_type dx(int i, int j) const {
821 return c.val(j)*expr2.dx(i,j);
822 }
823
824 KOKKOS_INLINE_FUNCTION
825 const val_type fastAccessDx(int i, int j) const {
826 return c.val(j)*expr2.fastAccessDx(i,j);
827 }
828
829 protected:
830
831 ConstT c;
832 const ExprT2& expr2;
833 };
834
835 template <typename ExprT>
836 KOKKOS_INLINE_FUNCTION
837 bool toBool(const Expr<ExprT,ExprSpecMPVector>& x) {
838 bool is_zero = (x.val() == 0.0);
839 for (int i=0; i<x.size(); i++)
840 for (int j=0; j<x.val().size(); ++j)
841 is_zero = is_zero && (x.dx(i,j) == 0.0);
842 return !is_zero;
843 }
844
845 template <typename ExprT>
846 std::ostream& operator << (std::ostream& os, const Expr<ExprT,ExprSpecMPVector>& x) {
847 os << x.val() << " [";
848
849 for (int i=0; i< x.size(); i++) {
850 os << " [";
851 for (int j=0; j<x.val().size(); ++j) {
852 os << " " << x.dx(i,j);
853 }
854 os << " ]";
855 }
856
857 os << " ]";
858 return os;
859 }
860 }
861}
862
863#endif // SACADO_FAD_OPS_MP_VECTOR_HPP
fabs
fabs(expr.val())
asinh
asinh(expr.val())
tan
tan(expr.val())
abs
abs(expr.val())
SinOp
expr expr SinOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:558
SinhOp
expr expr SinhOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:604
cos
cos(expr.val())
SqrtOp
expr expr SqrtOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:544
ACosOp
expr expr ACosOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:574
ATanOp
expr expr ATanOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:590
MinOp
expr2 j expr1 expr1 expr2 expr2 j expr1 c c c c MinOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:1017
cosh
cosh(expr.val())
ACoshOp
expr expr ACoshOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:619
acos
acos(expr.val())
sin
sin(expr.val())
sinh
sinh(expr.val())
ASinOp
expr expr ASinOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:582
FAD_BINARYOP_MACRO
#define FAD_BINARYOP_MACRO(OPNAME, OP, USING, MPVALUE, VALUE, DX, CDX1, CDX2, FASTACCESSDX, MPVAL_CONST_DX_1, MPVAL_CONST_DX_2, VAL_CONST_DX_1, VAL_CONST_DX_2, CONST_DX_1, CONST_DX_2, CONST_FASTACCESSDX_1, CONST_FASTACCESSDX_2)
Definition Sacado_Fad_Exp_MP_Vector.hpp:689
cbrt
cbrt(expr.val())
log10
log10(expr.val())
TanhOp
expr expr TanhOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:611
Log10Op
j Log10Op
Definition Sacado_Fad_Exp_MP_Vector.hpp:537
TanOp
expr expr TanOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:565
CoshOp
expr expr CoshOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:597
MultiplicationOp
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 MultiplicationOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:924
ASinhOp
expr expr ASinhOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:628
Atan2Op
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 j expr1 expr1 expr1 expr1 j expr1 c *expr2 expr1 c expr1 c expr1 c expr1 expr1 expr1 expr1 j *expr1 expr2 expr1 expr1 j *expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 Atan2Op
Definition Sacado_Fad_Exp_MP_Vector.hpp:962
FAbsOp
FAbsOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:651
exp
exp(expr.val())
atan
atan(expr.val())
acosh
acosh(expr.val())
j
j
Definition Sacado_Fad_Exp_MP_Vector.hpp:527
AbsOp
expr expr AbsOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:644
DivisionOp
expr1 expr1 expr1 expr2 expr1 expr1 c expr2 expr1 c expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 j expr1 expr1 expr1 expr1 j expr1 c *expr2 expr1 c expr1 c expr1 c expr1 DivisionOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:942
atan2
atan2(expr1.val(), expr2.val())
sqrt
sqrt(expr.val())
ATanhOp
expr expr ATanhOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:636
SubtractionOp
SubtractionOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:907
CbrtOp
CbrtOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:658
ExpOp
expr expr expr expr ExpOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:523
fastAccessDx
expr expr expr expr fastAccessDx(i, j)) FAD_UNARYOP_MACRO(exp
Definition Sacado_Fad_Exp_MP_Vector.hpp:663
val
expr val()
tanh
tanh(expr.val())
atanh
atanh(expr.val())
dx
expr expr expr dx(i, j)
CosOp
expr expr CosOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:551
MaxOp
expr2 j expr1 expr1 expr2 expr2 j expr1 c c c c MaxOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:1000
FAD_UNARYOP_MACRO
#define FAD_UNARYOP_MACRO(OPNAME, OP, USING, MPVALUE, VALUE, DX, FASTACCESSDX)
Definition Sacado_Fad_Exp_MP_Vector.hpp:445
UnaryMinusOp
UnaryMinusOp
Definition Sacado_Fad_Exp_MP_Vector.hpp:516
asin
asin(expr.val())
Sacado_Fad_Expr_MP_Vector.hpp
FAD_BINARYOP_MACRO
#define FAD_BINARYOP_MACRO(OPNAME, OP, MPVALUE, VALUE, DX, FASTACCESSDX, MPVAL_CONST_DX_1, MPVAL_CONST_DX_2, VAL_CONST_DX_1, VAL_CONST_DX_2, CONST_DX_1, CONST_DX_2, CONST_FASTACCESSDX_1, CONST_FASTACCESSDX_2)
FAD_UNARYOP_MACRO
#define FAD_UNARYOP_MACRO(OPNAME, OP, MPVALUE, VALUE, DX, FASTACCESSDX)
Definition Sacado_Fad_Ops_MP_Vector.hpp:59
Generated by doxygen 1.17.0