koffi 2.3.6-beta.6 → 2.3.7

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

@@ -1,97 +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_BEST_RATIONAL_APPROX
-#define JKJ_HEADER_BEST_RATIONAL_APPROX
-
-#include "continued_fractions.h"
-#include <cassert>
-#include <cstdlib>
-
-namespace jkj {
-    template <class UInt>
-    struct best_rational_approx_output {
-        unsigned_rational<UInt> below;
-        unsigned_rational<UInt> above;
-    };
-
-    // Find the best rational approximations from below and from above of denominators no more than
-    // denominator_upper_bound for the given number x.
-    template <class ContinuedFractionsImpl, class UInt, class PositiveNumber>
-    best_rational_approx_output<typename ContinuedFractionsImpl::uint_type>
-    find_best_rational_approx(PositiveNumber const& x, UInt const& denominator_upper_bound) {
-        assert(denominator_upper_bound > 0);
-
-        using uint_type = typename ContinuedFractionsImpl::uint_type;
-        best_rational_approx_output<uint_type> ret_value;
-
-        // Initialize a continued fractions calculator.
-        ContinuedFractionsImpl cf{x};
-
-        // First, find the last convergent whose denominator is bounded above by the given upper
-        // bound.
-        unsigned_rational<uint_type> previous_convergent;
-        unsigned_rational<uint_type> current_convergent;
-        do {
-            previous_convergent = cf.previous_convergent();
-            current_convergent = cf.current_convergent();
-
-            // Obtain the next convergent.
-            if (!cf.update()) {
-                // If there is no more convergents, we already obtained the perfect approximation.
-                ret_value.below = cf.current_convergent();
-                ret_value.above = cf.current_convergent();
-                return ret_value;
-            }
-        } while (cf.current_denominator() <= denominator_upper_bound);
-
-        // If the current convergent is of even index,
-        // then the current convergent is the best approximation from below,
-        // and the best approximation from above is the last semiconvergent.
-        // If the current convergent is of odd index, then the other way around.
-        // Note that cf.current_index() is one larger than the index of the current convergent,
-        // so we need to reverse the parity.
-
-        auto compute_bounds = [&](auto& major, auto& minor) {
-            // The current convergent is the best approximation from below.
-            major = current_convergent;
-
-            // The best approximation from above is the last semiconvergent.
-            using std::div;
-            auto semiconvergent_coeff =
-                div(denominator_upper_bound - previous_convergent.denominator,
-                    current_convergent.denominator)
-                    .quot;
-
-            minor.numerator =
-                previous_convergent.numerator + semiconvergent_coeff * current_convergent.numerator;
-            minor.denominator = previous_convergent.denominator +
-                                semiconvergent_coeff * current_convergent.denominator;
-        };
-
-        if (cf.current_index() % 2 == 1) {
-            compute_bounds(ret_value.below, ret_value.above);
-        }
-        else {
-            compute_bounds(ret_value.above, ret_value.below);
-        }
-
-        return ret_value;
-    }
-}
-
-#endif

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

@@ -1,218 +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_BIG_UINT
-#define JKJ_HEADER_BIG_UINT
-
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <iterator>
-#include <vector>
-
-namespace jkj {
-    class big_uint {
-    public:
-        using element_type = std::uint64_t;
-        static constexpr std::size_t element_number_of_bits = 64;
-
-    private:
-        // Least significant element first.
-        std::vector<element_type> elements;
-
-    public:
-        // elements is empty if and only if it represents 0.
-        big_uint() = default;
-        big_uint(element_type n) {
-            if (n != 0) {
-                elements.push_back(n);
-            }
-        }
-
-        // Remove leading zeros.
-        explicit big_uint(std::initializer_list<element_type> list)
-            : big_uint(list.begin(), list.end()) {}
-
-        // Remove leading zeros.
-        template <class Iter, class = typename std::iterator_traits<Iter>::iterator_category>
-        big_uint(Iter first, Iter last) : elements(first, last) {
-            auto effective_size = elements.size();
-            while (effective_size > 0) {
-                if (elements[effective_size - 1] != 0) {
-                    break;
-                }
-                --effective_size;
-            }
-            elements.resize(effective_size);
-        }
-
-        element_type operator[](std::size_t idx) const { return elements[idx]; }
-
-        bool is_zero() const noexcept { return elements.empty(); }
-        bool is_even() const noexcept {
-            if (elements.empty()) {
-                return true;
-            }
-            else {
-                return elements[0] % 2 == 0;
-            }
-        }
-
-        friend std::size_t log2p1(big_uint const& n) noexcept;
-
-        static big_uint power_of_2(std::size_t k);
-        static big_uint pow(big_uint base, std::size_t k);
-
-        // Repeat multiplying 2 until the number becomes bigger than or equal to the given number.
-        // Returns the number of multiplications, which is ceil(log2(n/*this)).
-        // Precondition: *this is not zero and n should be bigger than or equal to the current
-        // number. Note that this function need not require &n != this.
-        std::size_t multiply_2_until(big_uint const& n);
-
-        // Repeat multiplying 2 while the number becomes less than or equal to the given number.
-        // Returns the number of multiplications, which is floor(log2(n/*this)).
-        // Precondition: *this is not zero and n should be bigger than or equal to the current
-        // number. Note that this function need not require &n != this.
-        std::size_t multiply_2_while(big_uint const& n);
-
-        void multiply_2() &;
-        void multiply_5() &;
-
-        bool operator==(big_uint const& n) const noexcept { return elements == n.elements; }
-        bool operator!=(big_uint const& n) const noexcept { return elements != n.elements; }
-        bool operator==(element_type n) const noexcept {
-            return (elements.size() == 0 && n == 0) || (elements.size() == 1 && elements[0] == n);
-        }
-        bool operator!=(element_type n) const noexcept {
-            return (elements.size() == 0 && n != 0) || (elements.size() == 1 && elements[0] != n) ||
-                   (elements.size() > 1);
-        }
-
-    private:
-        int comparison_common(big_uint const& n) const noexcept;
-
-    public:
-        bool operator<(big_uint const& n) const noexcept { return comparison_common(n) < 0; }
-        bool operator<=(big_uint const& n) const noexcept { return comparison_common(n) <= 0; }
-        bool operator>(big_uint const& n) const noexcept { return comparison_common(n) > 0; }
-        bool operator>=(big_uint const& n) const noexcept { return comparison_common(n) >= 0; }
-
-        bool operator<(element_type n) const noexcept {
-            return (elements.size() == 0 && n != 0) || (elements.size() == 1 && elements[0] < n);
-        }
-        bool operator<=(element_type n) const noexcept {
-            return (elements.size() == 0 && n == 0) || (elements.size() == 1 && elements[0] <= n);
-        }
-        bool operator>(element_type n) const noexcept {
-            return (elements.size() == 1 && elements[0] > n) || (elements.size() > 1);
-        }
-        bool operator>=(element_type n) const noexcept {
-            return (elements.size() == 0 && n == 0) || (elements.size() == 1 && elements[0] >= n) ||
-                   (elements.size() > 1);
-        }
-
-        big_uint& operator+=(big_uint const& n) &;
-        big_uint& operator+=(element_type n) &;
-        template <class T>
-        big_uint operator+(T const& n) const {
-            auto r = *this;
-            return r += n;
-        }
-        friend big_uint operator+(element_type n, big_uint const& m) { return m + n; }
-        big_uint& operator++() & {
-            *this += 1;
-            return *this;
-        }
-        big_uint operator++(int) & {
-            auto temp = *this;
-            *this += 1;
-            return temp;
-        }
-
-        // Precondition: n should be strictly smaller than or equal to the current number
-        big_uint& operator-=(big_uint const& n) &;
-        big_uint operator-(big_uint const& n) const {
-            auto r = *this;
-            return r -= n;
-        }
-
-        // Precondition: *this should be nonzero
-        big_uint& operator--() &;
-
-        big_uint& operator*=(element_type n) &;
-        big_uint operator*(element_type n) {
-            auto r = *this;
-            return r *= n;
-        }
-        friend big_uint operator*(big_uint const& x, big_uint const& y);
-        big_uint& operator*=(big_uint const& y) & {
-            auto result = *this * y;
-            *this = result;
-            return *this;
-        }
-
-        // Perform long division
-        // *this becomes the remainder, returns the quotient
-        // Precondition: n != 0
-        big_uint long_division(big_uint const& n);
-
-        big_uint operator/(big_uint const& n) const {
-            auto temp = *this;
-            return temp.long_division(n);
-        }
-        big_uint operator/(element_type n) const {
-            auto temp = *this;
-            return temp.long_division(n);
-        }
-        big_uint operator%(big_uint const& n) const {
-            auto temp = *this;
-            temp.long_division(n);
-            return temp;
-        }
-        big_uint operator%(element_type n) const {
-            auto temp = *this;
-            temp.long_division(n);
-            return temp;
-        }
-
-        // Convert the number into decimal, and returns the
-        // array of (at most) 19 digits.
-        std::vector<std::uint64_t> to_decimal() const;
-    };
-
-    std::size_t log2p1(big_uint const& n) noexcept;
-    big_uint operator*(big_uint const& x, big_uint const& y);
-
-    struct big_uint_div_t {
-        big_uint quot;
-        big_uint rem;
-    };
-    inline big_uint_div_t div(big_uint const& x, big_uint const& y) {
-        big_uint_div_t ret;
-        ret.rem = x;
-        ret.quot = ret.rem.long_division(y);
-        return ret;
-    }
-    inline big_uint_div_t div(big_uint&& x, big_uint const& y) {
-        big_uint_div_t ret;
-        ret.rem = static_cast<big_uint&&>(x);
-        ret.quot = ret.rem.long_division(y);
-        return ret;
-    }
-}
-
-#endif

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

@@ -1,174 +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_CONTINUED_FRACTIONS
-#define JKJ_HEADER_CONTINUED_FRACTIONS
-
-namespace jkj {
-    // Continued fractions calculator for positive numbers.
-
-    template <class UInt>
-    struct unsigned_rational {
-        UInt numerator = 0;
-        UInt denominator = 0;
-
-        unsigned_rational() = default;
-        unsigned_rational(UInt const& numerator) : numerator{numerator}, denominator{1} {}
-        unsigned_rational(UInt&& numerator)
-            : numerator{static_cast<UInt&&>(numerator)}, denominator{1} {}
-        unsigned_rational(UInt const& numerator, UInt const& denominator)
-            : numerator{numerator}, denominator{denominator} {}
-        unsigned_rational(UInt&& numerator, UInt const& denominator)
-            : numerator{static_cast<UInt&&>(numerator)}, denominator{denominator} {}
-        unsigned_rational(UInt const& numerator, UInt&& denominator)
-            : numerator{numerator}, denominator{static_cast<UInt&&>(denominator)} {}
-        unsigned_rational(UInt&& numerator, UInt&& denominator)
-            : numerator{static_cast<UInt&&>(numerator)}, denominator{
-                                                             static_cast<UInt&&>(denominator)} {}
-
-        friend bool operator<(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator < y.numerator * x.denominator;
-        }
-        friend bool operator<=(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator <= y.numerator * x.denominator;
-        }
-        friend bool operator>(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator > y.numerator * x.denominator;
-        }
-        friend bool operator>=(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator >= y.numerator * x.denominator;
-        }
-        friend bool operator==(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator == y.numerator * x.denominator;
-        }
-        friend bool operator!=(unsigned_rational const& x, unsigned_rational const& y) {
-            return x.numerator * y.denominator != y.numerator * x.denominator;
-        }
-
-        // Performs no reduction.
-        friend unsigned_rational operator+(unsigned_rational const& x, unsigned_rational const& y) {
-            return {x.numerator * y.denominator + y.numerator * x.denominator,
-                    x.denominator * y.denominator};
-        }
-        // Performs no reduction.
-        unsigned_rational& operator+=(unsigned_rational const& y) & {
-            numerator *= y.denominator;
-            numerator += y.numerator * denominator;
-            denominator *= y.denominator;
-            return *this;
-        }
-        // Performs no reduction.
-        friend unsigned_rational operator-(unsigned_rational const& x, unsigned_rational const& y) {
-            return {x.numerator * y.denominator - y.numerator * x.denominator,
-                    x.denominator * y.denominator};
-        }
-        // Performs no reduction.
-        unsigned_rational& operator-=(unsigned_rational const& y) & {
-            numerator *= y.denominator;
-            numerator -= y.numerator * denominator;
-            denominator *= y.denominator;
-            return *this;
-        }
-        // Performs no reduction.
-        friend unsigned_rational operator*(unsigned_rational const& x, unsigned_rational const& y) {
-            return {x.numerator * y.numerator, x.denominator * y.denominator};
-        }
-        // Performs no reduction.
-        unsigned_rational& operator*=(unsigned_rational const& y) & {
-            numerator *= y.numerator;
-            denominator *= y.denominator;
-            return *this;
-        }
-        // Performs no reduction.
-        friend unsigned_rational operator/(unsigned_rational const& x, unsigned_rational const& y) {
-            return {x.numerator * y.denominator, x.denominator * y.numerator};
-        }
-        // Performs no reduction.
-        unsigned_rational& operator/=(unsigned_rational const& y) & {
-            numerator *= y.denominator;
-            denominator *= y.numerator;
-            return *this;
-        }
-    };
-
-    template <class Impl, class UInt>
-    class continued_fractions {
-        // The (-1)st coefficient is assumed to be 0.
-        UInt current_coefficient_{0};
-        unsigned_rational<UInt> current_convergent_{1, 0};
-        unsigned_rational<UInt> previous_convergent_{0, 1};
-        int current_index_ = -1;
-        bool terminated_ = false;
-
-    protected:
-        void set_terminate_flag() noexcept { terminated_ = true; }
-
-    public:
-        using uint_type = UInt;
-
-        int current_index() const noexcept { return current_index_; }
-
-        UInt const& current_coefficient() const noexcept { return current_coefficient_; }
-
-        unsigned_rational<UInt> const& current_convergent() const noexcept {
-            return current_convergent_;
-        }
-
-        UInt const& current_numerator() const noexcept { return current_convergent().numerator; }
-
-        UInt const& current_denominator() const noexcept {
-            return current_convergent().denominator;
-        }
-
-        unsigned_rational<UInt> const& previous_convergent() const noexcept {
-            return previous_convergent_;
-        }
-
-        UInt const& previous_numerator() const noexcept { return previous_convergent().numerator; }
-
-        UInt const& previous_denominator() const noexcept {
-            return previous_convergent().denominator;
-        }
-
-        bool is_terminated() const noexcept { return terminated_; }
-
-        // Do nothing if the procedure is terminated.
-        // Returns true if the update is done,
-        // and returns false if the procedure is already terminated.
-        bool update() {
-            if (!is_terminated()) {
-                unsigned_rational<UInt> new_output;
-                current_coefficient_ = static_cast<Impl&>(*this).compute_next_coefficient();
-
-                unsigned_rational<UInt> new_convergent{
-                    previous_numerator() + current_coefficient_ * current_numerator(),
-                    previous_denominator() + current_coefficient_ * current_denominator()};
-                previous_convergent_ = static_cast<unsigned_rational<UInt>&&>(current_convergent_);
-                current_convergent_ = static_cast<unsigned_rational<UInt>&&>(new_convergent);
-
-                ++current_index_;
-
-                return true;
-            }
-            else {
-                return false;
-            }
-        }
-    };
-}
-
-#endif