Support comparing Constant to ZERO (#668)

This might come in handy sometimes.  (Inspired by an actual use case.)
Seems like a sensible operation to provide.  Follow-on to #607.

Author: chiphogg

au/constant.hh

@@ -122,6 +122,26 @@ struct Constant : detail::MakesQuantityFromNumber<Constant, Unit>,
         return as<typename CorrespondingQuantity<T>::Rep>(
             typename CorrespondingQuantity<T>::Unit{});
     }
+
+    // Comparison with Zero.
+    //
+    // A Constant represents a value of 1 in its unit, which is never zero.
+    friend constexpr bool operator==(Constant, Zero) { return false; }
+    friend constexpr bool operator!=(Constant, Zero) { return true; }
+    friend constexpr bool operator<(Constant, Zero) { return !is_positive(); }
+    friend constexpr bool operator<=(Constant, Zero) { return !is_positive(); }
+    friend constexpr bool operator>(Constant, Zero) { return is_positive(); }
+    friend constexpr bool operator>=(Constant, Zero) { return is_positive(); }
+
+    friend constexpr bool operator==(Zero, Constant) { return false; }
+    friend constexpr bool operator!=(Zero, Constant) { return true; }
+    friend constexpr bool operator<(Zero, Constant) { return is_positive(); }
+    friend constexpr bool operator<=(Zero, Constant) { return is_positive(); }
+    friend constexpr bool operator>(Zero, Constant) { return !is_positive(); }
+    friend constexpr bool operator>=(Zero, Constant) { return !is_positive(); }
+
+ private:
+    static constexpr bool is_positive() { return IsPositive<detail::MagT<Unit>>::value; }
 };
 
 // Make a constant from the given unit.

au/constant_test.cc

@@ -510,6 +510,52 @@ TEST(Constant, OrderingWorksWithNegativeConstants) {
     EXPECT_THAT(c, Not(Le(neg_c)));
 }
 
+TEST(Constant, EqualityComparisonWithZero) {
+    constexpr auto one_meter = make_constant(meters);
+
+    EXPECT_THAT(one_meter == ZERO, IsFalse());
+    EXPECT_THAT(ZERO == one_meter, IsFalse());
+    EXPECT_THAT(one_meter != ZERO, IsTrue());
+    EXPECT_THAT(ZERO != one_meter, IsTrue());
+}
+
+TEST(Constant, EqualityComparisonWithZeroForNegativeConstant) {
+    constexpr auto neg_meter = -make_constant(meters);
+
+    EXPECT_THAT(neg_meter == ZERO, IsFalse());
+    EXPECT_THAT(ZERO == neg_meter, IsFalse());
+    EXPECT_THAT(neg_meter != ZERO, IsTrue());
+    EXPECT_THAT(ZERO != neg_meter, IsTrue());
+}
+
+TEST(Constant, OrderingComparisonWithZero) {
+    constexpr auto one_meter = make_constant(meters);
+
+    EXPECT_THAT(one_meter > ZERO, IsTrue());
+    EXPECT_THAT(one_meter >= ZERO, IsTrue());
+    EXPECT_THAT(one_meter < ZERO, IsFalse());
+    EXPECT_THAT(one_meter <= ZERO, IsFalse());
+
+    EXPECT_THAT(ZERO < one_meter, IsTrue());
+    EXPECT_THAT(ZERO <= one_meter, IsTrue());
+    EXPECT_THAT(ZERO > one_meter, IsFalse());
+    EXPECT_THAT(ZERO >= one_meter, IsFalse());
+}
+
+TEST(Constant, OrderingComparisonWithZeroForNegativeConstant) {
+    constexpr auto neg_meter = -make_constant(meters);
+
+    EXPECT_THAT(neg_meter < ZERO, IsTrue());
+    EXPECT_THAT(neg_meter <= ZERO, IsTrue());
+    EXPECT_THAT(neg_meter > ZERO, IsFalse());
+    EXPECT_THAT(neg_meter >= ZERO, IsFalse());
+
+    EXPECT_THAT(ZERO > neg_meter, IsTrue());
+    EXPECT_THAT(ZERO >= neg_meter, IsTrue());
+    EXPECT_THAT(ZERO < neg_meter, IsFalse());
+    EXPECT_THAT(ZERO <= neg_meter, IsFalse());
+}
+
 TEST(Constant, OrderingWorksWithScaledConstants) {
     constexpr auto half_c = c / mag<2>();
     constexpr auto double_c = c * mag<2>();