koffi 0.9.0 → 0.9.3

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

@@ -0,0 +1,267 @@
+// 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

@@ -0,0 +1,182 @@
+// 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

@@ -0,0 +1,57 @@
+// 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