koffi 2.3.6 → 2.3.8

package/vendor/dragonbox/subproject/test/results/plot_required_bits.m

@@ -1,18 +0,0 @@
-function [] = plot_required_bits(filename)
-
-table = readtable(filename);
-fig = figure('Color','w');
-hold on
-mul_fig_handle = plot(table{:,1}, table{:,2});
-int_fig_handle = plot(table{:,1}, table{:,3});
-legend([mul_fig_handle int_fig_handle], ...
-    ["For multiplication", "For integer check"]);
-axis([min(table{:,1}) max(table{:,1}) min(min(table{:,2:3})) max(max(table{:,2:3}))]);
-xlabel('$e$', 'Interpreter', 'latex');
-ylabel('Upper bound on required number of bits');
-h = gca;
-h.YTick = 0:8:max(max(table{:,2:3}));
-h.YGrid = 'on';
-hold off
-
-end

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

@@ -1,88 +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_to_chars.h"
-#include "ryu/ryu.h"
-
-#include <iostream>
-#include <iomanip>
-#include <string_view>
-#include <utility>
-
-template <class Float, class...Args>
-static bool test_all_shorter_interval_cases_impl(Args&&... args) {
-    using ieee754_traits = jkj::dragonbox::default_float_traits<Float>;
-    using ieee754_format_info = typename ieee754_traits::format;
-    using carrier_uint = typename ieee754_traits::carrier_uint;
-
-    char buffer1[64];
-    char buffer2[64];
-
-    bool success = true;
-    for (int e = ieee754_format_info::min_exponent; e <= ieee754_format_info::max_exponent; ++e) {
-        // Compose a floating-point number
-        carrier_uint br = carrier_uint(e - ieee754_format_info::exponent_bias)
-                          << ieee754_format_info::significand_bits;
-        auto x = jkj::dragonbox::float_bits<Float>{br}.to_float();
-
-        jkj::dragonbox::to_chars(x, buffer1, std::forward<Args>(args)...);
-        if constexpr (std::is_same_v<Float, float>) {
-            f2s_buffered(x, buffer2);
-        }
-        else {
-            d2s_buffered(x, buffer2);
-        }
-
-        std::string_view view1(buffer1);
-        std::string_view view2(buffer2);
-
-        if (view1 != view2) {
-            std::cout << "Error detected! [Ryu = " << buffer2 << ", Dragonbox = " << buffer1
-                      << "]\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 << "[Testing all shorter interval cases for binary32...]\n";
-    success &= test_all_shorter_interval_cases_impl<float>();
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Testing all shorter interval cases for binary64...]\n";
-    success &= test_all_shorter_interval_cases_impl<double>();
-    std::cout << "Done.\n\n\n";
-
-    std::cout << "[Testing all shorter interval cases for binary64 with compressed cache...]\n";
-    success &= test_all_shorter_interval_cases_impl<double>(
-        jkj::dragonbox::policy::cache::compact);
-    std::cout << "Done.\n\n\n";
-
-    if (!success) {
-        return -1;
-    }
-}

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

@@ -1,95 +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_to_chars.h"
-#include "random_float.h"
-#include "ryu/ryu.h"
-#include <iostream>
-#include <string_view>
-#include <utility>
-
-template <class Float, class TypenameString, class... Args>
-static bool uniform_random_test(std::size_t number_of_tests, TypenameString&& type_name_string,
-                                Args&&... args) {
-    char buffer1[64];
-    char buffer2[64];
-    auto rg = generate_correctly_seeded_mt19937_64();
-    bool success = true;
-    for (std::size_t test_idx = 0; test_idx < number_of_tests; ++test_idx) {
-        auto x = uniformly_randomly_generate_general_float<Float>(rg);
-
-        // Check if the output is identical to that of Ryu
-        jkj::dragonbox::to_chars(x, buffer1, std::forward<Args>(args)...);
-        if constexpr (std::is_same_v<Float, float>) {
-            f2s_buffered(x, buffer2);
-        }
-        else {
-            d2s_buffered(x, buffer2);
-        }
-
-        std::string_view view1(buffer1);
-        std::string_view view2(buffer2);
-
-        if (view1 != view2) {
-            std::cout << "Error detected! [Ryu = " << buffer2 << ", Dragonbox = " << buffer1
-                      << "]\n";
-            success = false;
-        }
-    }
-
-    if (success) {
-        std::cout << "Uniform random test for " << type_name_string << " with " << number_of_tests
-                  << " examples succeeded.\n";
-    }
-
-    return success;
-}
-
-int main() {
-    constexpr bool run_float = true;
-    constexpr std::size_t number_of_uniform_random_tests_float = 10000000;
-
-    constexpr bool run_double = true;
-    constexpr std::size_t number_of_uniform_random_tests_double = 10000000;
-
-    constexpr bool run_double_with_compressed_cache = true;
-    constexpr std::size_t number_of_uniform_random_tests_double_compressed = 10000000;
-
-    bool success = true;
-
-    if constexpr (run_float) {
-        std::cout << "[Testing uniformly randomly generated float inputs...]\n";
-        success &= uniform_random_test<float>(number_of_uniform_random_tests_float, "float");
-        std::cout << "Done.\n\n\n";
-    }
-    if constexpr (run_double) {
-        std::cout << "[Testing uniformly randomly generated double inputs...]\n";
-        success &= uniform_random_test<double>(number_of_uniform_random_tests_double, "double");
-        std::cout << "Done.\n\n\n";
-    }
-    if constexpr (run_double_with_compressed_cache) {
-        std::cout
-            << "[Testing uniformly randomly generated double inputs with compressed cache...]\n";
-        success &= uniform_random_test<double>(number_of_uniform_random_tests_double_compressed,
-                                               "double", jkj::dragonbox::policy::cache::compact);
-        std::cout << "Done.\n\n\n";
-    }
-
-    if (!success) {
-        return -1;
-    }
-}

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

@@ -1,338 +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 "best_rational_approx.h"
-#include "good_rational_approx.h"
-#include "big_uint.h"
-#include "rational_continued_fractions.h"
-#include "dragonbox/dragonbox.h"
-#include <algorithm>
-#include <cstddef>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <limits>
-#include <stdexcept>
-#include <utility>
-#include <vector>
-
-std::ostream& operator<<(std::ostream& out, jkj::big_uint const& n) {
-    auto dec = n.to_decimal();
-    assert(!dec.empty());
-
-    out << dec.back();
-
-    auto cur_fill = out.fill();
-    out << std::setfill('0');
-
-    for (std::size_t back_idx = 0; back_idx < dec.size() - 1; ++back_idx) {
-        out << std::setw(19) << dec[dec.size() - back_idx - 2];
-    }
-
-    out << std::setfill(cur_fill);
-    return out;
-}
-
-struct analysis_result {
-    struct result_per_cache_entry {
-        int sufficient_bits_for_multiplication;
-        int sufficient_bits_for_integer_checks;
-        jkj::unsigned_rational<jkj::big_uint> distance_to_upper_bound;
-    };
-    std::vector<result_per_cache_entry> results;
-
-    struct error_case {
-        int e;
-        int k;
-        jkj::unsigned_rational<jkj::big_uint> target;
-        jkj::unsigned_rational<jkj::big_uint> unit;
-        std::vector<jkj::big_uint> candidate_multipliers{};
-    };
-    std::vector<error_case> error_cases;
-};
-
-template <class FloatTraits>
-bool analyze(std::ostream& out) {
-    out << "e,bits_for_multiplication,bits_for_integer_check\n";
-
-    using impl = jkj::dragonbox::detail::impl<typename FloatTraits::type, FloatTraits>;
-    using namespace jkj::dragonbox::detail::log;
-
-    auto n_max = jkj::big_uint::power_of_2(impl::significand_bits + 2);
-
-    analysis_result result;
-    result.results.resize(impl::max_k - impl::min_k + 1);
-
-    jkj::unsigned_rational<jkj::big_uint> target{1, 1}, unit;
-    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 k = impl::kappa - floor_log10_pow2(e);
-        auto exp_2 = k - floor_log2_pow10(k) - 1;
-        int beta = e + floor_log2_pow10(k);
-
-        auto& results_for_k = result.results[k - impl::min_k];
-
-        // target = 2^(k - klog2(10) - 1) * 5^k = phi_k / 2^Q in [1/2, 1).
-        if (k != prev_k) {
-            target.numerator = 1;
-            target.denominator = 1;
-            if (k >= 0) {
-                target.numerator = jkj::big_uint::pow(5, k);
-            }
-            else {
-                target.denominator = jkj::big_uint::pow(5, -k);
-            }
-            if (exp_2 >= 0) {
-                target.numerator *= jkj::big_uint::power_of_2(exp_2);
-            }
-            else {
-                target.denominator *= jkj::big_uint::power_of_2(-exp_2);
-            }
-        }
-
-        // 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);
-        }
-
-
-        jkj::unsigned_rational<jkj::big_uint> upper_bound;
-        int sufficient_bits_for_integer_checks;
-        if (unit.denominator <= n_max) {
-            if (unit.denominator == 1) {
-                upper_bound = {unit.numerator * n_max + 1, n_max * jkj::big_uint::power_of_2(beta)};
-            }
-            else {
-                // We want to find the largest v <= n_max such that va == -1 (mod b).
-                // To obtain such v, we first find the smallest positive v0 such that
-                // v0 * a == -1 (mod b). Then v = v0 + floor((n_max - v0)/b) * b.
-                auto v0 = jkj::find_best_rational_approx<
-                              jkj::rational_continued_fractions<jkj::big_uint>>(
-                              unit, unit.denominator - 1)
-                              .above.denominator;
-                auto v = v0 + ((n_max - v0) / unit.denominator) * unit.denominator;
-
-                auto div_result = div(v * unit.numerator + 1, unit.denominator);
-                assert(div_result.rem.is_zero());
-                upper_bound = jkj::unsigned_rational<jkj::big_uint>{
-                    div_result.quot, v * jkj::big_uint::power_of_2(beta)};
-            }
-
-            sufficient_bits_for_integer_checks =
-                impl::carrier_bits + int(jkj::big_uint(1).multiply_2_until(unit.denominator));
-        }
-        else {
-            auto [below, above] =
-                jkj::find_best_rational_approx<jkj::rational_continued_fractions<jkj::big_uint>>(
-                    unit, n_max);
-
-            upper_bound = std::move(above);
-            upper_bound.denominator *= jkj::big_uint::power_of_2(beta);
-
-            sufficient_bits_for_integer_checks =
-                impl::carrier_bits +
-                int((unit.numerator * below.denominator - below.numerator * unit.denominator)
-                        .multiply_2_until(unit.denominator));
-
-            // Collect all cases where cache_bits seems insufficient.
-            if (sufficient_bits_for_integer_checks > impl::cache_bits) {
-                result.error_cases.push_back({e, k, target, unit});
-            }
-        }
-
-        // Compute the required number of bits for successful multiplication.
-        // The following is an upper bound.
-        auto div_result = div(upper_bound.denominator * target.denominator,
-                              upper_bound.numerator * target.denominator -
-                                  upper_bound.denominator * target.numerator);
-        if (!div_result.rem.is_zero()) {
-            div_result.quot += 1;
-        }
-        auto sufficient_bits_for_multiplication =
-            int(jkj::big_uint(1).multiply_2_until(div_result.quot));
-
-        // Tentatively decrease the above result to find the minimum admissible value.
-        while (sufficient_bits_for_multiplication > 0) {
-            auto r = (jkj::big_uint::power_of_2(sufficient_bits_for_multiplication - 1) *
-                      target.numerator) %
-                     target.denominator;
-            if (!r.is_zero()) {
-                r = target.denominator - r;
-            }
-
-            if (r * upper_bound.denominator >=
-                jkj::big_uint::power_of_2(sufficient_bits_for_multiplication - 1) *
-                    (upper_bound.numerator * target.denominator -
-                     upper_bound.denominator * target.numerator)) {
-                break;
-            }
-
-            --sufficient_bits_for_multiplication;
-        }
-
-        out << e << "," << sufficient_bits_for_multiplication << ","
-            << sufficient_bits_for_integer_checks << "\n";
-
-        // Update.
-        if (results_for_k.sufficient_bits_for_multiplication < sufficient_bits_for_multiplication) {
-            results_for_k.sufficient_bits_for_multiplication = sufficient_bits_for_multiplication;
-        }
-        if (results_for_k.sufficient_bits_for_integer_checks < sufficient_bits_for_integer_checks) {
-            results_for_k.sufficient_bits_for_integer_checks = sufficient_bits_for_integer_checks;
-        }
-        auto distance = jkj::unsigned_rational<jkj::big_uint>{
-            upper_bound.numerator * target.denominator - upper_bound.denominator * target.numerator,
-            upper_bound.denominator * target.denominator};
-        if (results_for_k.distance_to_upper_bound.denominator.is_zero()) {
-            results_for_k.distance_to_upper_bound = std::move(distance);
-        }
-        else if (results_for_k.distance_to_upper_bound.numerator * distance.denominator >
-                 distance.numerator * results_for_k.distance_to_upper_bound.denominator) {
-            results_for_k.distance_to_upper_bound = distance;
-        }
-    }
-
-    // Analyze all error cases.
-    auto reciprocal_error_threshold =
-        jkj::big_uint::power_of_2(impl::cache_bits - impl::carrier_bits);
-    for (auto& ec : result.error_cases) {
-        // We want to find all n such that
-        // d:= na/b - floor(na/b) < 2^(q-Q).
-
-        ec.candidate_multipliers = jkj::find_all_good_rational_approx_from_below_denoms<
-            jkj::rational_continued_fractions<jkj::big_uint>>(
-            ec.unit, n_max, jkj::unsigned_rational<jkj::big_uint>{1, reciprocal_error_threshold});
-    }
-
-    auto sufficient_bits_for_multiplication =
-        std::max_element(result.results.cbegin(), result.results.cend(),
-                         [](auto const& a, auto const& b) {
-                             return a.sufficient_bits_for_multiplication <
-                                    b.sufficient_bits_for_multiplication;
-                         })
-            ->sufficient_bits_for_multiplication;
-    auto sufficient_bits_for_integer_checks =
-        std::max_element(result.results.cbegin(), result.results.cend(),
-                         [](auto const& a, auto const& b) {
-                             return a.sufficient_bits_for_integer_checks <
-                                    b.sufficient_bits_for_integer_checks;
-                         })
-            ->sufficient_bits_for_integer_checks;
-    auto larger = std::max(sufficient_bits_for_multiplication, sufficient_bits_for_integer_checks);
-
-    auto distance_to_upper_bound =
-        std::min_element(
-            result.results.cbegin(), result.results.cend(),
-            [](auto const& a, auto const& b) {
-                if (a.distance_to_upper_bound.denominator == 0) {
-                    return false;
-                }
-                else if (b.distance_to_upper_bound.denominator == 0) {
-                    return true;
-                }
-                return a.distance_to_upper_bound.numerator * b.distance_to_upper_bound.denominator <
-                       b.distance_to_upper_bound.numerator * a.distance_to_upper_bound.denominator;
-            })
-            ->distance_to_upper_bound;
-
-    // Reduce the fraction.
-    distance_to_upper_bound =
-        jkj::find_best_rational_approx<jkj::rational_continued_fractions<jkj::big_uint>>(
-            distance_to_upper_bound, distance_to_upper_bound.denominator)
-            .below;
-
-    std::cout << "An upper bound on the minimum required bits for successful multiplication is "
-              << sufficient_bits_for_multiplication
-              << "-bits.\nAn upper bound on the minimum required bits for successful integer "
-                 "checks is "
-              << sufficient_bits_for_integer_checks << "-bits.\n";
-    std::cout << "A lower bound on the margin is " << distance_to_upper_bound.numerator << " / "
-              << distance_to_upper_bound.denominator << ".\n";
-
-    if (impl::cache_bits < larger) {
-        auto success = true;
-        std::cout << "Error cases:\n";
-        auto threshold = jkj::big_uint::power_of_2(impl::significand_bits + 1) - 1;
-        for (auto const& ec : result.error_cases) {
-            for (auto const& n : ec.candidate_multipliers) {
-                std::cout << "  e: " << ec.e << "  k: " << ec.k << "  n: " << n;
-
-                // When e != min_e and n != 1, 2, then
-                // n must be at least 2^(p+1)-2, otherwise this is a false
-                // positive.
-
-                if (ec.e != impl::min_exponent - impl::significand_bits && n != 1 && n != 2 &&
-                    n < threshold) {
-                    std::cout << "\n    n is smaller than " << threshold
-                              << ", so this case is a false positive.";
-                }
-                else if (ec.e == -81 && n == 29711844 || ec.e == -80 && n == 29711844) {
-                    std::cout << "\n    This case has been carefully addressed.";
-                }
-                else {
-                    success = false;
-                }
-
-                std::cout << "\n\n";
-            }
-        }
-
-        if (!success) {
-            std::cout << "Verification failed. " << impl::cache_bits
-                      << "-bits are not sufficient.\n\n";
-            return false;
-        }
-    }
-
-    std::cout << "Verified. " << impl::cache_bits << "-bits are sufficient.\n\n";
-    return true;
-}
-
-
-
-int main() {
-    bool success = true;
-    std::ofstream out;
-
-    std::cout << "[Verifying sufficiency of cache precision for binary32...]\n";
-    out.open("results/binary32.csv");
-    if (!analyze<jkj::dragonbox::default_float_traits<float>>(out)) {
-        success = false;
-    }
-    out.close();
-
-    std::cout << "[Verifying sufficiency of cache precision for binary64...]\n";
-    out.open("results/binary64.csv");
-    if (!analyze<jkj::dragonbox::default_float_traits<double>>(out)) {
-        success = false;
-    }
-    out.close();
-
-    return success ? 0 : -1;
-}