devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replace Eigen type metaprogramming with corresponding std types and make use of alias templates

Browse Source
This commit is contained in:
Erik Schultheis
2022-03-16 16:43:40 +00:00
committed by Antonio Sánchez
parent 514f90c9ff
commit 421cbf0866
191 changed files with 1147 additions and 1221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test/basicstuff.cpp
View File

@@ -11,14 +11,14 @@
#include "random_without_cast_overflow.h"
template <typename MatrixType>
typename internal::enable_if<(MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1),void>::type
std::enable_if_t<(MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1),void>
check_index(const MatrixType& m) {
VERIFY_RAISES_ASSERT(m[0]);
VERIFY_RAISES_ASSERT((m+m)[0]);
}
template <typename MatrixType>
typename internal::enable_if<!(MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1),void>::type
std::enable_if_t<!(MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1),void>
check_index(const MatrixType& /*unused*/) {}
template<typename MatrixType> void basicStuff(const MatrixType& m)
@@ -241,7 +241,7 @@ struct casting_test_runner {
};
template<typename SrcScalar>
struct casting_test_runner<SrcScalar, typename internal::enable_if<(NumTraits<SrcScalar>::IsComplex)>::type>
struct casting_test_runner<SrcScalar, std::enable_if_t<(NumTraits<SrcScalar>::IsComplex)>>
{
static void run() {
// Only a few casts from std::complex<T> are defined.

14
test/block.cpp
View File

@@ -10,7 +10,7 @@
#include "main.h"
template<typename MatrixType, typename Index, typename Scalar>
typename Eigen::internal::enable_if<!NumTraits<typename MatrixType::Scalar>::IsComplex,typename MatrixType::Scalar>::type
std::enable_if_t<!NumTraits<typename MatrixType::Scalar>::IsComplex,typename MatrixType::Scalar>
block_real_only(const MatrixType &m1, Index r1, Index r2, Index c1, Index c2, const Scalar& s1) {
// check cwise-Functions:
VERIFY_IS_APPROX(m1.row(r1).cwiseMax(s1), m1.cwiseMax(s1).row(r1));
@@ -23,28 +23,28 @@ block_real_only(const MatrixType &m1, Index r1, Index r2, Index c1, Index c2, co
}
template<typename MatrixType, typename Index, typename Scalar>
typename Eigen::internal::enable_if<NumTraits<typename MatrixType::Scalar>::IsComplex,typename MatrixType::Scalar>::type
std::enable_if_t<NumTraits<typename MatrixType::Scalar>::IsComplex,typename MatrixType::Scalar>
block_real_only(const MatrixType &, Index, Index, Index, Index, const Scalar&) {
return Scalar(0);
}
// Check at compile-time that T1==T2, and at runtime-time that a==b
template<typename T1,typename T2>
typename internal::enable_if<internal::is_same<T1,T2>::value,bool>::type
std::enable_if_t<internal::is_same<T1,T2>::value,bool>
is_same_block(const T1& a, const T2& b)
{
return a.isApprox(b);
}
template <typename MatrixType>
typename internal::enable_if<((MatrixType::Flags&RowMajorBit)==0),void>::type
std::enable_if_t<((MatrixType::Flags&RowMajorBit)==0),void>
check_left_top(const MatrixType& m, Index r, Index c,
Index rows, Index /*unused*/) {
VERIFY_IS_EQUAL(m.leftCols(c).coeff(r+c*rows), m(r,c));
}
template <typename MatrixType>
typename internal::enable_if<((MatrixType::Flags&RowMajorBit)!=0),void>::type
std::enable_if_t<((MatrixType::Flags&RowMajorBit)!=0),void>
check_left_top(const MatrixType& m, Index r, Index c,
Index /*unused*/, Index cols) {
VERIFY_IS_EQUAL(m.topRows(r).coeff(c+r*cols), m(r,c));
@@ -243,7 +243,7 @@ template<typename MatrixType> void block(const MatrixType& m)
template<typename MatrixType>
typename internal::enable_if<MatrixType::IsVectorAtCompileTime,void>::type
std::enable_if_t<MatrixType::IsVectorAtCompileTime,void>
compare_using_data_and_stride(const MatrixType& m)
{
Index rows = m.rows();
@@ -264,7 +264,7 @@ compare_using_data_and_stride(const MatrixType& m)
}
template<typename MatrixType>
typename internal::enable_if<!MatrixType::IsVectorAtCompileTime,void>::type
std::enable_if_t<!MatrixType::IsVectorAtCompileTime,void>
compare_using_data_and_stride(const MatrixType& m)
{
Index rows = m.rows();

2
test/geo_quaternion.cpp
View File

@@ -286,7 +286,7 @@ template<typename PlainObjectType> void check_const_correctness(const PlainObjec
// CMake can help with that.
// verify that map-to-const don't have LvalueBit
typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
typedef std::add_const_t<PlainObjectType> ConstPlainObjectType;
VERIFY( !(internal::traits<Map<ConstPlainObjectType> >::Flags & LvalueBit) );
VERIFY( !(internal::traits<Map<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) );
VERIFY( !(Map<ConstPlainObjectType>::Flags & LvalueBit) );

12
test/gpu_test_helper.h
View File

@@ -66,7 +66,7 @@ struct extract_output_indices_helper<N, Idx, std::index_sequence<OutputIndices..
typename std::conditional<
// If is a non-const l-value reference, append index.
std::is_lvalue_reference<T1>::value
&& !std::is_const<typename std::remove_reference<T1>::type>::value,
&& !std::is_const<std::remove_reference_t<T1>>::value,
std::index_sequence<OutputIndices..., Idx>,
std::index_sequence<OutputIndices...> >::type,
Ts...>::type;
@@ -95,8 +95,8 @@ struct void_helper {
template<typename Func, typename... Args>
static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC
auto call(Func&& func, Args&&... args) ->
typename std::enable_if<!std::is_same<decltype(func(args...)), void>::value,
decltype(func(args...))>::type {
std::enable_if_t<!std::is_same<decltype(func(args...)), void>::value,
decltype(func(args...))> {
return func(std::forward<Args>(args)...);
}
@@ -104,8 +104,8 @@ struct void_helper {
template<typename Func, typename... Args>
static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC
auto call(Func&& func, Args&&... args) ->
typename std::enable_if<std::is_same<decltype(func(args...)), void>::value,
Void>::type {
std::enable_if_t<std::is_same<decltype(func(args...)), void>::value,
Void> {
func(std::forward<Args>(args)...);
return Void{};
}
@@ -113,7 +113,7 @@ struct void_helper {
// Restores the original return type, Void -> void, T otherwise.
template<typename T>
static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC
typename std::enable_if<!std::is_same<typename std::decay<T>::type, Void>::value, T>::type
std::enable_if_t<!std::is_same<typename std::decay<T>::type, Void>::value, T>
restore(T&& val) {
return val;
}

4
test/indexed_view.cpp
View File

@@ -40,7 +40,7 @@ bool match(const T& xpr, std::string ref, std::string str_xpr = "") {
#define MATCH(X,R) match(X, R, #X)
template<typename T1,typename T2>
typename internal::enable_if<internal::is_same<T1,T2>::value,bool>::type
std::enable_if_t<internal::is_same<T1,T2>::value,bool>
is_same_eq(const T1& a, const T2& b)
{
return (a == b).all();
@@ -59,7 +59,7 @@ bool is_same_seq(const T1& a, const T2& b)
}
template<typename T1,typename T2>
typename internal::enable_if<internal::is_same<T1,T2>::value,bool>::type
std::enable_if_t<internal::is_same<T1,T2>::value,bool>
is_same_seq_type(const T1& a, const T2& b)
{
return is_same_seq(a,b);

4
test/inverse.cpp
View File

@@ -12,12 +12,12 @@
#include <Eigen/LU>
template<typename MatrixType>
void inverse_for_fixed_size(const MatrixType&, typename internal::enable_if<MatrixType::SizeAtCompileTime==Dynamic>::type* = 0)
void inverse_for_fixed_size(const MatrixType&, std::enable_if_t<MatrixType::SizeAtCompileTime==Dynamic>* = 0)
{
}
template<typename MatrixType>
void inverse_for_fixed_size(const MatrixType& m1, typename internal::enable_if<MatrixType::SizeAtCompileTime!=Dynamic>::type* = 0)
void inverse_for_fixed_size(const MatrixType& m1, std::enable_if_t<MatrixType::SizeAtCompileTime!=Dynamic>* = 0)
{
using std::abs;

6
test/main.h
View File

@@ -408,7 +408,7 @@ bool test_is_equal(const T& actual, const U& expected, bool expect_equal=true);
namespace Eigen {
template<typename T1,typename T2>
typename internal::enable_if<internal::is_same<T1,T2>::value,bool>::type
std::enable_if_t<internal::is_same<T1,T2>::value,bool>
is_same_type(const T1&, const T2&)
{
return true;
@@ -547,7 +547,7 @@ typename T1::RealScalar test_relative_error(const SparseMatrixBase<T1> &a, const
}
template<typename T1,typename T2>
typename NumTraits<typename NumTraits<T1>::Real>::NonInteger test_relative_error(const T1 &a, const T2 &b, typename internal::enable_if<internal::is_arithmetic<typename NumTraits<T1>::Real>::value, T1>::type* = 0)
typename NumTraits<typename NumTraits<T1>::Real>::NonInteger test_relative_error(const T1 &a, const T2 &b, std::enable_if_t<internal::is_arithmetic<typename NumTraits<T1>::Real>::value, T1>* = 0)
{
typedef typename NumTraits<typename NumTraits<T1>::Real>::NonInteger RealScalar;
return numext::sqrt(RealScalar(numext::abs2(a-b))/(numext::mini)(RealScalar(numext::abs2(a)),RealScalar(numext::abs2(b))));
@@ -579,7 +579,7 @@ typename NumTraits<typename T::Scalar>::Real get_test_precision(const T&, const
}
template<typename T>
typename NumTraits<T>::Real get_test_precision(const T&,typename internal::enable_if<internal::is_arithmetic<typename NumTraits<T>::Real>::value, T>::type* = 0)
typename NumTraits<T>::Real get_test_precision(const T&,std::enable_if_t<internal::is_arithmetic<typename NumTraits<T>::Real>::value, T>* = 0)
{
return test_precision<typename NumTraits<T>::Real>();
}

2
test/mapped_matrix.cpp
View File

@@ -146,7 +146,7 @@ template<typename PlainObjectType> void check_const_correctness(const PlainObjec
// CMake can help with that.
// verify that map-to-const don't have LvalueBit
typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
typedef std::add_const_t<PlainObjectType> ConstPlainObjectType;
VERIFY( !(internal::traits<Map<ConstPlainObjectType> >::Flags & LvalueBit) );
VERIFY( !(internal::traits<Map<ConstPlainObjectType, AlignedMax> >::Flags & LvalueBit) );
VERIFY( !(Map<ConstPlainObjectType>::Flags & LvalueBit) );

45
test/meta.cpp
View File

@@ -29,47 +29,28 @@ struct MyImpl : public MyInterface {
EIGEN_DECLARE_TEST(meta)
{
VERIFY((internal::conditional<(3<4),internal::true_type, internal::false_type>::type::value));
VERIFY(( internal::is_same<float,float>::value));
VERIFY((!internal::is_same<float,double>::value));
VERIFY((!internal::is_same<float,float&>::value));
VERIFY((!internal::is_same<float,const float&>::value));
VERIFY(( internal::is_same<float,internal::remove_all<const float&>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<const float*>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<const float*&>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<float**>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<float**&>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<float* const *&>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_all<float* const>::type >::value));
// test add_const
VERIFY(( internal::is_same< internal::add_const<float>::type, const float >::value));
VERIFY(( internal::is_same< internal::add_const<float*>::type, float* const>::value));
VERIFY(( internal::is_same< internal::add_const<float const*>::type, float const* const>::value));
VERIFY(( internal::is_same< internal::add_const<float&>::type, float& >::value));
// test remove_const
VERIFY(( internal::is_same< internal::remove_const<float const* const>::type, float const* >::value));
VERIFY(( internal::is_same< internal::remove_const<float const*>::type, float const* >::value));
VERIFY(( internal::is_same< internal::remove_const<float* const>::type, float* >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<const float&> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<const float*> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<const float*&> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<float**> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<float**&> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<float* const *&> >::value));
VERIFY(( internal::is_same<float,internal::remove_all_t<float* const> >::value));
// test add_const_on_value_type
VERIFY(( internal::is_same< internal::add_const_on_value_type<float&>::type, float const& >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type<float*>::type, float const* >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<float&>, float const& >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<float*>, float const* >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type<float>::type, const float >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type<const float>::type, const float >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type<const float* const>::type, const float* const>::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type<float* const>::type, const float* const>::value));
VERIFY(( internal::is_same<float,internal::remove_reference<float&>::type >::value));
VERIFY(( internal::is_same<const float,internal::remove_reference<const float&>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_pointer<float*>::type >::value));
VERIFY(( internal::is_same<const float,internal::remove_pointer<const float*>::type >::value));
VERIFY(( internal::is_same<float,internal::remove_pointer<float* const >::type >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<float>, const float >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<const float>, const float >::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<const float* const>, const float* const>::value));
VERIFY(( internal::is_same< internal::add_const_on_value_type_t<float* const>, const float* const>::value));
// is_convertible
STATIC_CHECK(( internal::is_convertible<float,double>::value ));

2
test/nesting_ops.cpp
View File

@@ -27,7 +27,7 @@ template <int N, typename ReferenceType, typename XprType>
bool verify_eval_type(const XprType &, const ReferenceType&)
{
typedef typename internal::nested_eval<XprType,N>::type EvalType;
return internal::is_same<typename internal::remove_all<EvalType>::type, typename internal::remove_all<ReferenceType>::type>::value;
return internal::is_same<internal::remove_all_t<EvalType>, internal::remove_all_t<ReferenceType>>::value;
}
template <typename MatrixType> void run_nesting_ops_1(const MatrixType& _m)

6
test/packetmath.cpp
View File

@@ -265,7 +265,7 @@ struct packetmath_pcast_ops_runner {
// Only some types support cast from std::complex<>.
template <typename Scalar, typename Packet>
struct packetmath_pcast_ops_runner<Scalar, Packet, typename internal::enable_if<NumTraits<Scalar>::IsComplex>::type> {
struct packetmath_pcast_ops_runner<Scalar, Packet, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
static void run() {
test_cast_runner<Packet, std::complex<float> >::run();
test_cast_runner<Packet, std::complex<double> >::run();
@@ -404,11 +404,11 @@ struct eigen_optimization_barrier_test {
};
template<typename Packet>
struct eigen_optimization_barrier_test<Packet, typename internal::enable_if<
struct eigen_optimization_barrier_test<Packet, std::enable_if_t<
!NumTraits<Packet>::IsComplex &&
!internal::is_same<Packet, Eigen::half>::value &&
!internal::is_same<Packet, Eigen::bfloat16>::value
>::type> {
>> {
static void run() {
typedef typename internal::unpacket_traits<Packet>::type Scalar;
Scalar s = internal::random<Scalar>();

4
test/product.h
View File

@@ -18,13 +18,13 @@ bool areNotApprox(const MatrixBase<Derived1>& m1, const MatrixBase<Derived2>& m2
}
template <typename LhsType, typename RhsType>
typename internal::enable_if<RhsType::SizeAtCompileTime==Dynamic,void>::type
std::enable_if_t<RhsType::SizeAtCompileTime==Dynamic,void>
check_mismatched_product(LhsType& lhs, const RhsType& rhs) {
VERIFY_RAISES_ASSERT(lhs = rhs*rhs);
}
template <typename LhsType, typename RhsType>
typename internal::enable_if<RhsType::SizeAtCompileTime!=Dynamic,void>::type
std::enable_if_t<RhsType::SizeAtCompileTime!=Dynamic,void>
check_mismatched_product(LhsType& /*unused*/, const RhsType& /*unused*/) {
}

8
test/product_small.cpp
View File

@@ -40,12 +40,12 @@ const TC& ref_prod(TC &C, const TA &A, const TB &B)
}
template<typename T, int Rows, int Cols, int Depth, int OC, int OA, int OB>
typename internal::enable_if<! ( (Rows ==1&&Depth!=1&&OA==ColMajor)
std::enable_if_t<! ( (Rows ==1&&Depth!=1&&OA==ColMajor)
|| (Depth==1&&Rows !=1&&OA==RowMajor)
|| (Cols ==1&&Depth!=1&&OB==RowMajor)
|| (Depth==1&&Cols !=1&&OB==ColMajor)
|| (Rows ==1&&Cols !=1&&OC==ColMajor)
|| (Cols ==1&&Rows !=1&&OC==RowMajor)),void>::type
|| (Cols ==1&&Rows !=1&&OC==RowMajor)),void>
test_lazy_single(int rows, int cols, int depth)
{
Matrix<T,Rows,Depth,OA> A(rows,depth); A.setRandom();
@@ -80,12 +80,12 @@ void test_dynamic_bool()
}
template<typename T, int Rows, int Cols, int Depth, int OC, int OA, int OB>
typename internal::enable_if< ( (Rows ==1&&Depth!=1&&OA==ColMajor)
std::enable_if_t< ( (Rows ==1&&Depth!=1&&OA==ColMajor)
|| (Depth==1&&Rows !=1&&OA==RowMajor)
|| (Cols ==1&&Depth!=1&&OB==RowMajor)
|| (Depth==1&&Cols !=1&&OB==ColMajor)
|| (Rows ==1&&Cols !=1&&OC==ColMajor)
|| (Cols ==1&&Rows !=1&&OC==RowMajor)),void>::type
|| (Cols ==1&&Rows !=1&&OC==RowMajor)),void>
test_lazy_single(int, int, int)
{
}

52
test/random_without_cast_overflow.h
View File

@@ -23,11 +23,11 @@ struct random_without_cast_overflow {
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
!NumTraits<TgtScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits < std::numeric_limits<TgtScalar>::digits ||
(std::numeric_limits<SrcScalar>::digits == std::numeric_limits<TgtScalar>::digits &&
NumTraits<SrcScalar>::IsSigned))>::type> {
std::enable_if_t<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
!NumTraits<TgtScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits < std::numeric_limits<TgtScalar>::digits ||
(std::numeric_limits<SrcScalar>::digits == std::numeric_limits<TgtScalar>::digits &&
NumTraits<SrcScalar>::IsSigned))>> {
static SrcScalar value() {
SrcScalar a = internal::random<SrcScalar>();
return a < SrcScalar(0) ? -(a + 1) : a;
@@ -38,9 +38,9 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<
std::enable_if_t<
NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger && !NumTraits<SrcScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>::type> {
(std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>> {
static SrcScalar value() {
TgtScalar b = internal::random<TgtScalar>();
return static_cast<SrcScalar>(b < TgtScalar(0) ? -(b + 1) : b);
@@ -51,9 +51,9 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<
std::enable_if_t<
NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger && NumTraits<SrcScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>::type> {
(std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>> {
static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
};
@@ -61,10 +61,10 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
!NumTraits<SrcScalar>::IsSigned && NumTraits<TgtScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits ==
std::numeric_limits<TgtScalar>::digits)>::type> {
std::enable_if_t<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
!NumTraits<SrcScalar>::IsSigned && NumTraits<TgtScalar>::IsSigned &&
(std::numeric_limits<SrcScalar>::digits ==
std::numeric_limits<TgtScalar>::digits)>> {
static SrcScalar value() { return internal::random<SrcScalar>() / 2; }
};
@@ -72,9 +72,9 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<
std::enable_if_t<
!NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsInteger &&
(std::numeric_limits<TgtScalar>::digits <= std::numeric_limits<SrcScalar>::digits)>::type> {
(std::numeric_limits<TgtScalar>::digits <= std::numeric_limits<SrcScalar>::digits)>> {
static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
};
@@ -82,9 +82,9 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<
std::enable_if_t<
!NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsInteger &&
(std::numeric_limits<TgtScalar>::digits > std::numeric_limits<SrcScalar>::digits)>::type> {
(std::numeric_limits<TgtScalar>::digits > std::numeric_limits<SrcScalar>::digits)>> {
static SrcScalar value() {
// NOTE: internal::random<T>() is limited by RAND_MAX, so random<int64_t> is always within that range.
// This prevents us from simply shifting bits, which would result in only 0 or -1.
@@ -99,8 +99,8 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && !NumTraits<TgtScalar>::IsInteger &&
!NumTraits<TgtScalar>::IsComplex>::type> {
std::enable_if_t<NumTraits<SrcScalar>::IsInteger && !NumTraits<TgtScalar>::IsInteger &&
!NumTraits<TgtScalar>::IsComplex>> {
static SrcScalar value() {
return static_cast<SrcScalar>(random_without_cast_overflow<TgtScalar, SrcScalar>::value());
}
@@ -110,10 +110,10 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<!NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex &&
!NumTraits<TgtScalar>::IsInteger && !NumTraits<TgtScalar>::IsComplex &&
(std::numeric_limits<SrcScalar>::digits >
std::numeric_limits<TgtScalar>::digits)>::type> {
std::enable_if_t<!NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex &&
!NumTraits<TgtScalar>::IsInteger && !NumTraits<TgtScalar>::IsComplex &&
(std::numeric_limits<SrcScalar>::digits >
std::numeric_limits<TgtScalar>::digits)>> {
static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
};
@@ -121,7 +121,7 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<NumTraits<SrcScalar>::IsComplex && !NumTraits<TgtScalar>::IsComplex>::type> {
std::enable_if_t<NumTraits<SrcScalar>::IsComplex && !NumTraits<TgtScalar>::IsComplex>> {
typedef typename NumTraits<SrcScalar>::Real SrcReal;
static SrcScalar value() { return SrcScalar(random_without_cast_overflow<SrcReal, TgtScalar>::value(), 0); }
};
@@ -130,7 +130,7 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<!NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>::type> {
std::enable_if_t<!NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>> {
typedef typename NumTraits<TgtScalar>::Real TgtReal;
static SrcScalar value() { return random_without_cast_overflow<SrcScalar, TgtReal>::value(); }
};
@@ -139,7 +139,7 @@ struct random_without_cast_overflow<
template <typename SrcScalar, typename TgtScalar>
struct random_without_cast_overflow<
SrcScalar, TgtScalar,
typename internal::enable_if<NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>::type> {
std::enable_if_t<NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>> {
typedef typename NumTraits<SrcScalar>::Real SrcReal;
typedef typename NumTraits<TgtScalar>::Real TgtReal;
static SrcScalar value() {

2
test/ref.cpp
View File

@@ -204,7 +204,7 @@ void ref_vector_fixed_sizes()
template<typename PlainObjectType> void check_const_correctness(const PlainObjectType&)
{
// verify that ref-to-const don't have LvalueBit
typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
typedef std::add_const_t<PlainObjectType> ConstPlainObjectType;
VERIFY( !(internal::traits<Ref<ConstPlainObjectType> >::Flags & LvalueBit) );
VERIFY( !(internal::traits<Ref<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) );
VERIFY( !(Ref<ConstPlainObjectType>::Flags & LvalueBit) );

2
test/reshape.cpp
View File

@@ -14,7 +14,7 @@ using Eigen::placeholders::last;
using Eigen::placeholders::all;
template<typename T1,typename T2>
typename internal::enable_if<internal::is_same<T1,T2>::value,bool>::type
std::enable_if_t<internal::is_same<T1,T2>::value,bool>
is_same_eq(const T1& a, const T2& b)
{
return (a.array() == b.array()).all();

4
test/sparse_block.cpp
View File

@@ -11,14 +11,14 @@
#include "AnnoyingScalar.h"
template<typename T>
typename Eigen::internal::enable_if<(T::Flags&RowMajorBit)==RowMajorBit, typename T::RowXpr>::type
std::enable_if_t<(T::Flags&RowMajorBit)==RowMajorBit, typename T::RowXpr>
innervec(T& A, Index i)
{
return A.row(i);
}
template<typename T>
typename Eigen::internal::enable_if<(T::Flags&RowMajorBit)==0, typename T::ColXpr>::type
std::enable_if_t<(T::Flags&RowMajorBit)==0, typename T::ColXpr>
innervec(T& A, Index i)
{
return A.col(i);

2
test/sparse_ref.cpp
View File

@@ -34,7 +34,7 @@ inline void on_temporary_creation() {
template<typename PlainObjectType> void check_const_correctness(const PlainObjectType&)
{
// verify that ref-to-const don't have LvalueBit
typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
typedef std::add_const_t<PlainObjectType> ConstPlainObjectType;
VERIFY( !(internal::traits<Ref<ConstPlainObjectType> >::Flags & LvalueBit) );
VERIFY( !(internal::traits<Ref<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) );
VERIFY( !(Ref<ConstPlainObjectType>::Flags & LvalueBit) );

4
test/swap.cpp
View File

@@ -22,7 +22,7 @@ struct other_matrix_type<Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCo
};
template <typename MatrixType>
typename internal::enable_if<(MatrixType::RowsAtCompileTime==1 || MatrixType::RowsAtCompileTime==Dynamic), void>::type
std::enable_if_t<(MatrixType::RowsAtCompileTime==1 || MatrixType::RowsAtCompileTime==Dynamic), void>
check_row_swap(MatrixType& m1) {
if (m1.rows() != 1) {
@@ -34,7 +34,7 @@ check_row_swap(MatrixType& m1) {
}
template <typename MatrixType>
typename internal::enable_if<!(MatrixType::RowsAtCompileTime==1 || MatrixType::RowsAtCompileTime==Dynamic), void>::type
std::enable_if_t<!(MatrixType::RowsAtCompileTime==1 || MatrixType::RowsAtCompileTime==Dynamic), void>
check_row_swap(MatrixType& /* unused */) {
}