diff --git a/include/ceres/jet.h b/include/ceres/jet.h
index b3c65fa..9a66317 100644
--- a/include/ceres/jet.h
+++ b/include/ceres/jet.h
@@ -164,11 +164,53 @@
 #include <limits>
 #include <numeric>
 #include <string>
+#include <type_traits>
 
 #include "Eigen/Core"
 #include "ceres/internal/port.h"
 
 namespace ceres {
+// Jet foward declaration necessary for the following partial specialization of
+// std::common_type.
+template <typename T, int N>
+struct Jet;
+}  // namespace ceres
+
+// Here we provide partial specializations of std::common_type for the Jet class
+// to allow determining a Jet type with a common underlying arithmetic type.
+// Such an arithmetic type can be either a scalar or an another Jet. An example
+// for a common type, say, between a float and a Jet<double, N> is a Jet<double,
+// N> (i.e., std::common_type_t<float, ceres::Jet<double, N>> and
+// ceres::Jet<double, N> refer to the same type.)
+//
+// The partial specialization are also used for determining compatible types by
+// means of SFINAE and thus allow such types to be expressed as operands of
+// logical comparison operators. Missing (partial) specialization of
+// std::common_type for a particular (custom) type will therefore disable the
+// use of comparison operators defined by Ceres.
+//
+// Since these partial specializations are used as SFINAE constraints, they
+// enable standard promotion rules between various scalar types and consequently
+// their use in comparison against a Jet without providing implicit
+// conversions from a scalar, such as an int, to a Jet (see the implementation
+// of logical comparison operators below).
+
+template <typename T, int N, typename U>
+struct std::common_type<T, ceres::Jet<U, N>> {
+  using type = ceres::Jet<common_type_t<T, U>, N>;
+};
+
+template <typename T, int N, typename U>
+struct std::common_type<ceres::Jet<T, N>, U> {
+  using type = ceres::Jet<common_type_t<T, U>, N>;
+};
+
+template <typename T, int N, typename U>
+struct std::common_type<ceres::Jet<T, N>, ceres::Jet<U, N>> {
+  using type = ceres::Jet<common_type_t<T, U>, N>;
+};
+
+namespace ceres {
 
 template <typename T, int N>
 struct Jet {
@@ -354,19 +396,32 @@
   return Jet<T, N>(f.a * s_inverse, f.v * s_inverse);
 }
 
-// Binary comparison operators for both scalars and jets.
-#define CERES_DEFINE_JET_COMPARISON_OPERATOR(op)                    \
-  template <typename T, int N>                                      \
-  inline bool operator op(const Jet<T, N>& f, const Jet<T, N>& g) { \
-    return f.a op g.a;                                              \
-  }                                                                 \
-  template <typename T, int N>                                      \
-  inline bool operator op(const T& s, const Jet<T, N>& g) {         \
-    return s op g.a;                                                \
-  }                                                                 \
-  template <typename T, int N>                                      \
-  inline bool operator op(const Jet<T, N>& f, const T& s) {         \
-    return f.a op s;                                                \
+// Binary comparison operators for both scalars and jets. std::common_type_t is
+// used as an SFINAE constraint to selectively enable compatible operand types.
+// This allows comparison, for instance, against int literals without implicit
+// conversion. In case the Jet arithmetic type is a Jet itself, a recursive
+// expansion of Jet value is performed.
+#define CERES_DEFINE_JET_COMPARISON_OPERATOR(op)                               \
+  template <typename T, int N>                                                 \
+  constexpr bool operator op(                                                  \
+      const Jet<T, N>& f, const Jet<T, N>& g) noexcept(noexcept(f.a op g.a)) { \
+    return f.a op g.a;                                                         \
+  }                                                                            \
+  template <typename T,                                                        \
+            int N,                                                             \
+            typename U,                                                        \
+            std::common_type_t<T, U>* = nullptr>                               \
+  constexpr bool operator op(                                                  \
+      const U& s, const Jet<T, N>& g) noexcept(noexcept(s op g.a)) {           \
+    return s op g.a;                                                           \
+  }                                                                            \
+  template <typename T,                                                        \
+            int N,                                                             \
+            typename U,                                                        \
+            std::common_type_t<T, U>* = nullptr>                               \
+  constexpr bool operator op(const Jet<T, N>& f,                               \
+                             const U& s) noexcept(noexcept(f.a op s)) {        \
+    return f.a op s;                                                           \
   }
 CERES_DEFINE_JET_COMPARISON_OPERATOR(<)   // NOLINT
 CERES_DEFINE_JET_COMPARISON_OPERATOR(<=)  // NOLINT
diff --git a/internal/ceres/jet_test.cc b/internal/ceres/jet_test.cc
index 4680fd0..54834d1 100644
--- a/internal/ceres/jet_test.cc
+++ b/internal/ceres/jet_test.cc
@@ -1400,5 +1400,96 @@
   ExpectClose(e.v[0].v[0].v[0], kE, kTolerance);
 }
 
+#if GTEST_HAS_TYPED_TEST
+
+using Types = testing::Types<short,
+                             unsigned short,
+                             int,
+                             unsigned int,
+                             long,
+                             unsigned long,
+                             long long,
+                             unsigned long long,
+                             float,
+                             double,
+                             long double>;
+
+template <typename T>
+class JetTest : public testing::Test {};
+
+TYPED_TEST_SUITE(JetTest, Types);
+
+// Don't care about the dual part for comparison tests
+template <typename T>
+using J0 = Jet<T, 0>;
+using J0d = J0<double>;
+
+TYPED_TEST(JetTest, comparison_jet) {
+  using Scalar = TypeParam;
+
+  EXPECT_EQ(J0<Scalar>{0}, J0<Scalar>{0});
+  EXPECT_GE(J0<Scalar>{3}, J0<Scalar>{3});
+  EXPECT_GT(J0<Scalar>{3}, J0<Scalar>{2});
+  EXPECT_LE(J0<Scalar>{1}, J0<Scalar>{1});
+  EXPECT_LT(J0<Scalar>{1}, J0<Scalar>{2});
+  EXPECT_NE(J0<Scalar>{1}, J0<Scalar>{2});
+}
+
+TYPED_TEST(JetTest, comparison_scalar) {
+  using Scalar = TypeParam;
+
+  EXPECT_EQ(J0d{0.0}, Scalar{0});
+  EXPECT_GE(J0d{3.0}, Scalar{3});
+  EXPECT_GT(J0d{3.0}, Scalar{2});
+  EXPECT_LE(J0d{1.0}, Scalar{1});
+  EXPECT_LT(J0d{1.0}, Scalar{2});
+  EXPECT_NE(J0d{1.0}, Scalar{2});
+
+  EXPECT_EQ(Scalar{0}, J0d{0.0});
+  EXPECT_GE(Scalar{1}, J0d{1.0});
+  EXPECT_GT(Scalar{2}, J0d{1.0});
+  EXPECT_LE(Scalar{3}, J0d{3.0});
+  EXPECT_LT(Scalar{2}, J0d{3.0});
+  EXPECT_NE(Scalar{2}, J0d{1.0});
+}
+
+TYPED_TEST(JetTest, comparison_nested2x) {
+  using Scalar = TypeParam;
+
+  EXPECT_EQ(J0<J0d>{J0d{0.0}}, Scalar{0});
+  EXPECT_GE(J0<J0d>{J0d{3.0}}, Scalar{3});
+  EXPECT_GT(J0<J0d>{J0d{3.0}}, Scalar{2});
+  EXPECT_LE(J0<J0d>{J0d{1.0}}, Scalar{1});
+  EXPECT_LT(J0<J0d>{J0d{1.0}}, Scalar{2});
+  EXPECT_NE(J0<J0d>{J0d{1.0}}, Scalar{2});
+
+  EXPECT_EQ(Scalar{0}, J0<J0d>{J0d{0.0}});
+  EXPECT_GE(Scalar{1}, J0<J0d>{J0d{1.0}});
+  EXPECT_GT(Scalar{2}, J0<J0d>{J0d{1.0}});
+  EXPECT_LE(Scalar{3}, J0<J0d>{J0d{3.0}});
+  EXPECT_LT(Scalar{2}, J0<J0d>{J0d{3.0}});
+  EXPECT_NE(Scalar{2}, J0<J0d>{J0d{1.0}});
+}
+
+TYPED_TEST(JetTest, comparison_nested3x) {
+  using Scalar = TypeParam;
+
+  EXPECT_EQ(J0<J0<J0d>>{J0<J0d>{J0d{0.0}}}, Scalar{0});
+  EXPECT_GE(J0<J0<J0d>>{J0<J0d>{J0d{3.0}}}, Scalar{3});
+  EXPECT_GT(J0<J0<J0d>>{J0<J0d>{J0d{3.0}}}, Scalar{2});
+  EXPECT_LE(J0<J0<J0d>>{J0<J0d>{J0d{1.0}}}, Scalar{1});
+  EXPECT_LT(J0<J0<J0d>>{J0<J0d>{J0d{1.0}}}, Scalar{2});
+  EXPECT_NE(J0<J0<J0d>>{J0<J0d>{J0d{1.0}}}, Scalar{2});
+
+  EXPECT_EQ(Scalar{0}, J0<J0<J0d>>{J0<J0d>{J0d{0.0}}});
+  EXPECT_GE(Scalar{1}, J0<J0<J0d>>{J0<J0d>{J0d{1.0}}});
+  EXPECT_GT(Scalar{2}, J0<J0<J0d>>{J0<J0d>{J0d{1.0}}});
+  EXPECT_LE(Scalar{3}, J0<J0<J0d>>{J0<J0d>{J0d{3.0}}});
+  EXPECT_LT(Scalar{2}, J0<J0<J0d>>{J0<J0d>{J0d{3.0}}});
+  EXPECT_NE(Scalar{2}, J0<J0<J0d>>{J0<J0d>{J0d{1.0}}});
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
 }  // namespace internal
 }  // namespace ceres