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));