Merge pull request #1225 from cppalliance/1189

Replace sign boolean in constructor with an enum class

Author: mborland

doc/modules/ROOT/pages/basics.adoc

@@ -16,21 +16,33 @@ Every decimal type can be constructed in a few ways:
 
 [source, c++]
 ----
+namespace boost {
+namespace decimal {
+
+enum class construction_sign
+{
+    negative,
+    positive
+};
+
 template <typename UnsignedInteger, typename Integer>
-constexpr decimal32_t(UnsignedInteger coefficient, Integer exponent, bool is_negative = false) noexcept;
+constexpr decimal32_t(UnsignedInteger coefficient, Integer exponent, construction_sign resultant_sign = construction_sign::positive) noexcept;
 
 template <typename SignedInteger, typename Integer>
 constexpr decimal32_t(SignedInteger coefficient, Integer exponent) noexcept;
+
+} // namespace decimal
+} // namespace boost
 ----
 
 As you can see you are either allowed to pass a signed integer, or specify the signedness of the resulting number, but not both.
-This is designed to reduce confusion (e.g. what would be the resulting sign of `{-3, 0, true}`?)
+This is designed to reduce confusion (e.g. what would be the resulting sign of `{-3, 0, construction_sign::negative}`?)
 
 [souce, c++]
 ----
 boost::decimal::decimal32_t a {1, 1};           // constructs 1e1 = 10
 boost::decimal::decimal32_t b {-2, -1};         // constructs -2e-2 or -0.2
-boost::decimal::decimal32_t c {2U, -1, true};   // also constructs -2e-1 or -0.2 (Note: The coefficient must be an unsigned type)
+boost::decimal::decimal32_t c {2U, -1, construction_sign::negative};   // also constructs -2e-1 or -0.2 (Note: The coefficient must be an unsigned type)
 boost::decimal::decimal32_t e {5, 5};           // constructs 5x10^5
 boost::decimal::decimal32_t f {1234, -3}        // constructs 1.234 or 1234x10^-3
 ----

doc/modules/ROOT/pages/examples.adoc

@@ -26,7 +26,7 @@ int main()
 
     std::cout << sum << std::endl; // prints 0.3
 
-    const boost::decimal::decimal32_t neg_a {2, -1, true}; // Constructs the number -0.2
+    const boost::decimal::decimal32_t neg_a {2, -1, construction_sign::negative}; // Constructs the number -0.2
 
     sum += neg_a;
 

examples/basic_construction.cpp

@@ -2,17 +2,23 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/decimal.hpp>
+#include <boost/decimal/decimal32_t.hpp>
+#include <boost/decimal/decimal64_t.hpp>
+#include <boost/decimal/iostream.hpp>
 #include <iostream>
 #include <iomanip>
 
 int main()
 {
-    using namespace boost::decimal;
+    using boost::decimal::decimal32_t;
+    using boost::decimal::decimal64_t;
+    using boost::decimal::construction_sign;
+    using boost::decimal::isinf;
+    using boost::decimal::isnan;
 
     constexpr decimal32_t val_1 {100};         // Construction from an integer
     constexpr decimal32_t val_2 {10, 1};       // Construction from a signed integer and exponent
-    constexpr decimal32_t val_3 {1U, 2, false}; // Construction from an unsigned integer, exponent, and sign
+    constexpr decimal32_t val_3 {1U, 2, construction_sign::negative}; // Construction from an unsigned integer, exponent, and sign
 
     std::cout << "Val_1: " << val_1 << '\n'
               << "Val_2: " << val_2 << '\n'

include/boost/decimal/decimal128_t.hpp

@@ -40,6 +40,7 @@
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/components.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -272,7 +273,7 @@ BOOST_DECIMAL_EXPORT class decimal128_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal128_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal128_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -730,8 +731,9 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool is_negative) noexcept
+constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept
 {
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     bits_.high = is_negative ? detail::d128_sign_mask : UINT64_C(0);
 
     // If the coeff is not in range make it so
@@ -2254,7 +2256,7 @@ class numeric_limits_impl128
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal128_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal128_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal128_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal128_t { return boost::decimal::from_bits(boost::decimal::detail::d128_inf_mask); }

include/boost/decimal/decimal32_t.hpp

@@ -41,6 +41,7 @@
 #include <boost/decimal/detail/to_chars_result.hpp>
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -297,7 +298,7 @@ BOOST_DECIMAL_EXPORT class decimal32_t final // NOLINT(cppcoreguidelines-special
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal32_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal32_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -651,11 +652,12 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool is_negative) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)
+constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)
 {
     static_assert(detail::is_integral_v<T1>, "Coefficient must be an integer");
     static_assert(detail::is_integral_v<T2>, "Exponent must be an integer");
 
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     bits_ = is_negative ? detail::d32_sign_mask : UINT32_C(0);
 
     // If the coeff is not in range, make it so
@@ -2322,7 +2324,7 @@ class numeric_limits_impl32
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal32_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal32_t { return {boost::decimal::detail::d32_max_significand_value, max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal32_t { return {boost::decimal::detail::d32_max_significand_value, max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal32_t { return {boost::decimal::detail::d32_max_significand_value, max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal32_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal32_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal32_t { return boost::decimal::from_bits(boost::decimal::detail::d32_inf_mask); }

include/boost/decimal/decimal64_t.hpp

@@ -43,6 +43,7 @@
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/to_chars_result.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -335,7 +336,7 @@ BOOST_DECIMAL_EXPORT class decimal64_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal64_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal64_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -650,8 +651,9 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool is_negative) noexcept
+constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept
 {
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     bits_ = is_negative ? detail::d64_sign_mask : UINT64_C(0);
 
     // If the coeff is not in range, make it so
@@ -2231,7 +2233,7 @@ class numeric_limits_impl64
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal64_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal64_t { return {boost::decimal::detail::d64_max_significand_value, max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal64_t { return {boost::decimal::detail::d64_max_significand_value, max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal64_t { return {boost::decimal::detail::d64_max_significand_value, max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal64_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal64_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal64_t { return boost::decimal::from_bits(boost::decimal::detail::d64_inf_mask); }

include/boost/decimal/decimal_fast128_t.hpp

@@ -40,6 +40,7 @@
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/components.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -215,7 +216,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast128_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal_fast128_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal_fast128_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -489,12 +490,13 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal_fast128_t::decimal_fast128_t(T1 coeff, T2 exp, bool is_negative) noexcept
+constexpr decimal_fast128_t::decimal_fast128_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     sign_ = is_negative;
 
     // Normalize the significand in the constructor, so we don't have
@@ -1616,7 +1618,7 @@ class numeric_limits_impl128f
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal_fast128_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal_fast128_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal_fast128_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal_fast128_t { return boost::decimal::direct_init_d128(boost::decimal::detail::d128_fast_inf, 0, false); }

include/boost/decimal/decimal_fast32_t.hpp

@@ -41,6 +41,7 @@
 #include <boost/decimal/detail/to_chars_result.hpp>
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 #include <limits>
@@ -211,7 +212,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
     constexpr decimal_fast32_t() noexcept = default;
 
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
-    constexpr decimal_fast32_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal_fast32_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     template <typename T1, typename T2, std::enable_if_t<!detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     constexpr decimal_fast32_t(T1, T2, bool) noexcept { static_assert(detail::is_unsigned_v<T1>, "Construction from signed integer, exponent, and sign is ambiguous, so it is disallowed. You must use an Unsigned Integer for the coefficient to construct from {coefficient, exponent, sign}"); }
@@ -479,12 +480,13 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
 };
 
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
-constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, bool is_negative) noexcept
+constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     sign_ = is_negative;
 
     // Normalize in the constructor, so we never have to worry about it again
@@ -1578,7 +1580,7 @@ class numeric_limits_impl32f
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal_fast32_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal_fast32_t { return {UINT32_C(9'999'999), max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal_fast32_t { return {UINT32_C(9'999'999), max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal_fast32_t { return {UINT32_C(9'999'999), max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal_fast32_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal_fast32_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal_fast32_t { return boost::decimal::direct_init(boost::decimal::detail::d32_fast_inf, UINT8_C((0))); }

include/boost/decimal/decimal_fast64_t.hpp

@@ -41,6 +41,7 @@
 #include <boost/decimal/detail/to_chars_result.hpp>
 #include <boost/decimal/detail/chars_format.hpp>
 #include <boost/decimal/detail/from_string.hpp>
+#include <boost/decimal/detail/construction_sign.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -222,7 +223,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast64_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal_fast64_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
+    constexpr decimal_fast64_t(T1 coeff, T2 exp, detail::construction_sign_wrapper resultant_sign = construction_sign::positive) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -484,12 +485,13 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal_fast64_t::decimal_fast64_t(T1 coeff, T2 exp, bool is_negative) noexcept
+constexpr decimal_fast64_t::decimal_fast64_t(T1 coeff, T2 exp, const detail::construction_sign_wrapper resultant_sign) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
+    const auto is_negative {static_cast<bool>(resultant_sign)};
     sign_ = is_negative;
 
     // Normalize the value, so we don't have to worry about it with operations
@@ -1552,7 +1554,7 @@ class numeric_limits_impl64f
     // Member functions
     static constexpr auto (min)        () -> boost::decimal::decimal_fast64_t { return {UINT32_C(1), min_exponent}; }
     static constexpr auto (max)        () -> boost::decimal::decimal_fast64_t { return {UINT64_C(9'999'999'999'999'999), max_exponent - digits + 1}; }
-    static constexpr auto lowest       () -> boost::decimal::decimal_fast64_t { return {UINT64_C(9'999'999'999'999'999), max_exponent - digits + 1, true}; }
+    static constexpr auto lowest       () -> boost::decimal::decimal_fast64_t { return {UINT64_C(9'999'999'999'999'999), max_exponent - digits + 1, construction_sign::negative}; }
     static constexpr auto epsilon      () -> boost::decimal::decimal_fast64_t { return {UINT32_C(1), -digits + 1}; }
     static constexpr auto round_error  () -> boost::decimal::decimal_fast64_t { return epsilon(); }
     static constexpr auto infinity     () -> boost::decimal::decimal_fast64_t { return boost::decimal::direct_init_d64(