From 5e28c41549c5e71011bb9312104d1d30e919e53f Mon Sep 17 00:00:00 2001 From: Christian Seiler Date: Thu, 14 Nov 2013 22:27:06 +0100 Subject: C++11: add template metaprogramming helpers Create a new directory CXX11 under unsupported/Eigen that contains code that requires C++11. In that directory, add a few generic templates useful for any module relying on C++11. These templates may be included with #include <[unsupported/]Eigen/CXX11/Core>. At the moment, this will only provide templates in the Eigen::internal namespace. --- unsupported/Eigen/CXX11/Core | 41 ++ unsupported/Eigen/CXX11/src/Core/util/CXX11Meta.h | 504 +++++++++++++++++++++ .../Eigen/CXX11/src/Core/util/CXX11Workarounds.h | 104 +++++ unsupported/test/CMakeLists.txt | 8 + unsupported/test/cxx11_meta.cpp | 343 ++++++++++++++ 5 files changed, 1000 insertions(+) create mode 100644 unsupported/Eigen/CXX11/Core create mode 100644 unsupported/Eigen/CXX11/src/Core/util/CXX11Meta.h create mode 100644 unsupported/Eigen/CXX11/src/Core/util/CXX11Workarounds.h create mode 100644 unsupported/test/cxx11_meta.cpp diff --git a/unsupported/Eigen/CXX11/Core b/unsupported/Eigen/CXX11/Core new file mode 100644 index 000000000..1b1f1dcc1 --- /dev/null +++ b/unsupported/Eigen/CXX11/Core @@ -0,0 +1,41 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CXX11_CORE_MODULE +#define EIGEN_CXX11_CORE_MODULE + +#include + +#include + +/** \defgroup CXX11_Core_Module C++11 Core Module + * + * This module provides common core features for all modules that + * explicitly depend on C++11. Currently, this is only the Tensor + * module. Note that at this stage, you should not need to include + * this module directly. + * + * \code + * #include + * \endcode + */ + +#include + +#include "src/Core/util/CXX11Workarounds.h" +#include "src/Core/util/CXX11Meta.h" + +#include + +#endif // EIGEN_CXX11_CORE_MODULE + +/* + * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle; + */ diff --git a/unsupported/Eigen/CXX11/src/Core/util/CXX11Meta.h b/unsupported/Eigen/CXX11/src/Core/util/CXX11Meta.h new file mode 100644 index 000000000..55d3cc37b --- /dev/null +++ b/unsupported/Eigen/CXX11/src/Core/util/CXX11Meta.h @@ -0,0 +1,504 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CXX11META_H +#define EIGEN_CXX11META_H + +namespace Eigen { + +namespace internal { + +/** \internal + * \file CXX11/Core/util/CXX11Meta.h + * This file contains generic metaprogramming classes which are not specifically related to Eigen. + * This file expands upon Core/util/Meta.h and adds support for C++11 specific features. + */ + +template +struct type_list { constexpr static int count = sizeof...(tt); }; + +template +struct type_list { constexpr static int count = sizeof...(tt) + 1; typedef t first_type; }; + +template +struct numeric_list { constexpr static std::size_t count = sizeof...(nn); }; + +template +struct numeric_list { constexpr static std::size_t count = sizeof...(nn) + 1; constexpr static T first_value = n; }; + +/* numeric list constructors + * + * equivalencies: + * constructor result + * typename gen_numeric_list::type numeric_list + * typename gen_numeric_list_reversed::type numeric_list + * typename gen_numeric_list_swapped_pair::type numeric_list + * typename gen_numeric_list_repeated::type numeric_list + */ + +template struct gen_numeric_list : gen_numeric_list {}; +template struct gen_numeric_list { typedef numeric_list type; }; + +template struct gen_numeric_list_reversed : gen_numeric_list_reversed {}; +template struct gen_numeric_list_reversed { typedef numeric_list type; }; + +template struct gen_numeric_list_swapped_pair : gen_numeric_list_swapped_pair {}; +template struct gen_numeric_list_swapped_pair { typedef numeric_list type; }; + +template struct gen_numeric_list_repeated : gen_numeric_list_repeated {}; +template struct gen_numeric_list_repeated { typedef numeric_list type; }; + +/* list manipulation: concatenate */ + +template struct concat; + +template struct concat, type_list> { typedef type_list type; }; +template struct concat, numeric_list > { typedef numeric_list type; }; + +template struct mconcat; +template struct mconcat { typedef a type; }; +template struct mconcat : concat {}; +template struct mconcat : concat::type> {}; + +/* list manipulation: extract slices */ + +template struct take; +template struct take> : concat, typename take>::type> {}; +template struct take> { typedef type_list<> type; }; +template struct take<0, type_list> { typedef type_list<> type; }; +template<> struct take<0, type_list<>> { typedef type_list<> type; }; + +template struct take> : concat, typename take>::type> {}; +template struct take> { typedef numeric_list type; }; +template struct take<0, numeric_list> { typedef numeric_list type; }; +template struct take<0, numeric_list> { typedef numeric_list type; }; + +template struct h_skip_helper_numeric; +template struct h_skip_helper_numeric : h_skip_helper_numeric {}; +template struct h_skip_helper_numeric { typedef numeric_list type; }; +template struct h_skip_helper_numeric { typedef numeric_list type; }; +template struct h_skip_helper_numeric { typedef numeric_list type; }; + +template struct h_skip_helper_type; +template struct h_skip_helper_type : h_skip_helper_type {}; +template struct h_skip_helper_type<0, t, tt...> { typedef type_list type; }; +template struct h_skip_helper_type { typedef type_list<> type; }; +template<> struct h_skip_helper_type<0> { typedef type_list<> type; }; + +template +struct h_skip { + template + constexpr static inline typename h_skip_helper_numeric::type helper(numeric_list) { return typename h_skip_helper_numeric::type(); } + template + constexpr static inline typename h_skip_helper_type::type helper(type_list) { return typename h_skip_helper_type::type(); } +}; + +template struct skip { typedef decltype(h_skip::helper(a())) type; }; + +template struct slice : take::type> {}; + +/* list manipulation: retrieve single element from list */ + +template struct get; + +template struct get> : get> {}; +template struct get<0, type_list> { typedef a type; }; +template struct get> { static_assert((n - n) < 0, "meta-template get: The element to extract from a list must be smaller than the size of the list."); }; + +template struct get> : get> {}; +template struct get<0, numeric_list> { constexpr static int value = a; }; +template struct get> { static_assert((n - n) < 0, "meta-template get: The element to extract from a list must be smaller than the size of the list."); }; + +/* always get type, regardless of dummy; good for parameter pack expansion */ + +template struct id_numeric { typedef t type; }; +template struct id_type { typedef t type; }; + +/* equality checking, flagged version */ + +template struct is_same_gf : is_same { constexpr static int global_flags = 0; }; + +/* apply_op to list */ + +template< + bool from_left, // false + template class op, + typename additional_param, + typename... values +> +struct h_apply_op_helper { typedef type_list::type...> type; }; +template< + template class op, + typename additional_param, + typename... values +> +struct h_apply_op_helper { typedef type_list::type...> type; }; + +template< + bool from_left, + template class op, + typename additional_param +> +struct h_apply_op +{ + template + constexpr static typename h_apply_op_helper::type helper(type_list) + { return typename h_apply_op_helper::type(); } +}; + +template< + template class op, + typename additional_param, + typename a +> +struct apply_op_from_left { typedef decltype(h_apply_op::helper(a())) type; }; + +template< + template class op, + typename additional_param, + typename a +> +struct apply_op_from_right { typedef decltype(h_apply_op::helper(a())) type; }; + +/* see if an element is in a list */ + +template< + template class test, + typename check_against, + typename h_list, + bool last_check_positive = false +> +struct contained_in_list; + +template< + template class test, + typename check_against, + typename h_list +> +struct contained_in_list +{ + constexpr static bool value = true; +}; + +template< + template class test, + typename check_against, + typename a, + typename... as +> +struct contained_in_list, false> : contained_in_list, test::value> {}; + +template< + template class test, + typename check_against + EIGEN_TPL_PP_SPEC_HACK_DEFC(typename, empty) +> +struct contained_in_list, false> { constexpr static bool value = false; }; + +/* see if an element is in a list and check for global flags */ + +template< + template class test, + typename check_against, + typename h_list, + int default_flags = 0, + bool last_check_positive = false, + int last_check_flags = default_flags +> +struct contained_in_list_gf; + +template< + template class test, + typename check_against, + typename h_list, + int default_flags, + int last_check_flags +> +struct contained_in_list_gf +{ + constexpr static bool value = true; + constexpr static int global_flags = last_check_flags; +}; + +template< + template class test, + typename check_against, + typename a, + typename... as, + int default_flags, + int last_check_flags +> +struct contained_in_list_gf, default_flags, false, last_check_flags> : contained_in_list_gf, default_flags, test::value, test::global_flags> {}; + +template< + template class test, + typename check_against + EIGEN_TPL_PP_SPEC_HACK_DEFC(typename, empty), + int default_flags, + int last_check_flags +> +struct contained_in_list_gf, default_flags, false, last_check_flags> { constexpr static bool value = false; constexpr static int global_flags = default_flags; }; + +/* generic reductions */ + +template< + typename Reducer, + typename... Ts +> struct reduce; + +template< + typename Reducer, + typename A, + typename... Ts +> struct reduce +{ + constexpr static inline A run(A a, Ts...) { return a; } +}; + +template< + typename Reducer, + typename A, + typename B, + typename... Ts +> struct reduce +{ + constexpr static inline auto run(A a, B b, Ts... ts) -> decltype(Reducer::run(a, reduce::run(b, ts...))) { + return Reducer::run(a, reduce::run(b, ts...)); + } +}; + +/* generic binary operations */ + +struct sum_op { template constexpr static inline auto run(A a, B b) -> decltype(a + b) { return a + b; } }; +struct product_op { template constexpr static inline auto run(A a, B b) -> decltype(a * b) { return a * b; } }; + +struct logical_and_op { template constexpr static inline auto run(A a, B b) -> decltype(a && b) { return a && b; } }; +struct logical_or_op { template constexpr static inline auto run(A a, B b) -> decltype(a || b) { return a || b; } }; + +struct equal_op { template constexpr static inline auto run(A a, B b) -> decltype(a == b) { return a == b; } }; +struct not_equal_op { template constexpr static inline auto run(A a, B b) -> decltype(a != b) { return a != b; } }; +struct lesser_op { template constexpr static inline auto run(A a, B b) -> decltype(a < b) { return a < b; } }; +struct lesser_equal_op { template constexpr static inline auto run(A a, B b) -> decltype(a <= b) { return a <= b; } }; +struct greater_op { template constexpr static inline auto run(A a, B b) -> decltype(a < b) { return a < b; } }; +struct greater_equal_op { template constexpr static inline auto run(A a, B b) -> decltype(a >= b) { return a >= b; } }; + +/* generic unary operations */ + +struct not_op { template constexpr static inline auto run(A a) -> decltype(!a) { return !a; } }; +struct negation_op { template constexpr static inline auto run(A a) -> decltype(-a) { return -a; } }; +struct greater_equal_zero_op { template constexpr static inline auto run(A a) -> decltype(a >= 0) { return a >= 0; } }; + + +/* reductions for lists */ + +// using auto -> return value spec makes ICC 13.0 and 13.1 crash here, so we have to hack it +// together in front... (13.0 doesn't work with array_prod/array_reduce/... anyway, but 13.1 +// does... +template +constexpr inline decltype(reduce::run((*((Ts*)0))...)) arg_prod(Ts... ts) +{ + return reduce::run(ts...); +} + +template +constexpr inline decltype(reduce::run((*((Ts*)0))...)) arg_sum(Ts... ts) +{ + return reduce::run(ts...); +} + +/* reverse arrays */ + +template +constexpr inline Array h_array_reverse(Array arr, numeric_list) +{ + return {{std_array_get(arr)...}}; +} + +template +constexpr inline std::array array_reverse(std::array arr) +{ + return h_array_reverse(arr, typename gen_numeric_list::type()); +} + +/* generic array reductions */ + +// can't reuse standard reduce() interface above because Intel's Compiler +// *really* doesn't like it, so we just reimplement the stuff +// (start from N - 1 and work down to 0 because specialization for +// n == N - 1 also doesn't work in Intel's compiler, so it goes into +// an infinite loop) +template +struct h_array_reduce { + constexpr static inline auto run(std::array arr) -> decltype(Reducer::run(h_array_reduce::run(arr), std_array_get(arr))) + { + return Reducer::run(h_array_reduce::run(arr), std_array_get(arr)); + } +}; + +template +struct h_array_reduce +{ + constexpr static inline T run(std::array arr) + { + return std_array_get<0>(arr); + } +}; + +template +constexpr inline auto array_reduce(std::array arr) -> decltype(h_array_reduce::run(arr)) +{ + return h_array_reduce::run(arr); +} + +/* standard array reductions */ + +template +constexpr inline auto array_sum(std::array arr) -> decltype(array_reduce(arr)) +{ + return array_reduce(arr); +} + +template +constexpr inline auto array_prod(std::array arr) -> decltype(array_reduce(arr)) +{ + return array_reduce(arr); +} + +/* zip an array */ + +template +constexpr inline std::array h_array_zip(std::array a, std::array b, numeric_list) +{ + return std::array{{ Op::run(std_array_get(a), std_array_get(b))... }}; +} + +template +constexpr inline std::array array_zip(std::array a, std::array b) +{ + return h_array_zip(a, b, typename gen_numeric_list::type()); +} + +/* zip an array and reduce the result */ + +template +constexpr inline auto h_array_zip_and_reduce(std::array a, std::array b, numeric_list) -> decltype(reduce::type...>::run(Op::run(std_array_get(a), std_array_get(b))...)) +{ + return reduce::type...>::run(Op::run(std_array_get(a), std_array_get(b))...); +} + +template +constexpr inline auto array_zip_and_reduce(std::array a, std::array b) -> decltype(h_array_zip_and_reduce(a, b, typename gen_numeric_list::type())) +{ + return h_array_zip_and_reduce(a, b, typename gen_numeric_list::type()); +} + +/* apply stuff to an array */ + +template +constexpr inline std::array h_array_apply(std::array a, numeric_list) +{ + return std::array{{ Op::run(std_array_get(a))... }}; +} + +template +constexpr inline std::array array_apply(std::array a) +{ + return h_array_apply(a, typename gen_numeric_list::type()); +} + +/* apply stuff to an array and reduce */ + +template +constexpr inline auto h_array_apply_and_reduce(std::array arr, numeric_list) -> decltype(reduce::type...>::run(Op::run(std_array_get(arr))...)) +{ + return reduce::type...>::run(Op::run(std_array_get(arr))...); +} + +template +constexpr inline auto array_apply_and_reduce(std::array a) -> decltype(h_array_apply_and_reduce(a, typename gen_numeric_list::type())) +{ + return h_array_apply_and_reduce(a, typename gen_numeric_list::type()); +} + +/* repeat a value n times (and make an array out of it + * usage: + * std::array = repeat<16>(42); + */ + +template +struct h_repeat +{ + template + constexpr static inline std::array run(t v, numeric_list) + { + return {{ typename id_numeric::type(v)... }}; + } +}; + +template +constexpr std::array repeat(t v) { return h_repeat::run(v, typename gen_numeric_list::type()); } + +/* instantiate a class by a C-style array */ +template +struct h_instantiate_by_c_array; + +template +struct h_instantiate_by_c_array +{ + static InstType run(ArrType* arr, Ps... args) + { + return h_instantiate_by_c_array::run(arr + 1, args..., arr[0]); + } +}; + +template +struct h_instantiate_by_c_array +{ + static InstType run(ArrType* arr, Ps... args) + { + return h_instantiate_by_c_array::run(arr + 1, arr[0], args...); + } +}; + +template +struct h_instantiate_by_c_array +{ + static InstType run(ArrType* arr, Ps... args) + { + (void)arr; + return InstType(args...); + } +}; + +template +struct h_instantiate_by_c_array +{ + static InstType run(ArrType* arr, Ps... args) + { + (void)arr; + return InstType(args...); + } +}; + +template +InstType instantiate_by_c_array(ArrType* arr) +{ + return h_instantiate_by_c_array::run(arr); +} + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_CXX11META_H + +/* + * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle; + */ diff --git a/unsupported/Eigen/CXX11/src/Core/util/CXX11Workarounds.h b/unsupported/Eigen/CXX11/src/Core/util/CXX11Workarounds.h new file mode 100644 index 000000000..eec38b343 --- /dev/null +++ b/unsupported/Eigen/CXX11/src/Core/util/CXX11Workarounds.h @@ -0,0 +1,104 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CXX11WORKAROUNDS_H +#define EIGEN_CXX11WORKAROUNDS_H + +/* COMPATIBILITY CHECKS + * (so users of compilers that are too old get some realistic error messages) + */ +#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER < 1310) +#error Intel Compiler only supports required C++ features since version 13.1. +// note that most stuff in principle works with 13.0 but when combining +// some features, at some point 13.0 will just fail with an internal assertion +#elif defined(__clang__) && (__clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 1)) +// note that it _should_ work with 3.1 but it was only tested with 3.2 +#error Clang C++ Compiler (clang++) only supports required C++ features since version 3.1. +#elif defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)) +// G++ < 4.6 by default will continue processing the source files - even if we use #error to make +// it error out. For this reason, we use the pragma to make sure G++ aborts at the first error +// it sees. Unfortunately, that is still not our #error directive, but at least the output is +// short enough the user has a chance to see that the compiler version is not sufficient for +// the funky template mojo we use. +#pragma GCC diagnostic error "-Wfatal-errors" +#error GNU C++ Compiler (g++) only supports required C++ features since version 4.6. +#endif + +/* Check that the compiler at least claims to support C++11. It might not be sufficient + * because the compiler may not implement it correctly, but at least we'll know. + */ +#if __cplusplus <= 199711L +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) +#pragma GCC diagnostic error "-Wfatal-errors" +#endif +#error This library needs at least a C++11 compliant compiler. If you use g++/clang, please enable the -std=c++11 compiler flag. (-std=c++0x on older versions.) +#endif + +namespace Eigen { + +namespace internal { + +/* std::get is only constexpr in C++14, not yet in C++11 + * - libstdc++ from version 4.7 onwards has it nevertheless, + * so use that + * - libstdc++ older versions: use _M_instance directly + * - libc++ all versions so far: use __elems_ directly + * - all other libs: use std::get to be portable, but + * this may not be constexpr + */ +#if defined(__GLIBCXX__) && __GLIBCXX__ < 20120322 +#define STD_GET_ARR_HACK a._M_instance[I] +#elif defined(_LIBCPP_VERSION) +#define STD_GET_ARR_HACK a.__elems_[I] +#else +#define STD_GET_ARR_HACK std::template get(a) +#endif + +template constexpr inline T& std_array_get(std::array& a) { return (T&) STD_GET_ARR_HACK; } +template constexpr inline T&& std_array_get(std::array&& a) { return (T&&) STD_GET_ARR_HACK; } +template constexpr inline T const& std_array_get(std::array const& a) { return (T const&) STD_GET_ARR_HACK; } + +#undef STD_GET_ARR_HACK + +/* Suppose you have a template of the form + * template struct X; + * And you want to specialize it in such a way: + * template struct X> { ::: }; + * template<> struct X> { ::: }; + * This will work in Intel's compiler 13.0, but only to some extent in g++ 4.6, since + * g++ can only match templates called with parameter packs if the number of template + * arguments is not a fixed size (so inside the first specialization, referencing + * X> will fail in g++). On the other hand, g++ will accept the following: + * template struct X> { ::: }: + * as an additional (!) specialization, which will then only match the empty case. + * But Intel's compiler 13.0 won't accept that, it will only accept the empty syntax, + * so we have to create a workaround for this. + */ +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +#define EIGEN_TPL_PP_SPEC_HACK_DEF(mt, n) mt... n +#define EIGEN_TPL_PP_SPEC_HACK_DEFC(mt, n) , EIGEN_TPL_PP_SPEC_HACK_DEF(mt, n) +#define EIGEN_TPL_PP_SPEC_HACK_USE(n) n... +#define EIGEN_TPL_PP_SPEC_HACK_USEC(n) , n... +#else +#define EIGEN_TPL_PP_SPEC_HACK_DEF(mt, n) +#define EIGEN_TPL_PP_SPEC_HACK_DEFC(mt, n) +#define EIGEN_TPL_PP_SPEC_HACK_USE(n) +#define EIGEN_TPL_PP_SPEC_HACK_USEC(n) +#endif + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_CXX11WORKAROUNDS_H + +/* + * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle; + */ diff --git a/unsupported/test/CMakeLists.txt b/unsupported/test/CMakeLists.txt index 38c89a234..841cab9d7 100644 --- a/unsupported/test/CMakeLists.txt +++ b/unsupported/test/CMakeLists.txt @@ -92,3 +92,11 @@ ei_add_test(gmres) ei_add_test(minres) ei_add_test(levenberg_marquardt) ei_add_test(bdcsvd) + +option(EIGEN_TEST_CXX11 "Enable testing of C++11 features (e.g. Tensor module)." OFF) +if(EIGEN_TEST_CXX11) + # FIXME: add C++11 compiler switch in some portable way + # (MSVC doesn't need any for example, so this will + # clash there) + ei_add_test(cxx11_meta "-std=c++0x") +endif() diff --git a/unsupported/test/cxx11_meta.cpp b/unsupported/test/cxx11_meta.cpp new file mode 100644 index 000000000..03a9efe54 --- /dev/null +++ b/unsupported/test/cxx11_meta.cpp @@ -0,0 +1,343 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include "main.h" + +#include + +using Eigen::internal::is_same; +using Eigen::internal::type_list; +using Eigen::internal::numeric_list; +using Eigen::internal::gen_numeric_list; +using Eigen::internal::gen_numeric_list_reversed; +using Eigen::internal::gen_numeric_list_swapped_pair; +using Eigen::internal::gen_numeric_list_repeated; +using Eigen::internal::concat; +using Eigen::internal::mconcat; +using Eigen::internal::take; +using Eigen::internal::skip; +using Eigen::internal::slice; +using Eigen::internal::get; +using Eigen::internal::id_numeric; +using Eigen::internal::id_type; +using Eigen::internal::is_same_gf; +using Eigen::internal::apply_op_from_left; +using Eigen::internal::apply_op_from_right; +using Eigen::internal::contained_in_list; +using Eigen::internal::contained_in_list_gf; +using Eigen::internal::arg_prod; +using Eigen::internal::arg_sum; +using Eigen::internal::sum_op; +using Eigen::internal::product_op; +using Eigen::internal::array_reverse; +using Eigen::internal::array_sum; +using Eigen::internal::array_prod; +using Eigen::internal::array_reduce; +using Eigen::internal::array_zip; +using Eigen::internal::array_zip_and_reduce; +using Eigen::internal::array_apply; +using Eigen::internal::array_apply_and_reduce; +using Eigen::internal::repeat; +using Eigen::internal::instantiate_by_c_array; + +struct dummy_a {}; +struct dummy_b {}; +struct dummy_c {}; +struct dummy_d {}; +struct dummy_e {}; + +// dummy operation for testing apply +template struct dummy_op; +template<> struct dummy_op { typedef dummy_c type; }; +template<> struct dummy_op { typedef dummy_d type; }; +template<> struct dummy_op { typedef dummy_a type; }; +template<> struct dummy_op { typedef dummy_d type; }; +template<> struct dummy_op { typedef dummy_b type; }; +template<> struct dummy_op { typedef dummy_d type; }; +template<> struct dummy_op { typedef dummy_e type; }; +template<> struct dummy_op { typedef dummy_e type; }; +template<> struct dummy_op { typedef dummy_e type; }; + +template struct dummy_test { constexpr static bool value = false; constexpr static int global_flags = 0; }; +template<> struct dummy_test { constexpr static bool value = true; constexpr static int global_flags = 1; }; +template<> struct dummy_test { constexpr static bool value = true; constexpr static int global_flags = 2; }; +template<> struct dummy_test { constexpr static bool value = true; constexpr static int global_flags = 4; }; + +struct times2_op { template static A run(A v) { return v * 2; } }; + +struct dummy_inst +{ + int c; + + dummy_inst() : c(0) {} + explicit dummy_inst(int) : c(1) {} + dummy_inst(int, int) : c(2) {} + dummy_inst(int, int, int) : c(3) {} + dummy_inst(int, int, int, int) : c(4) {} + dummy_inst(int, int, int, int, int) : c(5) {} +}; + +static void test_gen_numeric_list() +{ + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); +} + +static void test_concat() +{ + VERIFY((is_same, type_list<>>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + + VERIFY((is_same>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + VERIFY((is_same, type_list>::type, type_list>::value)); + + VERIFY((is_same>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); + VERIFY((is_same, numeric_list>::type, numeric_list>::value)); +} + +static void test_slice() +{ + typedef type_list tl; + typedef numeric_list il; + + VERIFY((is_same::type, type_list<>>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, type_list<>>::value)); + + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); + + VERIFY((is_same::type, typename take<3, tl>::type>::value)); + VERIFY((is_same::type, typename take<3, il>::type>::value)); + VERIFY((is_same::type, type_list>::value)); + VERIFY((is_same::type, numeric_list>::value)); +} + +static void test_get() +{ + typedef type_list tl; + typedef numeric_list il; + + VERIFY((is_same::type, dummy_a>::value)); + VERIFY((is_same::type, dummy_a>::value)); + VERIFY((is_same::type, dummy_b>::value)); + VERIFY((is_same::type, dummy_b>::value)); + VERIFY((is_same::type, dummy_c>::value)); + VERIFY((is_same::type, dummy_c>::value)); + + VERIFY_IS_EQUAL(((int)get<0, il>::value), 4); + VERIFY_IS_EQUAL(((int)get<1, il>::value), 8); + VERIFY_IS_EQUAL(((int)get<2, il>::value), 15); + VERIFY_IS_EQUAL(((int)get<3, il>::value), 16); + VERIFY_IS_EQUAL(((int)get<4, il>::value), 23); + VERIFY_IS_EQUAL(((int)get<5, il>::value), 42); +} + +static void test_id_helper(dummy_a a, dummy_a b, dummy_a c) +{ + (void)a; + (void)b; + (void)c; +} + +template +static void test_id_numeric() +{ + test_id_helper(typename id_numeric::type()...); +} + +template +static void test_id_type() +{ + test_id_helper(typename id_type::type()...); +} + +static void test_id() +{ + // don't call VERIFY here, just assume it works if it compiles + // (otherwise it will complain that it can't find the function) + test_id_numeric<1, 4, 6>(); + test_id_type(); +} + +static void test_is_same_gf() +{ + VERIFY((!is_same_gf::value)); + VERIFY((!!is_same_gf::value)); + VERIFY_IS_EQUAL((!!is_same_gf::global_flags), 0); + VERIFY_IS_EQUAL((!!is_same_gf::global_flags), 0); +} + +static void test_apply_op() +{ + typedef type_list tl; + VERIFY((!!is_same::type, type_list>::value)); + VERIFY((!!is_same::type, type_list>::value)); +} + +static void test_contained_in_list() +{ + typedef type_list tl; + + VERIFY((!!contained_in_list::value)); + VERIFY((!!contained_in_list::value)); + VERIFY((!!contained_in_list::value)); + VERIFY((!contained_in_list::value)); + VERIFY((!contained_in_list::value)); + + VERIFY((!!contained_in_list_gf::value)); + VERIFY((!!contained_in_list_gf::value)); + VERIFY((!!contained_in_list_gf::value)); + VERIFY((!contained_in_list_gf::value)); + VERIFY((!contained_in_list_gf::value)); + + VERIFY_IS_EQUAL(((int)contained_in_list_gf::global_flags), 1); + VERIFY_IS_EQUAL(((int)contained_in_list_gf::global_flags), 2); + VERIFY_IS_EQUAL(((int)contained_in_list_gf::global_flags), 4); + VERIFY_IS_EQUAL(((int)contained_in_list_gf::global_flags), 0); + VERIFY_IS_EQUAL(((int)contained_in_list_gf::global_flags), 0); +} + +static void test_arg_reductions() +{ + VERIFY_IS_EQUAL(arg_sum(1,2,3,4), 10); + VERIFY_IS_EQUAL(arg_prod(1,2,3,4), 24); + VERIFY_IS_APPROX(arg_sum(0.5, 2, 5), 7.5); + VERIFY_IS_APPROX(arg_prod(0.5, 2, 5), 5.0); +} + +static void test_array_reverse_and_reduce() +{ + std::array a{{4, 8, 15, 16, 23, 42}}; + std::array b{{42, 23, 16, 15, 8, 4}}; + + // there is no operator<< for std::array, so VERIFY_IS_EQUAL will + // not compile + VERIFY((array_reverse(a) == b)); + VERIFY((array_reverse(b) == a)); + VERIFY_IS_EQUAL((array_sum(a)), 108); + VERIFY_IS_EQUAL((array_sum(b)), 108); + VERIFY_IS_EQUAL((array_prod(a)), 7418880); + VERIFY_IS_EQUAL((array_prod(b)), 7418880); +} + +static void test_array_zip_and_apply() +{ + std::array a{{4, 8, 15, 16, 23, 42}}; + std::array b{{0, 1, 2, 3, 4, 5}}; + std::array c{{4, 9, 17, 19, 27, 47}}; + std::array d{{0, 8, 30, 48, 92, 210}}; + std::array e{{0, 2, 4, 6, 8, 10}}; + + VERIFY((array_zip(a, b) == c)); + VERIFY((array_zip(a, b) == d)); + VERIFY((array_apply(b) == e)); + VERIFY_IS_EQUAL((array_apply_and_reduce(a)), 216); + VERIFY_IS_EQUAL((array_apply_and_reduce(b)), 30); + VERIFY_IS_EQUAL((array_zip_and_reduce(a, b)), 14755932); + VERIFY_IS_EQUAL((array_zip_and_reduce(a, b)), 388); +} + +static void test_array_misc() +{ + std::array a3{{1, 1, 1}}; + std::array a6{{2, 2, 2, 2, 2, 2}}; + VERIFY((repeat<3, int>(1) == a3)); + VERIFY((repeat<6, int>(2) == a6)); + + int data[5] = { 0, 1, 2, 3, 4 }; + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 0); + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 1); + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 2); + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 3); + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 4); + VERIFY_IS_EQUAL((instantiate_by_c_array(data).c), 5); +} + +void test_cxx11_meta() +{ + CALL_SUBTEST(test_gen_numeric_list()); + CALL_SUBTEST(test_concat()); + CALL_SUBTEST(test_slice()); + CALL_SUBTEST(test_get()); + CALL_SUBTEST(test_id()); + CALL_SUBTEST(test_is_same_gf()); + CALL_SUBTEST(test_apply_op()); + CALL_SUBTEST(test_contained_in_list()); + CALL_SUBTEST(test_arg_reductions()); + CALL_SUBTEST(test_array_reverse_and_reduce()); + CALL_SUBTEST(test_array_zip_and_apply()); + CALL_SUBTEST(test_array_misc()); +} + +/* + * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle; + */ -- cgit v1.2.3