Add operator<

include/boost/decimal/detail/u128.hpp

@@ -215,6 +215,39 @@ u128
     friend constexpr bool operator!=(unsigned __int128 lhs, u128 rhs) noexcept;
 
     #endif // BOOST_DECIMAL_HAS_INT128
+
+    // Less than for signed integers
+    friend constexpr bool operator<(u128 lhs, std::int8_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::int16_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::int32_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::int64_t rhs) noexcept;
+
+    friend constexpr bool operator<(std::int8_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::int16_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::int32_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::int64_t lhs, u128 rhs) noexcept;
+
+    // Less than for unsigned integers
+    friend constexpr bool operator<(u128 lhs, std::uint8_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::uint16_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::uint32_t rhs) noexcept;
+    friend constexpr bool operator<(u128 lhs, std::uint64_t rhs) noexcept;
+
+    friend constexpr bool operator<(std::uint8_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::uint16_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::uint32_t lhs, u128 rhs) noexcept;
+    friend constexpr bool operator<(std::uint64_t lhs, u128 rhs) noexcept;
+
+    // Less than for 128-bit types
+    friend constexpr bool operator<(u128 lhs, u128 rhs) noexcept;
+
+    #ifdef BOOST_DECIMAL_HAS_INT128
+    friend constexpr bool operator<(u128 lhs, __int128 rhs) noexcept;
+    friend constexpr bool operator<(__int128 lhs, u128 rhs) noexcept;
+
+    friend constexpr bool operator<(u128 lhs, unsigned __int128 rhs) noexcept;
+    friend constexpr bool operator<(unsigned __int128 lhs, u128 rhs) noexcept;
+    #endif // BOOST_DECIMAL_HAS_INT128
 };
 
 // Signed assignment operators
@@ -541,6 +574,111 @@ constexpr bool operator!=(const unsigned __int128 lhs, const u128 rhs) noexcept
 
 #endif // BOOST_DECIMAL_HAS_INT128
 
+constexpr bool operator<(const u128 lhs, const std::int8_t rhs) noexcept
+{
+    return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::int16_t rhs) noexcept
+{
+    return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::int32_t rhs) noexcept
+{
+    return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::int64_t rhs) noexcept
+{
+    return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::uint8_t rhs) noexcept
+{
+    return lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::uint16_t rhs) noexcept
+{
+    return lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::uint32_t rhs) noexcept
+{
+    return lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const u128 lhs, const std::uint64_t rhs) noexcept
+{
+    return lhs.high == UINT64_C(0) && lhs.low < static_cast<std::uint64_t>(rhs);
+}
+
+constexpr bool operator<(const std::int8_t lhs, const u128 rhs) noexcept
+{
+    return lhs > 0 && rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::int16_t lhs, const u128 rhs) noexcept
+{
+    return lhs > 0 && rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::int32_t lhs, const u128 rhs) noexcept
+{
+    return lhs > 0 && rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::int64_t lhs, const u128 rhs) noexcept
+{
+    return lhs > 0 && rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::uint8_t lhs, const u128 rhs) noexcept
+{
+    return rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::uint16_t lhs, const u128 rhs) noexcept
+{
+    return rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::uint32_t lhs, const u128 rhs) noexcept
+{
+    return rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const std::uint64_t lhs, const u128 rhs) noexcept
+{
+    return rhs.high == UINT64_C(0) && static_cast<std::uint64_t>(lhs) < rhs.low;
+}
+
+constexpr bool operator<(const u128 lhs, const u128 rhs) noexcept
+{
+    return lhs.high == rhs.high ? lhs.low < rhs.low : lhs.high < rhs.high;
+}
+
+constexpr bool operator<(const u128 lhs, const __int128 rhs) noexcept
+{
+    return lhs < static_cast<u128>(rhs);
+}
+
+constexpr bool operator<(const __int128 lhs, const u128 rhs) noexcept
+{
+    return static_cast<u128>(lhs) < rhs;
+}
+
+constexpr bool operator<(const u128 lhs, const unsigned __int128 rhs) noexcept
+{
+    return lhs < static_cast<u128>(rhs);
+}
+
+constexpr bool operator<(const unsigned __int128 lhs, const u128 rhs) noexcept
+{
+    return static_cast<u128>(lhs) < rhs;
+}
+
 } // namespace detail
 } // namespace decimal
 } // namespace boost

test/test_u128.cpp

@@ -243,6 +243,24 @@ void test_operator_inequality()
     BOOST_TEST((true != bool_val) == (bool_val != true));
 }
 
+template <typename IntType>
+void test_operator_less()
+{
+    boost::random::uniform_int_distribution<IntType> dist(std::numeric_limits<IntType>::min(),
+                                                          std::numeric_limits<IntType>::max());
+
+    for (std::size_t i {}; i < N; ++i)
+    {
+        const IntType value {dist(rng)};
+        const IntType value2 {dist(rng)};
+        unsigned __int128 builtin_value = static_cast<unsigned __int128>(value);
+        boost::decimal::detail::u128 emulated_value {value};
+
+        BOOST_TEST(((value2 < emulated_value) == (emulated_value < value2)) ==
+                   ((value2 < builtin_value) == (builtin_value < value2)));
+    }
+}
+
 int main()
 {
     test_arithmetic_constructor<std::int8_t>();
@@ -316,6 +334,18 @@ int main()
     test_operator_inequality<std::uint64_t>();
     test_operator_inequality<unsigned __int128>();
 
+    test_operator_less<std::int8_t>();
+    test_operator_less<std::int16_t>();
+    test_operator_less<std::int32_t>();
+    test_operator_less<std::int64_t>();
+    test_operator_less<__int128>();
+
+    test_operator_less<std::uint8_t>();
+    test_operator_less<std::uint16_t>();
+    test_operator_less<std::uint32_t>();
+    test_operator_less<std::uint64_t>();
+    test_operator_less<unsigned __int128>();
+
     return boost::report_errors();
 }