Fix "unary minus operator applied to unsigned type, result still unsigned" on MSVC and other stupid warnings
diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h
index eab717f..61f0eb9 100644
--- a/Eigen/src/Core/GenericPacketMath.h
+++ b/Eigen/src/Core/GenericPacketMath.h
@@ -335,12 +335,9 @@
/** \internal \returns -a (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet pnegate(const Packet& a) {
- return -a;
-}
-
-template <>
-EIGEN_DEVICE_FUNC inline bool pnegate(const bool& a) {
- return !a;
+ EIGEN_STATIC_ASSERT((!is_same<typename unpacket_traits<Packet>::type, bool>::value),
+ NEGATE IS NOT DEFINED FOR BOOLEAN TYPES)
+ return numext::negate(a);
}
/** \internal \returns conj(a) (coeff-wise) */
@@ -1117,8 +1114,9 @@
/** \internal \returns the log10 of \a a (coeff-wise) */
template <typename Packet>
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog2(const Packet& a) {
- typedef typename internal::unpacket_traits<Packet>::type Scalar;
- return pmul(pset1<Packet>(Scalar(EIGEN_LOG2E)), plog(a));
+ using Scalar = typename internal::unpacket_traits<Packet>::type;
+ using RealScalar = typename NumTraits<Scalar>::Real;
+ return pmul(pset1<Packet>(Scalar(RealScalar(EIGEN_LOG2E))), plog(a));
}
/** \internal \returns the square-root of \a a (coeff-wise) */
@@ -1403,6 +1401,12 @@
template <size_t N>
struct Selector {
bool select[N];
+ template <typename MaskType = int>
+ EIGEN_DEVICE_FUNC inline MaskType mask(size_t begin = 0, size_t end = N) const {
+ MaskType res = 0;
+ for (size_t i = begin; i < end; i++) res |= (static_cast<MaskType>(select[i]) << i);
+ return res;
+ }
};
template <typename Packet>
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h
index f907d1e..2a42b18 100644
--- a/Eigen/src/Core/MathFunctions.h
+++ b/Eigen/src/Core/MathFunctions.h
@@ -861,6 +861,25 @@
typedef Scalar type;
};
+// suppress "unary minus operator applied to unsigned type, result still unsigned" warnings on MSVC
+// note: `0 - a` is distinct from `-a` when Scalar is a floating point type and `a` is zero
+
+template <typename Scalar, bool IsInteger = NumTraits<Scalar>::IsInteger>
+struct negate_impl {
+ static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run(const Scalar& a) { return -a; }
+};
+
+template <typename Scalar>
+struct negate_impl<Scalar, true> {
+ EIGEN_STATIC_ASSERT((!is_same<Scalar, bool>::value), NEGATE IS NOT DEFINED FOR BOOLEAN TYPES)
+ static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run(const Scalar& a) { return Scalar(0) - a; }
+};
+
+template <typename Scalar>
+struct negate_retval {
+ typedef Scalar type;
+};
+
template <typename Scalar, bool IsInteger = NumTraits<typename unpacket_traits<Scalar>::type>::IsInteger>
struct nearest_integer_impl {
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar run_floor(const Scalar& x) {
@@ -1067,6 +1086,11 @@
}
template <typename Scalar>
+EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(negate, Scalar) negate(const Scalar& x) {
+ return EIGEN_MATHFUNC_IMPL(negate, Scalar)::run(x);
+}
+
+template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
}
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c1bed80..5c53556 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2147,20 +2147,13 @@
template <>
EIGEN_STRONG_INLINE Packet16f pblend(const Selector<16>& ifPacket, const Packet16f& thenPacket,
const Packet16f& elsePacket) {
- __mmask16 m = (ifPacket.select[0]) | (ifPacket.select[1] << 1) | (ifPacket.select[2] << 2) |
- (ifPacket.select[3] << 3) | (ifPacket.select[4] << 4) | (ifPacket.select[5] << 5) |
- (ifPacket.select[6] << 6) | (ifPacket.select[7] << 7) | (ifPacket.select[8] << 8) |
- (ifPacket.select[9] << 9) | (ifPacket.select[10] << 10) | (ifPacket.select[11] << 11) |
- (ifPacket.select[12] << 12) | (ifPacket.select[13] << 13) | (ifPacket.select[14] << 14) |
- (ifPacket.select[15] << 15);
+ __mmask16 m = ifPacket.mask<__mmask16>();
return _mm512_mask_blend_ps(m, elsePacket, thenPacket);
}
template <>
EIGEN_STRONG_INLINE Packet8d pblend(const Selector<8>& ifPacket, const Packet8d& thenPacket,
const Packet8d& elsePacket) {
- __mmask8 m = (ifPacket.select[0]) | (ifPacket.select[1] << 1) | (ifPacket.select[2] << 2) |
- (ifPacket.select[3] << 3) | (ifPacket.select[4] << 4) | (ifPacket.select[5] << 5) |
- (ifPacket.select[6] << 6) | (ifPacket.select[7] << 7);
+ __mmask8 m = ifPacket.mask<__mmask8>();
return _mm512_mask_blend_pd(m, elsePacket, thenPacket);
}
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h
index 008109a..e91ef4d 100644
--- a/Eigen/src/Core/arch/SSE/PacketMath.h
+++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -296,6 +296,7 @@
HasMax = 0,
HasConj = 0,
HasSqrt = 1,
+ HasNegate = 0,
HasSign = 0 // Don't try to vectorize psign<bool> = identity.
};
};
@@ -602,11 +603,6 @@
}
template <>
-EIGEN_STRONG_INLINE Packet16b pnegate(const Packet16b& a) {
- return a;
-}
-
-template <>
EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
return a;
}
diff --git a/Eigen/src/Core/functors/UnaryFunctors.h b/Eigen/src/Core/functors/UnaryFunctors.h
index 2f9b920..8d95819 100644
--- a/Eigen/src/Core/functors/UnaryFunctors.h
+++ b/Eigen/src/Core/functors/UnaryFunctors.h
@@ -24,7 +24,7 @@
*/
template <typename Scalar>
struct scalar_opposite_op {
- EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const { return -a; }
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const { return numext::negate(a); }
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const {
return internal::pnegate(a);
@@ -455,8 +455,9 @@
*/
template <typename Scalar>
struct scalar_log2_op {
+ using RealScalar = typename NumTraits<Scalar>::Real;
EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const {
- return Scalar(EIGEN_LOG2E) * numext::log(a);
+ return Scalar(RealScalar(EIGEN_LOG2E)) * numext::log(a);
}
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
diff --git a/test/array_cwise.cpp b/test/array_cwise.cpp
index 543ef2e..9fb104c 100644
--- a/test/array_cwise.cpp
+++ b/test/array_cwise.cpp
@@ -614,9 +614,9 @@
VERIFY(o2.cols() == cols);
ArrayType2 o3(rows, cols);
- VERIFY(o3(0) == Scalar(rows) && o3(1) == Scalar(cols));
+ VERIFY(o3(0) == RealScalar(rows) && o3(1) == RealScalar(cols));
ArrayType2 o4(static_cast<int>(rows), static_cast<int>(cols));
- VERIFY(o4(0) == Scalar(rows) && o4(1) == Scalar(cols));
+ VERIFY(o4(0) == RealScalar(rows) && o4(1) == RealScalar(cols));
}
{
TwoDArrayType o1{rows, cols};
@@ -627,9 +627,9 @@
VERIFY(o2.cols() == cols);
ArrayType2 o3{rows, cols};
- VERIFY(o3(0) == Scalar(rows) && o3(1) == Scalar(cols));
+ VERIFY(o3(0) == RealScalar(rows) && o3(1) == RealScalar(cols));
ArrayType2 o4{int(rows), int(cols)};
- VERIFY(o4(0) == Scalar(rows) && o4(1) == Scalar(cols));
+ VERIFY(o4(0) == RealScalar(rows) && o4(1) == RealScalar(cols));
}
}
diff --git a/test/bfloat16_float.cpp b/test/bfloat16_float.cpp
index 922a6d1..5be49d9 100644
--- a/test/bfloat16_float.cpp
+++ b/test/bfloat16_float.cpp
@@ -82,7 +82,7 @@
// Conversion to bool
VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(3)), true);
VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(0.33333f)), true);
- VERIFY_IS_EQUAL(bfloat16(-0.0), false);
+ VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(-0.0)), false);
VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(0.0)), false);
// Explicit conversion to float.
diff --git a/test/geo_eulerangles.cpp b/test/geo_eulerangles.cpp
index 3d443de..11c0449 100644
--- a/test/geo_eulerangles.cpp
+++ b/test/geo_eulerangles.cpp
@@ -23,6 +23,7 @@
typedef AngleAxis<Scalar> AngleAxisx;
const Matrix3 m(AngleAxisx(ea[0], Vector3::Unit(i)) * AngleAxisx(ea[1], Vector3::Unit(j)) *
AngleAxisx(ea[2], Vector3::Unit(k)));
+ const Scalar kPi = Scalar(EIGEN_PI);
// Test non-canonical eulerAngles
{
@@ -33,11 +34,11 @@
// approx_or_less_than does not work for 0
VERIFY(0 < eabis[0] || test_isMuchSmallerThan(eabis[0], Scalar(1)));
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[0], Scalar(EIGEN_PI));
- VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(EIGEN_PI), eabis[1]);
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], Scalar(EIGEN_PI));
- VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(EIGEN_PI), eabis[2]);
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[2], Scalar(EIGEN_PI));
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[0], kPi);
+ VERIFY_IS_APPROX_OR_LESS_THAN(-kPi, eabis[1]);
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], kPi);
+ VERIFY_IS_APPROX_OR_LESS_THAN(-kPi, eabis[2]);
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[2], kPi);
}
// Test canonicalEulerAngles
@@ -47,20 +48,20 @@
AngleAxisx(eabis[2], Vector3::Unit(k)));
VERIFY_IS_APPROX(m, mbis);
- VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(EIGEN_PI), eabis[0]);
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[0], Scalar(EIGEN_PI));
+ VERIFY_IS_APPROX_OR_LESS_THAN(-kPi, eabis[0]);
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[0], kPi);
if (i != k) {
// Tait-Bryan sequence
- VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(EIGEN_PI / 2), eabis[1]);
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], Scalar(EIGEN_PI / 2));
+ VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(kPi / 2), eabis[1]);
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], Scalar(kPi / 2));
} else {
// Proper Euler sequence
// approx_or_less_than does not work for 0
VERIFY(0 < eabis[1] || test_isMuchSmallerThan(eabis[1], Scalar(1)));
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], Scalar(EIGEN_PI));
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[1], kPi);
}
- VERIFY_IS_APPROX_OR_LESS_THAN(-Scalar(EIGEN_PI), eabis[2]);
- VERIFY_IS_APPROX_OR_LESS_THAN(eabis[2], Scalar(EIGEN_PI));
+ VERIFY_IS_APPROX_OR_LESS_THAN(-kPi, eabis[2]);
+ VERIFY_IS_APPROX_OR_LESS_THAN(eabis[2], kPi);
}
}
@@ -100,7 +101,10 @@
typedef Quaternion<Scalar> Quaternionx;
typedef AngleAxis<Scalar> AngleAxisx;
- Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+ const Scalar kPi = Scalar(EIGEN_PI);
+ const Scalar smallVal = static_cast<Scalar>(0.001);
+
+ Scalar a = internal::random<Scalar>(-kPi, kPi);
Quaternionx q1;
q1 = AngleAxisx(a, Vector3::Random().normalized());
Matrix3 m;
@@ -120,65 +124,65 @@
check_all_var(ea);
// Check with random angles in range [-pi:pi]x[-pi:pi]x[-pi:pi].
- ea = Array3::Random() * Scalar(EIGEN_PI);
+ ea = Array3::Random() * kPi;
check_all_var(ea);
- auto test_with_some_zeros = [](const Vector3& eaz) {
+ auto test_with_some_zeros = [=](const Vector3& eaz) {
check_all_var(eaz);
Vector3 ea_glz = eaz;
ea_glz[0] = Scalar(0);
check_all_var(ea_glz);
- ea_glz[0] = internal::random<Scalar>(-0.001, 0.001);
+ ea_glz[0] = internal::random<Scalar>(-smallVal, smallVal);
check_all_var(ea_glz);
ea_glz[2] = Scalar(0);
check_all_var(ea_glz);
- ea_glz[2] = internal::random<Scalar>(-0.001, 0.001);
+ ea_glz[2] = internal::random<Scalar>(-smallVal, smallVal);
check_all_var(ea_glz);
};
// Check gimbal lock configurations and a bit noisy gimbal locks
Vector3 ea_gl = ea;
- ea_gl[1] = EIGEN_PI / 2;
+ ea_gl[1] = kPi / 2;
test_with_some_zeros(ea_gl);
- ea_gl[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_gl[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_gl[1] = -EIGEN_PI / 2;
+ ea_gl[1] = -kPi / 2;
test_with_some_zeros(ea_gl);
- ea_gl[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_gl[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_gl[1] = EIGEN_PI / 2;
+ ea_gl[1] = kPi / 2;
ea_gl[2] = ea_gl[0];
test_with_some_zeros(ea_gl);
- ea_gl[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_gl[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_gl[1] = -EIGEN_PI / 2;
+ ea_gl[1] = -kPi / 2;
test_with_some_zeros(ea_gl);
- ea_gl[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_gl[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
// Similar to above, but with pi instead of pi/2
Vector3 ea_pi = ea;
- ea_pi[1] = EIGEN_PI;
+ ea_pi[1] = kPi;
test_with_some_zeros(ea_gl);
- ea_pi[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_pi[1] = -EIGEN_PI;
+ ea_pi[1] = -kPi;
test_with_some_zeros(ea_gl);
- ea_pi[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_pi[1] = EIGEN_PI;
+ ea_pi[1] = kPi;
ea_pi[2] = ea_pi[0];
test_with_some_zeros(ea_gl);
- ea_pi[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea_pi[1] = -EIGEN_PI;
+ ea_pi[1] = -kPi;
test_with_some_zeros(ea_gl);
- ea_pi[1] += internal::random<Scalar>(-0.001, 0.001);
+ ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
test_with_some_zeros(ea_gl);
- ea[2] = ea[0] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
+ ea[2] = ea[0] = internal::random<Scalar>(0, kPi);
check_all_var(ea);
- ea[0] = ea[1] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
+ ea[0] = ea[1] = internal::random<Scalar>(0, kPi);
check_all_var(ea);
ea[1] = 0;
diff --git a/test/indexed_view.cpp b/test/indexed_view.cpp
index 1f1e808..064cc4a 100644
--- a/test/indexed_view.cpp
+++ b/test/indexed_view.cpp
@@ -790,6 +790,7 @@
VERIFY_IS_EQUAL(int(slice1.SizeAtCompileTime), 6);
VERIFY_IS_EQUAL(int(slice2.SizeAtCompileTime), 6);
auto slice3 = A(all, seq(fix<0>, last, fix<2>));
+ TEST_SET_BUT_UNUSED_VARIABLE(slice3)
VERIFY_IS_EQUAL(int(slice3.RowsAtCompileTime), kRows);
VERIFY_IS_EQUAL(int(slice3.ColsAtCompileTime), (kCols + 1) / 2);
}
diff --git a/test/mapstaticmethods.cpp b/test/mapstaticmethods.cpp
index ac90bdc..b18b24a 100644
--- a/test/mapstaticmethods.cpp
+++ b/test/mapstaticmethods.cpp
@@ -9,21 +9,14 @@
#include "main.h"
-// GCC<=4.8 has spurious shadow warnings, because `ptr` re-appears inside template instantiations
-// workaround: put these in an anonymous namespace
-namespace {
-float* ptr;
-const float* const_ptr;
-} // namespace
-
template <typename PlainObjectType, bool IsDynamicSize = PlainObjectType::SizeAtCompileTime == Dynamic,
bool IsVector = PlainObjectType::IsVectorAtCompileTime>
struct mapstaticmethods_impl {};
template <typename PlainObjectType, bool IsVector>
struct mapstaticmethods_impl<PlainObjectType, false, IsVector> {
- static void run(const PlainObjectType& m) {
- mapstaticmethods_impl<PlainObjectType, true, IsVector>::run(m);
+ static void run(const PlainObjectType& m, float* ptr, const float* const_ptr) {
+ mapstaticmethods_impl<PlainObjectType, true, IsVector>::run(m, ptr, const_ptr);
int i = internal::random<int>(2, 5), j = internal::random<int>(2, 5);
@@ -66,7 +59,7 @@
template <typename PlainObjectType>
struct mapstaticmethods_impl<PlainObjectType, true, false> {
- static void run(const PlainObjectType& m) {
+ static void run(const PlainObjectType& m, float* ptr, const float* const_ptr) {
Index rows = m.rows(), cols = m.cols();
int i = internal::random<int>(2, 5), j = internal::random<int>(2, 5);
@@ -110,7 +103,7 @@
template <typename PlainObjectType>
struct mapstaticmethods_impl<PlainObjectType, true, true> {
- static void run(const PlainObjectType& v) {
+ static void run(const PlainObjectType& v, float* ptr, const float* const_ptr) {
Index size = v.size();
int i = internal::random<int>(2, 5);
@@ -133,34 +126,34 @@
};
template <typename PlainObjectType>
-void mapstaticmethods(const PlainObjectType& m) {
- mapstaticmethods_impl<PlainObjectType>::run(m);
+void mapstaticmethods(const PlainObjectType& m, float* ptr, const float* const_ptr) {
+ mapstaticmethods_impl<PlainObjectType>::run(m, ptr, const_ptr);
VERIFY(true); // just to avoid 'unused function' warning
}
EIGEN_DECLARE_TEST(mapstaticmethods) {
- ptr = internal::aligned_new<float>(1000);
+ float* ptr = internal::aligned_new<float>(1000);
for (int i = 0; i < 1000; i++) ptr[i] = float(i);
- const_ptr = ptr;
+ const float* const_ptr = ptr;
- CALL_SUBTEST_1((mapstaticmethods(Matrix<float, 1, 1>())));
- CALL_SUBTEST_1((mapstaticmethods(Vector2f())));
- CALL_SUBTEST_2((mapstaticmethods(Vector3f())));
- CALL_SUBTEST_2((mapstaticmethods(Matrix2f())));
- CALL_SUBTEST_3((mapstaticmethods(Matrix4f())));
- CALL_SUBTEST_3((mapstaticmethods(Array4f())));
- CALL_SUBTEST_4((mapstaticmethods(Array3f())));
- CALL_SUBTEST_4((mapstaticmethods(Array33f())));
- CALL_SUBTEST_5((mapstaticmethods(Array44f())));
- CALL_SUBTEST_5((mapstaticmethods(VectorXf(1))));
- CALL_SUBTEST_5((mapstaticmethods(VectorXf(8))));
- CALL_SUBTEST_6((mapstaticmethods(MatrixXf(1, 1))));
- CALL_SUBTEST_6((mapstaticmethods(MatrixXf(5, 7))));
- CALL_SUBTEST_7((mapstaticmethods(ArrayXf(1))));
- CALL_SUBTEST_7((mapstaticmethods(ArrayXf(5))));
- CALL_SUBTEST_8((mapstaticmethods(ArrayXXf(1, 1))));
- CALL_SUBTEST_8((mapstaticmethods(ArrayXXf(8, 6))));
+ CALL_SUBTEST_1((mapstaticmethods(Matrix<float, 1, 1>(), ptr, const_ptr)));
+ CALL_SUBTEST_1((mapstaticmethods(Vector2f(), ptr, const_ptr)));
+ CALL_SUBTEST_2((mapstaticmethods(Vector3f(), ptr, const_ptr)));
+ CALL_SUBTEST_2((mapstaticmethods(Matrix2f(), ptr, const_ptr)));
+ CALL_SUBTEST_3((mapstaticmethods(Matrix4f(), ptr, const_ptr)));
+ CALL_SUBTEST_3((mapstaticmethods(Array4f(), ptr, const_ptr)));
+ CALL_SUBTEST_4((mapstaticmethods(Array3f(), ptr, const_ptr)));
+ CALL_SUBTEST_4((mapstaticmethods(Array33f(), ptr, const_ptr)));
+ CALL_SUBTEST_5((mapstaticmethods(Array44f(), ptr, const_ptr)));
+ CALL_SUBTEST_5((mapstaticmethods(VectorXf(1), ptr, const_ptr)));
+ CALL_SUBTEST_5((mapstaticmethods(VectorXf(8), ptr, const_ptr)));
+ CALL_SUBTEST_6((mapstaticmethods(MatrixXf(1, 1), ptr, const_ptr)));
+ CALL_SUBTEST_6((mapstaticmethods(MatrixXf(5, 7), ptr, const_ptr)));
+ CALL_SUBTEST_7((mapstaticmethods(ArrayXf(1), ptr, const_ptr)));
+ CALL_SUBTEST_7((mapstaticmethods(ArrayXf(5), ptr, const_ptr)));
+ CALL_SUBTEST_8((mapstaticmethods(ArrayXXf(1, 1), ptr, const_ptr)));
+ CALL_SUBTEST_8((mapstaticmethods(ArrayXXf(8, 6), ptr, const_ptr)));
internal::aligned_delete(ptr, 1000);
}
diff --git a/test/numext.cpp b/test/numext.cpp
index ac9b66d..a2d511b 100644
--- a/test/numext.cpp
+++ b/test/numext.cpp
@@ -34,26 +34,46 @@
#define VERIFY_IS_EQUAL_OR_NANS(a, b) VERIFY(test_is_equal_or_nans(a, b))
template <typename T>
+void check_negate() {
+ Index size = 1000;
+ for (Index i = 0; i < size; i++) {
+ T val = i == 0 ? T(0) : internal::random<T>(T(0), NumTraits<T>::highest());
+ T neg_val = numext::negate(val);
+ VERIFY_IS_EQUAL(T(val + neg_val), T(0));
+ VERIFY_IS_EQUAL(numext::negate(neg_val), val);
+ }
+}
+
+template <typename T>
void check_abs() {
typedef typename NumTraits<T>::Real Real;
Real zero(0);
- if (NumTraits<T>::IsSigned) VERIFY_IS_EQUAL(numext::abs(-T(1)), T(1));
+ if (NumTraits<T>::IsSigned) VERIFY_IS_EQUAL(numext::abs(numext::negate(T(1))), T(1));
VERIFY_IS_EQUAL(numext::abs(T(0)), T(0));
VERIFY_IS_EQUAL(numext::abs(T(1)), T(1));
for (int k = 0; k < 100; ++k) {
T x = internal::random<T>();
- if (!internal::is_same<T, bool>::value) x = x / Real(2);
+ x = x / Real(2);
if (NumTraits<T>::IsSigned) {
- VERIFY_IS_EQUAL(numext::abs(x), numext::abs(-x));
- VERIFY(numext::abs(-x) >= zero);
+ VERIFY_IS_EQUAL(numext::abs(x), numext::abs(numext::negate(x)));
+ VERIFY(numext::abs(numext::negate(x)) >= zero);
}
VERIFY(numext::abs(x) >= zero);
VERIFY_IS_APPROX(numext::abs2(x), numext::abs2(numext::abs(x)));
}
}
+template <>
+void check_abs<bool>() {
+ for (bool x : {true, false}) {
+ VERIFY_IS_EQUAL(numext::abs(x), x);
+ VERIFY(numext::abs(x) >= false);
+ VERIFY_IS_EQUAL(numext::abs2(x), numext::abs2(numext::abs(x)));
+ }
+}
+
template <typename T>
void check_arg() {
typedef typename NumTraits<T>::Real Real;
@@ -236,16 +256,17 @@
negative_values = {static_cast<T>(-1), static_cast<T>(NumTraits<T>::lowest())};
non_negative_values = {static_cast<T>(0), static_cast<T>(1), static_cast<T>(NumTraits<T>::highest())};
} else {
- // has sign bit
- const T neg_zero = static_cast<T>(-0.0);
- const T neg_one = static_cast<T>(-1.0);
- const T neg_inf = -std::numeric_limits<T>::infinity();
- const T neg_nan = -std::numeric_limits<T>::quiet_NaN();
// does not have sign bit
const T pos_zero = static_cast<T>(0.0);
const T pos_one = static_cast<T>(1.0);
const T pos_inf = std::numeric_limits<T>::infinity();
const T pos_nan = std::numeric_limits<T>::quiet_NaN();
+ // has sign bit
+ const T neg_zero = numext::negate(pos_zero);
+ const T neg_one = numext::negate(pos_one);
+ const T neg_inf = numext::negate(pos_inf);
+ const T neg_nan = numext::negate(pos_nan);
+
negative_values = {neg_zero, neg_one, neg_inf, neg_nan};
non_negative_values = {pos_zero, pos_one, pos_inf, pos_nan};
}
@@ -273,6 +294,22 @@
EIGEN_DECLARE_TEST(numext) {
for (int k = 0; k < g_repeat; ++k) {
+ CALL_SUBTEST(check_negate<signed char>());
+ CALL_SUBTEST(check_negate<unsigned char>());
+ CALL_SUBTEST(check_negate<short>());
+ CALL_SUBTEST(check_negate<unsigned short>());
+ CALL_SUBTEST(check_negate<int>());
+ CALL_SUBTEST(check_negate<unsigned int>());
+ CALL_SUBTEST(check_negate<long>());
+ CALL_SUBTEST(check_negate<unsigned long>());
+ CALL_SUBTEST(check_negate<half>());
+ CALL_SUBTEST(check_negate<bfloat16>());
+ CALL_SUBTEST(check_negate<float>());
+ CALL_SUBTEST(check_negate<double>());
+ CALL_SUBTEST(check_negate<long double>());
+ CALL_SUBTEST(check_negate<std::complex<float> >());
+ CALL_SUBTEST(check_negate<std::complex<double> >());
+
CALL_SUBTEST(check_abs<bool>());
CALL_SUBTEST(check_abs<signed char>());
CALL_SUBTEST(check_abs<unsigned char>());
diff --git a/test/packetmath.cpp b/test/packetmath.cpp
index db8c9b5..8bfa321 100644
--- a/test/packetmath.cpp
+++ b/test/packetmath.cpp
@@ -34,11 +34,11 @@
}
template <typename T>
inline T REF_NMADD(const T& a, const T& b, const T& c) {
- return (-a * b) + c;
+ return c - a * b;
}
template <typename T>
inline T REF_NMSUB(const T& a, const T& b, const T& c) {
- return (-a * b) - c;
+ return test::negate(a * b + c);
}
template <typename T>
inline T REF_DIV(const T& a, const T& b) {
@@ -427,6 +427,32 @@
}
};
+template <typename Scalar, typename Packet, bool HasNegate = internal::packet_traits<Scalar>::HasNegate>
+struct negate_test_impl {
+ static void run_negate(Scalar* data1, Scalar* data2, Scalar* ref, int PacketSize) {
+ CHECK_CWISE1_IF(HasNegate, test::negate, internal::pnegate);
+ }
+ static void run_nmsub(Scalar* data1, Scalar* data2, Scalar* ref, int PacketSize) {
+ CHECK_CWISE3_IF(HasNegate, REF_NMSUB, internal::pnmsub);
+ }
+};
+
+template <typename Scalar, typename Packet>
+struct negate_test_impl<Scalar, Packet, false> {
+ static void run_negate(Scalar*, Scalar*, Scalar*, int) {}
+ static void run_nmsub(Scalar*, Scalar*, Scalar*, int) {}
+};
+
+template <typename Scalar, typename Packet>
+void negate_test(Scalar* data1, Scalar* data2, Scalar* ref, int size) {
+ negate_test_impl<Scalar, Packet>::run_negate(data1, data2, ref, size);
+}
+
+template <typename Scalar, typename Packet>
+void nmsub_test(Scalar* data1, Scalar* data2, Scalar* ref, int size) {
+ negate_test_impl<Scalar, Packet>::run_negate(data1, data2, ref, size);
+}
+
template <typename Scalar, typename Packet>
void packetmath() {
typedef internal::packet_traits<Scalar> PacketTraits;
@@ -533,7 +559,7 @@
CHECK_CWISE2_IF(PacketTraits::HasMul, REF_MUL, internal::pmul);
CHECK_CWISE2_IF(PacketTraits::HasDiv, REF_DIV, internal::pdiv);
- CHECK_CWISE1_IF(PacketTraits::HasNegate, test::negate, internal::pnegate);
+ negate_test<Scalar, Packet>(data1, data2, ref, PacketSize);
CHECK_CWISE1_IF(PacketTraits::HasReciprocal, REF_RECIPROCAL, internal::preciprocal);
CHECK_CWISE1(numext::conj, internal::pconj);
CHECK_CWISE1_IF(PacketTraits::HasSign, numext::sign, internal::psign);
@@ -689,7 +715,7 @@
CHECK_CWISE1_IF(PacketTraits::HasRsqrt, numext::rsqrt, internal::prsqrt);
CHECK_CWISE3_IF(true, REF_MADD, internal::pmadd);
if (!std::is_same<Scalar, bool>::value && NumTraits<Scalar>::IsSigned) {
- CHECK_CWISE3_IF(PacketTraits::HasNegate, REF_NMSUB, internal::pnmsub);
+ nmsub_test<Scalar, Packet>(data1, data2, ref, PacketSize);
}
// For pmsub, pnmadd, the values can cancel each other to become near zero,
@@ -698,11 +724,11 @@
for (int i = 0; i < PacketSize; ++i) {
data1[i] = numext::abs(internal::random<Scalar>());
data1[i + PacketSize] = numext::abs(internal::random<Scalar>());
- data1[i + 2 * PacketSize] = -numext::abs(internal::random<Scalar>());
+ data1[i + 2 * PacketSize] = Scalar(0) - numext::abs(internal::random<Scalar>());
}
if (!std::is_same<Scalar, bool>::value && NumTraits<Scalar>::IsSigned) {
CHECK_CWISE3_IF(true, REF_MSUB, internal::pmsub);
- CHECK_CWISE3_IF(PacketTraits::HasNegate, REF_NMADD, internal::pnmadd);
+ CHECK_CWISE3_IF(true, REF_NMADD, internal::pnmadd);
}
}
diff --git a/test/packetmath_test_shared.h b/test/packetmath_test_shared.h
index 86a01fb..d8de04b 100644
--- a/test/packetmath_test_shared.h
+++ b/test/packetmath_test_shared.h
@@ -22,11 +22,16 @@
namespace test {
-template <typename T>
+template <typename T, std::enable_if_t<NumTraits<T>::IsSigned, bool> = true>
T negate(const T& x) {
return -x;
}
+template <typename T, std::enable_if_t<!NumTraits<T>::IsSigned, bool> = true>
+T negate(const T& x) {
+ return T(0) - x;
+}
+
template <typename T>
Map<const Array<unsigned char, sizeof(T), 1> > bits(const T& x) {
return Map<const Array<unsigned char, sizeof(T), 1> >(reinterpret_cast<const unsigned char*>(&x));
diff --git a/test/sparse_vector.cpp b/test/sparse_vector.cpp
index 8d47fb0..e4b1963 100644
--- a/test/sparse_vector.cpp
+++ b/test/sparse_vector.cpp
@@ -110,29 +110,29 @@
// test move
{
- SparseVectorType v3(std::move(v1));
- VERIFY_IS_APPROX(v3, refV1);
- v1 = v3;
+ SparseVectorType tmp(std::move(v1));
+ VERIFY_IS_APPROX(tmp, refV1);
+ v1 = tmp;
}
{
- SparseVectorType v3;
- v3 = std::move(v1);
- VERIFY_IS_APPROX(v3, refV1);
- v1 = v3;
+ SparseVectorType tmp;
+ tmp = std::move(v1);
+ VERIFY_IS_APPROX(tmp, refV1);
+ v1 = tmp;
}
{
- SparseVectorType v3(std::move(mv1));
- VERIFY_IS_APPROX(v3, refV1);
- mv1 = v3;
+ SparseVectorType tmp(std::move(mv1));
+ VERIFY_IS_APPROX(tmp, refV1);
+ mv1 = tmp;
}
{
- SparseVectorType v3;
- v3 = std::move(mv1);
- VERIFY_IS_APPROX(v3, refV1);
- mv1 = v3;
+ SparseVectorType tmp;
+ tmp = std::move(mv1);
+ VERIFY_IS_APPROX(tmp, refV1);
+ mv1 = tmp;
}
// test conservative resize
diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp
index aac7248..dc1a5c7 100644
--- a/test/vectorization_logic.cpp
+++ b/test/vectorization_logic.cpp
@@ -287,6 +287,7 @@
typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half,
typename internal::packet_traits<Scalar>::type>::value>
struct vectorization_logic_half {
+ using RealScalar = typename NumTraits<Scalar>::Real;
typedef internal::packet_traits<Scalar> PacketTraits;
typedef typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half PacketType;
static constexpr int PacketSize = internal::unpacket_traits<PacketType>::size;
@@ -355,10 +356,12 @@
VERIFY(test_assign(Vector1(), Vector1().template segment<MinVSize>(0).derived(),
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal,
CompleteUnrolling));
- VERIFY(test_assign(Vector1(), Scalar(2.1) * Vector1() - Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
+ VERIFY(test_assign(Vector1(), Scalar(RealScalar(2.1)) * Vector1() - Vector1(), InnerVectorizedTraversal,
+ CompleteUnrolling));
VERIFY(test_assign(
Vector1(),
- (Scalar(2.1) * Vector1().template segment<MinVSize>(0) - Vector1().template segment<MinVSize>(0)).derived(),
+ (Scalar(RealScalar(2.1)) * Vector1().template segment<MinVSize>(0) - Vector1().template segment<MinVSize>(0))
+ .derived(),
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal, CompleteUnrolling));
VERIFY(test_assign(Vector1(), Vector1().cwiseProduct(Vector1()), InnerVectorizedTraversal, CompleteUnrolling));
VERIFY(test_assign(Vector1(), Vector1().template cast<Scalar>(), InnerVectorizedTraversal, CompleteUnrolling));
