Debian Codegraph @

packages/stokhos/src/sacado/kokkos/vector/Sacado_MP_Vector.hpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Stokhos Package
4 //
5 // Copyright 2009 NTESS and the Stokhos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 #ifndef SACADO_MP_VECTOR_HPP
11 #define SACADO_MP_VECTOR_HPP
12
13 #include "Stokhos_ConfigDefs.h"
14
15 #ifdef HAVE_STOKHOS_SACADO
16
17 #include <ostream> // for std::ostream
18 #include <initializer_list>
19
20 #include "Kokkos_Macros.hpp"
21
22 #include "Sacado_MP_ExpressionTraits.hpp"
23 #include "Sacado_MP_VectorTraits.hpp"
24 #include "Sacado_Traits.hpp"
25 #include "Sacado_mpl_apply.hpp"
26 #include "Sacado_mpl_range_c.hpp"
27 #include "Stokhos_mpl_for_each.hpp"
28 #include "Stokhos_MemoryTraits.hpp"
29 #include "Stokhos_Is_Constant.hpp"
30 #include "Stokhos_ViewStorage.hpp"
31
32 #include "Kokkos_View_Utils.hpp"
33
34 namespace Sacado {
35
36 //! Namespace for multipoint classes
37 namespace MP {
38
39 //! Wrapper for a generic expression template
40 /*!
41 * This class is used to limit the overload set for building up
42 * expressions. Each expression object should derive from this
43 * using CRTP:
44 *
45 * \code
46 * class T : public Expr<T> { ... };
47 * \endcode
48 *
49 * In this case the default implementation here should be correct for
50 * any expression class. If not, an expression class is free to change
51 * the implementation through partial specialization.
52 */
53 template <typename T>
54 class Expr {
55 public:
56
57 //! Typename of derived object, returned by derived()
58 /*!
59 * This assumes a CRTP pattern where T is infact derived from
60 * Expr<T>
61 */
62 typedef T derived_type;
63
64 //! Return derived object
65 /*!
66 * This assumes a CRTP pattern where T is infact derived from
67 * Expr<T>. This will only compile if this infact the case.
68 */
69 KOKKOS_INLINE_FUNCTION
70 const derived_type& derived() const {
71 return static_cast<const derived_type&>(*this);
72 }
73
74 //! Return derived object
75 /*!
76 * This assumes a CRTP pattern where T is infact derived from
77 * Expr<T>. This will only compile if this infact the case.
78 */
79 KOKKOS_INLINE_FUNCTION
80 const volatile derived_type& derived() const volatile {
81 return static_cast<const volatile derived_type&>(*this);
82 }
83
84 // Allow explicit casting to integral types, since we don't have an
85 // integral ensemble type.
86 template <typename U, typename Enabled = typename std::enable_if<std::is_integral<U>::value>::type>
87 KOKKOS_INLINE_FUNCTION
88 explicit operator U() const { return static_cast<U>(derived().val()); }
89
90 };
91
92 //! Vectorized evaluation class
93 template <typename Storage>
94 class Vector : public Expr< Vector<Storage> > {
95 public:
96
97 //! Typename of storage class
98 typedef Storage storage_type;
99
100 typedef typename storage_type::value_type value_type;
101 typedef typename storage_type::ordinal_type ordinal_type;
102 typedef typename storage_type::execution_space execution_space;
103 typedef typename storage_type::pointer pointer;
104 typedef typename storage_type::volatile_pointer volatile_pointer;
105 typedef typename storage_type::const_pointer const_pointer;
106 typedef typename storage_type::const_volatile_pointer const_volatile_pointer;
107 typedef typename storage_type::reference reference;
108 typedef typename storage_type::volatile_reference volatile_reference;
109 typedef typename storage_type::const_reference const_reference;
110 typedef typename storage_type::const_volatile_reference const_volatile_reference;
111
112 typedef typename execution_space::memory_space memory_space;
113 typedef typename Stokhos::MemoryTraits<memory_space> MemTraits;
114
115 //! Typename of scalar's (which may be different from value_type)
116 typedef typename ScalarType<value_type>::type scalar_type;
117
118 typedef Vector base_expr_type;
119
120 //! Turn Vector into a meta-function class usable with mpl::apply
121 template < class NewStorageType >
122 struct apply {
123 typedef Vector< NewStorageType > type;
124 };
125
126 //! Number of arguments
127 static const int num_args = 1;
128
129 #if STOKHOS_ALIGN_MEMORY
130 KOKKOS_INLINE_FUNCTION
131 static void* operator new(std::size_t sz) {
132 return MemTraits::alloc(sz);
133 }
134 KOKKOS_INLINE_FUNCTION
135 static void* operator new[](std::size_t sz) {
136 return MemTraits::alloc(sz);
137 }
138 KOKKOS_INLINE_FUNCTION
139 static void* operator new(std::size_t sz, void* ptr) {
140 return ptr;
141 }
142 KOKKOS_INLINE_FUNCTION
143 static void* operator new[](std::size_t sz, void* ptr) {
144 return ptr;
145 }
146 KOKKOS_INLINE_FUNCTION
147 static void operator delete(void* ptr) {
148 MemTraits::free(ptr);
149 }
150 KOKKOS_INLINE_FUNCTION
151 static void operator delete[](void* ptr) {
152 MemTraits::free(ptr);
153 }
154 KOKKOS_INLINE_FUNCTION
155 static void operator delete(void* ptr, void*) {
156 MemTraits::free(ptr);
157 }
158 KOKKOS_INLINE_FUNCTION
159 static void operator delete[](void* ptr, void*) {
160 MemTraits::free(ptr);
161 }
162 #endif
163
164 //! Default constructor
165 /*!
166 * May not intialize the coefficient array.
167 */
168 KOKKOS_DEFAULTED_FUNCTION
169 Vector() = default;
170
171 //! Constructor with supplied value \c x
172 /*!
173 * Sets size to 1 and first coefficient to x (represents a constant).
174 */
175 KOKKOS_INLINE_FUNCTION
176 Vector(const value_type& x) : s(1,x) {}
177
178 //! View constructor
179 /*!
180 * Creates vector with pre-allocated data. Set \c owned = true
181 * if this Vector should take over management of the data.
182 */
183 KOKKOS_INLINE_FUNCTION
184 Vector(ordinal_type sz, pointer v, bool owned) : s(sz,v,owned) {}
185
186 //! Constructor for creating a view out of pre-allocated memory
187 /*!
188 * This does not do any initialization of the coefficients.
189 */
190 KOKKOS_INLINE_FUNCTION
191 Vector(ordinal_type sz, const value_type& x) : s(sz,x) {}
192
193 //! Constructor with supplied storage
194 KOKKOS_INLINE_FUNCTION
195 Vector(const storage_type& ss) : s(ss) {}
196
197 //! Copy constructor
198 KOKKOS_DEFAULTED_FUNCTION
199 Vector(const Vector& x) = default;
200
201 //! Copy constructor
202 KOKKOS_INLINE_FUNCTION
203 Vector(const volatile Vector& x) : s(x.s) {}
204
205 //! Copy constructor from any Expression object
206 template <typename S>
207 KOKKOS_INLINE_FUNCTION
208 Vector(const Expr<S>& xx) :
209 s(xx.derived().size()) {
210 typedef typename Expr<S>::derived_type expr_type;
211 const expr_type& x = xx.derived();
212
213 #ifdef STOKHOS_DEBUG
214 if (s.size() != x.size())
215 Kokkos::Impl::raise_error("Vector(): Mismatched sizes");
216 #endif
217
218 if (x.hasFastAccess(s.size())) {
219 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
220 #pragma ivdep
221 #endif
222 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
223 #pragma vector aligned
224 #endif
225 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
226 #pragma unroll
227 #endif
228 for (ordinal_type i=0; i<s.size(); i++)
229 s[i] = x.fastAccessCoeff(i);
230 }
231 else {
232 for (ordinal_type i=0; i<s.size(); i++)
233 s[i] = x.coeff(i);
234 }
235 }
236
237 //! Intialize from initializer_list
238 /*!
239 * When static fixed storage is used:
240 * * passing an empty initializer list initializes all samples in the ensemble to zero;
241 * * passing an initializer list of length 1 initializes all samples in the ensemble to the passed value;
242 * * all other mismatches in size between the initializer list and the ensemble produce an abort.
243 */
244 KOKKOS_INLINE_FUNCTION
245 Vector(std::initializer_list<value_type> l) : s(l.size(), l.begin()) {
246 if constexpr (Storage::is_static) {
247 const auto lsz = static_cast<ordinal_type>(l.size());
248 const ordinal_type sz = this->size();
249 if (lsz < sz) {
250 if (lsz > 1) {
251 Kokkos::abort("Size mismatch in list initialization of MP Vector with static fixed storage.");
252 }
253 else {
254 const value_type v = lsz > 0 ? *l.begin() : value_type(0);
255 s.init(v);
256 }
257 }
258 }
259 }
260
261 //! Destructor
262 KOKKOS_DEFAULTED_FUNCTION
263 ~Vector() = default;
264
265 //! Initialize coefficients to value
266 KOKKOS_INLINE_FUNCTION
267 void init(const value_type& v) { s.init(v); }
268
269 //! Initialize coefficients to value
270 KOKKOS_INLINE_FUNCTION
271 void init(const value_type& v) volatile { s.init(v); }
272
273 //! Initialize coefficients to an array of values
274 KOKKOS_INLINE_FUNCTION
275 void init(const value_type* v) { s.init(v); }
276
277 //! Initialize coefficients to an array of values
278 KOKKOS_INLINE_FUNCTION
279 void init(const value_type* v) volatile { s.init(v); }
280
281 //! Initialize coefficients from an Vector with different storage
282 template <typename S>
283 KOKKOS_INLINE_FUNCTION
284 void init(const Vector<S>& v) {
285 s.init(v.s.coeff(), v.s.size());
286 }
287
288 //! Initialize coefficients from an Vector with different storage
289 template <typename S>
290 KOKKOS_INLINE_FUNCTION
291 void init(const Vector<S>& v) volatile {
292 s.init(v.s.coeff(), v.s.size());
293 }
294
295 //! Load coefficients to an array of values
296 KOKKOS_INLINE_FUNCTION
297 void load(value_type* v) { s.load(v); }
298
299 //! Load coefficients to an array of values
300 KOKKOS_INLINE_FUNCTION
301 void load(value_type* v) volatile { s.load(v); }
302
303 //! Load coefficients into an Vector with different storage
304 template <typename S>
305 KOKKOS_INLINE_FUNCTION
306 void load(Vector<S>& v) { s.load(v.s.coeff()); }
307
308 //! Load coefficients into an Vector with different storage
309 template <typename S>
310 KOKKOS_INLINE_FUNCTION
311 void load(Vector<S>& v) volatile { s.load(v.s.coeff()); }
312
313 //! Reset size
314 /*!
315 * Coefficients are preserved.
316 */
317 KOKKOS_INLINE_FUNCTION
318 void reset(ordinal_type sz_new) {
319 ordinal_type sz = this->size();
320 s.resize(sz_new);
321 if (sz == 1 && sz_new > sz)
322 for (ordinal_type i=1; i<sz_new; i++)
323 s[i] = s[0];
324 }
325
326 //! Reset size
327 /*!
328 * Coefficients are preserved.
329 */
330 KOKKOS_INLINE_FUNCTION
331 void reset(ordinal_type sz_new) volatile {
332 ordinal_type sz = this->size();
333 s.resize(sz_new);
334 if (sz == 1 && sz_new > sz)
335 for (ordinal_type i=1; i<sz_new; i++)
336 s[i] = s[0];
337 }
338
339 //! Prepare vector for writing
340 /*!
341 * This method prepares the vector for writing through coeff() and
342 * fastAccessCoeff() member functions. It ensures the handle for the
343 * coefficients is not shared among any other vector.
344 * If the handle is not shared it does nothing, so there
345 * is no cost in calling this method in this case. If the handle is
346 * shared and this method is not called, any changes to the coefficients
347 * by coeff() or fastAccessCoeff() may change other vector objects.
348 */
349 KOKKOS_INLINE_FUNCTION
350 void copyForWrite() volatile { }
351
352 //! Returns whether two MP objects have the same values
353 template <typename S>
354 KOKKOS_INLINE_FUNCTION
355 bool isEqualTo(const Expr<S>& xx) const {
356 const typename Expr<S>::derived_type& x = xx.derived();
357 typedef IsEqual<value_type> IE;
358 if (x.size() != this->size()) return false;
359 bool eq = true;
360 for (ordinal_type i=0; i<this->size(); i++)
361 eq = eq && IE::eval(x.coeff(i), this->coeff(i));
362 return eq;
363 }
364
365 //! Returns whether two MP objects have the same values
366 template <typename S>
367 KOKKOS_INLINE_FUNCTION
368 bool isEqualTo(const Expr<S>& xx) const volatile {
369 const typename Expr<S>::derived_type& x = xx.derived();
370 typedef IsEqual<value_type> IE;
371 if (x.size() != this->size()) return false;
372 bool eq = true;
373 for (ordinal_type i=0; i<this->size(); i++)
374 eq = eq && IE::eval(x.coeff(i), this->coeff(i));
375 return eq;
376 }
377
378 /*!
379 * @name Assignment operators
380 */
381 //@{
382
383 //! Assignment from initializer_list
384 /*!
385 * No KOKKOS_INLINE_FUNCTION as it is not callable from the device
386 */
387 Vector& operator=(std::initializer_list<value_type> l) {
388 const ordinal_type lsz = l.size();
389 if (lsz != s.size())
390 s.resize(lsz);
391 s.init(l.begin(), lsz);
392 return *this;
393 }
394
395 //! Assignment from initializer_list
396 /*!
397 * No KOKKOS_INLINE_FUNCTION as it is not callable from the device
398 */
399 /*volatile*/ Vector&
400 operator=(std::initializer_list<value_type> l) volatile {
401 const ordinal_type lsz = l.size();
402 if (lsz != s.size())
403 s.resize(lsz);
404 s.init(l.begin(), lsz);
405 return const_cast<Vector&>(*this);
406 }
407
408 //! Assignment operator with constant right-hand-side
409 KOKKOS_INLINE_FUNCTION
410 Vector& operator=(const value_type& x) {
411 s.init(x);
412 return *this;
413 }
414
415 //! Assignment operator with constant right-hand-side
416 KOKKOS_INLINE_FUNCTION
417 /*volatile*/ Vector& operator=(const value_type& x) volatile {
418 s.init(x);
419 return const_cast<Vector&>(*this);
420 }
421
422 //! Assignment with Vector right-hand-side
423 KOKKOS_INLINE_FUNCTION
424 Vector& operator=(const Vector& x) {
425 if (this != &x) {
426 s = x.s;
427
428 // For DyamicStorage as a view (is_owned=false), we need to set
429 // the trailing entries when assigning a constant vector (because
430 // the copy constructor in this case doesn't reset the size of this)
431 //
432 // Note: supporting this technically makes the Vector non-POD, even
433 // with a static storage type where this branch will get optimized
434 // out. We would have to remove DynamicStorage-as-a view as an option
435 // or partial specialize on StaticFixedStorage to fix this. However
436 // the volatile operator=() and copy constructor overloads make
437 // Vector non-POD anyway.
438 if (s.size() > x.s.size())
439 for (ordinal_type i=x.s.size(); i<s.size(); i++)
440 s[i] = s[0];
441 }
442
443 return *this;
444 }
445
446 //! Assignment with Vector right-hand-side
447 KOKKOS_INLINE_FUNCTION
448 Vector& operator=(const volatile Vector& x) {
449 if (this != &x) {
450 s = x.s;
451
452 // For DyamicStorage as a view (is_owned=false), we need to set
453 // the trailing entries when assigning a constant vector (because
454 // the copy constructor in this case doesn't reset the size of this)
455 //
456 // Note: supporting this technically makes the Vector non-POD, even
457 // with a static storage type where this branch will get optimized
458 // out. We would have to remove DynamicStorage-as-a view as an option
459 // or partial specialize on StaticFixedStorage to fix this. However
460 // the volatile operator=() and copy constructor overloads make
461 // Vector non-POD anyway.
462 if (s.size() > x.s.size())
463 for (ordinal_type i=x.s.size(); i<s.size(); i++)
464 s[i] = s[0];
465 }
466
467 return *this;
468 }
469
470 //! Assignment with Vector right-hand-side
471 KOKKOS_INLINE_FUNCTION
472 /*volatile*/ Vector& operator=(const Vector& x) volatile {
473 if (this != &x) {
474 s = x.s;
475
476 // For DyamicStorage as a view (is_owned=false), we need to set
477 // the trailing entries when assigning a constant vector (because
478 // the copy constructor in this case doesn't reset the size of this)
479 //
480 // Note: supporting this technically makes the Vector non-POD, even
481 // with a static storage type where this branch will get optimized
482 // out. We would have to remove DynamicStorage-as-a view as an option
483 // or partial specialize on StaticFixedStorage to fix this. However
484 // the volatile operator=() and copy constructor overloads make
485 // Vector non-POD anyway.
486 if (s.size() > x.s.size())
487 for (ordinal_type i=x.s.size(); i<s.size(); i++)
488 s[i] = s[0];
489 }
490
491 return const_cast<Vector&>(*this);
492 }
493
494 //! Assignment with Vector right-hand-side
495 KOKKOS_INLINE_FUNCTION
496 /*volatile*/ Vector& operator=(const volatile Vector& x) volatile {
497 if (this != &x) {
498 s = x.s;
499
500 // For DyamicStorage as a view (is_owned=false), we need to set
501 // the trailing entries when assigning a constant vector (because
502 // the copy constructor in this case doesn't reset the size of this)
503 //
504 // Note: supporting this technically makes the Vector non-POD, even
505 // with a static storage type where this branch will get optimized
506 // out. We would have to remove DynamicStorage-as-a view as an option
507 // or partial specialize on StaticFixedStorage to fix this. However
508 // the volatile operator=() and copy constructor overloads make
509 // Vector non-POD anyway.
510 if (s.size() > x.s.size())
511 for (ordinal_type i=x.s.size(); i<s.size(); i++)
512 s[i] = s[0];
513 }
514
515 return const_cast<Vector&>(*this);
516 }
517
518 //! Assignment with any expression right-hand-side
519 template <typename S>
520 KOKKOS_INLINE_FUNCTION
521 Vector& operator=(const Expr<S>& xx) {
522 typedef typename Expr<S>::derived_type expr_type;
523 const expr_type& x = xx.derived();
524
525 this->reset(x.size());
526
527 #ifdef STOKHOS_DEBUG
528 if (s.size() != x.size())
529 Kokkos::Impl::raise_error("Vector::operator=(): Mismatched sizes");
530 #endif
531
532 if (x.hasFastAccess(s.size())) {
533 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
534 #pragma ivdep
535 #endif
536 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
537 #pragma vector aligned
538 #endif
539 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
540 #pragma unroll
541 #endif
542 for (ordinal_type i=0; i<s.size(); i++)
543 s[i] = x.fastAccessCoeff(i);
544 }
545 else {
546 for (ordinal_type i=0; i<s.size(); i++)
547 s[i] = x.coeff(i);
548 }
549 return *this;
550 }
551
552 //! Assignment with any expression right-hand-side
553 template <typename S>
554 KOKKOS_INLINE_FUNCTION
555 /*volatile*/ Vector& operator=(const Expr<S>& xx) volatile {
556 typedef typename Expr<S>::derived_type expr_type;
557 const expr_type& x = xx.derived();
558
559 this->reset(x.size());
560
561 #ifdef STOKHOS_DEBUG
562 if (s.size() != x.size())
563 Kokkos::Impl::raise_error("Vector::operator=(): Mismatched sizes");
564 #endif
565
566 if (x.hasFastAccess(s.size())) {
567 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
568 #pragma ivdep
569 #endif
570 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
571 #pragma vector aligned
572 #endif
573 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
574 #pragma unroll
575 #endif
576 for (ordinal_type i=0; i<s.size(); i++)
577 s[i] = x.fastAccessCoeff(i);
578 }
579 else {
580 for (ordinal_type i=0; i<s.size(); i++)
581 s[i] = x.coeff(i);
582 }
583 return const_cast<Vector&>(*this);
584 }
585
586 //! Assignment operator only valid for view storage
587 template< typename S >
588 KOKKOS_INLINE_FUNCTION
589 typename std::enable_if<( ! std::is_same<S,void>::value &&
590 Stokhos::is_ViewStorage<Storage>::value
591 ), Vector >
592 ::type const & operator = ( const Expr<S> & xx ) const
593 {
594 const typename Expr<S>::derived_type & x = xx.derived();
595
596 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
597 #pragma ivdep
598 #endif
599 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
600 #pragma vector aligned
601 #endif
602 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
603 #pragma unroll
604 #endif
605 for ( ordinal_type i = 0 ; i < s.size() ; ++i ) { s[i] = x.coeff(i); }
606
607 return *this ;
608 }
609
610 //! Assignment operator only valid for view storage
611 template< typename S >
612 KOKKOS_INLINE_FUNCTION
613 volatile
614 typename std::enable_if<( ! std::is_same<S,void>::value &&
615 Stokhos::is_ViewStorage<Storage>::value
616 ), Vector >
617 ::type const & operator = ( const Expr<S> & xx ) const volatile
618 {
619 const typename Expr<S>::derived_type & x = xx.derived();
620
621 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
622 #pragma ivdep
623 #endif
624 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
625 #pragma vector aligned
626 #endif
627 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
628 #pragma unroll
629 #endif
630 for ( ordinal_type i = 0 ; i < s.size() ; ++i ) { s[i] = x.coeff(i); }
631
632 return *this ;
633 }
634
635 //@}
636
637 /*!
638 * Accessor methods
639 */
640
641 //! Returns storage object
642 KOKKOS_INLINE_FUNCTION
643 const volatile storage_type& storage() const volatile { return s; }
644
645 //! Returns storage object
646 KOKKOS_INLINE_FUNCTION
647 const storage_type& storage() const { return s; }
648
649 //! Returns storage object
650 KOKKOS_INLINE_FUNCTION
651 volatile storage_type& storage() volatile { return s; }
652
653 //! Returns storage object
654 KOKKOS_INLINE_FUNCTION
655 storage_type& storage() { return s; }
656
657 /*!
658 * @name Value accessor methods
659 */
660 //@{
661
662 //! Returns value
663 KOKKOS_INLINE_FUNCTION
664 const_volatile_reference val() const volatile { return s[0]; }
665
666 //! Returns value
667 KOKKOS_INLINE_FUNCTION
668 const_reference val() const { return s[0]; }
669
670 //! Returns value
671 KOKKOS_INLINE_FUNCTION
672 volatile_reference val() volatile { return s[0]; }
673
674 //! Returns value
675 KOKKOS_INLINE_FUNCTION
676 reference val() { return s[0]; }
677
678 //@}
679
680 /*!
681 * @name Coefficient accessor methods
682 */
683 //@{
684
685 //! Returns size of vector
686 KOKKOS_INLINE_FUNCTION
687 ordinal_type size() const { return s.size();}
688
689 //! Returns size of vector
690 KOKKOS_INLINE_FUNCTION
691 ordinal_type size() const volatile { return s.size();}
692
693 //! Returns true if vector has size >= sz
694 KOKKOS_INLINE_FUNCTION
695 bool hasFastAccess(ordinal_type sz) const { return s.size()>=sz;}
696
697 //! Returns true if vector has size >= sz
698 KOKKOS_INLINE_FUNCTION
699 bool hasFastAccess(ordinal_type sz) const volatile { return s.size()>=sz;}
700
701 //! Returns coefficient array
702 KOKKOS_INLINE_FUNCTION
703 const_pointer coeff() const { return s.coeff();}
704
705 //! Returns coefficient array
706 KOKKOS_INLINE_FUNCTION
707 const_volatile_pointer coeff() const volatile { return s.coeff();}
708
709 //! Returns coefficient array
710 KOKKOS_INLINE_FUNCTION
711 volatile_pointer coeff() volatile { return s.coeff();}
712
713 //! Returns coefficient array
714 KOKKOS_INLINE_FUNCTION
715 pointer coeff() { return s.coeff();}
716
717 //! Returns term \c i with bounds checking
718 KOKKOS_INLINE_FUNCTION
719 value_type coeff(ordinal_type i) const volatile {
720 return i<s.size() ? s[i] : s[0]; }
721
722 //! Returns term \c i with bounds checking
723 KOKKOS_INLINE_FUNCTION
724 value_type coeff(ordinal_type i) const {
725 return i<s.size() ? s[i] : s[0]; }
726
727 //! Returns term \c i with bounds checking
728 KOKKOS_INLINE_FUNCTION
729 value_type coeff(ordinal_type i) volatile {
730 return i<s.size() ? s[i] : s[0]; }
731
732 //! Returns term \c i with bounds checking
733 KOKKOS_INLINE_FUNCTION
734 value_type coeff(ordinal_type i) {
735 return i<s.size() ? s[i] : s[0]; }
736
737 //! Returns term \c i without bounds checking
738 KOKKOS_INLINE_FUNCTION
739 const_volatile_reference fastAccessCoeff(ordinal_type i) const volatile {
740 return s[i];}
741
742 //! Returns term \c i without bounds checking
743 KOKKOS_INLINE_FUNCTION
744 const_reference fastAccessCoeff(ordinal_type i) const {
745 return s[i];}
746
747 //! Returns term \c i without bounds checking
748 KOKKOS_INLINE_FUNCTION
749 volatile_reference fastAccessCoeff(ordinal_type i) volatile {
750 return s[i];}
751
752 //! Returns term \c i without bounds checking
753 KOKKOS_INLINE_FUNCTION
754 reference fastAccessCoeff(ordinal_type i) {
755 return s[i];}
756
757 //! Returns term \c i without bounds checking
758 KOKKOS_INLINE_FUNCTION
759 const_volatile_reference operator[](ordinal_type i) const volatile {
760 return s[i];}
761
762 //! Returns term \c i without bounds checking
763 KOKKOS_INLINE_FUNCTION
764 const_reference operator[](ordinal_type i) const {
765 return s[i];}
766
767 //! Returns term \c i without bounds checking
768 KOKKOS_INLINE_FUNCTION
769 volatile_reference operator[](ordinal_type i) volatile {
770 return s[i];}
771
772 //! Returns term \c i without bounds checking
773 KOKKOS_INLINE_FUNCTION
774 reference operator[](ordinal_type i) {
775 return s[i];}
776
777 template <int i>
778 KOKKOS_INLINE_FUNCTION
779 value_type getCoeff() const volatile {
780 return s.template getCoeff<i>(); }
781
782 template <int i>
783 KOKKOS_INLINE_FUNCTION
784 value_type getCoeff() const {
785 return s.template getCoeff<i>(); }
786
787 template <int i>
788 KOKKOS_INLINE_FUNCTION
789 volatile_reference getCoeff() volatile {
790 return s.template getCoeff<i>(); }
791
792 template <int i>
793 KOKKOS_INLINE_FUNCTION
794 reference getCoeff() {
795 return s.template getCoeff<i>(); }
796
797 //! Return iterator to first element of coefficient array
798 KOKKOS_INLINE_FUNCTION
799 pointer begin() { return s.coeff(); }
800
801 //! Return iterator to first element of coefficient array
802 KOKKOS_INLINE_FUNCTION
803 const_pointer begin() const { return s.coeff(); }
804
805 //! Return iterator to first element of coefficient array
806 KOKKOS_INLINE_FUNCTION
807 volatile_pointer begin() volatile { return s.coeff(); }
808
809 //! Return iterator to first element of coefficient array
810 KOKKOS_INLINE_FUNCTION
811 const_volatile_pointer begin() const volatile { return s.coeff(); }
812
813 //! Return iterator to first element of coefficient array
814 KOKKOS_INLINE_FUNCTION
815 const_pointer cbegin() const { return s.coeff(); }
816
817 //! Return iterator to first element of coefficient array
818 KOKKOS_INLINE_FUNCTION
819 const_volatile_pointer cbegin() const volatile { return s.coeff(); }
820
821 //! Return iterator following last element of coefficient array
822 KOKKOS_INLINE_FUNCTION
823 pointer end() { return s.coeff() + s.size(); }
824
825 //! Return iterator following last element of coefficient array
826 KOKKOS_INLINE_FUNCTION
827 const_pointer end() const { return s.coeff() + s.size(); }
828
829 //! Return iterator following last element of coefficient array
830 KOKKOS_INLINE_FUNCTION
831 volatile_pointer end() volatile { return s.coeff() + s.size(); }
832
833 //! Return iterator following last element of coefficient array
834 KOKKOS_INLINE_FUNCTION
835 const_volatile_pointer end() const volatile { return s.coeff() + s.size(); }
836
837 //! Return iterator following last element of coefficient array
838 KOKKOS_INLINE_FUNCTION
839 const_pointer cend() const { return s.coeff()+ s.size(); }
840
841 //! Return iterator following last element of coefficient array
842 KOKKOS_INLINE_FUNCTION
843 const_volatile_pointer cend() const volatile { return s.coeff()+ s.size(); }
844
845 //@}
846
847 /*!
848 * @name Unary operators
849 */
850 //@{
851
852 //! Addition-assignment operator with constant right-hand-side
853 KOKKOS_INLINE_FUNCTION
854 Vector& operator += (const value_type& x) {
855 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
856 #pragma ivdep
857 #endif
858 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
859 #pragma vector aligned
860 #endif
861 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
862 #pragma unroll
863 #endif
864 for (ordinal_type i=0; i<s.size(); i++)
865 s[i] += x;
866 return *this;
867 }
868
869 //! Addition-assignment operator with constant right-hand-side
870 KOKKOS_INLINE_FUNCTION
871 Vector& operator += (const volatile value_type& x) {
872 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
873 #pragma ivdep
874 #endif
875 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
876 #pragma vector aligned
877 #endif
878 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
879 #pragma unroll
880 #endif
881 for (ordinal_type i=0; i<s.size(); i++)
882 s[i] += x;
883 return *this;
884 }
885
886 //! Addition-assignment operator with constant right-hand-side
887 KOKKOS_INLINE_FUNCTION
888 /*volatile*/ Vector& operator += (const value_type& x) volatile {
889 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
890 #pragma ivdep
891 #endif
892 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
893 #pragma vector aligned
894 #endif
895 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
896 #pragma unroll
897 #endif
898 for (ordinal_type i=0; i<s.size(); i++)
899 s[i] += x;
900 return const_cast<Vector&>(*this);
901 }
902
903 //! Addition-assignment operator with constant right-hand-side
904 KOKKOS_INLINE_FUNCTION
905 /*volatile*/ Vector& operator += (const volatile value_type& x) volatile {
906 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
907 #pragma ivdep
908 #endif
909 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
910 #pragma vector aligned
911 #endif
912 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
913 #pragma unroll
914 #endif
915 for (ordinal_type i=0; i<s.size(); i++)
916 s[i] += x;
917 return const_cast<Vector&>(*this);
918 }
919
920 //! Subtraction-assignment operator with constant right-hand-side
921 KOKKOS_INLINE_FUNCTION
922 Vector& operator -= (const value_type& x) {
923 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
924 #pragma ivdep
925 #endif
926 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
927 #pragma vector aligned
928 #endif
929 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
930 #pragma unroll
931 #endif
932 for (ordinal_type i=0; i<s.size(); i++)
933 s[i] -= x;
934 return *this;
935 }
936
937 //! Subtraction-assignment operator with constant right-hand-side
938 KOKKOS_INLINE_FUNCTION
939 Vector& operator -= (const volatile value_type& x) {
940 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
941 #pragma ivdep
942 #endif
943 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
944 #pragma vector aligned
945 #endif
946 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
947 #pragma unroll
948 #endif
949 for (ordinal_type i=0; i<s.size(); i++)
950 s[i] -= x;
951 return *this;
952 }
953
954 //! Subtraction-assignment operator with constant right-hand-side
955 KOKKOS_INLINE_FUNCTION
956 /*volatile*/ Vector& operator -= (const value_type& x) volatile {
957 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
958 #pragma ivdep
959 #endif
960 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
961 #pragma vector aligned
962 #endif
963 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
964 #pragma unroll
965 #endif
966 for (ordinal_type i=0; i<s.size(); i++)
967 s[i] -= x;
968 return const_cast<Vector&>(*this);
969 }
970
971 //! Subtraction-assignment operator with constant right-hand-side
972 KOKKOS_INLINE_FUNCTION
973 /*volatile*/ Vector& operator -= (const volatile value_type& x) volatile {
974 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
975 #pragma ivdep
976 #endif
977 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
978 #pragma vector aligned
979 #endif
980 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
981 #pragma unroll
982 #endif
983 for (ordinal_type i=0; i<s.size(); i++)
984 s[i] -= x;
985 return const_cast<Vector&>(*this);
986 }
987
988 //! Multiplication-assignment operator with constant right-hand-side
989 KOKKOS_INLINE_FUNCTION
990 Vector& operator *= (const value_type& x) {
991 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
992 #pragma ivdep
993 #endif
994 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
995 #pragma vector aligned
996 #endif
997 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
998 #pragma unroll
999 #endif
1000 for (ordinal_type i=0; i<s.size(); i++)
1001 s[i] *= x;
1002 return *this;
1003 }
1004
1005 //! Multiplication-assignment operator with constant right-hand-side
1006 KOKKOS_INLINE_FUNCTION
1007 Vector& operator *= (const volatile value_type& x) {
1008 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1009 #pragma ivdep
1010 #endif
1011 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1012 #pragma vector aligned
1013 #endif
1014 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1015 #pragma unroll
1016 #endif
1017 for (ordinal_type i=0; i<s.size(); i++)
1018 s[i] *= x;
1019 return *this;
1020 }
1021
1022 //! Multiplication-assignment operator with constant right-hand-side
1023 KOKKOS_INLINE_FUNCTION
1024 /*volatile*/ Vector& operator *= (const value_type& x) volatile {
1025 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1026 #pragma ivdep
1027 #endif
1028 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1029 #pragma vector aligned
1030 #endif
1031 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1032 #pragma unroll
1033 #endif
1034 for (ordinal_type i=0; i<s.size(); i++)
1035 s[i] *= x;
1036 return const_cast<Vector&>(*this);
1037 }
1038
1039 //! Multiplication-assignment operator with constant right-hand-side
1040 KOKKOS_INLINE_FUNCTION
1041 /*volatile*/ Vector& operator *= (const volatile value_type& x) volatile {
1042 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1043 #pragma ivdep
1044 #endif
1045 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1046 #pragma vector aligned
1047 #endif
1048 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1049 #pragma unroll
1050 #endif
1051 for (ordinal_type i=0; i<s.size(); i++)
1052 s[i] *= x;
1053 return const_cast<Vector&>(*this);
1054 }
1055
1056 //! Division-assignment operator with constant right-hand-side
1057 KOKKOS_INLINE_FUNCTION
1058 Vector& operator /= (const value_type& x) {
1059 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1060 #pragma ivdep
1061 #endif
1062 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1063 #pragma vector aligned
1064 #endif
1065 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1066 #pragma unroll
1067 #endif
1068 for (ordinal_type i=0; i<s.size(); i++)
1069 s[i] /= x;
1070 return *this;
1071 }
1072
1073 //! Division-assignment operator with constant right-hand-side
1074 KOKKOS_INLINE_FUNCTION
1075 Vector& operator /= (const volatile value_type& x) {
1076 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1077 #pragma ivdep
1078 #endif
1079 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1080 #pragma vector aligned
1081 #endif
1082 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1083 #pragma unroll
1084 #endif
1085 for (ordinal_type i=0; i<s.size(); i++)
1086 s[i] /= x;
1087 return *this;
1088 }
1089
1090 //! Division-assignment operator with constant right-hand-side
1091 KOKKOS_INLINE_FUNCTION
1092 /*volatile*/ Vector& operator /= (const value_type& x) volatile {
1093 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1094 #pragma ivdep
1095 #endif
1096 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1097 #pragma vector aligned
1098 #endif
1099 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1100 #pragma unroll
1101 #endif
1102 for (ordinal_type i=0; i<s.size(); i++)
1103 s[i] /= x;
1104 return const_cast<Vector&>(*this);
1105 }
1106
1107 //! Division-assignment operator with constant right-hand-side
1108 KOKKOS_INLINE_FUNCTION
1109 /*volatile*/ Vector& operator /= (const volatile value_type& x) volatile {
1110 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1111 #pragma ivdep
1112 #endif
1113 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1114 #pragma vector aligned
1115 #endif
1116 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1117 #pragma unroll
1118 #endif
1119 for (ordinal_type i=0; i<s.size(); i++)
1120 s[i] /= x;
1121 return const_cast<Vector&>(*this);
1122 }
1123
1124 //! Addition-assignment operator with Expr right-hand-side
1125 template <typename S>
1126 KOKKOS_INLINE_FUNCTION
1127 Vector& operator += (const Expr<S>& xx) {
1128 //*this = *this + x;
1129 typedef typename Expr<S>::derived_type expr_type;
1130 const expr_type& x = xx.derived();
1131
1132 if (x.size() > s.size())
1133 this->reset(x.size());
1134
1135 #ifdef STOKHOS_DEBUG
1136 if (s.size() < x.size())
1137 Kokkos::Impl::raise_error("Vector::operator+=(): Mismatched sizes");
1138 #endif
1139
1140 if (x.hasFastAccess(s.size())) {
1141 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1142 #pragma ivdep
1143 #endif
1144 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1145 #pragma vector aligned
1146 #endif
1147 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1148 #pragma unroll
1149 #endif
1150 for (ordinal_type i=0; i<s.size(); i++)
1151 s[i] += x.fastAccessCoeff(i);
1152 }
1153 else {
1154 for (ordinal_type i=0; i<s.size(); i++)
1155 s[i] += x.coeff(i);
1156 }
1157 return *this;
1158 }
1159
1160 //! Addition-assignment operator with Expr right-hand-side
1161 template <typename S>
1162 KOKKOS_INLINE_FUNCTION
1163 Vector& operator += (const volatile Expr<S>& xx) {
1164 //*this = *this + x;
1165 typedef typename Expr<S>::derived_type expr_type;
1166 const volatile expr_type& x = xx.derived();
1167
1168 if (x.size() > s.size())
1169 this->reset(x.size());
1170
1171 #ifdef STOKHOS_DEBUG
1172 if (s.size() < x.size())
1173 Kokkos::Impl::raise_error("Vector::operator+=(): Mismatched sizes");
1174 #endif
1175
1176 if (x.hasFastAccess(s.size())) {
1177 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1178 #pragma ivdep
1179 #endif
1180 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1181 #pragma vector aligned
1182 #endif
1183 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1184 #pragma unroll
1185 #endif
1186 for (ordinal_type i=0; i<s.size(); i++)
1187 s[i] += x.fastAccessCoeff(i);
1188 }
1189 else {
1190 for (ordinal_type i=0; i<s.size(); i++)
1191 s[i] += x.coeff(i);
1192 }
1193 return *this;
1194 }
1195
1196 //! Addition-assignment operator with Expr right-hand-side
1197 template <typename S>
1198 KOKKOS_INLINE_FUNCTION
1199 /*volatile*/ Vector& operator += (const Expr<S>& xx) volatile {
1200 //*this = *this + x;
1201 typedef typename Expr<S>::derived_type expr_type;
1202 const expr_type& x = xx.derived();
1203
1204 if (x.size() > s.size())
1205 this->reset(x.size());
1206
1207 #ifdef STOKHOS_DEBUG
1208 if (s.size() < x.size())
1209 Kokkos::Impl::raise_error("Vector::operator+=(): Mismatched sizes");
1210 #endif
1211
1212 if (x.hasFastAccess(s.size())) {
1213 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1214 #pragma ivdep
1215 #endif
1216 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1217 #pragma vector aligned
1218 #endif
1219 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1220 #pragma unroll
1221 #endif
1222 for (ordinal_type i=0; i<s.size(); i++)
1223 s[i] += x.fastAccessCoeff(i);
1224 }
1225 else {
1226 for (ordinal_type i=0; i<s.size(); i++)
1227 s[i] += x.coeff(i);
1228 }
1229 return const_cast<Vector&>(*this);
1230 }
1231
1232 //! Addition-assignment operator with Expr right-hand-side
1233 template <typename S>
1234 KOKKOS_INLINE_FUNCTION
1235 /*volatile*/ Vector& operator += (const volatile Expr<S>& xx) volatile {
1236 //*this = *this + x;
1237 typedef typename Expr<S>::derived_type expr_type;
1238 const volatile expr_type& x = xx.derived();
1239
1240 if (x.size() > s.size())
1241 this->reset(x.size());
1242
1243 #ifdef STOKHOS_DEBUG
1244 if (s.size() < x.size())
1245 Kokkos::Impl::raise_error("Vector::operator+=(): Mismatched sizes");
1246 #endif
1247
1248 if (x.hasFastAccess(s.size())) {
1249 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1250 #pragma ivdep
1251 #endif
1252 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1253 #pragma vector aligned
1254 #endif
1255 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1256 #pragma unroll
1257 #endif
1258 for (ordinal_type i=0; i<s.size(); i++)
1259 s[i] += x.fastAccessCoeff(i);
1260 }
1261 else {
1262 for (ordinal_type i=0; i<s.size(); i++)
1263 s[i] += x.coeff(i);
1264 }
1265 return const_cast<Vector&>(*this);
1266 }
1267
1268 //! Subtraction-assignment operator with Expr right-hand-side
1269 template <typename S>
1270 KOKKOS_INLINE_FUNCTION
1271 Vector& operator -= (const Expr<S>& xx) {
1272 //*this = *this - x;
1273 typedef typename Expr<S>::derived_type expr_type;
1274 const expr_type& x = xx.derived();
1275
1276 if (x.size() > s.size())
1277 this->reset(x.size());
1278
1279 #ifdef STOKHOS_DEBUG
1280 if (s.size() < x.size())
1281 Kokkos::Impl::raise_error("Vector::operator-=(): Mismatched sizes");
1282 #endif
1283
1284 if (x.hasFastAccess(s.size())) {
1285 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1286 #pragma ivdep
1287 #endif
1288 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1289 #pragma vector aligned
1290 #endif
1291 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1292 #pragma unroll
1293 #endif
1294 for (ordinal_type i=0; i<s.size(); i++)
1295 s[i] -= x.fastAccessCoeff(i);
1296 }
1297 else {
1298 for (ordinal_type i=0; i<s.size(); i++)
1299 s[i] -= x.coeff(i);
1300 }
1301 return *this;
1302 }
1303
1304 //! Subtraction-assignment operator with Expr right-hand-side
1305 template <typename S>
1306 KOKKOS_INLINE_FUNCTION
1307 Vector& operator -= (const volatile Expr<S>& xx) {
1308 //*this = *this - x;
1309 typedef typename Expr<S>::derived_type expr_type;
1310 const volatile expr_type& x = xx.derived();
1311
1312 if (x.size() > s.size())
1313 this->reset(x.size());
1314
1315 #ifdef STOKHOS_DEBUG
1316 if (s.size() < x.size())
1317 Kokkos::Impl::raise_error("Vector::operator-=(): Mismatched sizes");
1318 #endif
1319
1320 if (x.hasFastAccess(s.size())) {
1321 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1322 #pragma ivdep
1323 #endif
1324 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1325 #pragma vector aligned
1326 #endif
1327 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1328 #pragma unroll
1329 #endif
1330 for (ordinal_type i=0; i<s.size(); i++)
1331 s[i] -= x.fastAccessCoeff(i);
1332 }
1333 else {
1334 for (ordinal_type i=0; i<s.size(); i++)
1335 s[i] -= x.coeff(i);
1336 }
1337 return *this;
1338 }
1339
1340 //! Subtraction-assignment operator with Expr right-hand-side
1341 template <typename S>
1342 KOKKOS_INLINE_FUNCTION
1343 /*volatile*/ Vector& operator -= (const Expr<S>& xx) volatile {
1344 //*this = *this - x;
1345 typedef typename Expr<S>::derived_type expr_type;
1346 const expr_type& x = xx.derived();
1347
1348 if (x.size() > s.size())
1349 this->reset(x.size());
1350
1351 #ifdef STOKHOS_DEBUG
1352 if (s.size() < x.size())
1353 Kokkos::Impl::raise_error("Vector::operator-=(): Mismatched sizes");
1354 #endif
1355
1356 if (x.hasFastAccess(s.size())) {
1357 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1358 #pragma ivdep
1359 #endif
1360 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1361 #pragma vector aligned
1362 #endif
1363 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1364 #pragma unroll
1365 #endif
1366 for (ordinal_type i=0; i<s.size(); i++)
1367 s[i] -= x.fastAccessCoeff(i);
1368 }
1369 else {
1370 for (ordinal_type i=0; i<s.size(); i++)
1371 s[i] -= x.coeff(i);
1372 }
1373 return const_cast<Vector&>(*this);
1374 }
1375
1376 //! Subtraction-assignment operator with Expr right-hand-side
1377 template <typename S>
1378 KOKKOS_INLINE_FUNCTION
1379 /*volatile*/ Vector& operator -= (const volatile Expr<S>& xx) volatile {
1380 //*this = *this - x;
1381 typedef typename Expr<S>::derived_type expr_type;
1382 const volatile expr_type& x = xx.derived();
1383
1384 if (x.size() > s.size())
1385 this->reset(x.size());
1386
1387 #ifdef STOKHOS_DEBUG
1388 if (s.size() < x.size())
1389 Kokkos::Impl::raise_error("Vector::operator-=(): Mismatched sizes");
1390 #endif
1391
1392 if (x.hasFastAccess(s.size())) {
1393 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1394 #pragma ivdep
1395 #endif
1396 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1397 #pragma vector aligned
1398 #endif
1399 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1400 #pragma unroll
1401 #endif
1402 for (ordinal_type i=0; i<s.size(); i++)
1403 s[i] -= x.fastAccessCoeff(i);
1404 }
1405 else {
1406 for (ordinal_type i=0; i<s.size(); i++)
1407 s[i] -= x.coeff(i);
1408 }
1409 return const_cast<Vector&>(*this);
1410 }
1411
1412 //! Multiplication-assignment operator with Expr right-hand-side
1413 template <typename S>
1414 KOKKOS_INLINE_FUNCTION
1415 Vector& operator *= (const Expr<S>& xx) {
1416 //*this = *this * x;
1417 typedef typename Expr<S>::derived_type expr_type;
1418 const expr_type& x = xx.derived();
1419
1420 if (x.size() > s.size())
1421 this->reset(x.size());
1422
1423 #ifdef STOKHOS_DEBUG
1424 if (s.size() < x.size())
1425 Kokkos::Impl::raise_error("Vector::operator*=(): Mismatched sizes");
1426 #endif
1427
1428 if (x.hasFastAccess(s.size())) {
1429 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1430 #pragma ivdep
1431 #endif
1432 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1433 #pragma vector aligned
1434 #endif
1435 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1436 #pragma unroll
1437 #endif
1438 for (ordinal_type i=0; i<s.size(); i++)
1439 s[i] *= x.fastAccessCoeff(i);
1440 }
1441 else {
1442 for (ordinal_type i=0; i<s.size(); i++)
1443 s[i] *= x.coeff(i);
1444 }
1445 return *this;
1446 }
1447
1448 //! Multiplication-assignment operator with Expr right-hand-side
1449 template <typename S>
1450 KOKKOS_INLINE_FUNCTION
1451 Vector& operator *= (const volatile Expr<S>& xx) {
1452 //*this = *this * x;
1453 typedef typename Expr<S>::derived_type expr_type;
1454 const volatile expr_type& x = xx.derived();
1455
1456 if (x.size() > s.size())
1457 this->reset(x.size());
1458
1459 #ifdef STOKHOS_DEBUG
1460 if (s.size() < x.size())
1461 Kokkos::Impl::raise_error("Vector::operator*=(): Mismatched sizes");
1462 #endif
1463
1464 if (x.hasFastAccess(s.size())) {
1465 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1466 #pragma ivdep
1467 #endif
1468 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1469 #pragma vector aligned
1470 #endif
1471 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1472 #pragma unroll
1473 #endif
1474 for (ordinal_type i=0; i<s.size(); i++)
1475 s[i] *= x.fastAccessCoeff(i);
1476 }
1477 else {
1478 for (ordinal_type i=0; i<s.size(); i++)
1479 s[i] *= x.coeff(i);
1480 }
1481 return *this;
1482 }
1483
1484 //! Multiplication-assignment operator with Expr right-hand-side
1485 template <typename S>
1486 KOKKOS_INLINE_FUNCTION
1487 /*volatile*/ Vector& operator *= (const Expr<S>& xx) volatile {
1488 //*this = *this * x;
1489 typedef typename Expr<S>::derived_type expr_type;
1490 const expr_type& x = xx.derived();
1491
1492 if (x.size() > s.size())
1493 this->reset(x.size());
1494
1495 #ifdef STOKHOS_DEBUG
1496 if (s.size() < x.size())
1497 Kokkos::Impl::raise_error("Vector::operator*=(): Mismatched sizes");
1498 #endif
1499
1500 if (x.hasFastAccess(s.size())) {
1501 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1502 #pragma ivdep
1503 #endif
1504 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1505 #pragma vector aligned
1506 #endif
1507 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1508 #pragma unroll
1509 #endif
1510 for (ordinal_type i=0; i<s.size(); i++)
1511 s[i] *= x.fastAccessCoeff(i);
1512 }
1513 else {
1514 for (ordinal_type i=0; i<s.size(); i++)
1515 s[i] *= x.coeff(i);
1516 }
1517 return const_cast<Vector&>(*this);
1518 }
1519
1520 //! Multiplication-assignment operator with Expr right-hand-side
1521 template <typename S>
1522 KOKKOS_INLINE_FUNCTION
1523 /*volatile*/ Vector& operator *= (const volatile Expr<S>& xx) volatile {
1524 //*this = *this * x;
1525 typedef typename Expr<S>::derived_type expr_type;
1526 const volatile expr_type& x = xx.derived();
1527
1528 if (x.size() > s.size())
1529 this->reset(x.size());
1530
1531 #ifdef STOKHOS_DEBUG
1532 if (s.size() < x.size())
1533 Kokkos::Impl::raise_error("Vector::operator*=(): Mismatched sizes");
1534 #endif
1535
1536 if (x.hasFastAccess(s.size())) {
1537 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1538 #pragma ivdep
1539 #endif
1540 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1541 #pragma vector aligned
1542 #endif
1543 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1544 #pragma unroll
1545 #endif
1546 for (ordinal_type i=0; i<s.size(); i++)
1547 s[i] *= x.fastAccessCoeff(i);
1548 }
1549 else {
1550 for (ordinal_type i=0; i<s.size(); i++)
1551 s[i] *= x.coeff(i);
1552 }
1553 return const_cast<Vector&>(*this);
1554 }
1555
1556 //! Division-assignment operator with Expr right-hand-side
1557 template <typename S>
1558 KOKKOS_INLINE_FUNCTION
1559 Vector& operator /= (const Expr<S>& xx) {
1560 //*this = *this / x;
1561 typedef typename Expr<S>::derived_type expr_type;
1562 const expr_type& x = xx.derived();
1563
1564 if (x.size() > s.size())
1565 this->reset(x.size());
1566
1567 #ifdef STOKHOS_DEBUG
1568 if (s.size() < x.size())
1569 Kokkos::Impl::raise_error("Vector::operator/=(): Mismatched sizes");
1570 #endif
1571
1572 if (x.hasFastAccess(s.size())) {
1573 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1574 #pragma ivdep
1575 #endif
1576 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1577 #pragma vector aligned
1578 #endif
1579 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1580 #pragma unroll
1581 #endif
1582 for (ordinal_type i=0; i<s.size(); i++)
1583 s[i] /= x.fastAccessCoeff(i);
1584 }
1585 else {
1586 for (ordinal_type i=0; i<s.size(); i++)
1587 s[i] /= x.coeff(i);
1588 }
1589 return *this;
1590 }
1591
1592 //! Division-assignment operator with Expr right-hand-side
1593 template <typename S>
1594 KOKKOS_INLINE_FUNCTION
1595 Vector& operator /= (const volatile Expr<S>& xx) {
1596 //*this = *this / x;
1597 typedef typename Expr<S>::derived_type expr_type;
1598 const volatile expr_type& x = xx.derived();
1599
1600 if (x.size() > s.size())
1601 this->reset(x.size());
1602
1603 #ifdef STOKHOS_DEBUG
1604 if (s.size() < x.size())
1605 Kokkos::Impl::raise_error("Vector::operator/=(): Mismatched sizes");
1606 #endif
1607
1608 if (x.hasFastAccess(s.size())) {
1609 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1610 #pragma ivdep
1611 #endif
1612 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1613 #pragma vector aligned
1614 #endif
1615 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1616 #pragma unroll
1617 #endif
1618 for (ordinal_type i=0; i<s.size(); i++)
1619 s[i] /= x.fastAccessCoeff(i);
1620 }
1621 else {
1622 for (ordinal_type i=0; i<s.size(); i++)
1623 s[i] /= x.coeff(i);
1624 }
1625 return *this;
1626 }
1627
1628 //! Division-assignment operator with Expr right-hand-side
1629 template <typename S>
1630 KOKKOS_INLINE_FUNCTION
1631 /*volatile*/ Vector& operator /= (const Expr<S>& xx) volatile {
1632 //*this = *this / x;
1633 typedef typename Expr<S>::derived_type expr_type;
1634 const expr_type& x = xx.derived();
1635
1636 if (x.size() > s.size())
1637 this->reset(x.size());
1638
1639 #ifdef STOKHOS_DEBUG
1640 if (s.size() < x.size())
1641 Kokkos::Impl::raise_error("Vector::operator/=(): Mismatched sizes");
1642 #endif
1643
1644 if (x.hasFastAccess(s.size())) {
1645 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1646 #pragma ivdep
1647 #endif
1648 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1649 #pragma vector aligned
1650 #endif
1651 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1652 #pragma unroll
1653 #endif
1654 for (ordinal_type i=0; i<s.size(); i++)
1655 s[i] /= x.fastAccessCoeff(i);
1656 }
1657 else {
1658 for (ordinal_type i=0; i<s.size(); i++)
1659 s[i] /= x.coeff(i);
1660 }
1661 return const_cast<Vector&>(*this);
1662 }
1663
1664 //! Division-assignment operator with Expr right-hand-side
1665 template <typename S>
1666 KOKKOS_INLINE_FUNCTION
1667 /*volatile*/ Vector& operator /= (const volatile Expr<S>& xx) volatile {
1668 //*this = *this / x;
1669 typedef typename Expr<S>::derived_type expr_type;
1670 const volatile expr_type& x = xx.derived();
1671
1672 if (x.size() > s.size())
1673 this->reset(x.size());
1674
1675 #ifdef STOKHOS_DEBUG
1676 if (s.size() < x.size())
1677 Kokkos::Impl::raise_error("Vector::operator/=(): Mismatched sizes");
1678 #endif
1679
1680 if (x.hasFastAccess(s.size())) {
1681 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
1682 #pragma ivdep
1683 #endif
1684 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
1685 #pragma vector aligned
1686 #endif
1687 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
1688 #pragma unroll
1689 #endif
1690 for (ordinal_type i=0; i<s.size(); i++)
1691 s[i] /= x.fastAccessCoeff(i);
1692 }
1693 else {
1694 for (ordinal_type i=0; i<s.size(); i++)
1695 s[i] /= x.coeff(i);
1696 }
1697 return const_cast<Vector&>(*this);
1698 }
1699
1700 //! Prefix ++
1701 KOKKOS_INLINE_FUNCTION
1702 Vector& operator++() {
1703 for (ordinal_type i=0; i<s.size(); i++)
1704 ++(s[i]);
1705 return *this;
1706 }
1707
1708 //! Prefix ++
1709 KOKKOS_INLINE_FUNCTION
1710 volatile Vector& operator++() volatile {
1711 for (ordinal_type i=0; i<s.size(); i++)
1712 ++(s[i]);
1713 return *this;
1714 }
1715
1716 //! Postfix ++
1717 KOKKOS_INLINE_FUNCTION
1718 Vector operator++(int) {
1719 Vector tmp(*this);
1720 ++(*this);
1721 return tmp;
1722 }
1723
1724 //! Postfix ++
1725 KOKKOS_INLINE_FUNCTION
1726 Vector operator++(int) volatile {
1727 Vector tmp(*this);
1728 ++(*this);
1729 return tmp;
1730 }
1731
1732 //! Prefix --
1733 KOKKOS_INLINE_FUNCTION
1734 Vector& operator--() {
1735 for (ordinal_type i=0; i<s.size(); i++)
1736 --(s[i]);
1737 return *this;
1738 }
1739
1740 //! Prefix --
1741 KOKKOS_INLINE_FUNCTION
1742 volatile Vector& operator--() volatile {
1743 for (ordinal_type i=0; i<s.size(); i++)
1744 --(s[i]);
1745 return *this;
1746 }
1747
1748 //! Postfix --
1749 KOKKOS_INLINE_FUNCTION
1750 Vector operator--(int) {
1751 Vector tmp(*this);
1752 --(*this);
1753 return tmp;
1754 }
1755
1756 //! Postfix --
1757 KOKKOS_INLINE_FUNCTION
1758 Vector operator--(int) volatile {
1759 Vector tmp(*this);
1760 --(*this);
1761 return tmp;
1762 }
1763
1764 //@}
1765
1766 KOKKOS_INLINE_FUNCTION
1767 std::string name() const volatile { return "x"; }
1768
1769 protected:
1770
1771 Storage s;
1772
1773 template <typename expr_type>
1774 struct StaticOp {
1775 storage_type& s;
1776 const expr_type& x;
1777
1778 KOKKOS_INLINE_FUNCTION
1779 StaticOp(storage_type& s_, const expr_type& x_) : s(s_), x(x_) {}
1780
1781 template <typename ArgT>
1782 KOKKOS_INLINE_FUNCTION
1783 void operator() (ArgT arg) const {
1784 const int Arg = ArgT::value;
1785 s.template getCoeff<Arg>() = x.template getCoeff<Arg>();
1786 }
1787
1788 };
1789
1790 }; // class Vector
1791 }
1792 }
1793
1794 #if STOKHOS_USE_MP_VECTOR_SFS_SPEC
1795 #include "Sacado_MP_Vector_SFS.hpp"
1796 #endif
1797
1798 namespace Sacado{
1799 namespace MP {
1800
1801 //! Type for storing nodes in expression graph
1802 /*!
1803 * Since expression nodes are returned by value in the overloaded
1804 * operators, we can't store them by reference in general.
1805 */
1806 template <typename T> struct const_expr_ref {
1807 typedef const T type;
1808 };
1809
1810 //! Type for storing nodes in expression graph
1811 /*!
1812 * Specialization for leaf-nodes, which can be stored by reference
1813 * since they are an argument to the expression.
1814 */
1815 template <typename S> struct const_expr_ref< Vector<S> > {
1816 typedef const Vector<S>& type;
1817 };
1818
1819 //! Type for storing nodes in expression graph
1820 /*!
1821 * Specialization for leaf-nodes, which can be stored by reference
1822 * since they are an argument to the expression.
1823 */
1824 template <typename S> struct const_expr_ref< volatile Vector<S> > {
1825 typedef const volatile Vector<S>& type;
1826 };
1827
1828 //! Traits class for removing volatile from type
1829 template <typename T> struct remove_volatile {
1830 typedef T type;
1831 };
1832 template <typename T> struct remove_volatile<volatile T> {
1833 typedef T type;
1834 };
1835
1836 //! Traits class for adding volatile to type
1837 template <typename T> struct add_volatile {
1838 typedef volatile T type;
1839 };
1840 template <typename T> struct add_volatile<volatile T> {
1841 typedef volatile T type;
1842 };
1843
1844 template <typename Storage>
1845 std::ostream&
1846 operator << (std::ostream& os, const Vector<Storage>& a)
1847 {
1848 typedef typename Vector<Storage>::ordinal_type ordinal_type;
1849
1850 os << "[ ";
1851
1852 for (ordinal_type i=0; i<a.size(); i++) {
1853 os << a.coeff(i) << " ";
1854 }
1855
1856 os << "]";
1857 return os;
1858 }
1859
1860 template <typename Storage>
1861 std::ostream&
1862 operator << (std::ostream& os, const volatile Vector<Storage>& a)
1863 {
1864 typedef typename Vector<Storage>::ordinal_type ordinal_type;
1865
1866 os << "[ ";
1867
1868 for (ordinal_type i=0; i<a.size(); i++) {
1869 os << a.coeff(i) << " ";
1870 }
1871
1872 os << "]";
1873 return os;
1874 }
1875
1876 template <typename Storage>
1877 std::istream&
1878 operator >> (std::istream& is, Vector<Storage>& a)
1879 {
1880 typedef typename Vector<Storage>::ordinal_type ordinal_type;
1881 typedef typename Vector<Storage>::value_type value_type;
1882
1883 //
1884 // Need to check all of this for errors, end-of-line, etc...
1885 //
1886
1887 char b = 0;
1888 if (Storage::is_static) {
1889 is >> b; // "["
1890 for (ordinal_type i=0; i<a.size(); i++) {
1891 is >> a.fastAccessCoeff(i);
1892 }
1893 is >> b; // "]";
1894 }
1895 else {
1896 std::vector<value_type> c;
1897 value_type v;
1898 is >> b; // "["
1899 while (is >> b && b != ']') {
1900 is.putback(b);
1901 is >> v;
1902 c.push_back(v);
1903 }
1904 ordinal_type n = c.size();
1905 a.reset(n);
1906 for (ordinal_type i=0; i<n; ++i)
1907 a.fastAccessCoeff(i) = c[i];
1908 }
1909
1910 return is;
1911 }
1912
1913 //------------------------------------------------------------------------
1914 //------------------------------------------------------------------------
1915
1916 /**\brief Define a partition of a View of Sacado::MP::Vector type */
1917 template <unsigned Size = 0>
1918 struct VectorPartition {
1919 static const unsigned PartitionSize = Size;
1920 unsigned begin ;
1921 unsigned end ;
1922
1923 template< typename iType0 , typename iType1 >
1924 KOKKOS_INLINE_FUNCTION
1925 VectorPartition( const iType0 & i0 , const iType1 & i1 ) :
1926 begin(i0), end(i1) {
1927 }
1928 };
1929
1930 template <typename T>
1931 struct is_vector_partition {
1932 static const bool value = false;
1933 };
1934
1935 template <unsigned Size>
1936 struct is_vector_partition< VectorPartition<Size> > {
1937 static const bool value = true;
1938 };
1939
1940 } // namespace MP
1941
1942 template <typename T>
1943 struct IsExpr< MP::Expr<T> > {
1944 static const bool value = true;
1945 };
1946
1947 template <typename T>
1948 struct BaseExprType< MP::Expr<T> > {
1949 typedef typename MP::Expr<T>::derived_type derived_type;
1950 typedef typename derived_type::base_expr_type type;
1951 };
1952
1953 template <typename S>
1954 struct IsExpr< MP::Vector<S> > {
1955 static const bool value = true;
1956 };
1957
1958 template <typename S>
1959 struct BaseExprType< MP::Vector<S> > {
1960 typedef MP::Vector<S> type;
1961 };
1962
1963 //! Trait class to determine if a scalar type is a Vector
1964 template <typename T> struct is_mp_vector {
1965 static const bool value = false;
1966 };
1967 template <typename S> struct is_mp_vector< MP::Vector<S> > {
1968 static const bool value = true;
1969 };
1970 template <typename T> struct is_mp_vector< const T > {
1971 static const bool value = is_mp_vector<T>::value;
1972 };
1973 template <typename T> struct is_mp_vector< T* > {
1974 static const bool value = is_mp_vector<T>::value;
1975 };
1976 template <typename T> struct is_mp_vector< T[] > {
1977 static const bool value = is_mp_vector<T>::value;
1978 };
1979 template <typename T, unsigned N> struct is_mp_vector< T[N] > {
1980 static const bool value = is_mp_vector<T>::value;
1981 };
1982
1983 // Utility function to see if a MP::Vector is really a constant
1984 template <typename Storage>
1985 bool is_constant(const Sacado::MP::Vector<Storage>& x)
1986 {
1987 typedef typename Storage::ordinal_type ordinal_type;
1988 typedef typename Storage::value_type value_type;
1989
1990 // All size-1 vectors are constants
1991 const ordinal_type sz = x.size();
1992 if (sz == 1) return true;
1993
1994 // Maybe use a tolerance????
1995 const value_type val = x.fastAccessCoeff(0);
1996 for (ordinal_type i=1; i<sz; ++i)
1997 if (x.fastAccessCoeff(i) != val) return false;
1998
1999 return true;
2000 }
2001
2002 } // namespace Sacado
2003
2004 #include "Sacado_MP_Vector_ops.hpp"
2005 #include "Stokhos_MP_Vector_MaskTraits.hpp"
2006
2007 #if STOKHOS_ALIGN_MEMORY
2008
2009 #include <memory>
2010
2011 namespace std {
2012
2013 template <typename Storage>
2014 class allocator< Sacado::MP::Vector< Storage > >
2015 : public Stokhos::aligned_allocator< Sacado::MP::Vector< Storage > > {
2016 public:
2017 typedef Sacado::MP::Vector<Storage> T;
2018 typedef Stokhos::aligned_allocator<T> Base;
2019 typedef typename Base::value_type value_type;
2020 typedef typename Base::pointer pointer;
2021 typedef typename Base::const_pointer const_pointer;
2022 typedef typename Base::reference reference;
2023 typedef typename Base::const_reference const_reference;
2024 typedef typename Base::size_type size_type;
2025 typedef typename Base::difference_type difference_type;
2026
2027 template <class U> struct rebind { typedef allocator<U> other; };
2028 allocator() {}
2029 template <class U> allocator(const allocator<U>&) {}
2030 };
2031
2032 template <typename Storage>
2033 class allocator< const Sacado::MP::Vector< Storage > >
2034 : public Stokhos::aligned_allocator< const Sacado::MP::Vector< Storage > > {
2035 public:
2036 typedef Sacado::MP::Vector<Storage> T;
2037 typedef Stokhos::aligned_allocator<const T> Base;
2038 typedef typename Base::value_type value_type;
2039 typedef typename Base::pointer pointer;
2040 typedef typename Base::const_pointer const_pointer;
2041 typedef typename Base::reference reference;
2042 typedef typename Base::const_reference const_reference;
2043 typedef typename Base::size_type size_type;
2044 typedef typename Base::difference_type difference_type;
2045
2046 template <class U> struct rebind { typedef allocator<U> other; };
2047 allocator() {}
2048 template <class U> allocator(const allocator<U>&) {}
2049 };
2050
2051 }
2052
2053 #endif
2054
2055 #include "Kokkos_NumericTraits.hpp"
2056
2057 namespace Kokkos {
2058
2059 template <typename Storage>
2060 struct reduction_identity< Sacado::MP::Vector<Storage> > {
2061 typedef Sacado::MP::Vector<Storage> Vector;
2062 typedef typename Storage::value_type scalar;
2063 typedef reduction_identity<scalar> RIS;
2064 KOKKOS_FORCEINLINE_FUNCTION constexpr static Vector sum() {
2065 return Vector(RIS::sum());
2066 }
2067 KOKKOS_FORCEINLINE_FUNCTION constexpr static Vector prod() {
2068 return Vector(RIS::prod());
2069 }
2070 KOKKOS_FORCEINLINE_FUNCTION constexpr static Vector max() {
2071 return Vector(RIS::max());
2072 }
2073 KOKKOS_FORCEINLINE_FUNCTION constexpr static Vector min() {
2074 return Vector(RIS::min());
2075 }
2076 };
2077
2078 namespace Impl {
2079 template <typename Storage>
2080 struct promote<Sacado::MP::Vector<Storage>,false> {
2081 using type = typename Sacado::MP::Vector<Storage>;
2082 };
2083 }
2084
2085 }
2086
2087 #endif // HAVE_STOKHOS_SACADO
2088
2089 #endif // SACADO_MP_VECTOR_HPP