koffi 2.3.6 → 2.3.8

package/vendor/dragonbox/subproject/common/include/good_rational_approx.h

@@ -1,267 +0,0 @@
-// Copyright 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.
-
-#ifndef JKJ_HEADER_GOOD_RATIONAL_APPROX
-#define JKJ_HEADER_GOOD_RATIONAL_APPROX
-
-#include "continued_fractions.h"
-#include <cassert>
-#include <cstdlib>
-#include <vector>
-
-namespace jkj {
-    // Find all denominators of rational approximations from below of denominators no more than
-    // denominator_upper_bound for the given number x whose error in the strong sense is at most
-    // error_threshold. The returned list might contain several different denominators of the same
-    // rational number.
-    template <class ContinuedFractionsImpl, class UInt, class PositiveNumberX,
-              class PositiveNumberEpsilon>
-    std::vector<typename ContinuedFractionsImpl::uint_type>
-    find_all_good_rational_approx_from_below_denoms(PositiveNumberX const& x,
-                                         UInt const& denominator_upper_bound,
-                                         PositiveNumberEpsilon const& error_threshold) {
-        assert(denominator_upper_bound > 0);
-
-        using uint_type = typename ContinuedFractionsImpl::uint_type;
-        std::vector<uint_type> results;
-
-        if (error_threshold >= PositiveNumberEpsilon(1)) {
-            for (UInt i = 1; i <= denominator_upper_bound; ++i) {
-                results.push_back(i);
-            }
-            return results;
-        }
-
-        // Initialize a continued fractions calculator.
-        ContinuedFractionsImpl cf{x};
-
-        // We will find the first even semiconvergent whose error is at most the threshold.
-        // If such semiconvergent has the denominator strictly bigger than the
-        // denominator_upper_bound, then there is no n such that nx - floor(nx) <= epsilon.
-        unsigned_rational<uint_type> previous_convergent; // even
-        unsigned_rational<uint_type> current_convergent;  // odd
-        uint_type semiconvergent_coeff = 0;
-        unsigned_rational<uint_type> semiconvergent;
-
-        auto perfect_approx_possible = [&] {
-            // If there is no more convergent, we already obtained the perfect approximation.
-            // This means that x = p/q is rational with q <= denominator_upper_bound.
-            // In this case, just return q, 2q, 3q, ... up to denominator_upper_bound.
-
-            auto denominator = cf.current_denominator();
-            while (denominator <= denominator_upper_bound) {
-                results.push_back(denominator);
-                denominator += cf.current_denominator();
-            }
-        };
-
-        auto update_semiconvergent = [&] {
-            semiconvergent.numerator =
-                previous_convergent.numerator + semiconvergent_coeff * current_convergent.numerator;
-            semiconvergent.denominator = previous_convergent.denominator +
-                                         semiconvergent_coeff * current_convergent.denominator;
-        };
-
-        auto gcd = [&](auto a, auto b) {
-            decltype(a) t;
-            while (b != 0) {
-                t = b;
-                b = a % b;
-                a = static_cast<decltype(a)&&>(t);
-            }
-            return a;
-        };
-
-        auto subroutine_for_each_semiconvergent = [&] {
-            auto push_all_multiples = [&](auto const& candidate) {
-                auto error = candidate.denominator * x - candidate.numerator;
-                auto error_multiple = error;
-                auto denominator_multiple = candidate.denominator;
-                while (error_multiple < error_threshold &&
-                       denominator_multiple <= denominator_upper_bound) {
-                    results.push_back(denominator_multiple);
-                    error_multiple += error;
-                    denominator_multiple += candidate.denominator;
-                }
-            };
-            push_all_multiples(semiconvergent);
-
-            auto b_max = uint_type(denominator_upper_bound) / semiconvergent.denominator;
-
-            for (decltype(b_max) b = 2; b <= b_max; ++b) {
-                unsigned_rational<uint_type> candidate{b * semiconvergent.numerator,
-                                                       b * semiconvergent.denominator};
-
-                auto a_max = (uint_type(denominator_upper_bound) - candidate.denominator) /
-                             current_convergent.denominator;
-                for (decltype(a_max) a = 1; a <= a_max && a < b; ++a) {
-                    candidate.numerator += current_convergent.numerator;
-                    candidate.denominator += current_convergent.denominator;
-
-                    // If a and b are not coprime, skip.
-                    if (gcd(a, b) != 1) {
-                        continue;
-                    }
-
-                    push_all_multiples(candidate);
-                }
-            }
-        };
-
-        while (true) {
-            // Currently, cf.current_index() is odd.
-            // Obtain the next convergent.
-            if (!cf.update()) {
-                perfect_approx_possible();
-
-                // The last convergent is of odd index, and we are looking for semiconvergents after
-                // the last even convergent. These semiconvergents should have the same error
-                // with the last even convergent, and since the last even convergent has been
-                // confirmed to have error worse than the threshold, there is nothing left to do.
-                return results;
-            }
-
-            // Now, cf.current_index() is even.
-            if (cf.current_denominator() * x - cf.current_numerator() < error_threshold) {
-                // In this case, we should look at semiconvergents.
-                if (cf.current_index() == 0) {
-                    // In this case, the semiconvergent we are looking for is the 0th convergent.
-                    break;
-                }
-                else {
-                    while (true) {
-                        ++semiconvergent_coeff;
-                        update_semiconvergent();
-
-                        if (semiconvergent.denominator > denominator_upper_bound) {
-                            // This means there is no semiconvergent satisfying the condition.
-                            return results;
-                        }
-
-                        if (semiconvergent_coeff == cf.current_coefficient()) {
-                            // Found the first semiconvergent, which is the next convergent.
-                            break;
-                        }
-
-                        if (semiconvergent.denominator * x - semiconvergent.numerator <
-                            error_threshold) {
-                            // Found the first semiconvergent.
-                            // Iterate until reaching the next convergent.
-                            while (true) {
-                                subroutine_for_each_semiconvergent();
-                                ++semiconvergent_coeff;
-                                update_semiconvergent();
-
-                                if (semiconvergent.denominator > denominator_upper_bound) {
-                                    return results;
-                                }
-
-                                if (semiconvergent_coeff == cf.current_coefficient()) {
-                                    break;
-                                }
-                            }
-                            break;
-                        }
-                    }
-                }
-                break;
-            }
-
-            if (cf.current_denominator() > denominator_upper_bound) {
-                // In this case, we haven't found any convergent that has better error than the
-                // threshold, which means there is no n satisfying nx - floor(nx) <= epsilon.
-                return results;
-            }
-
-            // Currently, cf.current_index() is even.
-            // Obtain the next convergent.
-            if (!cf.update()) {
-                // In this case, there is no n satisfying nx - floor(nx) <= epsilon
-                // other than those making x an integer.
-                perfect_approx_possible();
-                return results;
-            }
-
-            // Now, cf.current_index() is odd.
-            if (cf.current_denominator() > denominator_upper_bound) {
-                // In this case, we haven't found any convergent that has better error than the
-                // threshold, which means there is no n satisfying nx - floor(nx) <= epsilon.
-                return results;
-            }
-
-            previous_convergent = cf.previous_convergent();
-            current_convergent = cf.current_convergent();
-        }
-
-        // We have found the first even semiconvergent with a good enough error.
-        assert(cf.current_index() % 2 == 0);
-
-        // Now, iterate over all subsequent convergents.
-        while (true) {
-            if (!cf.update()) {
-                perfect_approx_possible();
-                break;
-            }
-
-            // Now, cf.current_index() is odd.
-            previous_convergent = cf.previous_convergent();
-            current_convergent = cf.current_convergent();
-            semiconvergent_coeff = 0;
-            update_semiconvergent();
-            subroutine_for_each_semiconvergent();
-
-            if (cf.current_denominator() > denominator_upper_bound) {
-                break;
-            }
-
-            // Obtain the next even convergent.
-            if (!cf.update()) {
-                perfect_approx_possible();
-
-                // The last convergent is of odd index, and we are looking for semiconvergents
-                // after the last even convergent.
-                while (true) {
-                    ++semiconvergent_coeff;
-                    update_semiconvergent();
-
-                    if (semiconvergent.denominator > denominator_upper_bound) {
-                        break;
-                    }
-
-                    subroutine_for_each_semiconvergent();
-                }
-                return results;
-            }
-
-            // Iterate over all semiconvergents.
-            for (semiconvergent_coeff = 1; semiconvergent_coeff < cf.current_coefficient();
-                 ++semiconvergent_coeff) {
-                update_semiconvergent();
-
-                if (semiconvergent.denominator > denominator_upper_bound) {
-                    return results;
-                }
-
-                subroutine_for_each_semiconvergent();
-            }
-        }
-
-        return results;
-    }
-}
-
-#endif

package/vendor/dragonbox/subproject/common/include/random_float.h

@@ -1,182 +0,0 @@
-// Copyright 2020-2021 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.
-
-#ifndef JKJ_HEADER_RANDOM_FLOAT
-#define JKJ_HEADER_RANDOM_FLOAT
-
-#include "dragonbox/dragonbox.h"
-#include <algorithm>
-#include <cstring>
-#include <random>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-// For correct seeding
-class repeating_seed_seq {
-public:
-    using result_type = std::uint32_t;
-
-    repeating_seed_seq() : stored_values{0} {}
-    template <class InputIterator>
-    repeating_seed_seq(InputIterator first, InputIterator last) : stored_values(first, last) {}
-    template <class T>
-    repeating_seed_seq(std::initializer_list<T> list) : stored_values(list) {}
-
-    repeating_seed_seq(std::random_device&& rd, std::size_t count) {
-        stored_values.resize(count);
-        for (auto& elem : stored_values)
-            elem = rd();
-    }
-
-    template <class RandomAccessIterator>
-    void generate(RandomAccessIterator first, RandomAccessIterator last) {
-        auto count = last - first;
-        auto q = count / stored_values.size();
-        for (std::size_t i = 0; i < q; ++i) {
-            std::copy_n(stored_values.cbegin(), stored_values.size(), first);
-            first += stored_values.size();
-        }
-        count -= q * stored_values.size();
-        std::copy_n(stored_values.cbegin(), count, first);
-    }
-
-    std::size_t size() const noexcept { return stored_values.size(); }
-
-    template <class OutputIterator>
-    void param(OutputIterator first) const {
-        std::copy(stored_values.begin(), stored_values.end(), first);
-    }
-
-private:
-    std::vector<std::uint32_t> stored_values;
-};
-
-inline std::mt19937_64 generate_correctly_seeded_mt19937_64() {
-    repeating_seed_seq seed_seq{std::random_device{}, std::mt19937_64::state_size *
-                                                          std::mt19937_64::word_size /
-                                                          (sizeof(std::uint32_t) * 8)};
-    return std::mt19937_64{seed_seq};
-}
-
-template <class Float, class RandGen>
-Float uniformly_randomly_generate_finite_float(RandGen& rg) {
-    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;
-    using uniform_distribution = std::uniform_int_distribution<carrier_uint>;
-
-    // Generate sign bit
-    auto sign_bit = uniform_distribution{0, 1}(rg);
-
-    // Generate exponent bits
-    auto exponent_bits =
-        uniform_distribution{0, (carrier_uint(1) << ieee754_format_info::exponent_bits) - 2}(rg);
-
-    // Generate significand bits
-    auto significand_bits =
-        uniform_distribution{0, (carrier_uint(1) << ieee754_format_info::significand_bits) - 1}(rg);
-
-    auto bit_representation = (sign_bit << (ieee754_traits::carrier_bits - 1)) |
-                              (exponent_bits << (ieee754_format_info::significand_bits)) |
-                              significand_bits;
-
-    return ieee754_traits::carrier_to_float(bit_representation);
-}
-
-template <class Float, class RandGen>
-Float uniformly_randomly_generate_general_float(RandGen& rg) {
-    using ieee754_traits = jkj::dragonbox::default_float_traits<Float>;
-    using carrier_uint = typename ieee754_traits::carrier_uint;
-    using uniform_distribution = std::uniform_int_distribution<carrier_uint>;
-
-    // Generate sign bit
-    auto bit_representation = uniform_distribution{0, std::numeric_limits<carrier_uint>::max()}(rg);
-    return ieee754_traits::carrier_to_float(bit_representation);
-}
-
-// This function tries to uniformly randomly generate a float number with the
-// given number of decimal digits, and the end-result is not perfectly bias-free.
-// However, I don't think there is an easy way to do it correctly.
-template <class Float, class RandGen>
-Float randomly_generate_float_with_given_digits(unsigned int digits, RandGen& rg) {
-    using ieee754_traits = jkj::dragonbox::default_float_traits<Float>;
-    using carrier_uint = typename ieee754_traits::carrier_uint;
-    using signed_int_t = std::make_signed_t<carrier_uint>;
-
-    assert(digits >= 1);
-    assert(digits <= ieee754_traits::format::decimal_digits);
-
-    // Generate sign uniformly randomly
-    signed_int_t sign = std::uniform_int_distribution<signed_int_t>{0, 1}(rg) == 0 ? 1 : -1;
-
-
-    // Try to generate significand uniformly randomly
-    Float result;
-    signed_int_t from = 0, to = 9;
-    if (digits > 1) {
-        from = 1;
-        for (unsigned int e = 1; e < digits - 1; ++e) {
-            from *= 10;
-        }
-        to = from * 10 - 1;
-    }
-
-    while (true) {
-        auto significand = std::uniform_int_distribution<signed_int_t>{from, to}(rg);
-        if (digits > 1) {
-            significand *= 10;
-            significand += std::uniform_int_distribution<signed_int_t>{1, 9}(rg);
-        }
-
-        // Generate exponent uniformly randomly
-        auto exp = std::uniform_int_distribution<int>{
-            std::numeric_limits<Float>::min_exponent10 - (int(digits) - 1),
-            std::numeric_limits<Float>::max_exponent10 - (int(digits) - 1)}(rg);
-
-        // Cook up
-        auto str = std::to_string(sign * significand) + 'e' + std::to_string(exp);
-
-        if constexpr (std::is_same_v<Float, float>) {
-            result = std::strtof(str.c_str(), nullptr);
-        }
-        else {
-            result = std::strtod(str.c_str(), nullptr);
-        }
-
-        if (!std::isfinite(result)) {
-            continue;
-        }
-
-        // Discard if a shorter representation exists
-        // We don't need to care about sign and correct rounding here
-        if (from != 0) {
-            auto roundtrip = jkj::dragonbox::to_decimal(
-                result, jkj::dragonbox::policy::sign::ignore,
-                jkj::dragonbox::policy::decimal_to_binary_rounding::nearest_to_even,
-                jkj::dragonbox::policy::binary_to_decimal_rounding::do_not_care);
-            if (roundtrip.significand <= carrier_uint(from * 10)) {
-                continue;
-            }
-        }
-        break;
-    }
-
-    return result;
-}
-
-#endif

package/vendor/dragonbox/subproject/common/include/rational_continued_fractions.h

@@ -1,57 +0,0 @@
-// Copyright 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.
-
-#ifndef JKJ_HEADER_RATIONAL_CONTINUED_FRACTIONS
-#define JKJ_HEADER_RATIONAL_CONTINUED_FRACTIONS
-
-#include "continued_fractions.h"
-#include <cassert>
-#include <cstdlib>
-
-namespace jkj {
-    template <class UInt>
-    class rational_continued_fractions
-        : public continued_fractions<rational_continued_fractions<UInt>, UInt> {
-        using crtp_base = continued_fractions<rational_continued_fractions<UInt>, UInt>;
-        friend crtp_base;
-
-        UInt prev_error_;
-        UInt curr_error_;
-
-        UInt compute_next_coefficient() {
-            using std::div;
-            auto div_result = div(prev_error_, curr_error_);
-            prev_error_ = static_cast<UInt&&>(curr_error_);
-            curr_error_ = static_cast<UInt&&>(div_result.rem);
-
-            if (curr_error_ == 0) {
-                crtp_base::set_terminate_flag();
-            }
-
-            return static_cast<UInt&&>(div_result.quot);
-        }
-
-    public:
-        rational_continued_fractions(unsigned_rational<UInt> r)
-            : prev_error_{static_cast<UInt&&>(r.numerator)}, curr_error_{static_cast<UInt&&>(
-                                                                 r.denominator)} {
-            assert(curr_error_ != 0);
-        }
-    };
-}
-
-#endif