koffi 2.3.6-beta.6 → 2.3.7

package/vendor/dragonbox/subproject/test/source/verify_compressed_cache.cpp

@@ -1,154 +0,0 @@
-// Copyright 2020-2022 Junekey Jeon
-//
-// The contents of this file may be used under the terms of
-// the Apache License v2.0 with LLVM Exceptions.
-//
-//    (See accompanying file LICENSE-Apache or copy at
-//     https://llvm.org/foundation/relicensing/LICENSE.txt)
-//
-// Alternatively, the contents of this file may be used under the terms of
-// the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE-Boost or copy at
-//     https://www.boost.org/LICENSE_1_0.txt)
-//
-// Unless required by applicable law or agreed to in writing, this software
-// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.
-
-#include "dragonbox/dragonbox.h"
-#include "big_uint.h"
-#include "rational_continued_fractions.h"
-
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <vector>
-
-int main() {
-    // We are trying to verify that an appropriate shift of phi_k * 5^a
-    // can be used instead of phi_(a+k). Since phi_k is defined in terms of ceiling,
-    // the shift of phi_k * 5^a will be phi_(a+k) + (error) for some nonnegative error.
-    //
-    // For correct multiplication, the margin for binary32 is at least
-    // 2^64 * 5091154818982829 / 12349290596248284087255008291061760 = 7.60...,
-    // so we are safe if the error is up to 7.
-    // The margin for binary64 is at least
-    // 2^128 * 723173431431821867556830303887 /
-    // 18550103527668669801949286474444582643081334006759269899933694558208
-    // = 13.26..., so we are safe if the error is up to 13.
-    //
-    // For correct integer checks, the case b > n_max is fine because the only condition on the
-    // recovered cache is a lower bound which must be already true for phi_k.
-    // For the case b <= n_max, we only need to check the upper bound
-    // (recovered_cache) < 2^(Q-beta) * a/b + 2^(q-beta)/(floor(nmax/b) * b),
-    // so we check it manually for each e.
-
-    using namespace jkj::dragonbox::detail::log;
-    using namespace jkj::dragonbox::detail::wuint;
-    using info = jkj::dragonbox::detail::compressed_cache_detail;
-    using impl = jkj::dragonbox::detail::impl<double>;
-
-    std::cout << "[Verifying cache recovery for compressed cache...]\n";
-
-    jkj::unsigned_rational<jkj::big_uint> unit;
-    auto n_max = jkj::big_uint::power_of_2(impl::significand_bits + 2);
-    int prev_k = impl::max_k + 1;
-    for (int e = impl::min_exponent - impl::significand_bits;
-         e <= impl::max_exponent - impl::significand_bits; ++e) {
-        int const k = impl::kappa - floor_log10_pow2(e);
-
-        using jkj::dragonbox::policy::cache::full;
-        auto const real_cache = full.get_cache<jkj::dragonbox::ieee754_binary64>(k);
-
-        // Compute the base index.
-        int const kb =
-            ((k - impl::min_k) / info::compression_ratio) * info::compression_ratio + impl::min_k;
-
-        // Get the base cache.
-        auto const base_cache = full.get_cache<jkj::dragonbox::ieee754_binary64>(kb);
-
-        // Get the index offset.
-        auto const offset = k - kb;
-
-        if (offset != 0) {
-            // Obtain the corresponding power of 5.
-            auto const pow5 = info::pow5.table[offset];
-
-            // Compute the required amount of bit-shifts.
-            auto const alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
-            assert(alpha > 0 && alpha < 64);
-
-            // Try to recover the real cache.
-            auto recovered_cache = umul128(base_cache.high(), pow5);
-            auto const middle_low = umul128(base_cache.low(), pow5);
-
-            recovered_cache += middle_low.high();
-
-            auto const high_to_middle = recovered_cache.high() << (64 - alpha);
-            auto const middle_to_low = recovered_cache.low() << (64 - alpha);
-
-            recovered_cache = uint128{(recovered_cache.low() >> alpha) | high_to_middle,
-                                      ((middle_low.low() >> alpha) | middle_to_low)};
-
-            if (recovered_cache.low() + 1 == 0) {
-                std::cout << "Overflow detected.\n";
-                return -1;
-            }
-            else {
-                recovered_cache = {recovered_cache.high(), recovered_cache.low() + 1};
-            }
-
-            // Measure the difference
-            if (real_cache.high() != recovered_cache.high() ||
-                real_cache.low() > recovered_cache.low()) {
-                std::cout << "Overflow detected.\n";
-                return -1;
-            }
-            auto const diff = std::uint32_t(recovered_cache.low() - real_cache.low());
-
-            if (diff != 0) {
-                if (diff > 13) {
-                    // Multiplication might be no longer valid.
-                    std::cout << "Overflow detected.\n";
-                    return -1;
-                }
-
-                // For the case b <= n_max, integer check might be no longer valid.
-                int const beta = e + floor_log2_pow10(k);
-
-                // unit = 2^(e + k - 1) * 5^k = a/b.
-                unit.numerator = 1;
-                unit.denominator = 1;
-                if (k >= 0) {
-                    unit.numerator = jkj::big_uint::pow(5, k);
-                }
-                else {
-                    unit.denominator = jkj::big_uint::pow(5, -k);
-                }
-                if (e + k - 1 >= 0) {
-                    unit.numerator *= jkj::big_uint::power_of_2(e + k - 1);
-                }
-                else {
-                    unit.denominator *= jkj::big_uint::power_of_2(-e - k + 1);
-                }
-
-                if (unit.denominator <= n_max) {
-                    // Check (recovered_cache) < 2^(Q-beta) * a/b + 2^(q-beta)/(floor(nmax/b) * b),
-                    // or equivalently,
-                    // b * (recovered_cache) - 2^(Q-beta) * a < 2^(q-beta) / floor(nmax/b).
-                    auto const rc = jkj::big_uint{recovered_cache.low(), recovered_cache.high()};
-                    auto const left_hand_side =
-                        unit.denominator * rc -
-                        jkj::big_uint::power_of_2(impl::cache_bits - beta) * unit.numerator;
-
-                    if (left_hand_side * (n_max / unit.denominator) >=
-                        jkj::big_uint::power_of_2(impl::carrier_bits - beta)) {
-                        std::cout << "Overflow detected.\n";
-                        return -1;
-                    }
-                }
-            }
-        }
-    }
-    std::cout << "Verification succeeded. No error detected.\n";
-}

package/vendor/dragonbox/subproject/test/source/verify_fast_multiplication.cpp

@@ -1,168 +0,0 @@
-// Copyright 2020-2022 Junekey Jeon
-//
-// The contents of this file may be used under the terms of
-// the Apache License v2.0 with LLVM Exceptions.
-//
-//    (See accompanying file LICENSE-Apache or copy at
-//     https://llvm.org/foundation/relicensing/LICENSE.txt)
-//
-// Alternatively, the contents of this file may be used under the terms of
-// the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE-Boost or copy at
-//     https://www.boost.org/LICENSE_1_0.txt)
-//
-// Unless required by applicable law or agreed to in writing, this software
-// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.
-
-#include "dragonbox/dragonbox.h"
-#include "big_uint.h"
-#include "continued_fractions.h"
-
-#include <iostream>
-
-template <class Float, class CachePolicy>
-static bool verify_fast_multiplication_xz(CachePolicy&& cache_policy) {
-    using impl = jkj::dragonbox::detail::impl<Float>;
-    using format = typename impl::format;
-    using carrier_uint = typename impl::carrier_uint;
-
-    constexpr auto four_fl = (carrier_uint(1) << (impl::significand_bits + 2)) - 1;
-    constexpr auto two_fr = (carrier_uint(1) << (impl::significand_bits + 1)) + 1;
-
-    using jkj::dragonbox::detail::log::floor_log10_pow2_minus_log10_4_over_3;
-    using jkj::dragonbox::detail::log::floor_log2_pow10;
-
-    bool success = true;
-
-    for (int e = impl::min_exponent + 1 - impl::significand_bits;
-         e <= impl::max_exponent - impl::significand_bits; ++e) {
-
-        // Compute k and beta.
-        int const k = -floor_log10_pow2_minus_log10_4_over_3(e);
-        int const beta = e + floor_log2_pow10(k);
-
-        // Load cache.
-        auto const cache = cache_policy.template get_cache<format>(k);
-
-        // Compute the endpoints using the fast method.
-        auto x_fast = impl::compute_left_endpoint_for_shorter_interval_case(cache, beta);
-        auto z_fast = impl::compute_right_endpoint_for_shorter_interval_case(cache, beta);
-
-        // Precisely compute the endpoints.
-        jkj::unsigned_rational<jkj::big_uint> precise_multiplier{1, 1};
-        if (k >= 0) {
-            precise_multiplier.numerator = jkj::big_uint::pow(5, k);
-        }
-        else {
-            precise_multiplier.denominator = jkj::big_uint::pow(5, -k);
-        }
-        if (e + k >= 0) {
-            precise_multiplier.numerator *= jkj::big_uint::power_of_2(e + k);
-        }
-        else {
-            precise_multiplier.denominator *= jkj::big_uint::power_of_2(-e - k);
-        }
-
-        auto x_exact =
-            (four_fl * precise_multiplier.numerator) / (4 * precise_multiplier.denominator);
-        auto z_exact =
-            (two_fr * precise_multiplier.numerator) / (2 * precise_multiplier.denominator);
-
-        if (x_exact != x_fast) {
-            std::cout << "(e = " << e << ") left endpoint is not correct; computed = " << x_fast
-                      << "; true_value = " << x_exact[0] << "\n";
-            success = false;
-        }
-        if (z_exact != z_fast) {
-            std::cout << "(e = " << e << ") right endpoint is not correct; computed = " << z_fast
-                      << "; true_value = " << z_exact[0] << "\n";
-            success = false;
-        }
-    }
-
-    if (success) {
-        std::cout << "All cases are verified.\n";
-    }
-    else {
-        std::cout << "Error detected.\n";
-    }
-
-    return success;
-}
-
-template <class Float, class CachePolicy>
-static bool verify_fast_multiplication_yru(CachePolicy&& cache_policy) {
-    using impl = jkj::dragonbox::detail::impl<Float>;
-    using format = typename impl::format;
-    bool success = true;
-
-    for (int k = impl::min_k; k <= impl::max_k; ++k) {
-        auto const cache = cache_policy.template get_cache<format>(k);
-
-        // Since Q - p - beta - 2 >= q, it suffices to check that the lower half of the cache is not 0.
-        auto const lower_half = [cache] {
-            if constexpr (std::is_same_v<typename impl::format, jkj::dragonbox::ieee754_binary32>) {
-                return std::uint32_t(cache);
-            }
-            else {
-                return cache.low();
-            }
-        }();
-
-        // If the lower half is zero, we need to check if the cache is precise.
-        if (lower_half == 0) {
-            if (k < 0 || k > jkj::dragonbox::detail::log::floor_log5_pow2(impl::cache_bits)) {
-                std::cout << "(k = " << k << ") computation might be incorrect\n";
-                success = false;
-            }
-        }
-    }
-
-    if (success) {
-        std::cout << "All cases are verified.\n";
-    }
-    else {
-        std::cout << "Error detected.\n";
-    }
-
-    return success;
-}
-
-int main() {
-    bool success = true;
-
-    std::cout << "[Verifying fast computation of xi and zi for the shorter interval case "
-                 "with full cache (binary32)...]\n";
-    success &= verify_fast_multiplication_xz<float>(jkj::dragonbox::policy::cache::full);
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying fast computation of yru for the shorter interval case "
-                 "with full cache (binary32)...]\n";
-    success &= verify_fast_multiplication_yru<float>(jkj::dragonbox::policy::cache::full);
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying fast computation of xi and zi for the shorter interval case "
-                 "with full cache (binary64)...]\n";
-    success &= verify_fast_multiplication_xz<double>(jkj::dragonbox::policy::cache::full);
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying fast computation of xi and zi for the shorter interval case "
-                 "with compressed cache (binary64)...]\n";
-    success &= verify_fast_multiplication_xz<double>(jkj::dragonbox::policy::cache::compact);
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying fast computation of yru for the shorter interval case "
-                 "with full cache (binary64)...]\n";
-    success &= verify_fast_multiplication_yru<double>(jkj::dragonbox::policy::cache::full);
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying fast computation of yru for the shorter interval case "
-                 "with compressed cache (binary64)...]\n";
-    success &= verify_fast_multiplication_yru<double>(jkj::dragonbox::policy::cache::compact);
-    std::cout << "Done.\n\n\n";
-
-    if (!success) {
-        return -1;
-    }
-}

package/vendor/dragonbox/subproject/test/source/verify_log_computation.cpp

@@ -1,251 +0,0 @@
-// Copyright 2020 Junekey Jeon
-//
-// The contents of this file may be used under the terms of
-// the Apache License v2.0 with LLVM Exceptions.
-//
-//    (See accompanying file LICENSE-Apache or copy at
-//     https://llvm.org/foundation/relicensing/LICENSE.txt)
-//
-// Alternatively, the contents of this file may be used under the terms of
-// the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE-Boost or copy at
-//     https://www.boost.org/LICENSE_1_0.txt)
-//
-// Unless required by applicable law or agreed to in writing, this software
-// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.
-
-#include "big_uint.h"
-#include "dragonbox/dragonbox.h"
-
-#include <functional>
-#include <iostream>
-
-int floor_log10_pow2_precise(int e) {
-    using namespace jkj::dragonbox::detail::log;
-    bool is_negative;
-    if (e < 0) {
-        is_negative = true;
-        e = -e;
-    }
-    else {
-        is_negative = false;
-    }
-
-    auto power_of_2 = jkj::big_uint::power_of_2(std::size_t(e));
-    auto power_of_10 = jkj::big_uint(1);
-    int k = 0;
-    while (power_of_10 <= power_of_2) {
-        power_of_10.multiply_5();
-        power_of_10.multiply_2();
-        ++k;
-    }
-
-    return is_negative ? -k : k - 1;
-}
-
-int floor_log10_pow2_minus_log10_4_over_3_precise(int e) {
-    e -= 2;
-
-    if (e < 0) {
-        e = -e;
-        auto power_of_2 = jkj::big_uint::power_of_2(std::size_t(e));
-        auto power_of_10_times_3 = jkj::big_uint(3);
-        int k = 0;
-        while (power_of_10_times_3 < power_of_2) {
-            power_of_10_times_3.multiply_5();
-            power_of_10_times_3.multiply_2();
-            ++k;
-        }
-        return -k;
-    }
-    else {
-        auto power_of_2_times_3 = jkj::big_uint::power_of_2(std::size_t(e)) * 3;
-        auto power_of_10 = jkj::big_uint(1);
-        int k = 0;
-        while (power_of_10 <= power_of_2_times_3) {
-            power_of_10.multiply_5();
-            power_of_10.multiply_2();
-            ++k;
-        }
-        return k - 1;
-    }
-}
-
-int floor_log2_pow10_precise(int e) {
-    bool is_negative;
-    if (e < 0) {
-        is_negative = true;
-        e = -e;
-    }
-    else {
-        is_negative = false;
-    }
-
-    auto power_of_10 = jkj::big_uint(1);
-    for (int i = 0; i < e; ++i) {
-        power_of_10.multiply_5();
-        power_of_10.multiply_2();
-    }
-
-    auto k = int(log2p1(power_of_10));
-
-    return is_negative ? -k : k - 1;
-}
-
-int floor_log5_pow2_precise(int e) {
-    bool is_negative;
-    if (e < 0) {
-        is_negative = true;
-        e = -e;
-    }
-    else {
-        is_negative = false;
-    }
-
-    auto power_of_2 = jkj::big_uint::power_of_2(std::size_t(e));
-    auto power_of_5 = jkj::big_uint(1);
-    int k = 0;
-    while (power_of_5 <= power_of_2) {
-        power_of_5.multiply_5();
-        ++k;
-    }
-
-    return is_negative ? -k : k - 1;
-}
-
-int floor_log5_pow2_minus_log5_3_precise(int e) {
-    if (e >= 0) {
-        auto power_of_2 = jkj::big_uint::power_of_2(std::size_t(e));
-        auto power_of_5_times_3 = jkj::big_uint(3);
-        int k = 0;
-        while (power_of_5_times_3 <= power_of_2) {
-            power_of_5_times_3.multiply_5();
-            ++k;
-        }
-        return k - 1;
-    }
-    else {
-        e = -e;
-        auto power_of_2_times_3 = jkj::big_uint::power_of_2(std::size_t(e)) * 3;
-        auto power_of_5 = jkj::big_uint(1);
-        int k = 0;
-        while (power_of_5 < power_of_2_times_3) {
-            power_of_5.multiply_5();
-            ++k;
-        }
-        return -k;
-    }
-}
-
-struct verify_result {
-    int min_exponent;
-    int max_exponent;
-};
-
-template <jkj::dragonbox::detail::log::multiply m, jkj::dragonbox::detail::log::subtract f,
-          jkj::dragonbox::detail::log::shift k>
-verify_result verify(std::string_view name, std::function<int(int)> precise_calculator = nullptr) {
-    // Compute the maximum possible e
-    constexpr auto max_exponent_upper_bound =
-        std::numeric_limits<std::int32_t>::max() / std::int32_t(m);
-    constexpr auto min_exponent_lower_bound =
-        -std::int32_t(-std::int64_t(std::numeric_limits<std::int32_t>::min() + std::int32_t(f)) /
-                      std::int32_t(m));
-
-    verify_result result{int(min_exponent_lower_bound), int(max_exponent_upper_bound)};
-
-    bool reach_upper_bound = false;
-    bool reach_lower_bound = false;
-    for (std::int32_t e = 0; e <= std::max(-min_exponent_lower_bound, max_exponent_upper_bound);
-         ++e) {
-        if (!reach_upper_bound) {
-            auto true_value = precise_calculator(int(e));
-            auto computed_value = int((e * std::int32_t(m) - std::int32_t(f)) >> std::size_t(k));
-            if (computed_value != true_value) {
-                std::cout << "  - error with positive e ("
-                          << "e: " << e << ", true value: " << true_value
-                          << ", computed value: " << computed_value << ")\n";
-
-                reach_upper_bound = true;
-                result.max_exponent = int(e) - 1;
-            }
-        }
-
-        if (!reach_lower_bound) {
-            auto true_value = precise_calculator(-int(e));
-            auto computed_value = int((-e * std::int32_t(m) - std::int32_t(f)) >> std::size_t(k));
-            if (computed_value != true_value) {
-                std::cout << "  - error with negative e ("
-                          << "e: " << (-int(e)) << ", true value: " << true_value
-                          << ", computed value: " << computed_value << ")\n";
-
-                reach_lower_bound = true;
-                result.min_exponent = -int(e) + 1;
-            }
-        }
-
-        if (reach_upper_bound && reach_lower_bound) {
-            break;
-        }
-    }
-
-    std::cout << name << " is correct for e in [" << result.min_exponent << ", "
-              << result.max_exponent << "]\n\n";
-
-    return result;
-}
-
-int main() {
-    using namespace jkj::dragonbox::detail::log;
-
-    bool success = true;
-    std::cout << "[Verifying log computation...]\n";
-
-    {
-        auto result = verify<multiply(315653), subtract(0), shift(20)>("floor_log10_pow2",
-                                                                       floor_log10_pow2_precise);
-        if (result.min_exponent > floor_log10_pow2_min_exponent ||
-            result.max_exponent < floor_log10_pow2_max_exponent) {
-            success = false;
-        }
-    }
-    {
-        auto result = verify<multiply(1741647), subtract(0), shift(19)>("floor_log2_pow10",
-                                                                        floor_log2_pow10_precise);
-        if (result.min_exponent > floor_log2_pow10_min_exponent ||
-            result.max_exponent < floor_log2_pow10_max_exponent) {
-            success = false;
-        }
-    }
-    {
-        auto result = verify<multiply(631305), subtract(261663), shift(21)>(
-            "floor_log10_pow2_minus_log10_4_over_3", floor_log10_pow2_minus_log10_4_over_3_precise);
-        if (result.min_exponent > floor_log10_pow2_minus_log10_4_over_3_min_exponent ||
-            result.max_exponent < floor_log10_pow2_minus_log10_4_over_3_max_exponent) {
-            success = false;
-        }
-    }
-    {
-        auto result = verify<multiply(225799), subtract(0), shift(19)>("floor_log5_pow2",
-                                                                       floor_log5_pow2_precise);
-        if (result.min_exponent > floor_log5_pow2_min_exponent ||
-            result.max_exponent < floor_log5_pow2_max_exponent) {
-            success = false;
-        }
-    }
-    {
-        auto result = verify<multiply(451597), subtract(715764), shift(20)>(
-            "floor_log5_pow2_minus_log5_3", floor_log5_pow2_minus_log5_3_precise);
-        if (result.min_exponent > floor_log5_pow2_minus_log5_3_min_exponent ||
-            result.max_exponent < floor_log5_pow2_minus_log5_3_max_exponent) {
-            success = false;
-        }
-    }
-
-    std::cout << "Done.\n\n\n";
-
-    if (!success) {
-        return -1;
-    }
-}

package/vendor/dragonbox/subproject/test/source/verify_magic_division.cpp

@@ -1,113 +0,0 @@
-// Copyright 2020 Junekey Jeon
-//
-// The contents of this file may be used under the terms of
-// the Apache License v2.0 with LLVM Exceptions.
-//
-//    (See accompanying file LICENSE-Apache or copy at
-//     https://llvm.org/foundation/relicensing/LICENSE.txt)
-//
-// Alternatively, the contents of this file may be used under the terms of
-// the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE-Boost or copy at
-//     https://www.boost.org/LICENSE_1_0.txt)
-//
-// Unless required by applicable law or agreed to in writing, this software
-// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.
-
-#include "dragonbox/dragonbox.h"
-
-#include <iostream>
-#include <iomanip>
-
-template <class Float>
-static bool verify_check_divisibility_and_divide_by_pow10() {
-    using namespace jkj::dragonbox::detail;
-
-    constexpr int kappa = impl<Float>::kappa;
-    constexpr auto max_n = compute_power<kappa + 1>(std::uint32_t(10));
-    constexpr auto divisor = compute_power<kappa>(std::uint32_t(10));
-
-    bool success = true;
-    for (std::uint32_t n = 0; n <= max_n; ++n) {
-        std::uint32_t computed_quotient = n;
-        auto computed_divisibility =
-            div::check_divisibility_and_divide_by_pow10<kappa>(computed_quotient);
-
-        if (computed_quotient != (n / divisor)) {
-            std::cout << "Dividing n = " << n << " by " << divisor
-                      << "; computed_quotient = " << computed_quotient
-                      << "; true_quotient = " << (n / divisor) << std::endl;
-            success = false;
-        }
-        if (computed_divisibility != (n % divisor == 0)) {
-            std::cout << "Dividing n = " << n << " by " << divisor
-                      << "; computed_divisibility = " << std::boolalpha << computed_divisibility
-                      << "; true_divisibility = " << (n % divisor == 0) << std::endl;
-            success = false;
-        }
-    }
-
-    if (success) {
-        std::cout << "All cases are verified.\n";
-    }
-    else {
-        std::cout << "Error detected.\n";
-    }
-
-    return success;
-}
-
-template <class Float>
-static bool verify_divide_by_pow10() {
-    using namespace jkj::dragonbox::detail;
-
-    constexpr int kappa = impl<Float>::kappa;
-    constexpr auto max_n = compute_power<kappa + 1>(std::uint32_t(10));
-    constexpr auto divisor = compute_power<kappa>(std::uint32_t(10));
-
-    bool success = true;
-    for (std::uint32_t n = 0; n <= max_n; ++n) {
-        auto computed_quotient = div::small_division_by_pow10<kappa>(n);
-
-        if (computed_quotient != (n / divisor)) {
-            std::cout << "Dividing n = " << n << " by " << divisor
-                      << "; computed_quotient = " << computed_quotient
-                      << "; true_quotient = " << (n / divisor) << std::endl;
-            success = false;
-        }
-    }
-
-    if (success) {
-        std::cout << "All cases are verified.\n";
-    }
-    else {
-        std::cout << "Error detected.\n";
-    }
-
-    return success;
-}
-
-int main() {
-    bool success = true;
-
-    std::cout << "[Verifying divisibility check and division by 10^kappa for binary32...]\n";
-    success &= verify_check_divisibility_and_divide_by_pow10<float>();
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying division by 10^kappa for binary32...]\n";
-    success &= verify_divide_by_pow10<float>();
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying divisibility check and division by 10^kappa for binary64...]\n";
-    success &= verify_check_divisibility_and_divide_by_pow10<double>();
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Verifying division by 10^kappa for binary64...]\n";
-    success &= verify_divide_by_pow10<double>();
-    std::cout << "Done.\n\n\n";
-
-    if (!success) {
-        return -1;
-    }
-}