From f23dc5b971d1c11bc0fcb7068788a30e4bd7cbf1 Mon Sep 17 00:00:00 2001 From: Rasmus Munk Larsen Date: Thu, 3 Dec 2020 14:32:45 -0800 Subject: Revert "Add log2() operator to Eigen" This reverts commit 4d91519a9be061da5d300079fca17dd0b9328050. --- Eigen/src/Core/GenericPacketMath.h | 7 --- Eigen/src/Core/GlobalFunctions.h | 3 +- Eigen/src/Core/arch/AVX/MathFunctions.h | 14 ----- Eigen/src/Core/arch/AVX512/MathFunctions.h | 15 ------ Eigen/src/Core/arch/Default/BFloat16.h | 3 -- .../Core/arch/Default/GenericPacketMathFunctions.h | 63 ++++------------------ .../arch/Default/GenericPacketMathFunctionsFwd.h | 12 ----- Eigen/src/Core/arch/Default/Half.h | 4 -- Eigen/src/Core/arch/SSE/MathFunctions.h | 10 ---- Eigen/src/Core/functors/UnaryFunctors.h | 16 ------ Eigen/src/plugins/ArrayCwiseUnaryOps.h | 13 ----- test/array_cwise.cpp | 4 -- test/packetmath.cpp | 8 --- 13 files changed, 12 insertions(+), 160 deletions(-) diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h index 96c459601..e2fc7002b 100644 --- a/Eigen/src/Core/GenericPacketMath.h +++ b/Eigen/src/Core/GenericPacketMath.h @@ -650,13 +650,6 @@ Packet plog1p(const Packet& a) { return numext::log1p(a); } template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10(const Packet& a) { EIGEN_USING_STD(log10); return log10(a); } -/** \internal \returns the log10 of \a a (coeff-wise) */ -template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet plog2(const Packet& a) { - typedef typename internal::unpacket_traits::type Scalar; - return pmul(pset1(Scalar(M_LOG2E)), plog(a)); -} - /** \internal \returns the square-root of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psqrt(const Packet& a) { EIGEN_USING_STD(sqrt); return sqrt(a); } diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h index 629af94b9..0a539ed8e 100644 --- a/Eigen/src/Core/GlobalFunctions.h +++ b/Eigen/src/Core/GlobalFunctions.h @@ -81,8 +81,7 @@ namespace Eigen EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(expm1,scalar_expm1_op,exponential of a value minus 1,\sa ArrayBase::expm1) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op,natural logarithm,\sa Eigen::log10 DOXCOMMA ArrayBase::log) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log1p,scalar_log1p_op,natural logarithm of 1 plus the value,\sa ArrayBase::log1p) - EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log10) - EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log2,scalar_log2_op,base 2 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log2) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op,absolute value,\sa ArrayBase::abs DOXCOMMA MatrixBase::cwiseAbs) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2,scalar_abs2_op,squared absolute value,\sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(arg,scalar_arg_op,complex argument,\sa ArrayBase::arg DOXCOMMA MatrixBase::cwiseArg) diff --git a/Eigen/src/Core/arch/AVX/MathFunctions.h b/Eigen/src/Core/arch/AVX/MathFunctions.h index 5fe2cff32..e2e704d82 100644 --- a/Eigen/src/Core/arch/AVX/MathFunctions.h +++ b/Eigen/src/Core/arch/AVX/MathFunctions.h @@ -42,18 +42,6 @@ plog(const Packet4d& _x) { return plog_double(_x); } -template <> -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f -plog2(const Packet8f& _x) { - return plog2_float(_x); -} - -template <> -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d -plog2(const Packet4d& _x) { - return plog2_double(_x); -} - template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f plog1p(const Packet8f& _x) { return generic_plog1p(_x); @@ -173,7 +161,6 @@ Packet4d prsqrt(const Packet4d& _x) { F16_PACKET_FUNCTION(Packet8f, Packet8h, psin) F16_PACKET_FUNCTION(Packet8f, Packet8h, pcos) F16_PACKET_FUNCTION(Packet8f, Packet8h, plog) -F16_PACKET_FUNCTION(Packet8f, Packet8h, plog2) F16_PACKET_FUNCTION(Packet8f, Packet8h, plog1p) F16_PACKET_FUNCTION(Packet8f, Packet8h, pexpm1) F16_PACKET_FUNCTION(Packet8f, Packet8h, pexp) @@ -184,7 +171,6 @@ F16_PACKET_FUNCTION(Packet8f, Packet8h, prsqrt) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, psin) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pcos) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog) -BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog2) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog1p) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexpm1) BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexp) diff --git a/Eigen/src/Core/arch/AVX512/MathFunctions.h b/Eigen/src/Core/arch/AVX512/MathFunctions.h index 66f3252cd..c04da6795 100644 --- a/Eigen/src/Core/arch/AVX512/MathFunctions.h +++ b/Eigen/src/Core/arch/AVX512/MathFunctions.h @@ -50,21 +50,6 @@ plog(const Packet8d& _x) { F16_PACKET_FUNCTION(Packet16f, Packet16h, plog) BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog) -template <> -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f -plog2(const Packet16f& _x) { - return plog2_float(_x); -} - -template <> -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d -plog2(const Packet8d& _x) { - return plog2_double(_x); -} - -F16_PACKET_FUNCTION(Packet16f, Packet16h, plog2) -BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog2) - // Exponential function. Works by writing "x = m*log(2) + r" where // "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then // "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1). diff --git a/Eigen/src/Core/arch/Default/BFloat16.h b/Eigen/src/Core/arch/Default/BFloat16.h index 616dcf667..351f451a3 100644 --- a/Eigen/src/Core/arch/Default/BFloat16.h +++ b/Eigen/src/Core/arch/Default/BFloat16.h @@ -512,9 +512,6 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log1p(const bfloat16& a) { EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log10(const bfloat16& a) { return bfloat16(::log10f(float(a))); } -EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log2(const bfloat16& a) { - return bfloat16(static_cast(M_LOG2E) * ::logf(float(a))); -} EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sqrt(const bfloat16& a) { return bfloat16(::sqrtf(float(a))); } diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h index c6bb89b05..60db2e12f 100644 --- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h +++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h @@ -59,16 +59,16 @@ pldexp_double(Packet a, Packet exponent) return pmul(a, preinterpret(plogical_shift_left<52>(ei))); } -// Natural or base 2 logarithm. +// Natural logarithm // Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2) // and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can // be easily approximated by a polynomial centered on m=1 for stability. // TODO(gonnet): Further reduce the interval allowing for lower-degree // polynomial interpolants -> ... -> profit! -template +template EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet plog_impl_float(const Packet _x) +Packet plog_float(const Packet _x) { Packet x = _x; @@ -131,13 +131,8 @@ Packet plog_impl_float(const Packet _x) x = padd(x, y); // Add the logarithm of the exponent back to the result of the interpolation. - if (base2) { - const Packet cst_log2e = pset1(static_cast(M_LOG2E)); - x = pmadd(x, cst_log2e, e); - } else { - const Packet cst_ln2 = pset1(static_cast(M_LN2)); - x = pmadd(e, cst_ln2, x); - } + const Packet cst_ln2 = pset1(M_LN2); + x = pmadd(e, cst_ln2, x); Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x)); Packet iszero_mask = pcmp_eq(_x,pzero(_x)); @@ -150,23 +145,8 @@ Packet plog_impl_float(const Packet _x) por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask)); } -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog_float(const Packet _x) -{ - return plog_impl_float(_x); -} - -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog2_float(const Packet _x) -{ - return plog_impl_float(_x); -} -/* Returns the base e (2.718...) or base 2 logarithm of x. +/* Returns the base e (2.718...) logarithm of x. * The argument is separated into its exponent and fractional parts. * The logarithm of the fraction in the interval [sqrt(1/2), sqrt(2)], * is approximated by @@ -175,16 +155,16 @@ Packet plog2_float(const Packet _x) * * for more detail see: http://www.netlib.org/cephes/ */ -template +template EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet plog_impl_double(const Packet _x) +Packet plog_double(const Packet _x) { Packet x = _x; const Packet cst_1 = pset1(1.0); const Packet cst_neg_half = pset1(-0.5); - // The smallest non denormalized double. + // The smallest non denormalized float number. const Packet cst_min_norm_pos = pset1frombits( static_cast(0x0010000000000000ull)); const Packet cst_minus_inf = pset1frombits( static_cast(0xfff0000000000000ull)); const Packet cst_pos_inf = pset1frombits( static_cast(0x7ff0000000000000ull)); @@ -252,13 +232,8 @@ Packet plog_impl_double(const Packet _x) x = padd(x, y); // Add the logarithm of the exponent back to the result of the interpolation. - if (base2) { - const Packet cst_log2e = pset1(M_LOG2E); - x = pmadd(x, cst_log2e, e); - } else { - const Packet cst_ln2 = pset1(M_LN2); - x = pmadd(e, cst_ln2, x); - } + const Packet cst_ln2 = pset1(M_LN2); + x = pmadd(e, cst_ln2, x); Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x)); Packet iszero_mask = pcmp_eq(_x,pzero(_x)); @@ -271,22 +246,6 @@ Packet plog_impl_double(const Packet _x) por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask)); } -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog_double(const Packet _x) -{ - return plog_impl_double(_x); -} - -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog2_double(const Packet _x) -{ - return plog_impl_double(_x); -} - /** \internal \returns log(1 + x) computed using W. Kahan's formula. See: http://www.plunk.org/~hatch/rightway.php */ diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h index b0f0b78fc..0e02a1b20 100644 --- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h +++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h @@ -32,24 +32,12 @@ EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_float(const Packet _x); -/** \internal \returns log2(x) for single precision float */ -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog2_float(const Packet _x); - /** \internal \returns log(x) for single precision float */ template EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_double(const Packet _x); -/** \internal \returns log2(x) for single precision float */ -template -EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -EIGEN_UNUSED -Packet plog2_double(const Packet _x); - /** \internal \returns log(1 + x) */ template Packet generic_plog1p(const Packet& x); diff --git a/Eigen/src/Core/arch/Default/Half.h b/Eigen/src/Core/arch/Default/Half.h index db85f4edf..7029c500d 100644 --- a/Eigen/src/Core/arch/Default/Half.h +++ b/Eigen/src/Core/arch/Default/Half.h @@ -622,10 +622,6 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log1p(const half& a) { EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log10(const half& a) { return half(::log10f(float(a))); } -EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log2(const half& a) { - return half(static_cast(M_LOG2E) * ::logf(float(a))); -} - EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sqrt(const half& a) { #if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \ defined(EIGEN_HIP_DEVICE_COMPILE) diff --git a/Eigen/src/Core/arch/SSE/MathFunctions.h b/Eigen/src/Core/arch/SSE/MathFunctions.h index 2d7df2f7b..d5b62e86a 100644 --- a/Eigen/src/Core/arch/SSE/MathFunctions.h +++ b/Eigen/src/Core/arch/SSE/MathFunctions.h @@ -29,16 +29,6 @@ Packet2d plog(const Packet2d& _x) { return plog_double(_x); } -template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f plog2(const Packet4f& _x) { - return plog2_float(_x); -} - -template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet2d plog2(const Packet2d& _x) { - return plog2_double(_x); -} - template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog1p(const Packet4f& _x) { return generic_plog1p(_x); diff --git a/Eigen/src/Core/functors/UnaryFunctors.h b/Eigen/src/Core/functors/UnaryFunctors.h index c037576dc..8c0ed8481 100644 --- a/Eigen/src/Core/functors/UnaryFunctors.h +++ b/Eigen/src/Core/functors/UnaryFunctors.h @@ -395,22 +395,6 @@ template struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, PacketAccess = packet_traits::HasLog10 }; }; -/** \internal - * - * \brief Template functor to compute the base-2 logarithm of a scalar - * - * \sa class CwiseUnaryOp, Cwise::log2() - */ -template struct scalar_log2_op { - EIGEN_EMPTY_STRUCT_CTOR(scalar_log2_op) - EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return Scalar(M_LOG2E) * std::log(a); } - template - EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog2(a); } -}; -template -struct functor_traits > -{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = packet_traits::HasLog }; }; - /** \internal * \brief Template functor to compute the square root of a scalar * \sa class CwiseUnaryOp, Cwise::sqrt() diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/Eigen/src/plugins/ArrayCwiseUnaryOps.h index b7ea22a9d..59a4ee6a0 100644 --- a/Eigen/src/plugins/ArrayCwiseUnaryOps.h +++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.h @@ -14,7 +14,6 @@ typedef CwiseUnaryOp, const Derived> Expm1Retu typedef CwiseUnaryOp, const Derived> LogReturnType; typedef CwiseUnaryOp, const Derived> Log1pReturnType; typedef CwiseUnaryOp, const Derived> Log10ReturnType; -typedef CwiseUnaryOp, const Derived> Log2ReturnType; typedef CwiseUnaryOp, const Derived> CosReturnType; typedef CwiseUnaryOp, const Derived> SinReturnType; typedef CwiseUnaryOp, const Derived> TanReturnType; @@ -160,18 +159,6 @@ log10() const return Log10ReturnType(derived()); } -/** \returns an expression of the coefficient-wise base-2 logarithm of *this. - * - * This function computes the coefficient-wise base-2 logarithm. - * - */ -EIGEN_DEVICE_FUNC -inline const Log2ReturnType -log2() const -{ - return Log2ReturnType(derived()); -} - /** \returns an expression of the coefficient-wise square root of *this. * * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the diff --git a/test/array_cwise.cpp b/test/array_cwise.cpp index 6910f0e1f..48c0935a4 100644 --- a/test/array_cwise.cpp +++ b/test/array_cwise.cpp @@ -319,7 +319,6 @@ template void array_real(const ArrayType& m) VERIFY_IS_APPROX(m3.log(), log(m3)); VERIFY_IS_APPROX(m3.log1p(), log1p(m3)); VERIFY_IS_APPROX(m3.log10(), log10(m3)); - VERIFY_IS_APPROX(m3.log2(), log2(m3)); VERIFY((!(m1>m2) == (m1<=m2)).all()); @@ -373,7 +372,6 @@ template void array_real(const ArrayType& m) VERIFY_IS_APPROX(pow(m3,RealScalar(-0.5)), m3.rsqrt()); VERIFY_IS_APPROX(log10(m3), log(m3)/log(10)); - VERIFY_IS_APPROX(log2(m3), log(m3)/log(2)); // scalar by array division const RealScalar tiny = sqrt(std::numeric_limits::epsilon()); @@ -425,7 +423,6 @@ template void array_complex(const ArrayType& m) VERIFY_IS_APPROX(m1.inverse(), inverse(m1)); VERIFY_IS_APPROX(m1.log(), log(m1)); VERIFY_IS_APPROX(m1.log10(), log10(m1)); - VERIFY_IS_APPROX(m1.log2(), log2(m1)); VERIFY_IS_APPROX(m1.abs(), abs(m1)); VERIFY_IS_APPROX(m1.abs2(), abs2(m1)); VERIFY_IS_APPROX(m1.sqrt(), sqrt(m1)); @@ -481,7 +478,6 @@ template void array_complex(const ArrayType& m) VERIFY_IS_APPROX(abs(m1), sqrt(square(m1.real())+square(m1.imag()))); VERIFY_IS_APPROX(abs(m1), sqrt(abs2(m1))); VERIFY_IS_APPROX(log10(m1), log(m1)/log(10)); - VERIFY_IS_APPROX(log2(m1), log(m1)/log(2)); VERIFY_IS_APPROX( m1.sign(), -(-m1).sign() ); VERIFY_IS_APPROX( m1.sign() * m1.abs(), m1); diff --git a/test/packetmath.cpp b/test/packetmath.cpp index d995e8b71..ae0ead820 100644 --- a/test/packetmath.cpp +++ b/test/packetmath.cpp @@ -488,13 +488,6 @@ void packetmath() { packetmath_minus_zero_add(); } -// Notice that this definition works for complex types as well. -// c++11 has std::log2 for real, but not for complex types. -template -Scalar log2(Scalar x) { - return Scalar(M_LOG2E) * std::log(x); -} - template void packetmath_real() { typedef internal::packet_traits PacketTraits; @@ -513,7 +506,6 @@ void packetmath_real() { if (internal::random(0, 1) < 0.1f) data1[internal::random(0, PacketSize)] = Scalar(0); CHECK_CWISE1_IF(PacketTraits::HasLog, std::log, internal::plog); - CHECK_CWISE1_IF(PacketTraits::HasLog, log2, internal::plog2); CHECK_CWISE1_IF(PacketTraits::HasRsqrt, 1 / std::sqrt, internal::prsqrt); for (int i = 0; i < size; ++i) { -- cgit v1.2.3