• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_CXX11_META_H
11 #define EIGEN_EMULATE_CXX11_META_H
12 
13 
14 
15 namespace Eigen {
16 
17 namespace internal {
18 
19 /** \internal
20   * \file CXX11/util/EmulateCXX11Meta.h
21   * This file emulates a subset of the functionality provided by CXXMeta.h for
22   * compilers that don't yet support cxx11 such as nvcc.
23   */
24 
25 struct empty_list { static const std::size_t count = 0; };
26 
27 template<typename T, typename Tail=empty_list> struct type_list {
28   typedef T HeadType;
29   typedef Tail TailType;
30   static const T head;
31   static const Tail tail;
32   static const std::size_t count = 1 + Tail::count;
33 };
34 
35 struct null_type { };
36 
37 template<typename T1 = null_type, typename T2 = null_type, typename T3 = null_type,
38          typename T4 = null_type, typename T5 = null_type, typename T6 = null_type,
39          typename T7 = null_type, typename T8 = null_type>
40 struct make_type_list {
41   typedef typename make_type_list<T2, T3, T4, T5, T6, T7, T8>::type tailresult;
42 
43   typedef type_list<T1, tailresult> type;
44 };
45 
46 template<> struct make_type_list<> {
47   typedef empty_list type;
48 };
49 
50 
51 template <std::size_t index, class TList> struct get_type;
52 
53 template <class Head, class Tail>
54 struct get_type<0, type_list<Head, Tail> >
55 {
56   typedef Head type;
57 };
58 
59 template <std::size_t i, class Head, class Tail>
60 struct get_type<i, type_list<Head, Tail> >
61 {
62   typedef typename get_type<i-1, Tail>::type type;
63 };
64 
65 
66 /* numeric list */
67 template <typename T, T n>
68 struct type2val {
69   typedef T type;
70   static const T value = n;
71 };
72 
73 
74 template<typename T, size_t n, T V> struct gen_numeric_list_repeated;
75 
76 template<typename T, T V> struct gen_numeric_list_repeated<T, 1, V> {
77   typedef typename make_type_list<type2val<T, V> >::type type;
78 };
79 
80 template<typename T, T V> struct gen_numeric_list_repeated<T, 2, V> {
81   typedef typename make_type_list<type2val<T, V>, type2val<T, V> >::type type;
82 };
83 
84 template<typename T, T V> struct gen_numeric_list_repeated<T, 3, V> {
85   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V> >::type type;
86 };
87 
88 template<typename T, T V> struct gen_numeric_list_repeated<T, 4, V> {
89   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V>, type2val<T, V> >::type type;
90 };
91 
92 template<typename T, T V> struct gen_numeric_list_repeated<T, 5, V> {
93   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V>, type2val<T, V>, type2val<T, V> >::type type;
94 };
95 
96 template<typename T, T V> struct gen_numeric_list_repeated<T, 6, V> {
97   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V>,
98                                   type2val<T, V>, type2val<T, V>, type2val<T, V> >::type type;
99 };
100 
101 template<typename T, T V> struct gen_numeric_list_repeated<T, 7, V> {
102   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V>,
103                                   type2val<T, V>, type2val<T, V>, type2val<T, V>,
104                                   type2val<T, V> >::type type;
105 };
106 
107 template<typename T, T V> struct gen_numeric_list_repeated<T, 8, V> {
108   typedef typename make_type_list<type2val<T, V>, type2val<T, V>, type2val<T, V>,
109                                   type2val<T, V>, type2val<T, V>, type2val<T, V>,
110                                   type2val<T, V>, type2val<T, V> >::type type;
111 };
112 
113 
114 template <std::size_t index, class NList> struct get;
115 
116 template <std::size_t i>
117 struct get<i, empty_list>
118 {
119   get() { eigen_assert(false && "index overflow"); }
120   typedef void type;
121   static const char value = '\0';
122 };
123 
124 template <std::size_t i, class Head>
125 struct get<i, type_list<Head, empty_list> >
126 {
127   get() { eigen_assert(false && "index overflow"); }
128   typedef void type;
129   static const char value = '\0';
130 };
131 
132 template <class Head>
133 struct get<0, type_list<Head, empty_list> >
134 {
135   typedef typename Head::type type;
136   static const type value = Head::value;
137 };
138 
139 template <class Head, class Tail>
140 struct get<0, type_list<Head, Tail> >
141 {
142   typedef typename Head::type type;
143   static const type value = Head::value;
144 };
145 
146 template <std::size_t i, class Head, class Tail>
147 struct get<i, type_list<Head, Tail> >
148 {
149   typedef typename Tail::HeadType::type type;
150   static const type value = get<i-1, Tail>::value;
151 };
152 
153 
154 template <class NList> struct arg_prod {
155   static const typename NList::HeadType::type value = get<0, NList>::value * arg_prod<typename NList::TailType>::value;
156 };
157 template <> struct arg_prod<empty_list> {
158   static const int value = 1;
159 };
160 
161 
162 template<int n, typename t>
163 array<t, n> repeat(t v) {
164   array<t, n> array;
165   array.fill(v);
166   return array;
167 }
168 
169 template<std::size_t I, class Head, class Tail>
170 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Head::type array_get(type_list<Head, Tail>&) {
171   return get<I, type_list<Head, Tail> >::value;
172 }
173 template<std::size_t I, class Head, class Tail>
174 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Head::type array_get(const type_list<Head, Tail>&) {
175   return get<I, type_list<Head, Tail> >::value;
176 }
177 
178 template <class NList>
179 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NList::HeadType::type array_prod(const NList&) {
180   return arg_prod<NList>::value;
181 }
182 
183 template<typename t, std::size_t n>
184 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(const array<t, n>& a) {
185   t prod = 1;
186   for (size_t i = 0; i < n; ++i) { prod *= a[i]; }
187   return prod;
188 }
189 template<typename t>
190 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(const array<t, 0>& /*a*/) {
191   return 0;
192 }
193 
194 template<typename t>
195 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(const std::vector<t>& a) {
196   eigen_assert(a.size() > 0);
197   t prod = 1;
198   for (size_t i = 0; i < a.size(); ++i) { prod *= a[i]; }
199   return prod;
200 }
201 
202 
203 template<std::size_t I, class T>
204 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& array_get(std::vector<T>& a) {
205   return a[I];
206 }
207 template<std::size_t I, class T>
208 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& array_get(const std::vector<T>& a) {
209   return a[I];
210 }
211 
212 struct sum_op {
213   template<typename A, typename B> static inline bool run(A a, B b) { return a + b; }
214 };
215 struct product_op {
216   template<typename A, typename B> static inline bool run(A a, B b) { return a * b; }
217 };
218 
219 struct logical_and_op {
220   template<typename A, typename B> static inline bool run(A a, B b) { return a && b; }
221 };
222 struct logical_or_op {
223   template<typename A, typename B> static inline bool run(A a, B b) { return a || b; }
224 };
225 
226 struct equal_op {
227   template<typename A, typename B> static inline bool run(A a, B b) { return a == b; }
228 };
229 struct not_equal_op {
230   template<typename A, typename B> static inline bool run(A a, B b) { return a != b; }
231 };
232 struct lesser_op {
233   template<typename A, typename B> static inline bool run(A a, B b) { return a < b; }
234 };
235 struct lesser_equal_op {
236   template<typename A, typename B> static inline bool run(A a, B b) { return a <= b; }
237 };
238 
239 struct greater_op {
240   template<typename A, typename B> static inline bool run(A a, B b) { return a > b; }
241 };
242 struct greater_equal_op {
243   template<typename A, typename B> static inline bool run(A a, B b) { return a >= b; }
244 };
245 
246 struct not_op {
247   template<typename A> static inline bool run(A a) { return !a; }
248 };
249 struct negation_op {
250   template<typename A> static inline bool run(A a) { return -a; }
251 };
252 struct greater_equal_zero_op {
253   template<typename A> static inline bool run(A a) { return a >= 0; }
254 };
255 
256 
257 template<typename Reducer, typename Op, typename A, std::size_t N>
258 struct ArrayApplyAndReduce {
259   static inline bool run(const array<A, N>& a) {
260     EIGEN_STATIC_ASSERT(N >= 2, YOU_MADE_A_PROGRAMMING_MISTAKE);
261     bool result = Reducer::run(Op::run(a[0]), Op::run(a[1]));
262     for (size_t i = 2; i < N; ++i) {
263       result = Reducer::run(result, Op::run(a[i]));
264     }
265     return result;
266   }
267 };
268 
269 template<typename Reducer, typename Op, typename A>
270 struct ArrayApplyAndReduce<Reducer, Op, A, 1>  {
271   static inline bool run(const array<A, 1>& a) {
272     return Op::run(a[0]);
273   }
274 };
275 
276 template<typename Reducer, typename Op, typename A, std::size_t N>
277 inline bool array_apply_and_reduce(const array<A, N>& a) {
278   return ArrayApplyAndReduce<Reducer, Op, A, N>::run(a);
279 }
280 
281 template<typename Reducer, typename Op, typename A, typename B, std::size_t N>
282 struct ArrayZipAndReduce {
283   static inline bool run(const array<A, N>& a, const array<B, N>& b) {
284     EIGEN_STATIC_ASSERT(N >= 2, YOU_MADE_A_PROGRAMMING_MISTAKE);
285     bool result = Reducer::run(Op::run(a[0], b[0]), Op::run(a[1], b[1]));
286     for (size_t i = 2; i < N; ++i) {
287       result = Reducer::run(result, Op::run(a[i], b[i]));
288     }
289     return result;
290   }
291 };
292 
293 template<typename Reducer, typename Op, typename A, typename B>
294 struct ArrayZipAndReduce<Reducer, Op, A, B, 1> {
295   static inline bool run(const array<A, 1>& a, const array<B, 1>& b) {
296     return Op::run(a[0], b[0]);
297   }
298 };
299 
300 template<typename Reducer, typename Op, typename A, typename B, std::size_t N>
301 inline bool array_zip_and_reduce(const array<A, N>& a, const array<B, N>& b) {
302   return ArrayZipAndReduce<Reducer, Op, A, B, N>::run(a, b);
303 }
304 
305 }  // end namespace internal
306 
307 }  // end namespace Eigen
308 
309 
310 
311 #endif  // EIGEN_EMULATE_CXX11_META_H
312