diff --git a/Eigen/src/Core/Visitor.h b/Eigen/src/Core/Visitor.h
index 037a605..0302646 100644
--- a/Eigen/src/Core/Visitor.h
+++ b/Eigen/src/Core/Visitor.h
@@ -781,7 +781,7 @@
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::allFinite() const {
-  return derived().array().isFinite().all();
+  return derived().array().isFiniteTyped().all();
 }
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/util/Meta.h b/Eigen/src/Core/util/Meta.h
index d2336ce..80c893d 100644
--- a/Eigen/src/Core/util/Meta.h
+++ b/Eigen/src/Core/util/Meta.h
@@ -638,19 +638,23 @@
 template <typename A>
 constexpr bool is_int_or_enum_v = std::is_enum<A>::value || std::is_integral<A>::value;
 
+template <typename A, typename B>
+inline constexpr void plain_enum_asserts(A, B) {
+  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
+  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+}
+
 /// \internal Gets the minimum of two values which may be integers or enums
 template <typename A, typename B>
 inline constexpr int plain_enum_min(A a, B b) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  plain_enum_asserts(a, b);
   return ((int)a <= (int)b) ? (int)a : (int)b;
 }
 
 /// \internal Gets the maximum of two values which may be integers or enums
 template <typename A, typename B>
 inline constexpr int plain_enum_max(A a, B b) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  plain_enum_asserts(a, b);
   return ((int)a >= (int)b) ? (int)a : (int)b;
 }
 
@@ -662,8 +666,7 @@
  */
 template <typename A, typename B>
 inline constexpr int min_size_prefer_dynamic(A a, B b) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  plain_enum_asserts(a, b);
   if ((int)a == 0 || (int)b == 0) return 0;
   if ((int)a == 1 || (int)b == 1) return 1;
   if ((int)a == Dynamic || (int)b == Dynamic) return Dynamic;
@@ -678,8 +681,7 @@
  */
 template <typename A, typename B>
 inline constexpr int min_size_prefer_fixed(A a, B b) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  plain_enum_asserts(a, b);
   if ((int)a == 0 || (int)b == 0) return 0;
   if ((int)a == 1 || (int)b == 1) return 1;
   if ((int)a == Dynamic && (int)b == Dynamic) return Dynamic;
@@ -691,12 +693,46 @@
 /// \internal see `min_size_prefer_fixed`. No need for a separate variant for MaxSizes here.
 template <typename A, typename B>
 inline constexpr int max_size_prefer_dynamic(A a, B b) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  plain_enum_asserts(a, b);
   if ((int)a == Dynamic || (int)b == Dynamic) return Dynamic;
   return plain_enum_max(a, b);
 }
 
+template <typename A, typename B>
+inline constexpr bool enum_eq_not_dynamic(A a, B b) {
+  plain_enum_asserts(a, b);
+  if ((int)a == Dynamic || (int)b == Dynamic) return false;
+  return (int)a == (int)b;
+}
+
+template <typename A, typename B>
+inline constexpr bool enum_lt_not_dynamic(A a, B b) {
+  plain_enum_asserts(a, b);
+  if ((int)a == Dynamic || (int)b == Dynamic) return false;
+  return (int)a < (int)b;
+}
+
+template <typename A, typename B>
+inline constexpr bool enum_le_not_dynamic(A a, B b) {
+  plain_enum_asserts(a, b);
+  if ((int)a == Dynamic || (int)b == Dynamic) return false;
+  return (int)a <= (int)b;
+}
+
+template <typename A, typename B>
+inline constexpr bool enum_gt_not_dynamic(A a, B b) {
+  plain_enum_asserts(a, b);
+  if ((int)a == Dynamic || (int)b == Dynamic) return false;
+  return (int)a > (int)b;
+}
+
+template <typename A, typename B>
+inline constexpr bool enum_ge_not_dynamic(A a, B b) {
+  plain_enum_asserts(a, b);
+  if ((int)a == Dynamic || (int)b == Dynamic) return false;
+  return (int)a >= (int)b;
+}
+
 /// \internal Calculate logical XOR at compile time
 inline constexpr bool logical_xor(bool a, bool b) { return a != b; }
 
diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
index 5e5d45b..3f9d4e8 100644
--- a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
+++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
@@ -1,5 +1,3 @@
-
-
 typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
 typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
 typedef CwiseUnaryOp<internal::scalar_carg_op<Scalar>, const Derived> CArgReturnType;
@@ -41,6 +39,7 @@
 typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
 typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
 typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived> IsFiniteTypedReturnType;
 
 /** \returns an expression of the coefficient-wise absolute value of \c *this
  *
@@ -417,6 +416,9 @@
  * \sa isnan(), isinf()
  */
 EIGEN_DEVICE_FUNC inline const IsFiniteReturnType isFinite() const { return IsFiniteReturnType(derived()); }
+EIGEN_DEVICE_FUNC inline const IsFiniteTypedReturnType isFiniteTyped() const {
+  return IsFiniteTypedReturnType(derived());
+}
 
 /** \returns an expression of the coefficient-wise ! operator of *this
  *
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
index 74f2e6f..785cd4a 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
@@ -37,9 +37,7 @@
 template <typename DerivativeType, typename OtherDerivativeType>
 struct maybe_coherent_pad_helper<
     DerivativeType, OtherDerivativeType,
-    std::enable_if_t<DerivativeType::SizeAtCompileTime >= OtherDerivativeType::SizeAtCompileTime &&
-                     DerivativeType::SizeAtCompileTime != Dynamic &&
-                     OtherDerivativeType::SizeAtCompileTime != Dynamic>> {
+    std::enable_if_t<enum_ge_not_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime)>> {
   using type = const DerivativeType&;
   static const DerivativeType& pad(const DerivativeType& x, const OtherDerivativeType& /*y*/) { return x; }
 };