Classes | Macros | Functions
meta.cpp File Reference
#include "main.h"
#include <array>
#include <Eigen/src/Core/util/Meta.h>

Classes

struct  FooReturnType
 
struct  MyInterface
 
struct  MyImpl
 
struct  dummy_a
 
struct  dummy_b
 
struct  dummy_c
 
struct  dummy_d
 
struct  dummy_e
 
struct  dummy_op< dummy_a, dummy_b >
 
struct  dummy_op< dummy_b, dummy_a >
 
struct  dummy_op< dummy_b, dummy_c >
 
struct  dummy_op< dummy_c, dummy_b >
 
struct  dummy_op< dummy_c, dummy_a >
 
struct  dummy_op< dummy_a, dummy_c >
 
struct  dummy_op< dummy_a, dummy_a >
 
struct  dummy_op< dummy_b, dummy_b >
 
struct  dummy_op< dummy_c, dummy_c >
 
struct  dummy_test< A, B >
 
struct  dummy_test< dummy_a, dummy_a >
 
struct  dummy_test< dummy_b, dummy_b >
 
struct  dummy_test< dummy_c, dummy_c >
 
struct  times2_op
 
struct  dummy_inst
 

Macros

#define VERIFY_META_SQRT(X)   VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))
 

Functions

template<typename From , typename To >
bool check_is_convertible (const From &, const To &)
 
 EIGEN_DECLARE_TEST (meta)
 
static void test_gen_numeric_list ()
 
static void test_concat ()
 
static void test_slice ()
 
static void test_get ()
 
static void test_id_helper (dummy_a a, dummy_a b, dummy_a c)
 
template<int... ii>
static void test_id_numeric ()
 
template<typename... tt>
static void test_id_type ()
 
static void test_id ()
 
static void test_is_same_gf ()
 
static void test_apply_op ()
 
static void test_contained_in_list ()
 
static void test_arg_reductions ()
 
static void test_array_reverse_and_reduce ()
 
static void test_array_zip_and_apply ()
 
static void test_array_misc ()
 
 EIGEN_DECLARE_TEST (cxx11_meta)
 

Macro Definition Documentation

◆ VERIFY_META_SQRT

#define VERIFY_META_SQRT (   X)    VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))

Function Documentation

◆ check_is_convertible()

template<typename From , typename To >
bool check_is_convertible ( const From &  ,
const To &   
)
16  {
17  return internal::is_convertible<From, To>::value;
18 }
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87

References Eigen::value.

Referenced by EIGEN_DECLARE_TEST().

◆ EIGEN_DECLARE_TEST() [1/2]

EIGEN_DECLARE_TEST ( cxx11_meta  )
520  {
521  CALL_SUBTEST(test_gen_numeric_list());
522  CALL_SUBTEST(test_concat());
523  CALL_SUBTEST(test_slice());
524  CALL_SUBTEST(test_get());
525  CALL_SUBTEST(test_id());
526  CALL_SUBTEST(test_is_same_gf());
527  CALL_SUBTEST(test_apply_op());
528  CALL_SUBTEST(test_contained_in_list());
529  CALL_SUBTEST(test_arg_reductions());
530  CALL_SUBTEST(test_array_reverse_and_reduce());
531  CALL_SUBTEST(test_array_zip_and_apply());
532  CALL_SUBTEST(test_array_misc());
533 }
CALL_SUBTEST
#define CALL_SUBTEST(FUNC)
Definition: main.h:382
test_id
static void test_id()
Definition: meta.cpp:424
test_arg_reductions
static void test_arg_reductions()
Definition: meta.cpp:468
test_contained_in_list
static void test_contained_in_list()
Definition: meta.cpp:446
test_slice
static void test_slice()
Definition: meta.cpp:347
test_array_misc
static void test_array_misc()
Definition: meta.cpp:505
test_gen_numeric_list
static void test_gen_numeric_list()
Definition: meta.cpp:255
test_is_same_gf
static void test_is_same_gf()
Definition: meta.cpp:431
test_get
static void test_get()
Definition: meta.cpp:389
test_apply_op
static void test_apply_op()
Definition: meta.cpp:438
test_concat
static void test_concat()
Definition: meta.cpp:307
test_array_reverse_and_reduce
static void test_array_reverse_and_reduce()
Definition: meta.cpp:475
test_array_zip_and_apply
static void test_array_zip_and_apply()
Definition: meta.cpp:489

References CALL_SUBTEST, test_apply_op(), test_arg_reductions(), test_array_misc(), test_array_reverse_and_reduce(), test_array_zip_and_apply(), test_concat(), test_contained_in_list(), test_gen_numeric_list(), test_get(), test_id(), test_is_same_gf(), and test_slice().

◆ EIGEN_DECLARE_TEST() [2/2]

EIGEN_DECLARE_TEST ( meta  )
32  {
33  VERIFY((internal::is_same<float, float>::value));
34  VERIFY((!internal::is_same<float, double>::value));
35  VERIFY((!internal::is_same<float, float&>::value));
36  VERIFY((!internal::is_same<float, const float&>::value));
37 
38  VERIFY((internal::is_same<float, internal::remove_all_t<const float&>>::value));
39  VERIFY((internal::is_same<float, internal::remove_all_t<const float*>>::value));
40  VERIFY((internal::is_same<float, internal::remove_all_t<const float*&>>::value));
41  VERIFY((internal::is_same<float, internal::remove_all_t<float**>>::value));
42  VERIFY((internal::is_same<float, internal::remove_all_t<float**&>>::value));
43  VERIFY((internal::is_same<float, internal::remove_all_t<float* const*&>>::value));
44  VERIFY((internal::is_same<float, internal::remove_all_t<float* const>>::value));
45 
46  // test add_const_on_value_type
47  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float&>, float const&>::value));
48  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float*>, float const*>::value));
49 
50  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float>, const float>::value));
51  VERIFY((internal::is_same<internal::add_const_on_value_type_t<const float>, const float>::value));
52 
53  VERIFY((internal::is_same<internal::add_const_on_value_type_t<const float* const>, const float* const>::value));
54  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float* const>, const float* const>::value));
55 
56  // is_convertible
57  STATIC_CHECK((internal::is_convertible<float, double>::value));
58  STATIC_CHECK((internal::is_convertible<int, double>::value));
59  STATIC_CHECK((internal::is_convertible<int, short>::value));
60  STATIC_CHECK((internal::is_convertible<short, int>::value));
61  STATIC_CHECK((internal::is_convertible<double, int>::value));
62  STATIC_CHECK((internal::is_convertible<double, std::complex<double>>::value));
63  STATIC_CHECK((!internal::is_convertible<std::complex<double>, double>::value));
64  STATIC_CHECK((internal::is_convertible<Array33f, Matrix3f>::value));
65  STATIC_CHECK((internal::is_convertible<Matrix3f&, Matrix3f>::value));
66  STATIC_CHECK((internal::is_convertible<Matrix3f&, Matrix3f&>::value));
67  STATIC_CHECK((internal::is_convertible<Matrix3f&, const Matrix3f&>::value));
68  STATIC_CHECK((internal::is_convertible<const Matrix3f&, Matrix3f>::value));
69  STATIC_CHECK((internal::is_convertible<const Matrix3f&, const Matrix3f&>::value));
70  STATIC_CHECK((!internal::is_convertible<const Matrix3f&, Matrix3f&>::value));
71  STATIC_CHECK((!internal::is_convertible<const Matrix3f, Matrix3f&>::value));
72  STATIC_CHECK(!(internal::is_convertible<Matrix3f, Matrix3f&>::value));
73 
74  STATIC_CHECK(!(internal::is_convertible<int, int&>::value));
75  STATIC_CHECK((internal::is_convertible<const int, const int&>::value));
76 
77  // STATIC_CHECK((!internal::is_convertible<Matrix3f,Matrix3d>::value )); //does not even compile because the
78  // conversion is prevented by a static assertion
79  STATIC_CHECK((!internal::is_convertible<Array33f, int>::value));
80  STATIC_CHECK((!internal::is_convertible<MatrixXf, float>::value));
81  {
82  float f = 0.0f;
83  MatrixXf A, B;
84  VectorXf a, b;
85  VERIFY((check_is_convertible(a.dot(b), f)));
86  VERIFY((check_is_convertible(a.transpose() * b, f)));
87  VERIFY((!check_is_convertible(A * B, f)));
88  VERIFY((check_is_convertible(A * B, A)));
89  }
90 
91 #if (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC <= 990) || (EIGEN_COMP_CLANG_STRICT && EIGEN_COMP_CLANG <= 990) || \
92  (EIGEN_COMP_MSVC && EIGEN_COMP_MSVC <= 1914)
93  // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1752,
94  // basically, a fix in the c++ standard breaks our c++98 implementation
95  // of is_convertible for abstract classes.
96  // So the following tests are expected to fail with recent compilers.
97 
98  STATIC_CHECK((!internal::is_convertible<MyInterface, MyImpl>::value));
99  STATIC_CHECK((!internal::is_convertible<MyImpl, MyInterface>::value));
100  STATIC_CHECK((internal::is_convertible<MyImpl, const MyInterface&>::value));
101 
102 #endif
103 
104  {
105  int i = 0;
106  VERIFY((check_is_convertible(fix<3>(), i)));
107  VERIFY((!check_is_convertible(i, fix<DynamicIndex>())));
108  }
109 
110  VERIFY((internal::has_ReturnType<FooReturnType>::value));
111  VERIFY((internal::has_ReturnType<ScalarBinaryOpTraits<int, int>>::value));
112  VERIFY((!internal::has_ReturnType<MatrixXf>::value));
113  VERIFY((!internal::has_ReturnType<int>::value));
114 
115  VERIFY(internal::meta_sqrt<1>::ret == 1);
116 #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))
117  VERIFY_META_SQRT(2);
118  VERIFY_META_SQRT(3);
119  VERIFY_META_SQRT(4);
120  VERIFY_META_SQRT(5);
121  VERIFY_META_SQRT(6);
122  VERIFY_META_SQRT(8);
123  VERIFY_META_SQRT(9);
124  VERIFY_META_SQRT(15);
125  VERIFY_META_SQRT(16);
126  VERIFY_META_SQRT(17);
127  VERIFY_META_SQRT(255);
128  VERIFY_META_SQRT(256);
129  VERIFY_META_SQRT(257);
130  VERIFY_META_SQRT(1023);
131  VERIFY_META_SQRT(1024);
132  VERIFY_META_SQRT(1025);
133 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
b
Scalar * b
Definition: benchVecAdd.cpp:17
A
Matrix< SCALARA, Dynamic, Dynamic, opt_A > A
Definition: bench_gemm.cpp:47
B
Matrix< SCALARB, Dynamic, Dynamic, opt_B > B
Definition: bench_gemm.cpp:48
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
oomph::Matrix
Definition: matrices.h:74
f
static int f(const TensorMap< Tensor< int, 3 > > &tensor)
Definition: cxx11_tensor_map.cpp:237
ret
Eigen::DenseIndex ret
Definition: level1_cplx_impl.h:43
a
const Scalar * a
Definition: level2_cplx_impl.h:32
VERIFY
#define VERIFY(a)
Definition: main.h:362
STATIC_CHECK
#define STATIC_CHECK(COND)
Definition: main.h:380
check_is_convertible
bool check_is_convertible(const From &, const To &)
Definition: meta.cpp:16
VERIFY_META_SQRT
#define VERIFY_META_SQRT(X)
Eigen::ScalarBinaryOpTraits
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition: XprHelper.h:1043

References a, b, check_is_convertible(), f(), i, ret, STATIC_CHECK, Eigen::value, VERIFY, and VERIFY_META_SQRT.

◆ test_apply_op()

static void test_apply_op ( )
static
438  {
439  typedef type_list<dummy_a, dummy_b, dummy_c> tl;
440  VERIFY((!!is_same<typename apply_op_from_left<dummy_op, dummy_a, tl>::type,
441  type_list<dummy_e, dummy_c, dummy_d>>::value));
442  VERIFY((!!is_same<typename apply_op_from_right<dummy_op, dummy_a, tl>::type,
443  type_list<dummy_e, dummy_d, dummy_b>>::value));
444 }
Eigen::internal::apply_op_from_left
Definition: MoreMeta.h:263
Eigen::internal::apply_op_from_right
Definition: MoreMeta.h:268
Eigen::internal::is_same
Definition: Meta.h:205
Eigen::internal::type_list
Definition: MoreMeta.h:22

References Eigen::value, and VERIFY.

Referenced by EIGEN_DECLARE_TEST().

◆ test_arg_reductions()

static void test_arg_reductions ( )
static
468  {
469  VERIFY_IS_EQUAL(arg_sum(1, 2, 3, 4), 10);
470  VERIFY_IS_EQUAL(arg_prod(1, 2, 3, 4), 24);
471  VERIFY_IS_APPROX(arg_sum(0.5, 2, 5), 7.5);
472  VERIFY_IS_APPROX(arg_prod(0.5, 2, 5), 5.0);
473 }
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
Eigen::internal::arg_prod
constexpr EIGEN_DEVICE_FUNCdecltype(reduce< product_op, Ts... >::run((*((Ts *) 0))...)) EIGEN_STRONG_INLIN arg_prod)(Ts... ts)
Definition: MoreMeta.h:435
Eigen::internal::arg_sum
constexpr decltype(reduce< sum_op, Ts... >::run((*((Ts *) 0))...)) EIGEN_STRONG_INLIN arg_sum)(Ts... ts)
Definition: MoreMeta.h:441

References Eigen::internal::arg_prod, Eigen::internal::arg_sum, VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_array_misc()

static void test_array_misc ( )
static
505  {
506  array<int, 3> a3{{1, 1, 1}};
507  array<int, 6> a6{{2, 2, 2, 2, 2, 2}};
508  VERIFY((repeat<3, int>(1) == a3));
509  VERIFY((repeat<6, int>(2) == a6));
510 
511  int data[5] = {0, 1, 2, 3, 4};
512  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 0>(data).c), 0);
513  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 1>(data).c), 1);
514  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 2>(data).c), 2);
515  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 3>(data).c), 3);
516  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 4>(data).c), 4);
517  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 5>(data).c), 5);
518 }
data
int data[]
Definition: Map_placement_new.cpp:1
Eigen::array
std::array< T, N > array
Definition: EmulateArray.h:231
calibrate.c
int c
Definition: calibrate.py:100

References calibrate::c, data, VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_array_reverse_and_reduce()

static void test_array_reverse_and_reduce ( )
static
475  {
476  array<int, 6> a{{4, 8, 15, 16, 23, 42}};
477  array<int, 6> b{{42, 23, 16, 15, 8, 4}};
478 
479  // there is no operator<< for std::array, so VERIFY_IS_EQUAL will
480  // not compile
481  VERIFY((array_reverse(a) == b));
482  VERIFY((array_reverse(b) == a));
483  VERIFY_IS_EQUAL((array_sum(a)), 108);
484  VERIFY_IS_EQUAL((array_sum(b)), 108);
485  VERIFY_IS_EQUAL((array_prod(a)), 7418880);
486  VERIFY_IS_EQUAL((array_prod(b)), 7418880);
487 }
Eigen::internal::array_prod
constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto array_prod(const array< T, N > &arr) -> decltype(array_reduce< product_op, T, N >(arr, static_cast< T >(1)))
Definition: MoreMeta.h:497
Eigen::internal::array_reverse
constexpr EIGEN_STRONG_INLINE array< T, N > array_reverse(array< T, N > arr)
Definition: MoreMeta.h:453
Eigen::internal::array_sum
constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto array_sum(const array< T, N > &arr) -> decltype(array_reduce< sum_op, T, N >(arr, static_cast< T >(0)))
Definition: MoreMeta.h:491

References a, Eigen::internal::array_prod(), Eigen::internal::array_reverse(), Eigen::internal::array_sum(), b, VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_array_zip_and_apply()

static void test_array_zip_and_apply ( )
static
489  {
490  array<int, 6> a{{4, 8, 15, 16, 23, 42}};
491  array<int, 6> b{{0, 1, 2, 3, 4, 5}};
492  array<int, 6> c{{4, 9, 17, 19, 27, 47}};
493  array<int, 6> d{{0, 8, 30, 48, 92, 210}};
494  array<int, 6> e{{0, 2, 4, 6, 8, 10}};
495 
496  VERIFY((array_zip<sum_op>(a, b) == c));
497  VERIFY((array_zip<product_op>(a, b) == d));
498  VERIFY((array_apply<times2_op>(b) == e));
499  VERIFY_IS_EQUAL((array_apply_and_reduce<sum_op, times2_op>(a)), 216);
500  VERIFY_IS_EQUAL((array_apply_and_reduce<sum_op, times2_op>(b)), 30);
501  VERIFY_IS_EQUAL((array_zip_and_reduce<product_op, sum_op>(a, b)), 14755932);
502  VERIFY_IS_EQUAL((array_zip_and_reduce<sum_op, product_op>(a, b)), 388);
503 }
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)

References a, b, calibrate::c, e(), VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_concat()

static void test_concat ( )
static
307  {
308  VERIFY(
309  (is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<>>::type, type_list<dummy_a, dummy_a>>::value));
310  VERIFY(
311  (is_same<typename concat<type_list<>, type_list<dummy_a, dummy_a>>::type, type_list<dummy_a, dummy_a>>::value));
312  VERIFY((is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_a, dummy_a>>::type,
313  type_list<dummy_a, dummy_a, dummy_a, dummy_a>>::value));
314  VERIFY((is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_b, dummy_c>>::type,
315  type_list<dummy_a, dummy_a, dummy_b, dummy_c>>::value));
316  VERIFY((is_same<typename concat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
317  type_list<dummy_a, dummy_b, dummy_c>>::value));
318 
319  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int>>::type, numeric_list<int, 0, 0>>::value));
320  VERIFY((is_same<typename concat<numeric_list<int>, numeric_list<int, 0, 0>>::type, numeric_list<int, 0, 0>>::value));
321  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int, 0, 0>>::type,
322  numeric_list<int, 0, 0, 0, 0>>::value));
323  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int, 1, 2>>::type,
324  numeric_list<int, 0, 0, 1, 2>>::value));
325  VERIFY((is_same<typename concat<numeric_list<int, 0>, numeric_list<int, 1, 2>>::type,
326  numeric_list<int, 0, 1, 2>>::value));
327 
328  VERIFY((is_same<typename mconcat<type_list<dummy_a>>::type, type_list<dummy_a>>::value));
329  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>>::type, type_list<dummy_a, dummy_b>>::value));
330  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>, type_list<dummy_c>>::type,
331  type_list<dummy_a, dummy_b, dummy_c>>::value));
332  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
333  type_list<dummy_a, dummy_b, dummy_c>>::value));
334  VERIFY((is_same<typename mconcat<type_list<dummy_a, dummy_b>, type_list<dummy_c>>::type,
335  type_list<dummy_a, dummy_b, dummy_c>>::value));
336 
337  VERIFY((is_same<typename mconcat<numeric_list<int, 0>>::type, numeric_list<int, 0>>::value));
338  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1>>::type, numeric_list<int, 0, 1>>::value));
339  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1>, numeric_list<int, 2>>::type,
340  numeric_list<int, 0, 1, 2>>::value));
341  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1, 2>>::type,
342  numeric_list<int, 0, 1, 2>>::value));
343  VERIFY((is_same<typename mconcat<numeric_list<int, 0, 1>, numeric_list<int, 2>>::type,
344  numeric_list<int, 0, 1, 2>>::value));
345 }
compute_granudrum_aor.type
type
Definition: compute_granudrum_aor.py:141
Eigen::internal::concat
Definition: MoreMeta.h:87
Eigen::internal::mconcat
Definition: MoreMeta.h:99
Eigen::internal::numeric_list
Definition: MoreMeta.h:33

References compute_granudrum_aor::type, Eigen::value, and VERIFY.

Referenced by EIGEN_DECLARE_TEST().

◆ test_contained_in_list()

static void test_contained_in_list ( )
static
446  {
447  typedef type_list<dummy_a, dummy_b, dummy_c> tl;
448 
449  VERIFY((!!contained_in_list<is_same, dummy_a, tl>::value));
450  VERIFY((!!contained_in_list<is_same, dummy_b, tl>::value));
451  VERIFY((!!contained_in_list<is_same, dummy_c, tl>::value));
452  VERIFY((!contained_in_list<is_same, dummy_d, tl>::value));
453  VERIFY((!contained_in_list<is_same, dummy_e, tl>::value));
454 
455  VERIFY((!!contained_in_list_gf<dummy_test, dummy_a, tl>::value));
456  VERIFY((!!contained_in_list_gf<dummy_test, dummy_b, tl>::value));
457  VERIFY((!!contained_in_list_gf<dummy_test, dummy_c, tl>::value));
458  VERIFY((!contained_in_list_gf<dummy_test, dummy_d, tl>::value));
459  VERIFY((!contained_in_list_gf<dummy_test, dummy_e, tl>::value));
460 
461  VERIFY_IS_EQUAL(((int)contained_in_list_gf<dummy_test, dummy_a, tl>::global_flags), 1);
462  VERIFY_IS_EQUAL(((int)contained_in_list_gf<dummy_test, dummy_b, tl>::global_flags), 2);
463  VERIFY_IS_EQUAL(((int)contained_in_list_gf<dummy_test, dummy_c, tl>::global_flags), 4);
464  VERIFY_IS_EQUAL(((int)contained_in_list_gf<dummy_test, dummy_d, tl>::global_flags), 0);
465  VERIFY_IS_EQUAL(((int)contained_in_list_gf<dummy_test, dummy_e, tl>::global_flags), 0);
466 }
Eigen::internal::contained_in_list_gf
Definition: MoreMeta.h:296
Eigen::internal::contained_in_list
Definition: MoreMeta.h:276

References VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_gen_numeric_list()

static void test_gen_numeric_list ( )
static
255  {
256  VERIFY((is_same<typename gen_numeric_list<int, 0>::type, numeric_list<int>>::value));
257  VERIFY((is_same<typename gen_numeric_list<int, 1>::type, numeric_list<int, 0>>::value));
258  VERIFY((is_same<typename gen_numeric_list<int, 2>::type, numeric_list<int, 0, 1>>::value));
259  VERIFY((is_same<typename gen_numeric_list<int, 5>::type, numeric_list<int, 0, 1, 2, 3, 4>>::value));
260  VERIFY((is_same<typename gen_numeric_list<int, 10>::type, numeric_list<int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9>>::value));
261 
262  VERIFY((is_same<typename gen_numeric_list<int, 0, 42>::type, numeric_list<int>>::value));
263  VERIFY((is_same<typename gen_numeric_list<int, 1, 42>::type, numeric_list<int, 42>>::value));
264  VERIFY((is_same<typename gen_numeric_list<int, 2, 42>::type, numeric_list<int, 42, 43>>::value));
265  VERIFY((is_same<typename gen_numeric_list<int, 5, 42>::type, numeric_list<int, 42, 43, 44, 45, 46>>::value));
266  VERIFY((is_same<typename gen_numeric_list<int, 10, 42>::type,
267  numeric_list<int, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51>>::value));
268 
269  VERIFY((is_same<typename gen_numeric_list_reversed<int, 0>::type, numeric_list<int>>::value));
270  VERIFY((is_same<typename gen_numeric_list_reversed<int, 1>::type, numeric_list<int, 0>>::value));
271  VERIFY((is_same<typename gen_numeric_list_reversed<int, 2>::type, numeric_list<int, 1, 0>>::value));
272  VERIFY((is_same<typename gen_numeric_list_reversed<int, 5>::type, numeric_list<int, 4, 3, 2, 1, 0>>::value));
273  VERIFY((is_same<typename gen_numeric_list_reversed<int, 10>::type,
274  numeric_list<int, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0>>::value));
275 
276  VERIFY((is_same<typename gen_numeric_list_reversed<int, 0, 42>::type, numeric_list<int>>::value));
277  VERIFY((is_same<typename gen_numeric_list_reversed<int, 1, 42>::type, numeric_list<int, 42>>::value));
278  VERIFY((is_same<typename gen_numeric_list_reversed<int, 2, 42>::type, numeric_list<int, 43, 42>>::value));
279  VERIFY((is_same<typename gen_numeric_list_reversed<int, 5, 42>::type, numeric_list<int, 46, 45, 44, 43, 42>>::value));
280  VERIFY((is_same<typename gen_numeric_list_reversed<int, 10, 42>::type,
281  numeric_list<int, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42>>::value));
282 
283  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 0, 2, 3>::type, numeric_list<int>>::value));
284  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 1, 2, 3>::type, numeric_list<int, 0>>::value));
285  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 2, 2, 3>::type, numeric_list<int, 0, 1>>::value));
286  VERIFY(
287  (is_same<typename gen_numeric_list_swapped_pair<int, 5, 2, 3>::type, numeric_list<int, 0, 1, 3, 2, 4>>::value));
288  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 10, 2, 3>::type,
289  numeric_list<int, 0, 1, 3, 2, 4, 5, 6, 7, 8, 9>>::value));
290 
291  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 0, 44, 45, 42>::type, numeric_list<int>>::value));
292  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 1, 44, 45, 42>::type, numeric_list<int, 42>>::value));
293  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 2, 44, 45, 42>::type, numeric_list<int, 42, 43>>::value));
294  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 5, 44, 45, 42>::type,
295  numeric_list<int, 42, 43, 45, 44, 46>>::value));
296  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 10, 44, 45, 42>::type,
297  numeric_list<int, 42, 43, 45, 44, 46, 47, 48, 49, 50, 51>>::value));
298 
299  VERIFY((is_same<typename gen_numeric_list_repeated<int, 0, 0>::type, numeric_list<int>>::value));
300  VERIFY((is_same<typename gen_numeric_list_repeated<int, 1, 0>::type, numeric_list<int, 0>>::value));
301  VERIFY((is_same<typename gen_numeric_list_repeated<int, 2, 0>::type, numeric_list<int, 0, 0>>::value));
302  VERIFY((is_same<typename gen_numeric_list_repeated<int, 5, 0>::type, numeric_list<int, 0, 0, 0, 0, 0>>::value));
303  VERIFY((is_same<typename gen_numeric_list_repeated<int, 10, 0>::type,
304  numeric_list<int, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>>::value));
305 }
Eigen::internal::gen_numeric_list_repeated
Definition: MoreMeta.h:78
Eigen::internal::gen_numeric_list_reversed
Definition: MoreMeta.h:62
Eigen::internal::gen_numeric_list_swapped_pair
Definition: MoreMeta.h:71
Eigen::internal::gen_numeric_list
Definition: MoreMeta.h:55

References Eigen::value, and VERIFY.

Referenced by EIGEN_DECLARE_TEST().

◆ test_get()

static void test_get ( )
static
389  {
390  typedef type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c> tl;
391  typedef numeric_list<int, 4, 8, 15, 16, 23, 42> il;
392 
393  VERIFY((is_same<typename get<0, tl>::type, dummy_a>::value));
394  VERIFY((is_same<typename get<1, tl>::type, dummy_a>::value));
395  VERIFY((is_same<typename get<2, tl>::type, dummy_b>::value));
396  VERIFY((is_same<typename get<3, tl>::type, dummy_b>::value));
397  VERIFY((is_same<typename get<4, tl>::type, dummy_c>::value));
398  VERIFY((is_same<typename get<5, tl>::type, dummy_c>::value));
399 
400  VERIFY_IS_EQUAL(((int)get<0, il>::value), 4);
401  VERIFY_IS_EQUAL(((int)get<1, il>::value), 8);
402  VERIFY_IS_EQUAL(((int)get<2, il>::value), 15);
403  VERIFY_IS_EQUAL(((int)get<3, il>::value), 16);
404  VERIFY_IS_EQUAL(((int)get<4, il>::value), 23);
405  VERIFY_IS_EQUAL(((int)get<5, il>::value), 42);
406 }
Eigen::internal::get
Definition: MoreMeta.h:202
dummy_a
Definition: meta.cpp:170
dummy_b
Definition: meta.cpp:171
dummy_c
Definition: meta.cpp:172

References Eigen::value, VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_id()

static void test_id ( )
static
424  {
425  // don't call VERIFY here, just assume it works if it compiles
426  // (otherwise it will complain that it can't find the function)
427  test_id_numeric<1, 4, 6>();
428  test_id_type<dummy_a, dummy_b, dummy_c>();
429 }

Referenced by EIGEN_DECLARE_TEST().

◆ test_id_helper()

static void test_id_helper ( dummy_a  a,
dummy_a  b,
dummy_a  c 
)
static
408  {
409  (void)a;
410  (void)b;
411  (void)c;
412 }

References a, b, and calibrate::c.

Referenced by test_id_numeric(), and test_id_type().

◆ test_id_numeric()

template<int... ii>
static void test_id_numeric ( )
static
415  {
416  test_id_helper(typename id_numeric<int, ii, dummy_a>::type()...);
417 }
test_id_helper
static void test_id_helper(dummy_a a, dummy_a b, dummy_a c)
Definition: meta.cpp:408
Eigen::internal::id_numeric
Definition: MoreMeta.h:226

References test_id_helper().

◆ test_id_type()

template<typename... tt>
static void test_id_type ( )
static
420  {
421  test_id_helper(typename id_type<tt, dummy_a>::type()...);
422 }
Eigen::internal::id_type
Definition: MoreMeta.h:230

References test_id_helper().

◆ test_is_same_gf()

static void test_is_same_gf ( )
static
431  {
432  VERIFY((!is_same_gf<dummy_a, dummy_b>::value));
433  VERIFY((!!is_same_gf<dummy_a, dummy_a>::value));
434  VERIFY_IS_EQUAL((!!is_same_gf<dummy_a, dummy_b>::global_flags), false);
435  VERIFY_IS_EQUAL((!!is_same_gf<dummy_a, dummy_a>::global_flags), false);
436 }
Eigen::internal::is_same_gf
Definition: MoreMeta.h:237

References VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_slice()

static void test_slice ( )
static
347  {
348  typedef type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c> tl;
349  typedef numeric_list<int, 0, 1, 2, 3, 4, 5> il;
350 
351  VERIFY((is_same<typename take<0, tl>::type, type_list<>>::value));
352  VERIFY((is_same<typename take<1, tl>::type, type_list<dummy_a>>::value));
353  VERIFY((is_same<typename take<2, tl>::type, type_list<dummy_a, dummy_a>>::value));
354  VERIFY((is_same<typename take<3, tl>::type, type_list<dummy_a, dummy_a, dummy_b>>::value));
355  VERIFY((is_same<typename take<4, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b>>::value));
356  VERIFY((is_same<typename take<5, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c>>::value));
357  VERIFY((is_same<typename take<6, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
358 
359  VERIFY((is_same<typename take<0, il>::type, numeric_list<int>>::value));
360  VERIFY((is_same<typename take<1, il>::type, numeric_list<int, 0>>::value));
361  VERIFY((is_same<typename take<2, il>::type, numeric_list<int, 0, 1>>::value));
362  VERIFY((is_same<typename take<3, il>::type, numeric_list<int, 0, 1, 2>>::value));
363  VERIFY((is_same<typename take<4, il>::type, numeric_list<int, 0, 1, 2, 3>>::value));
364  VERIFY((is_same<typename take<5, il>::type, numeric_list<int, 0, 1, 2, 3, 4>>::value));
365  VERIFY((is_same<typename take<6, il>::type, numeric_list<int, 0, 1, 2, 3, 4, 5>>::value));
366 
367  VERIFY((is_same<typename skip<0, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
368  VERIFY((is_same<typename skip<1, tl>::type, type_list<dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
369  VERIFY((is_same<typename skip<2, tl>::type, type_list<dummy_b, dummy_b, dummy_c, dummy_c>>::value));
370  VERIFY((is_same<typename skip<3, tl>::type, type_list<dummy_b, dummy_c, dummy_c>>::value));
371  VERIFY((is_same<typename skip<4, tl>::type, type_list<dummy_c, dummy_c>>::value));
372  VERIFY((is_same<typename skip<5, tl>::type, type_list<dummy_c>>::value));
373  VERIFY((is_same<typename skip<6, tl>::type, type_list<>>::value));
374 
375  VERIFY((is_same<typename skip<0, il>::type, numeric_list<int, 0, 1, 2, 3, 4, 5>>::value));
376  VERIFY((is_same<typename skip<1, il>::type, numeric_list<int, 1, 2, 3, 4, 5>>::value));
377  VERIFY((is_same<typename skip<2, il>::type, numeric_list<int, 2, 3, 4, 5>>::value));
378  VERIFY((is_same<typename skip<3, il>::type, numeric_list<int, 3, 4, 5>>::value));
379  VERIFY((is_same<typename skip<4, il>::type, numeric_list<int, 4, 5>>::value));
380  VERIFY((is_same<typename skip<5, il>::type, numeric_list<int, 5>>::value));
381  VERIFY((is_same<typename skip<6, il>::type, numeric_list<int>>::value));
382 
383  VERIFY((is_same<typename slice<0, 3, tl>::type, typename take<3, tl>::type>::value));
384  VERIFY((is_same<typename slice<0, 3, il>::type, typename take<3, il>::type>::value));
385  VERIFY((is_same<typename slice<1, 3, tl>::type, type_list<dummy_a, dummy_b, dummy_b>>::value));
386  VERIFY((is_same<typename slice<1, 3, il>::type, numeric_list<int, 1, 2, 3>>::value));
387 }
Eigen::internal::skip
Definition: MoreMeta.h:192
Eigen::internal::slice
Definition: MoreMeta.h:197
Eigen::internal::take
Definition: MoreMeta.h:112

References Eigen::value, and VERIFY.

Referenced by EIGEN_DECLARE_TEST().