Sacado Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Sacado_Fad_SLFad_tmpl.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// @HEADER
29
30#if defined(HAVE_SACADO_KOKKOSCORE)
31#include "Kokkos_Atomic.hpp"
32#include "impl/Kokkos_Error.hpp"
33#endif
34
35namespace Sacado {
36
37 namespace FAD_NS {
38
39 // Forward declaration
40 template <typename T, int Num>
42
56 template <typename ValueT, int Num>
57 class SLFad :
58 public Expr< GeneralFad<ValueT,Fad::StaticStorage<ValueT,Num> > > {
59
60 public:
61
64 typedef GeneralFad<ValueT,StorageType> GeneralFadType;
65 typedef Expr<GeneralFadType> ExprType;
66
68 typedef typename ExprType::value_type value_type;
69
71 typedef typename ExprType::scalar_type scalar_type;
72
75
77 template <typename T>
78 struct apply {
80 };
81
83
86 template <int N>
87 struct apply_N {
89 };
90
95
97
102 ExprType() {}
103
105
108 template <typename S>
112
114
118 SLFad(const int sz, const ValueT & x, const DerivInit zero_out = InitDerivArray) :
119 ExprType(sz,x,zero_out) {}
120
122
128 SLFad(const int sz, const int i, const ValueT & x) :
129 ExprType(sz,i,x) {}
130
133 SLFad(const SLFad& x) :
134 ExprType(x) {}
135
137 template <typename S>
140 ExprType(x) {}
141
143
147
149 template <typename S>
151 SACADO_ENABLE_VALUE_FUNC(SLFad&) operator=(const S& v) {
152 GeneralFadType::operator=(v);
153 return *this;
154 }
155
158 SLFad& operator=(const SLFad& x) {
159 GeneralFadType::operator=(static_cast<const GeneralFadType&>(x));
160 return *this;
161 }
162
164 template <typename S>
166 SACADO_ENABLE_EXPR_FUNC(SLFad&) operator=(const Expr<S>& x)
167 {
168 GeneralFadType::operator=(x);
169 return *this;
170 }
171
173 template <typename S>
175 SACADO_ENABLE_VALUE_FUNC(SLFad&) operator += (const S& x) {
176 GeneralFadType::operator+=(x);
177 return *this;
178 }
179
181 template <typename S>
183 SACADO_ENABLE_VALUE_FUNC(SLFad&) operator -= (const S& x) {
184 GeneralFadType::operator-=(x);
185 return *this;
186 }
187
189 template <typename S>
191 SACADO_ENABLE_VALUE_FUNC(SLFad&) operator *= (const S& x) {
192 GeneralFadType::operator*=(x);
193 return *this;
194 }
195
197 template <typename S>
199 SACADO_ENABLE_VALUE_FUNC(SLFad&) operator /= (const S& x) {
200 GeneralFadType::operator/=(x);
201 return *this;
202 }
203
206 SLFad& operator += (const SLFad& x) {
207 GeneralFadType::operator+=(static_cast<const GeneralFadType&>(x));
208 return *this;
209 }
210
213 SLFad& operator -= (const SLFad& x) {
214 GeneralFadType::operator-=(static_cast<const GeneralFadType&>(x));
215 return *this;
216 }
217
220 SLFad& operator *= (const SLFad& x) {
221 GeneralFadType::operator*=(static_cast<const GeneralFadType&>(x));
222 return *this;
223 }
224
227 SLFad& operator /= (const SLFad& x) {
228 GeneralFadType::operator/=(static_cast<const GeneralFadType&>(x));
229 return *this;
230 }
231
233 template <typename S>
235 SACADO_ENABLE_EXPR_FUNC(SLFad&) operator += (const Expr<S>& x) {
236 GeneralFadType::operator+=(x);
237 //*this = *this + x;
238 return *this;
239 }
240
242 template <typename S>
244 SACADO_ENABLE_EXPR_FUNC(SLFad&) operator -= (const Expr<S>& x) {
245 GeneralFadType::operator-=(x);
246 return *this;
247 }
248
250 template <typename S>
252 SACADO_ENABLE_EXPR_FUNC(SLFad&) operator *= (const Expr<S>& x) {
253 GeneralFadType::operator*=(x);
254 return *this;
255 }
256
258 template <typename S>
260 SACADO_ENABLE_EXPR_FUNC(SLFad&) operator /= (const Expr<S>& x) {
261 GeneralFadType::operator/=(x);
262 return *this;
263 }
264
265 }; // class SLFad<ValueT,Num>
266
267 template <typename T, int N>
268 struct BaseExpr< GeneralFad<T,Fad::StaticStorage<T,N> > > {
270 };
271
272 template <typename T, int N>
273 struct ExprLevel< SLFad<T,N> > {
274 static const unsigned value =
275 ExprLevel< typename SLFad<T,N>::value_type >::value + 1;
276 };
277
278 template <typename T, int N>
279 struct IsFadExpr< SLFad<T,N> > {
280 static const bool value = true;
281 };
282
283 } // namespace Fad
284
285 template <typename T, int N>
286 struct IsFad< FAD_NS::SLFad<T,N> > {
287 static const bool value = true;
288 };
289
290 template <typename T, int N>
291 struct IsExpr< FAD_NS::SLFad<T,N> > {
292 static const bool value = true;
293 };
294
295 template <typename T, int N>
296 struct BaseExprType< FAD_NS::SLFad<T,N> > {
298 };
299
300 template <typename T,unsigned,unsigned> struct ViewFadType;
301 namespace FAD_NS {
302 template <typename,unsigned,unsigned,typename> class ViewFad;
303 }
304
306 template< class ValueType, int N, unsigned length, unsigned stride >
310
312
315 template< class ValueType, int N, unsigned length, unsigned stride >
319
320} // namespace Sacado
321
322#if defined(HAVE_SACADO_KOKKOSCORE)
323
324//-------------------------- Atomic Operators -----------------------
325
326namespace Sacado {
327
328 namespace FAD_NS {
329
330 // Overload of Kokkos::atomic_add for Fad types.
331 template <typename T, int N>
333 void atomic_add(SLFad<T,N>* dst, const SLFad<T,N>& x) {
334 using Kokkos::atomic_add;
335
336 const int xsz = x.size();
337 const int sz = dst->size();
338
339 // We currently cannot handle resizing since that would need to be
340 // done atomically.
341 if (xsz > sz)
342 Kokkos::abort(
343 "Sacado error: Fad resize within atomic_add() not supported!");
344
345 if (xsz != sz && sz > 0 && xsz > 0)
346 Kokkos::abort(
347 "Sacado error: Fad assignment of incompatiable sizes!");
348
349
350 if (sz > 0 && xsz > 0) {
352 atomic_add(&(dst->fastAccessDx(i)), x.fastAccessDx(i));
353 }
355 atomic_add(&(dst->val()), x.val());
356 }
357
358 } // namespace Fad
359
360} // namespace Sacado
361
362#endif // HAVE_SACADO_KOKKOSCORE
#define FAD_NS
#define SACADO_INLINE_FUNCTION
#define SACADO_FAD_THREAD_SINGLE
#define SACADO_FAD_DERIV_LOOP(I, SZ)
#define SACADO_ENABLE_VALUE_FUNC(RETURN_TYPE)
#define SACADO_ENABLE_VALUE_CTOR_DECL
#define SACADO_ENABLE_EXPR_FUNC(RETURN_TYPE)
#define SACADO_ENABLE_EXPR_CTOR_DECL
const int N
Forward-mode AD class using static memory allocation with long arrays and expression templates.
SACADO_INLINE_FUNCTION SLFad(const int sz, const ValueT &x, const DerivInit zero_out=InitDerivArray)
Constructor with size sz and value x.
SACADO_INLINE_FUNCTION SLFad(const S &x, SACADO_ENABLE_VALUE_CTOR_DECL)
Constructor with supplied value x convertible to ValueT.
SACADO_INLINE_FUNCTION SLFad(const SLFad &x)
Copy constructor.
Fad::StaticStorage< ValueT, Num > StorageType
Base classes.
SACADO_INLINE_FUNCTION ~SLFad()
Destructor.
SACADO_INLINE_FUNCTION SLFad(const Expr< S > &x, SACADO_ENABLE_EXPR_CTOR_DECL)
Copy constructor from any Expression object.
GeneralFad< ValueT, StorageType > GeneralFadType
ExprType::value_type value_type
Typename of values.
Expr< GeneralFadType > ExprType
SACADO_INLINE_FUNCTION SLFad(const int sz, const int i, const ValueT &x)
Constructor with size sz, index i, and value x.
ScalarType< ValueT >::type ScalarT
Typename of scalar's (which may be different from ValueT)
ExprType::scalar_type scalar_type
Typename of scalar's (which may be different from value_type)
SACADO_INLINE_FUNCTION SLFad()
Default constructor.
Forward-mode AD class using dynamic memory allocation and expression templates.
Fad specializations for Teuchos::BLAS wrappers.
DerivInit
Enum use to signal whether the derivative array should be initialized in AD object constructors.
@ InitDerivArray
Initialize the derivative array.
Get the base Fad type from a view/expression.
SLFad< typename GeneralFad< T, Fad::StaticStorage< T, N > >::value_type, N > type
Replace static derivative length.
Turn SLFad into a meta-function class usable with mpl::apply.
Is a type an expression.
static const bool value
Base template specification for whether a type is a Fad type.
static const bool value
Sacado::FAD_NS::ViewFad< ValueType, length, stride, Sacado::FAD_NS::SLFad< ValueType, N > > type
Sacado::FAD_NS::ViewFad< const ValueType, length, stride, Sacado::FAD_NS::SLFad< ValueType, N > > type
Get view type for any Fad type.