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

Modernize C++14 usage and minor optimizations in Core

Browse Source 
libeigen/eigen!2143

Co-authored-by: Rasmus Munk Larsen <rmlarsen@gmail.com>
Co-authored-by: Rasmus Munk Larsen <rmlarsen@google.com>
This commit is contained in:
Rasmus Munk Larsen
2026-02-18 12:47:51 -08:00
parent f69745b678
commit e953f1e504
8 changed files with 72 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Eigen/src/Core/InnerProduct.h
View File

@@ -216,8 +216,8 @@ struct scalar_inner_product_op {
template <typename Scalar, bool Conj>
struct scalar_inner_product_op<
Scalar,
typename std::enable_if<internal::is_same<typename ScalarBinaryOpTraits<Scalar, Scalar>::ReturnType, Scalar>::value,
Scalar>::type,
std::enable_if_t<internal::is_same<typename ScalarBinaryOpTraits<Scalar, Scalar>::ReturnType, Scalar>::value,
Scalar>,
Conj> {
using result_type = Scalar;
using conj_helper = conditional_conj<Scalar, Conj>;

12
Eigen/src/Core/NestByValue.h
View File

@@ -52,17 +52,11 @@ class NestByValue : public internal::dense_xpr_base<NestByValue<ExpressionType>
EIGEN_DEVICE_FUNC const ExpressionType& nestedExpression() const { return m_expression; }
EIGEN_DEVICE_FUNC typename std::enable_if<HasDirectAccess, const Scalar*>::type data() const {
return m_expression.data();
}
EIGEN_DEVICE_FUNC std::enable_if_t<HasDirectAccess, const Scalar*> data() const { return m_expression.data(); }
EIGEN_DEVICE_FUNC typename std::enable_if<HasDirectAccess, Index>::type innerStride() const {
return m_expression.innerStride();
}
EIGEN_DEVICE_FUNC std::enable_if_t<HasDirectAccess, Index> innerStride() const { return m_expression.innerStride(); }
EIGEN_DEVICE_FUNC typename std::enable_if<HasDirectAccess, Index>::type outerStride() const {
return m_expression.outerStride();
}
EIGEN_DEVICE_FUNC std::enable_if_t<HasDirectAccess, Index> outerStride() const { return m_expression.outerStride(); }
protected:
const ExpressionType m_expression;

54
Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
View File

@@ -1072,14 +1072,23 @@ EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
// syms x;
// cosf = @(x) cos(x);
// pade_cosf = pade(cosf(x), x, 0, 'Order', 8)
Packet sc1_num = pmadd(ss, pset1<Packet>(80737373), pset1<Packet>(-13853547000));
Packet sc2_num = pmadd(sc1_num, ss, pset1<Packet>(727718024880));
Packet sc3_num = pmadd(sc2_num, ss, pset1<Packet>(-11275015752000));
Packet sc4_num = pmadd(sc3_num, ss, pset1<Packet>(23594700729600));
Packet sc1_denum = pmadd(ss, pset1<Packet>(147173), pset1<Packet>(39328920));
Packet sc2_denum = pmadd(sc1_denum, ss, pset1<Packet>(5772800880));
Packet sc3_denum = pmadd(sc2_denum, ss, pset1<Packet>(522334612800));
Packet sc4_denum = pmadd(sc3_denum, ss, pset1<Packet>(23594700729600));
const Packet cn4 = pset1<Packet>(80737373);
const Packet cn3 = pset1<Packet>(-13853547000);
const Packet cn2 = pset1<Packet>(727718024880);
const Packet cn1 = pset1<Packet>(-11275015752000);
const Packet cn0 = pset1<Packet>(23594700729600); // shared with cd0
const Packet cd3 = pset1<Packet>(147173);
const Packet cd2 = pset1<Packet>(39328920);
const Packet cd1 = pset1<Packet>(5772800880);
const Packet cd0 = pset1<Packet>(522334612800);
Packet sc1_num = pmadd(ss, cn4, cn3);
Packet sc2_num = pmadd(sc1_num, ss, cn2);
Packet sc3_num = pmadd(sc2_num, ss, cn1);
Packet sc4_num = pmadd(sc3_num, ss, cn0);
Packet sc1_denum = pmadd(ss, cd3, cd2);
Packet sc2_denum = pmadd(sc1_denum, ss, cd1);
Packet sc3_denum = pmadd(sc2_denum, ss, cd0);
Packet sc4_denum = pmadd(sc3_denum, ss, cn0);
Packet scos = pdiv(sc4_num, sc4_denum);
// Padé approximant of sin(x)
@@ -1090,15 +1099,26 @@ EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
// syms x;
// sinf = @(x) sin(x);
// pade_sinf = pade(sinf(x), x, 0, 'Order', 8, 'OrderMode', 'relative')
Packet ss1_num = pmadd(ss, pset1<Packet>(4585922449), pset1<Packet>(-1066023933480));
Packet ss2_num = pmadd(ss1_num, ss, pset1<Packet>(83284044283440));
Packet ss3_num = pmadd(ss2_num, ss, pset1<Packet>(-2303682236856000));
Packet ss4_num = pmadd(ss3_num, ss, pset1<Packet>(15605159573203200));
Packet ss1_denum = pmadd(ss, pset1<Packet>(1029037), pset1<Packet>(345207016));
Packet ss2_denum = pmadd(ss1_denum, ss, pset1<Packet>(61570292784));
Packet ss3_denum = pmadd(ss2_denum, ss, pset1<Packet>(6603948711360));
Packet ss4_denum = pmadd(ss3_denum, ss, pset1<Packet>(346781323848960));
Packet ssin = pdiv(pmul(s, ss4_num), pmul(pset1<Packet>(45), ss4_denum));
const Packet sn4 = pset1<Packet>(4585922449);
const Packet sn3 = pset1<Packet>(-1066023933480);
const Packet sn2 = pset1<Packet>(83284044283440);
const Packet sn1 = pset1<Packet>(-2303682236856000);
const Packet sn0 = pset1<Packet>(15605159573203200);
const Packet sd3 = pset1<Packet>(1029037);
const Packet sd2 = pset1<Packet>(345207016);
const Packet sd1 = pset1<Packet>(61570292784);
const Packet sd0_inner = pset1<Packet>(6603948711360);
const Packet sd0 = pset1<Packet>(346781323848960);
const Packet cst_45 = pset1<Packet>(45);
Packet ss1_num = pmadd(ss, sn4, sn3);
Packet ss2_num = pmadd(ss1_num, ss, sn2);
Packet ss3_num = pmadd(ss2_num, ss, sn1);
Packet ss4_num = pmadd(ss3_num, ss, sn0);
Packet ss1_denum = pmadd(ss, sd3, sd2);
Packet ss2_denum = pmadd(ss1_denum, ss, sd1);
Packet ss3_denum = pmadd(ss2_denum, ss, sd0_inner);
Packet ss4_denum = pmadd(ss3_denum, ss, sd0);
Packet ssin = pdiv(pmul(s, ss4_num), pmul(cst_45, ss4_denum));
Packet poly_mask = preinterpret<Packet>(pcmp_eq(pand(q_int, cst_one), pzero(q_int)));

2
Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
View File

@@ -87,7 +87,7 @@ struct general_matrix_matrix_triangular_product<Index, LhsScalar, LhsStorageOrde
// !!! mc must be a multiple of nr
if (mc > Traits::nr) {
using UnsignedIndex = typename make_unsigned<Index>::type;
using UnsignedIndex = std::make_unsigned_t<Index>;
mc = (UnsignedIndex(mc) / Traits::nr) * Traits::nr;
}

39
Eigen/src/Core/products/GeneralMatrixVector.h
View File

@@ -149,10 +149,8 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
Index jend = numext::mini(j2 + block_cols, cols);
Index i = 0;
for (; i < n8; i += ResPacketSize * 8) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0)),
c2 = pset1<ResPacket>(ResScalar(0)), c3 = pset1<ResPacket>(ResScalar(0)),
c4 = pset1<ResPacket>(ResScalar(0)), c5 = pset1<ResPacket>(ResScalar(0)),
c6 = pset1<ResPacket>(ResScalar(0)), c7 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{}), c2 = pzero(ResPacket{}), c3 = pzero(ResPacket{}),
c4 = pzero(ResPacket{}), c5 = pzero(ResPacket{}), c6 = pzero(ResPacket{}), c7 = pzero(ResPacket{});
for (Index j = j2; j < jend; j += 1) {
RhsPacket b0 = pset1<RhsPacket>(rhs(j, 0));
@@ -175,8 +173,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
pstoreu(res + i + ResPacketSize * 7, pmadd(c7, palpha, ploadu<ResPacket>(res + i + ResPacketSize * 7)));
}
if (i < n4) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0)),
c2 = pset1<ResPacket>(ResScalar(0)), c3 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{}), c2 = pzero(ResPacket{}), c3 = pzero(ResPacket{});
for (Index j = j2; j < jend; j += 1) {
RhsPacket b0 = pset1<RhsPacket>(rhs(j, 0));
@@ -193,8 +190,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
i += ResPacketSize * 4;
}
if (i < n3) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0)),
c2 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{}), c2 = pzero(ResPacket{});
for (Index j = j2; j < jend; j += 1) {
RhsPacket b0 = pset1<RhsPacket>(rhs(j, 0));
@@ -209,7 +205,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
i += ResPacketSize * 3;
}
if (i < n2) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{});
for (Index j = j2; j < jend; j += 1) {
RhsPacket b0 = pset1<RhsPacket>(rhs(j, 0));
@@ -221,7 +217,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
i += ResPacketSize * 2;
}
if (i < n1) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{});
for (Index j = j2; j < jend; j += 1) {
RhsPacket b0 = pset1<RhsPacket>(rhs(j, 0));
c0 = pcj.pmadd(lhs.template load<LhsPacket, LhsAlignment>(i + 0, j), b0, c0);
@@ -230,7 +226,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
i += ResPacketSize;
}
if (HasHalf && i < n_half) {
ResPacketHalf c0 = pset1<ResPacketHalf>(ResScalar(0));
ResPacketHalf c0 = pzero(ResPacketHalf{});
for (Index j = j2; j < jend; j += 1) {
RhsPacketHalf b0 = pset1<RhsPacketHalf>(rhs(j, 0));
c0 = pcj_half.pmadd(lhs.template load<LhsPacketHalf, LhsAlignment>(i + 0, j), b0, c0);
@@ -240,7 +236,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
i += ResPacketSizeHalf;
}
if (HasQuarter && i < n_quarter) {
ResPacketQuarter c0 = pset1<ResPacketQuarter>(ResScalar(0));
ResPacketQuarter c0 = pzero(ResPacketQuarter{});
for (Index j = j2; j < jend; j += 1) {
RhsPacketQuarter b0 = pset1<RhsPacketQuarter>(rhs(j, 0));
c0 = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter, LhsAlignment>(i + 0, j), b0, c0);
@@ -328,17 +324,15 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLh
HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
};
using UnsignedIndex = typename make_unsigned<Index>::type;
using UnsignedIndex = std::make_unsigned_t<Index>;
const Index fullColBlockEnd = LhsPacketSize * (UnsignedIndex(cols) / LhsPacketSize);
const Index halfColBlockEnd = LhsPacketSizeHalf * (UnsignedIndex(cols) / LhsPacketSizeHalf);
const Index quarterColBlockEnd = LhsPacketSizeQuarter * (UnsignedIndex(cols) / LhsPacketSizeQuarter);
Index i = 0;
for (; i < n8; i += 8) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0)),
c2 = pset1<ResPacket>(ResScalar(0)), c3 = pset1<ResPacket>(ResScalar(0)),
c4 = pset1<ResPacket>(ResScalar(0)), c5 = pset1<ResPacket>(ResScalar(0)),
c6 = pset1<ResPacket>(ResScalar(0)), c7 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{}), c2 = pzero(ResPacket{}), c3 = pzero(ResPacket{}),
c4 = pzero(ResPacket{}), c5 = pzero(ResPacket{}), c6 = pzero(ResPacket{}), c7 = pzero(ResPacket{});
for (Index j = 0; j < fullColBlockEnd; j += LhsPacketSize) {
RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j, 0);
@@ -383,8 +377,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLh
res[(i + 7) * resIncr] += alpha * cc7;
}
for (; i < n4; i += 4) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0)),
c2 = pset1<ResPacket>(ResScalar(0)), c3 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{}), c2 = pzero(ResPacket{}), c3 = pzero(ResPacket{});
for (Index j = 0; j < fullColBlockEnd; j += LhsPacketSize) {
RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j, 0);
@@ -413,7 +406,7 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLh
res[(i + 3) * resIncr] += alpha * cc3;
}
for (; i < n2; i += 2) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0)), c1 = pset1<ResPacket>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{}), c1 = pzero(ResPacket{});
for (Index j = 0; j < fullColBlockEnd; j += LhsPacketSize) {
RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j, 0);
@@ -434,9 +427,9 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLh
res[(i + 1) * resIncr] += alpha * cc1;
}
for (; i < rows; ++i) {
ResPacket c0 = pset1<ResPacket>(ResScalar(0));
ResPacketHalf c0_h = pset1<ResPacketHalf>(ResScalar(0));
ResPacketQuarter c0_q = pset1<ResPacketQuarter>(ResScalar(0));
ResPacket c0 = pzero(ResPacket{});
ResPacketHalf c0_h = pzero(ResPacketHalf{});
ResPacketQuarter c0_q = pzero(ResPacketQuarter{});
for (Index j = 0; j < fullColBlockEnd; j += LhsPacketSize) {
RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j, 0);

94
Eigen/src/Core/util/Meta.h
View File

@@ -94,13 +94,7 @@ using std::false_type;
using std::true_type;
template <bool Condition>
struct bool_constant;
template <>
struct bool_constant<true> : true_type {};
template <>
struct bool_constant<false> : false_type {};
using bool_constant = std::integral_constant<bool, Condition>;
// Third-party libraries rely on these.
using std::conditional;
@@ -136,77 +130,24 @@ struct remove_all<T*> {
template <typename T>
using remove_all_t = typename remove_all<T>::type;
// Eigen's is_arithmetic is similar to std::is_arithmetic but can be specialized
// for SIMD packet types and other Eigen-specific types. The primary template
// delegates to std::is_arithmetic for fundamental types.
template <typename T>
struct is_arithmetic {
enum { value = false };
};
template <>
struct is_arithmetic<float> {
enum { value = true };
};
template <>
struct is_arithmetic<double> {
enum { value = true };
enum { value = std::is_arithmetic<T>::value };
};
// GPU devices treat `long double` as `double`.
#ifndef EIGEN_GPU_COMPILE_PHASE
#ifdef EIGEN_GPU_COMPILE_PHASE
template <>
struct is_arithmetic<long double> {
enum { value = true };
enum { value = false };
};
#endif
template <>
struct is_arithmetic<bool> {
enum { value = true };
};
template <>
struct is_arithmetic<char> {
enum { value = true };
};
template <>
struct is_arithmetic<signed char> {
enum { value = true };
};
template <>
struct is_arithmetic<unsigned char> {
enum { value = true };
};
template <>
struct is_arithmetic<signed short> {
enum { value = true };
};
template <>
struct is_arithmetic<unsigned short> {
enum { value = true };
};
template <>
struct is_arithmetic<signed int> {
enum { value = true };
};
template <>
struct is_arithmetic<unsigned int> {
enum { value = true };
};
template <>
struct is_arithmetic<signed long> {
enum { value = true };
};
template <>
struct is_arithmetic<unsigned long> {
enum { value = true };
};
template <typename T, typename U>
struct is_same {
enum { value = 0 };
};
template <typename T>
struct is_same<T, T> {
enum { value = 1 };
};
using std::is_same;
template <class T>
struct is_void : is_same<void, std::remove_const_t<T>> {};
using std::is_void;
/** \internal
* Implementation of std::void_t for SFINAE.
@@ -223,26 +164,11 @@ template <typename...>
using void_t = void;
#endif
template <>
struct is_arithmetic<signed long long> {
enum { value = true };
};
template <>
struct is_arithmetic<unsigned long long> {
enum { value = true };
};
using std::is_integral;
using std::make_unsigned;
template <typename T>
struct is_const {
enum { value = 0 };
};
template <typename T>
struct is_const<T const> {
enum { value = 1 };
};
using std::is_const;
template <typename T>
struct add_const_on_value_type {

2
Eigen/src/Core/util/Serializer.h
View File

@@ -129,7 +129,7 @@ struct serialize_impl;
template <size_t N, typename T1, typename... Ts>
struct serialize_impl<N, T1, Ts...> {
using Serializer = Eigen::Serializer<typename std::decay<T1>::type>;
using Serializer = Eigen::Serializer<std::decay_t<T1>>;
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t serialize_size(const T1& value, const Ts&... args) {
Serializer serializer;

5
Eigen/src/Core/util/XprHelper.h
View File

@@ -20,11 +20,10 @@ namespace internal {
// useful for unsigned / signed integer comparisons when idx is intended to be non-negative
template <typename IndexType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename make_unsigned<IndexType>::type returnUnsignedIndexValue(
const IndexType& idx) {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::make_unsigned_t<IndexType> returnUnsignedIndexValue(const IndexType& idx) {
EIGEN_STATIC_ASSERT((NumTraits<IndexType>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
eigen_internal_assert(idx >= 0 && "Index value is negative and target type is unsigned");
using UnsignedType = typename make_unsigned<IndexType>::type;
using UnsignedType = std::make_unsigned_t<IndexType>;
return static_cast<UnsignedType>(idx);
}