10 #ifndef EIGEN_EMULATE_CXX11_META_H 11 #define EIGEN_EMULATE_CXX11_META_H 25 struct empty_list {
static const std::size_t count = 0; };
27 template<
typename T,
typename Tail=empty_list>
struct type_list {
29 typedef Tail TailType;
31 static const Tail tail;
32 static const std::size_t count = 1 + Tail::count;
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;
43 typedef type_list<T1, tailresult> type;
46 template<>
struct make_type_list<> {
47 typedef empty_list type;
51 template <std::
size_t index,
class TList>
struct get_type;
53 template <
class Head,
class Tail>
54 struct get_type<0, type_list<Head, Tail> >
59 template <std::
size_t i,
class Head,
class Tail>
60 struct get_type<i, type_list<Head, Tail> >
62 typedef typename get_type<i-1, Tail>::type type;
67 template <
typename T, T n>
70 static const T value = n;
74 template<
typename T,
size_t n, T V>
struct gen_numeric_list_repeated;
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;
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;
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;
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;
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;
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;
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;
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;
114 template <std::
size_t index,
class NList>
struct get;
116 template <std::
size_t i>
117 struct get<i, empty_list>
119 get() { eigen_assert(
false &&
"index overflow"); }
121 static const char value =
'\0';
124 template <std::
size_t i,
class Head>
125 struct get<i, type_list<Head, empty_list> >
127 get() { eigen_assert(
false &&
"index overflow"); }
129 static const char value =
'\0';
132 template <
class Head>
133 struct get<0, type_list<Head, empty_list> >
135 typedef typename Head::type type;
136 static const type value = Head::value;
139 template <
class Head,
class Tail>
140 struct get<0, type_list<Head, Tail> >
142 typedef typename Head::type type;
143 static const type value = Head::value;
146 template <std::
size_t i,
class Head,
class Tail>
147 struct get<i, type_list<Head, Tail> >
149 typedef typename Tail::HeadType::type type;
150 static const type value =
get<i-1, Tail>::value;
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;
157 template <>
struct arg_prod<empty_list> {
158 static const int value = 1;
162 template<
int n,
typename t>
163 array<t, n> repeat(t v) {
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;
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;
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;
183 template<
typename t, std::
size_t n>
184 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(
const array<t, n>& a) {
186 for (
size_t i = 0; i < n; ++i) { prod *= a[i]; }
190 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(
const array<t, 0>& ) {
195 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t array_prod(
const std::vector<t>& a) {
196 eigen_assert(a.size() > 0);
198 for (
size_t i = 0; i < a.size(); ++i) { prod *= a[i]; }
203 template<std::
size_t I,
class T>
204 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& array_get(std::vector<T>& a) {
207 template<std::
size_t I,
class T>
208 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const T& array_get(
const std::vector<T>& a) {
213 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a + b; }
216 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a * b; }
219 struct logical_and_op {
220 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a && b; }
222 struct logical_or_op {
223 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a || b; }
227 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a == b; }
229 struct not_equal_op {
230 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a != b; }
233 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a < b; }
235 struct lesser_equal_op {
236 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a <= b; }
240 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a > b; }
242 struct greater_equal_op {
243 template<
typename A,
typename B>
static inline bool run(A a, B b) {
return a >= b; }
247 template<
typename A>
static inline bool run(A a) {
return !a; }
250 template<
typename A>
static inline bool run(A a) {
return -a; }
252 struct greater_equal_zero_op {
253 template<
typename A>
static inline bool run(A a) {
return a >= 0; }
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]));
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]);
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);
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]));
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]);
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);
311 #endif // EIGEN_EMULATE_CXX11_META_H Namespace containing all symbols from the Eigen library.
Definition: AdolcForward:45