EmulateArray.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_EMULATE_ARRAY_H
11 #define EIGEN_EMULATE_ARRAY_H
12 
13 
14 
15 // The array class is only available starting with cxx11. Emulate our own here
16 // if needed. Beware, msvc still doesn't advertise itself as a c++11 compiler!
17 // Moreover, CUDA doesn't support the STL containers, so we use our own instead.
18 #if (__cplusplus <= 199711L && EIGEN_COMP_MSVC < 1900) || defined(__CUDACC__) || defined(EIGEN_AVOID_STL_ARRAY)
19 
20 namespace Eigen {
21 template <typename T, size_t n> class array {
22  public:
23  EIGEN_DEVICE_FUNC
24  EIGEN_STRONG_INLINE T& operator[] (size_t index) { return values[index]; }
25  EIGEN_DEVICE_FUNC
26  EIGEN_STRONG_INLINE const T& operator[] (size_t index) const { return values[index]; }
27 
28  EIGEN_DEVICE_FUNC
29  EIGEN_STRONG_INLINE T& front() { return values[0]; }
30  EIGEN_DEVICE_FUNC
31  EIGEN_STRONG_INLINE const T& front() const { return values[0]; }
32 
33  EIGEN_DEVICE_FUNC
34  EIGEN_STRONG_INLINE T& back() { return values[n-1]; }
35  EIGEN_DEVICE_FUNC
36  EIGEN_STRONG_INLINE const T& back() const { return values[n-1]; }
37 
38  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
39  static std::size_t size() { return n; }
40 
41  T values[n];
42 
43  EIGEN_DEVICE_FUNC
45  EIGEN_DEVICE_FUNC
46  EIGEN_STRONG_INLINE array(const T& v) {
47  EIGEN_STATIC_ASSERT(n==1, YOU_MADE_A_PROGRAMMING_MISTAKE)
48  values[0] = v;
49  }
50  EIGEN_DEVICE_FUNC
51  EIGEN_STRONG_INLINE array(const T& v1, const T& v2) {
52  EIGEN_STATIC_ASSERT(n==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
53  values[0] = v1;
54  values[1] = v2;
55  }
56  EIGEN_DEVICE_FUNC
57  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3) {
58  EIGEN_STATIC_ASSERT(n==3, YOU_MADE_A_PROGRAMMING_MISTAKE)
59  values[0] = v1;
60  values[1] = v2;
61  values[2] = v3;
62  }
63  EIGEN_DEVICE_FUNC
64  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3,
65  const T& v4) {
66  EIGEN_STATIC_ASSERT(n==4, YOU_MADE_A_PROGRAMMING_MISTAKE)
67  values[0] = v1;
68  values[1] = v2;
69  values[2] = v3;
70  values[3] = v4;
71  }
72  EIGEN_DEVICE_FUNC
73  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
74  const T& v5) {
75  EIGEN_STATIC_ASSERT(n==5, YOU_MADE_A_PROGRAMMING_MISTAKE)
76  values[0] = v1;
77  values[1] = v2;
78  values[2] = v3;
79  values[3] = v4;
80  values[4] = v5;
81  }
82  EIGEN_DEVICE_FUNC
83  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
84  const T& v5, const T& v6) {
85  EIGEN_STATIC_ASSERT(n==6, YOU_MADE_A_PROGRAMMING_MISTAKE)
86  values[0] = v1;
87  values[1] = v2;
88  values[2] = v3;
89  values[3] = v4;
90  values[4] = v5;
91  values[5] = v6;
92  }
93  EIGEN_DEVICE_FUNC
94  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
95  const T& v5, const T& v6, const T& v7) {
96  EIGEN_STATIC_ASSERT(n==7, YOU_MADE_A_PROGRAMMING_MISTAKE)
97  values[0] = v1;
98  values[1] = v2;
99  values[2] = v3;
100  values[3] = v4;
101  values[4] = v5;
102  values[5] = v6;
103  values[6] = v7;
104  }
105  EIGEN_DEVICE_FUNC
107  const T& v1, const T& v2, const T& v3, const T& v4,
108  const T& v5, const T& v6, const T& v7, const T& v8) {
109  EIGEN_STATIC_ASSERT(n==8, YOU_MADE_A_PROGRAMMING_MISTAKE)
110  values[0] = v1;
111  values[1] = v2;
112  values[2] = v3;
113  values[3] = v4;
114  values[4] = v5;
115  values[5] = v6;
116  values[6] = v7;
117  values[7] = v8;
118  }
119 
120 #if EIGEN_HAS_VARIADIC_TEMPLATES
121  EIGEN_DEVICE_FUNC
122  EIGEN_STRONG_INLINE array(std::initializer_list<T> l) {
123  eigen_assert(l.size() == n);
124  internal::smart_copy(l.begin(), l.end(), values);
125  }
126 #endif
127 };
128 
129 
130 // Specialize array for zero size
131 template <typename T> class array<T, 0> {
132  public:
133  EIGEN_DEVICE_FUNC
135  eigen_assert(false && "Can't index a zero size array");
136  return dummy;
137  }
138  EIGEN_DEVICE_FUNC
139  EIGEN_STRONG_INLINE const T& operator[] (size_t) const {
140  eigen_assert(false && "Can't index a zero size array");
141  return dummy;
142  }
143 
144  EIGEN_DEVICE_FUNC
146  eigen_assert(false && "Can't index a zero size array");
147  return dummy;
148  }
149  EIGEN_DEVICE_FUNC
150  EIGEN_STRONG_INLINE const T& front() const {
151  eigen_assert(false && "Can't index a zero size array");
152  return dummy;
153  }
154  EIGEN_DEVICE_FUNC
156  eigen_assert(false && "Can't index a zero size array");
157  return dummy;
158  }
159  EIGEN_DEVICE_FUNC
160  EIGEN_STRONG_INLINE const T& back() const {
161  eigen_assert(false && "Can't index a zero size array");
162  return dummy;
163  }
164 
165  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::size_t size() { return 0; }
166 
167  EIGEN_DEVICE_FUNC
168  EIGEN_STRONG_INLINE array() : dummy() { }
169 
170 #if EIGEN_HAS_VARIADIC_TEMPLATES
171  EIGEN_DEVICE_FUNC array(std::initializer_list<T> l) : dummy() {
172  eigen_assert(l.size() == 0);
173  }
174 #endif
175 
176  private:
177  T dummy;
178 };
179 
180 // Comparison operator
181 // Todo: implement !=, <, <=, >, and >=
182 template<class T, std::size_t N>
183 EIGEN_DEVICE_FUNC bool operator==(const array<T,N>& lhs, const array<T,N>& rhs) {
184  for (std::size_t i = 0; i < N; ++i) {
185  if (lhs[i] != rhs[i]) {
186  return false;
187  }
188  }
189  return true;
190 }
191 
192 
193 namespace internal {
194 template<std::size_t I, class T, std::size_t N>
195 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& array_get(array<T,N>& a) {
196  return a[I];
197 }
198 template<std::size_t I, class T, std::size_t N>
199 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& array_get(const array<T,N>& a) {
200  return a[I];
201 }
202 
203 template <typename T> struct array_size;
204 template<class T, std::size_t N> struct array_size<array<T,N> > {
205  static const size_t value = N;
206 };
207 template <typename T> struct array_size;
208 template<class T, std::size_t N> struct array_size<array<T,N>& > {
209  static const size_t value = N;
210 };
211 template <typename T> struct array_size;
212 template<class T, std::size_t N> struct array_size<const array<T,N> > {
213  static const size_t value = N;
214 };
215 template <typename T> struct array_size;
216 template<class T, std::size_t N> struct array_size<const array<T,N>& > {
217  static const size_t value = N;
218 };
219 
220 } // end namespace internal
221 } // end namespace Eigen
222 
223 #else
224 
225 // The compiler supports c++11, and we're not targetting cuda: use std::array as Eigen::array
226 #include <array>
227 namespace Eigen {
228 
229 template <typename T, std::size_t N> using array = std::array<T, N>;
230 
231 namespace internal {
232 /* std::get is only constexpr in C++14, not yet in C++11
233  * - libstdc++ from version 4.7 onwards has it nevertheless,
234  * so use that
235  * - libstdc++ older versions: use _M_instance directly
236  * - libc++ all versions so far: use __elems_ directly
237  * - all other libs: use std::get to be portable, but
238  * this may not be constexpr
239  */
240 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20120322
241 #define STD_GET_ARR_HACK a._M_instance[I]
242 #elif defined(_LIBCPP_VERSION)
243 #define STD_GET_ARR_HACK a.__elems_[I]
244 #else
245 #define STD_GET_ARR_HACK std::template get<I, T, N>(a)
246 #endif
247 
248 template<std::size_t I, class T, std::size_t N> constexpr inline T& array_get(std::array<T,N>& a) { return (T&) STD_GET_ARR_HACK; }
249 template<std::size_t I, class T, std::size_t N> constexpr inline T&& array_get(std::array<T,N>&& a) { return (T&&) STD_GET_ARR_HACK; }
250 template<std::size_t I, class T, std::size_t N> constexpr inline T const& array_get(std::array<T,N> const& a) { return (T const&) STD_GET_ARR_HACK; }
251 
252 #undef STD_GET_ARR_HACK
253 
254 template <typename T> struct array_size;
255 template<class T, std::size_t N> struct array_size<const std::array<T,N> > {
256  static const size_t value = N;
257 };
258 template <typename T> struct array_size;
259 template<class T, std::size_t N> struct array_size<std::array<T,N> > {
260  static const size_t value = N;
261 };
262 } // end namespace internal
263 } // end namespace Eigen
264 
265 #endif
266 
267 #endif // EIGEN_EMULATE_ARRAY_H
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T & array_get(const array< T, N > &a)
Definition: EmulateArray.h:199
#define EIGEN_ALWAYS_INLINE
Definition: Macros.h:507
#define EIGEN_STRONG_INLINE
Definition: Macros.h:493
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T & front()
Definition: EmulateArray.h:145
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const Tuple< U, V > &x, const Tuple< U, V > &y)
Definition: TensorMeta.h:142
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array()
Definition: EmulateArray.h:168
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T & front() const
Definition: EmulateArray.h:150
EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE std::size_t size()
Definition: EmulateArray.h:39
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array()
Definition: EmulateArray.h:44
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T & operator[](size_t index)
Definition: EmulateArray.h:24
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7, const T &v8)
Definition: EmulateArray.h:106
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7)
Definition: EmulateArray.h:94
Definition: LDLT.h:16
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6)
Definition: EmulateArray.h:83
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T & back()
Definition: EmulateArray.h:34
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:122
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3, const T &v4)
Definition: EmulateArray.h:64
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2)
Definition: EmulateArray.h:51
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T & front()
Definition: EmulateArray.h:29
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T & back() const
Definition: EmulateArray.h:160
EIGEN_DEVICE_FUNC void smart_copy(const T *start, const T *end, T *target)
Definition: Memory.h:485
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v)
Definition: EmulateArray.h:46
#define eigen_assert(x)
Definition: Macros.h:577
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3, const T &v4, const T &v5)
Definition: EmulateArray.h:73
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(const T &v1, const T &v2, const T &v3)
Definition: EmulateArray.h:57
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T & back() const
Definition: EmulateArray.h:36
static const int N
Definition: TensorIntDiv.h:84
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T & back()
Definition: EmulateArray.h:155
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::size_t size()
Definition: EmulateArray.h:165
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T & front() const
Definition: EmulateArray.h:31


hebiros
Author(s): Xavier Artache , Matthew Tesch
autogenerated on Thu Sep 3 2020 04:08:11