mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
77 lines
3.4 KiB
C++
77 lines
3.4 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
|
|
//
|
|
// 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(__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
|
|
|
|
namespace Eigen {
|
|
|
|
namespace internal {
|
|
|
|
/* std::get is only constexpr in C++14, not yet in C++11
|
|
*/
|
|
|
|
|
|
template<std::size_t I_, class T> constexpr inline T& array_get(std::vector<T>& a) { return a[I_]; }
|
|
template<std::size_t I_, class T> constexpr inline T&& array_get(std::vector<T>&& a) { return a[I_]; }
|
|
template<std::size_t I_, class T> constexpr inline T const& array_get(std::vector<T> const& a) { return a[I_]; }
|
|
|
|
/* Suppose you have a template of the form
|
|
* template<typename T> struct X;
|
|
* And you want to specialize it in such a way:
|
|
* template<typename S1, typename... SN> struct X<Foo<S1, SN...>> { ::: };
|
|
* template<> struct X<Foo<>> { ::: };
|
|
* 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<Foo<Sn...>> will fail in g++). On the other hand, g++ will accept the following:
|
|
* template<typename S...> struct X<Foo<S...>> { ::: }:
|
|
* 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;
|
|
*/
|