Replace max_to_chars_chars with to_chars_capacity

John McFarlane · John McFarlane · commit fba5a8e55cef · 2022-01-27T23:39:45.000Z
diff --git a/include/cnl/_impl/charconv/to_chars.h b/include/cnl/_impl/charconv/to_chars.h
@@ -16,28 +16,17 @@
 #include "../num_traits/set_rounding.h"
 #include "../numbers/signedness.h"
 #include "constants.h"
+#include "to_chars_capacity.h"
 
 #include <array>
 #include <charconv>
 #include <limits>
-#include <numbers>
 #include <string_view>
 #include <system_error>
 
 /// compositional numeric library
 namespace cnl {
     namespace _impl {
-        // cnl::_impl::max_to_chars_chars
-        template<typename Scalar, int Base = 10>
-        struct max_to_chars_chars {
-        private:
-            static constexpr auto _sign_chars = static_cast<int>(cnl::numbers::signedness_v<Scalar>);
-            static constexpr auto _integer_chars = static_cast<int>(std::numeric_limits<Scalar>::digits * std::numbers::ln2 / std::numbers::ln10) + 1;
-
-        public:
-            static constexpr auto value = _sign_chars + _integer_chars;
-        };
-
         // cnl::_impl::itoc
         [[nodiscard]] constexpr auto itoc(int value)
         {
@@ -156,7 +145,7 @@ namespace cnl {
     [[nodiscard]] constexpr auto to_chars_static(number auto const& value)
     {
         using number = std::remove_cvref_t<decltype(value)>;
-        constexpr auto max_num_chars = _impl::max_to_chars_chars<number, Base>::value;
+        constexpr auto max_num_chars = _impl::to_chars_capacity<number>{}(Base);
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
         to_chars_static_result<max_num_chars> result;
diff --git a/include/cnl/_impl/charconv/to_chars_capacity.h b/include/cnl/_impl/charconv/to_chars_capacity.h
@@ -0,0 +1,36 @@
+
+//          Copyright John McFarlane 2022.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file ../LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(CNL_IMPL_CHARCONV_TO_CHARS_CAPACITY_H)
+#define CNL_IMPL_CHARCONV_TO_CHARS_CAPACITY_H
+
+#include "../../integer.h"
+#include "../cnl_assert.h"
+#include "../numbers/signedness.h"
+
+#include <limits>
+#include <numbers>
+
+namespace cnl::_impl {
+    // maximum number of characters necessary to represent given Scalar
+    // in give base in human-readable text excluding nul terminator,
+    // e.g. to_chars_capacity<int8_t>{}() == 4  // ["-128".."127"]
+    template<typename Scalar>
+    struct to_chars_capacity;
+
+    template<typename Scalar>
+    requires integer<Scalar>
+    struct to_chars_capacity<Scalar> {
+        [[nodiscard]] constexpr auto operator()(int /*base*/ = 10) const
+        {
+            auto const sign_chars = static_cast<int>(cnl::numbers::signedness_v<Scalar>);
+            auto const integer_chars = static_cast<int>(std::numeric_limits<Scalar>::digits * std::numbers::ln2 / std::numbers::ln10) + 1;
+            return sign_chars + integer_chars;
+        }
+    };
+}
+
+#endif  // CNL_IMPL_CHARCONV_TO_CHARS_CAPACITY_H
diff --git a/include/cnl/_impl/scaled_integer/to_chars.h b/include/cnl/_impl/scaled_integer/to_chars.h
@@ -21,6 +21,7 @@
 #include "definition.h"
 #include "num_traits.h"
 #include "numbers.h"
+#include "to_chars_capacity.h"
 
 #include <algorithm>
 #include <array>
@@ -36,64 +37,6 @@
 /// compositional numeric library
 namespace cnl {
     namespace _impl {
-        constexpr auto num_digits_from_binary(int num_digits, int radix)
-        {
-            switch (radix) {
-            case 2:
-                return num_digits;
-            case 8:
-                return (num_digits + 2) / 3;
-            case 10:
-                return (num_digits * 1000 + 3322) / 3321;
-            case 16:
-                return (num_digits + 3) / 4;
-            default: {
-                auto const binary_digits_per_digit{used_digits(radix - 1)};
-                return (num_digits + binary_digits_per_digit - 1) / binary_digits_per_digit;
-            }
-            }
-        }
-
-        constexpr auto num_digits_to_binary(int num_digits, int radix)
-        {
-            switch (radix) {
-            case 2:
-                return num_digits;
-            case 8:
-                return num_digits * 3;
-            case 10:
-                return (num_digits * 3322 + 678) / 1000;
-            case 16:
-                return num_digits * 4;
-            default:
-                return num_digits * used_digits(radix - 1);
-            }
-        }
-
-        template<typename Rep, int Exponent, int Radix>
-        struct max_to_chars_chars<scaled_integer<Rep, power<Exponent, Radix>>> {
-        private:
-            using scalar = cnl::scaled_integer<Rep, power<Exponent, Radix>>;
-
-            // This number is a little pessemistic in the case that Radix != 2.
-            static constexpr auto _fractional_digits =
-                    std::max(cnl::_impl::fractional_digits_v<scalar>, 0);
-
-            static constexpr auto _sign_chars = static_cast<int>(cnl::numbers::signedness_v<scalar>);
-            static constexpr auto _num_significant_integer_bits{cnl::digits_v<scalar> - _fractional_digits};
-            static constexpr auto _num_trailing_integer_bits{
-                    num_digits_to_binary(std::max(0, Exponent), Radix)};
-            static constexpr auto _num_integer_bits{
-                    _num_significant_integer_bits + _num_trailing_integer_bits};
-            static constexpr auto _integer_chars = num_digits_from_binary(_num_integer_bits, 10);
-            static constexpr auto _radix_chars = static_cast<int>(_fractional_digits > 0);
-            static constexpr auto _fractional_chars = std::max(0, _fractional_digits);
-
-        public:
-            static constexpr auto value =
-                    _sign_chars + _integer_chars + _radix_chars + _fractional_chars;
-        };
-
         struct descaled_info {
             std::string_view significand_digits;
             std::string_view exponent_chars;
diff --git a/include/cnl/_impl/scaled_integer/to_chars_capacity.h b/include/cnl/_impl/scaled_integer/to_chars_capacity.h
@@ -0,0 +1,79 @@
+
+//          Copyright John McFarlane 2022.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file ../LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(CNL_IMPL_SCALED_INTEGER_TO_CHARS_CAPACITY_H)
+#define CNL_IMPL_SCALED_INTEGER_TO_CHARS_CAPACITY_H
+
+#include "../charconv/to_chars_capacity.h"
+#include "../scaled/is_scaled_tag.h"
+#include "declaration.h"
+
+/// compositional numeric library
+namespace cnl::_impl {
+    constexpr auto num_digits_from_binary(int num_digits, int radix)
+    {
+        switch (radix) {
+        case 2:
+            return num_digits;
+        case 8:
+            return (num_digits + 2) / 3;
+        case 10:
+            return (num_digits * 1000 + 3322) / 3321;
+        case 16:
+            return (num_digits + 3) / 4;
+        default: {
+            auto const binary_digits_per_digit{used_digits(radix - 1)};
+            return (num_digits + binary_digits_per_digit - 1) / binary_digits_per_digit;
+        }
+        }
+    }
+
+    constexpr auto num_digits_to_binary(int num_digits, int radix)
+    {
+        switch (radix) {
+        case 2:
+            return num_digits;
+        case 8:
+            return num_digits * 3;
+        case 10:
+            return (num_digits * 3322 + 678) / 1000;
+        case 16:
+            return num_digits * 4;
+        default:
+            return num_digits * used_digits(radix - 1);
+        }
+    }
+
+    template<integer Rep, scaled_tag Scale>
+    struct to_chars_capacity<scaled_integer<Rep, Scale>> {
+        [[nodiscard]] constexpr auto operator()(int base = 10) const
+        {
+            CNL_ASSERT(base == 10);
+
+            using type = scaled_integer<Rep, Scale>;
+            constexpr auto exponent{Scale::exponent};
+            constexpr auto radix{Scale::radix};
+
+            // This number is a little pessemistic in the case that radix != 2.
+            auto const fractional_digits =
+                    std::max(cnl::_impl::fractional_digits_v<type>, 0);
+
+            auto const sign_chars = static_cast<int>(cnl::numbers::signedness_v<type>);
+            auto const num_significant_integer_bits{cnl::digits_v<type> - fractional_digits};
+            auto const num_trailing_integer_bits{
+                    num_digits_to_binary(std::max(0, exponent), radix)};
+            auto const num_integer_bits{
+                    num_significant_integer_bits + num_trailing_integer_bits};
+            auto const integer_chars = num_digits_from_binary(num_integer_bits, 10);
+            auto const radix_chars = static_cast<int>(fractional_digits > 0);
+            auto const fractional_chars = std::max(0, fractional_digits);
+
+            return sign_chars + integer_chars + radix_chars + fractional_chars;
+        }
+    };
+}
+
+#endif  // CNL_IMPL_SCALED_INTEGER_TO_CHARS_CAPACITY_H
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
@@ -100,6 +100,7 @@ set(test_sources
         overflow/wide/wide_overflow_int.cpp
         scaled_int/elastic/make_elastic_scaled_int.cpp
         scaled_int/elastic/elastic_scaled_int.cpp
+        scaled_int/elastic/to_chars_capacity.cpp
         scaled_int/rounding/elastic/rounding_elastic_scaled_int.cpp
         scaled_int/overflow/elastic/int.cpp
         static_int/shift_left.cpp
diff --git a/test/unit/scaled_int/elastic/elastic_scaled_int.cpp b/test/unit/scaled_int/elastic/elastic_scaled_int.cpp
@@ -634,7 +634,7 @@ TEST(elastic_scaled_integer, issue_88)  // NOLINT
 TEST(elastic_scaled_integer, to_string_thousand)  // NOLINT
 {
     auto const n{1000_cnl};
-    static_assert(5 == cnl::_impl::max_to_chars_chars<std::remove_cvref_t<decltype(n)>>::value);
+    static_assert(5 == cnl::_impl::to_chars_capacity<std::remove_cvref_t<decltype(n)>>{}());
 
     auto const expected{"1000"};
     auto const actual{cnl::to_string(1000_cnl)};
@@ -644,7 +644,7 @@ TEST(elastic_scaled_integer, to_string_thousand)  // NOLINT
 TEST(elastic_scaled_integer, to_string_thousandth)  // NOLINT
 {
     auto const n{.001_cnl};
-    static_assert(5 == cnl::_impl::max_to_chars_chars<std::remove_cvref_t<decltype(n)>>::value);
+    static_assert(5 == cnl::_impl::to_chars_capacity<std::remove_cvref_t<decltype(n)>>{}());
 
     auto const expected{".001"};
     auto const actual{cnl::to_string(n)};
@@ -654,7 +654,7 @@ TEST(elastic_scaled_integer, to_string_thousandth)  // NOLINT
 TEST(elastic_scaled_integer, to_string_123_456)  // NOLINT
 {
     auto const n{123.456_cnl};
-    static_assert(10 == cnl::_impl::max_to_chars_chars<std::remove_cvref_t<decltype(n)>>::value);
+    static_assert(10 == cnl::_impl::to_chars_capacity<std::remove_cvref_t<decltype(n)>>{}());
 
     auto const expected{"123.456"};
     auto const actual{cnl::to_string(n)};
@@ -664,7 +664,7 @@ TEST(elastic_scaled_integer, to_string_123_456)  // NOLINT
 TEST(elastic_scaled_integer, to_string_quite_wide)  // NOLINT
 {
     auto const n{-12345.67890_cnl};
-    static_assert(13 == cnl::_impl::max_to_chars_chars<std::remove_cvref_t<decltype(n)>>::value);
+    static_assert(13 == cnl::_impl::to_chars_capacity<std::remove_cvref_t<decltype(n)>>{}());
 
     auto const expected{"-12345.6789"};
     auto const actual{cnl::to_string(n)};
diff --git a/test/unit/scaled_int/elastic/to_chars_capacity.cpp b/test/unit/scaled_int/elastic/to_chars_capacity.cpp
@@ -0,0 +1,25 @@
+
+//          Copyright John McFarlane 2022.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file ../LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cnl/_impl/charconv/to_chars_capacity.h>
+
+#include <cnl/elastic_integer.h>
+#include <cnl/scaled_integer.h>
+
+#include <cstdint>
+
+namespace test_to_chars_capacity {
+    static_assert(
+            4 == cnl::_impl::to_chars_capacity<cnl::scaled_integer<std::uint8_t, cnl::power<2>>>{}());  // 1020
+    static_assert(
+            7 == cnl::_impl::to_chars_capacity<cnl::scaled_integer<std::int8_t, cnl::power<-3>>>{}());  // -15.875
+    static_assert(
+            5 == cnl::_impl::to_chars_capacity<cnl::scaled_integer<std::uint16_t, cnl::power<>>>{}());  // 65536
+    static_assert(
+            41 == cnl::_impl::to_chars_capacity<cnl::scaled_integer<cnl::elastic_integer<41>, cnl::power<-38>>>{}());
+    static_assert(
+            44 == cnl::_impl::to_chars_capacity<cnl::scaled_integer<std::int64_t, cnl::power<-32>>>{}());  // −2147483647.99999999976716935634613037109375
+}
diff --git a/test/unit/scaled_int/to_chars.h b/test/unit/scaled_int/to_chars.h
@@ -18,28 +18,6 @@
 #include <limits>
 #include <string>
 
-namespace test_max_to_chars_chars {
-    static_assert(
-            4 == cnl::_impl::max_to_chars_chars<scaled_integer<uint8, cnl::power<2>>>::value,
-            "cnl::_impl::max_to_chars_chars");  // 1020
-    static_assert(
-            7 == cnl::_impl::max_to_chars_chars<scaled_integer<int8, cnl::power<-3>>>::value,
-            "cnl::_impl::max_to_chars_chars");  // -15.875
-    static_assert(
-            5 == cnl::_impl::max_to_chars_chars<scaled_integer<uint16, cnl::power<>>>::value,
-            "cnl::_impl::max_to_chars_chars");  // 65536
-    static_assert(
-            41
-                    == cnl::_impl::max_to_chars_chars<cnl::scaled_integer<
-                            cnl::elastic_integer<41>, cnl::power<-38>>>::value,
-            "cnl::_impl::max_to_chars_chars");
-    static_assert(
-            44
-                    == cnl::_impl::max_to_chars_chars<
-                            cnl::scaled_integer<int64, cnl::power<-32>>>::value,
-            "cnl::_impl::max_to_chars_chars");  // −2147483647.99999999976716935634613037109375
-}
-
 namespace test_to_chars_natural {
     template<int BufferSize, typename Integer>
     void test(Integer const& value)
