Add aoc::math::prev_power_of_10 and tests for {next,prev}_power_of_10

Author: yut23

aoc_lib/src/test_math.cpp

@@ -56,9 +56,10 @@ std::size_t test_powers_of_10() {
 
     constexpr auto POWERS_OF_10 = aoc::math::gen_powers_of_10<IntegerT>();
     std::size_t size = POWERS_OF_10.size();
+    test(size, std::numeric_limits<IntegerT>::digits10 + 1);
     IntegerT max = std::numeric_limits<IntegerT>::max();
     int i = 0;
-    IntegerT x = 10;
+    IntegerT x = 1;
     while (x <= max / 10) {
         test(POWERS_OF_10.at(i), x,
              "incorrect element at index " + std::to_string(i));
@@ -82,6 +83,71 @@ std::size_t test_powers_of_10() {
     return test.num_failed();
 }
 
+template <class IntegerT>
+std::size_t test_next_power_of_10() {
+    const std::string type_name = util::demangle(typeid(IntegerT).name());
+    unit_test::PureTest test("aoc::math::next_power_of_10<" + type_name + ">",
+                             &aoc::math::next_power_of_10<IntegerT>);
+
+    test(0, 1);
+    test(1, 10);
+    test(2, 10);
+    test(9, 10);
+    test(10, 100);
+    test(11, 100);
+    test(99, 100);
+    for (unsigned int i = 0; i < std::numeric_limits<IntegerT>::digits10; ++i) {
+        IntegerT p10 = powi(static_cast<IntegerT>(10), i);
+        if (p10 >= 1) {
+            test(p10 - 1, p10);
+        }
+        if (IntegerT(p10 * 10) % IntegerT(10) == 0) {
+            test(p10, 10 * p10);
+            test(p10 + 1, 10 * p10);
+        }
+    }
+
+    test.done();
+    if (test.num_failed() > 0) {
+        std::cout << "POWERS_OF_10: "
+                  << pretty_print::repr(aoc::math::gen_powers_of_10<IntegerT>())
+                  << "\n";
+    }
+    return test.num_failed();
+}
+
+template <class IntegerT>
+std::size_t test_prev_power_of_10() {
+    const std::string type_name = util::demangle(typeid(IntegerT).name());
+    unit_test::PureTest test("aoc::math::prev_power_of_10<" + type_name + ">",
+                             &aoc::math::prev_power_of_10<IntegerT>);
+
+    test(0, 0);
+    test(1, 0);
+    test(2, 1);
+    test(9, 1);
+    test(10, 1);
+    test(11, 10);
+    test(99, 10);
+    for (unsigned int i = 1; i <= std::numeric_limits<IntegerT>::digits10;
+         ++i) {
+        IntegerT p10 = powi(static_cast<IntegerT>(10), i);
+        if (p10 >= 1) {
+            test(p10 - 1, p10 / 10);
+        }
+        test(p10, p10 / 10);
+        test(p10 + 1, p10);
+    }
+
+    test.done();
+    if (test.num_failed() > 0) {
+        std::cout << "POWERS_OF_10: "
+                  << pretty_print::repr(aoc::math::gen_powers_of_10<IntegerT>())
+                  << "\n";
+    }
+    return test.num_failed();
+}
+
 template <class IntegerT>
 std::size_t test_num_digits() {
     const std::string type_name = util::demangle(typeid(IntegerT).name());
@@ -184,6 +250,16 @@ int main() {
     failed_count += test_powers_of_10<std::int64_t>();
     failed_count += test_powers_of_10<std::uint64_t>();
 
+    failed_count += test_next_power_of_10<int>();
+    failed_count += test_next_power_of_10<unsigned int>();
+    failed_count += test_next_power_of_10<std::int64_t>();
+    failed_count += test_next_power_of_10<std::uint64_t>();
+
+    failed_count += test_prev_power_of_10<int>();
+    failed_count += test_prev_power_of_10<unsigned int>();
+    failed_count += test_prev_power_of_10<std::int64_t>();
+    failed_count += test_prev_power_of_10<std::uint64_t>();
+
     failed_count += test_num_digits<int>();
     failed_count += test_num_digits<unsigned int>();
     failed_count += test_num_digits<std::int64_t>();

aoc_lib/src/util/math.hpp

@@ -24,10 +24,11 @@ namespace aoc::math {
 
 template <typename IntegerT,
           int max_digits = std::numeric_limits<IntegerT>::digits10>
-constexpr std::array<IntegerT, max_digits> gen_powers_of_10() {
-    std::array<IntegerT, max_digits> arr;
+constexpr std::array<IntegerT, max_digits + 1> gen_powers_of_10() {
+    std::array<IntegerT, max_digits + 1> arr;
     IntegerT x = 1;
-    for (std::size_t i = 0; i < max_digits; ++i) {
+    arr[0] = 1;
+    for (std::size_t i = 1; i <= max_digits; ++i) {
         x *= 10;
         arr[i] = x;
     }
@@ -43,9 +44,13 @@ constexpr int num_digits(IntegerT value) {
             break;
         }
     }
-    return i + 1;
+    return i;
 }
 
+/**
+ * Throws std::overflow_error if the next power of 10 cannot be represented in
+ * an IntegerT.
+ */
 template <std::integral IntegerT>
 IntegerT next_power_of_10(IntegerT value) {
     constexpr auto POWERS = gen_powers_of_10<IntegerT>();
@@ -56,7 +61,24 @@ IntegerT next_power_of_10(IntegerT value) {
             return pow;
         }
     }
-    assert(false);
+    throw std::overflow_error("overflow in aoc::math::next_power_of_10");
+}
+
+/**
+ * Returns 0 for values 0 and 1.
+ */
+template <std::integral IntegerT>
+IntegerT prev_power_of_10(IntegerT value) {
+    constexpr auto POWERS = gen_powers_of_10<IntegerT>();
+    // this array is small, so a linear search performs better
+    auto end = POWERS.rend();
+    for (auto it = POWERS.rbegin(); it != end; ++it) {
+        // cppcheck-suppress useStlAlgorithm
+        if (*it < value) {
+            return *it;
+        }
+    }
+    return 0;
 }
 
 template <typename IntegerT>