koffi 2.3.6 → 2.3.8

package/vendor/dragonbox/subproject/common/source/big_uint.cpp

@@ -1,602 +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.
-
-#include "big_uint.h"
-#include "dragonbox/dragonbox.h"
-#include <cassert>
-#include <limits>
-
-namespace jkj {
-    static constexpr std::size_t log2p1(std::uint64_t x) noexcept {
-        // C++20 std::log2p1 is not yet supported
-        // return std::log2p1(x);
-
-        std::size_t ret = 0;
-        auto inspect = [&x, &ret](int shft) {
-            if ((x >> shft) != 0) {
-                x >>= shft;
-                ret += shft;
-            }
-        };
-
-        inspect(32);
-        inspect(16);
-        inspect(8);
-        inspect(4);
-        inspect(2);
-        inspect(1);
-
-        return ret + x;
-    }
-
-    std::size_t log2p1(big_uint const& n) noexcept {
-        if (n.is_zero()) {
-            return 0;
-        }
-        return (n.elements.size() - 1) * big_uint::element_number_of_bits +
-               log2p1(n.elements.back());
-    }
-
-    big_uint big_uint::power_of_2(std::size_t k) {
-        auto number_of_elmts = k / element_number_of_bits + 1;
-        big_uint ret_val;
-        ret_val.elements.resize(number_of_elmts, 0);
-        ret_val.elements.back() = (element_type(1) << (k % element_number_of_bits));
-        return ret_val;
-    }
-
-    big_uint big_uint::pow(big_uint base, std::size_t k) {
-        big_uint result{1};
-        while (true) {
-            if (k % 2 != 0) {
-                result *= base;
-            }
-            k /= 2;
-            if (k == 0) {
-                break;
-            }
-            base *= base;
-        }
-
-        return result;
-    }
-
-    std::size_t big_uint::multiply_2_until(big_uint const& n) {
-        assert(elements.size() != 0);
-
-        std::size_t number_of_multiplications = 0;
-
-        // Perform left-shift to match the leading-1 position.
-        // Perform element-wise shift first.
-        assert(elements.size() <= n.elements.size());
-        auto element_pos_offset = n.elements.size() - elements.size();
-        if (element_pos_offset > 0) {
-            number_of_multiplications = element_pos_offset * element_number_of_bits;
-            auto old_size = elements.size();
-            elements.resize(n.elements.size());
-
-            std::move_backward(std::begin(elements), std::begin(elements) + old_size,
-                               std::begin(elements) + elements.size());
-
-            std::fill_n(std::begin(elements), element_pos_offset, 0);
-        }
-        // And then perform bit-wise shift.
-        auto new_bit_pos = log2p1(elements.back());
-        auto bit_pos_offset =
-            std::ptrdiff_t(log2p1(n.elements.back())) - std::ptrdiff_t(new_bit_pos);
-        assert(element_pos_offset > 0 || (element_pos_offset == 0 && bit_pos_offset >= 0));
-        number_of_multiplications += bit_pos_offset;
-        if (bit_pos_offset > 0) {
-            // Left-shfit
-            auto shft = std::size_t(bit_pos_offset);
-            auto remaining_bits = element_number_of_bits - shft;
-            for (auto idx = elements.size() - 1; idx > 0; --idx) {
-                auto bits_to_transfer = elements[idx - 1] >> remaining_bits;
-
-                elements[idx] <<= shft;
-                elements[idx] |= bits_to_transfer;
-            }
-            elements[0] <<= shft;
-        }
-        else if (bit_pos_offset < 0) {
-            // Right-shift
-            auto shft = std::size_t(-bit_pos_offset);
-            auto remaining_bits = element_number_of_bits - shft;
-            elements[0] >>= shft;
-            for (std::size_t idx = 1; idx < elements.size(); ++idx) {
-                auto bits_to_transfer = elements[idx] << remaining_bits;
-
-                elements[idx - 1] |= bits_to_transfer;
-                elements[idx] >>= shft;
-            }
-        }
-
-        // Compare the shifted number with the given number.
-        bool is_bigger_than_or_equal_to = true;
-        for (auto idx = std::ptrdiff_t(elements.size()) - 1; idx >= 0; --idx) {
-            if (elements[idx] > n.elements[idx])
-                break;
-            else if (elements[idx] < n.elements[idx]) {
-                is_bigger_than_or_equal_to = false;
-                break;
-            }
-        }
-
-        // If our number is still less,
-        if (!is_bigger_than_or_equal_to) {
-            // Shift one more bit.
-            ++number_of_multiplications;
-            if (new_bit_pos == element_number_of_bits) {
-                elements.resize(elements.size() + 1);
-            }
-
-            constexpr auto remaining_bits = element_number_of_bits - 1;
-            for (auto idx = elements.size() - 1; idx > 0; --idx) {
-                elements[idx] <<= 1;
-                elements[idx] |= (elements[idx - 1] >> remaining_bits);
-            }
-            elements[0] <<= 1;
-        }
-
-        return number_of_multiplications;
-    }
-
-    std::size_t big_uint::multiply_2_while(big_uint const& n) {
-        assert(elements.size() != 0);
-
-        std::size_t number_of_multiplications = 0;
-
-        // Perform left-shift to match the leading-1 position.
-        // Perform element-wise shift first.
-        assert(elements.size() <= n.elements.size());
-        auto element_pos_offset = n.elements.size() - elements.size();
-        if (element_pos_offset > 0) {
-            number_of_multiplications = element_pos_offset * element_number_of_bits;
-            auto old_size = elements.size();
-            elements.resize(n.elements.size());
-
-            std::move_backward(std::begin(elements), std::begin(elements) + old_size,
-                               std::begin(elements) + elements.size());
-
-            std::fill_n(std::begin(elements), element_pos_offset, 0);
-        }
-        // And then perform bit-wise shift.
-        auto new_bit_pos = log2p1(elements.back());
-        auto bit_pos_offset =
-            std::ptrdiff_t(log2p1(n.elements.back())) - std::ptrdiff_t(new_bit_pos);
-        assert(element_pos_offset > 0 || (element_pos_offset == 0 && bit_pos_offset >= 0));
-        number_of_multiplications += bit_pos_offset;
-        if (bit_pos_offset > 0) {
-            // Left-shfit
-            auto shft = std::size_t(bit_pos_offset);
-            auto remaining_bits = element_number_of_bits - shft;
-            for (auto idx = elements.size() - 1; idx > 0; --idx) {
-                auto bits_to_transfer = elements[idx - 1] >> remaining_bits;
-
-                elements[idx] <<= shft;
-                elements[idx] |= bits_to_transfer;
-            }
-            elements[0] <<= shft;
-        }
-        else if (bit_pos_offset < 0) {
-            // Right-shift
-            auto shft = std::size_t(-bit_pos_offset);
-            auto remaining_bits = element_number_of_bits - shft;
-            elements[0] >>= shft;
-            for (std::size_t idx = 1; idx < elements.size(); ++idx) {
-                auto bits_to_transfer = elements[idx] << remaining_bits;
-
-                elements[idx - 1] |= bits_to_transfer;
-                elements[idx] >>= shft;
-            }
-        }
-
-        // Compare the shifted number with the given number.
-        bool is_strictly_bigger = true;
-        for (auto idx = std::ptrdiff_t(elements.size()) - 1; idx >= 0; --idx) {
-            if (elements[idx] > n.elements[idx])
-                break;
-            else if (elements[idx] <= n.elements[idx]) {
-                is_strictly_bigger = false;
-                break;
-            }
-        }
-
-        // If our number is strictly bigger,
-        if (is_strictly_bigger) {
-            // Shift one bit back.
-            assert(number_of_multiplications > 0);
-            --number_of_multiplications;
-
-            constexpr auto remaining_bits = element_number_of_bits - 1;
-            for (auto idx = 0; idx < elements.size() - 1; ++idx) {
-                elements[idx] >>= 1;
-                elements[idx] |= (elements[idx + 1] << remaining_bits);
-            }
-            elements.back() >>= 1;
-
-            if (elements.back() == 0) {
-                elements.pop_back();
-            }
-        }
-
-        return number_of_multiplications;
-    }
-
-    void big_uint::multiply_2() & {
-        // Shift to left by 1.
-        element_type carry = 0;
-        for (std::size_t idx = 0; idx < elements.size(); ++idx) {
-            auto new_element = (elements[idx] << 1) | carry;
-
-            // Keep the carry.
-            carry = (elements[idx] >> (element_number_of_bits - 1));
-
-            elements[idx] = new_element;
-        }
-
-        if (carry != 0) {
-            elements.push_back(1);
-        }
-    }
-
-    void big_uint::multiply_5() & {
-        if (elements.size() == 0) {
-            return;
-        }
-
-        element_type upper_2_bits = 0;
-        element_type carry = 0;
-        for (std::size_t idx = 0; idx < elements.size(); ++idx) {
-            auto times_4 = (elements[idx] << 2) | upper_2_bits;
-            upper_2_bits = (elements[idx] >> (element_number_of_bits - 2));
-
-            element_type new_carry = 0;
-            // Add *this with *this * 4.
-            elements[idx] += times_4;
-            // If carry happens,
-            if (elements[idx] < times_4) {
-                new_carry = 1;
-                // Add the carry from the previous element.
-                elements[idx] += carry;
-            }
-            // If no carry happens,
-            else {
-                // Add the carry from the previous element.
-                elements[idx] += carry;
-                // If carry happens,
-                if (elements[idx] < carry) {
-                    new_carry = 1;
-                }
-            }
-            carry = new_carry;
-        }
-
-        upper_2_bits += carry;
-        if (upper_2_bits != 0) {
-            elements.push_back(upper_2_bits);
-        }
-    }
-
-    int big_uint::comparison_common(big_uint const& n) const noexcept {
-        if (elements.size() < n.elements.size()) {
-            return -1;
-        }
-        else if (elements.size() > n.elements.size()) {
-            return +1;
-        }
-        else {
-            for (auto idx_p1 = elements.size(); idx_p1 > 0; --idx_p1) {
-                if (elements[idx_p1 - 1] < n.elements[idx_p1 - 1]) {
-                    return -1;
-                }
-                else if (elements[idx_p1 - 1] > n.elements[idx_p1 - 1]) {
-                    return +1;
-                }
-            }
-            return 0;
-        }
-    }
-
-    big_uint& big_uint::operator+=(big_uint const& n) & {
-        std::size_t min_size;
-        if (elements.size() >= n.elements.size()) {
-            min_size = n.elements.size();
-        }
-        else {
-            min_size = elements.size();
-            elements.insert(elements.cend(), n.elements.cbegin() + min_size, n.elements.cend());
-        }
-
-        unsigned int carry = 0;
-        for (std::size_t idx = 0; idx < min_size; ++idx) {
-            auto with_carry = elements[idx] + carry;
-            unsigned int first_carry = (with_carry < elements[idx]) ? 1 : 0;
-
-            auto n_element = n.elements[idx];
-            elements[idx] = with_carry + n_element;
-            carry = first_carry | ((elements[idx] < n_element) ? 1 : 0);
-        }
-
-        if (carry != 0) {
-            for (std::size_t idx = min_size; idx < elements.size(); ++idx) {
-                ++elements[idx];
-                if (elements[idx] != 0) {
-                    return *this;
-                }
-            }
-            elements.push_back(1);
-        }
-
-        return *this;
-    }
-
-    big_uint& big_uint::operator+=(element_type n) & {
-        if (is_zero()) {
-            elements.push_back(n);
-            return *this;
-        }
-
-        elements[0] += n;
-
-        // If carry happens,
-        if (elements[0] < n) {
-            // Propagate carry.
-            for (std::size_t idx = 1; idx < elements.size(); ++idx) {
-                ++elements[idx];
-                if (elements[idx] != 0) {
-                    return *this;
-                }
-            }
-            elements.push_back(1);
-        }
-        return *this;
-    }
-
-    big_uint& big_uint::operator-=(big_uint const& n) & {
-        // Underflow!
-        assert(elements.size() >= n.elements.size());
-
-        unsigned int borrow = 0;
-        for (std::size_t idx = 0; idx < n.elements.size(); ++idx) {
-            auto with_borrow = elements[idx] - borrow;
-            unsigned int first_borrow = (with_borrow > elements[idx]) ? 1 : 0;
-
-            auto n_element = n.elements[idx];
-            elements[idx] = with_borrow - n_element;
-            borrow = first_borrow | ((elements[idx] > with_borrow) ? 1 : 0);
-        }
-
-        if (borrow != 0) {
-            for (std::size_t idx = n.elements.size(); idx < elements.size(); ++idx) {
-                --elements[idx];
-                if (elements[idx] != std::numeric_limits<element_type>::max()) {
-                    goto remove_leading_zeros;
-                }
-            }
-            // Underflow!
-            assert(elements.back() != std::numeric_limits<element_type>::max());
-        }
-
-    remove_leading_zeros:
-        auto itr = elements.end();
-        for (; itr != elements.begin(); --itr) {
-            if (*(itr - 1) != 0) {
-                break;
-            }
-        }
-        elements.erase(itr, elements.end());
-
-        return *this;
-    }
-
-    big_uint& big_uint::operator--() & {
-        // Underflow!
-        assert(!is_zero());
-
-        for (std::size_t idx = 0; idx < elements.size(); ++idx) {
-            --elements[idx];
-            if (elements[idx] != std::numeric_limits<element_type>::max()) {
-                break;
-            }
-        }
-
-        // Remove leading zeros
-        auto itr = elements.end();
-        for (; itr != elements.begin(); --itr) {
-            if (*(itr - 1) != 0) {
-                break;
-            }
-        }
-        elements.erase(itr, elements.end());
-
-        return *this;
-    }
-
-    big_uint& big_uint::operator*=(element_type n) & {
-        if (n == 0) {
-            elements.clear();
-            return *this;
-        }
-
-        element_type carry = 0;
-        for (std::size_t idx = 0; idx < elements.size(); ++idx) {
-            auto mul = jkj::dragonbox::detail::wuint::umul128(elements[idx], n);
-            elements[idx] = mul.low() + carry;
-            carry = mul.high() + (elements[idx] < mul.low() ? 1 : 0);
-        }
-        if (carry != 0) {
-            elements.push_back(carry);
-        }
-
-        return *this;
-    }
-
-    big_uint operator*(big_uint const& x, big_uint const& y) {
-        if (x.is_zero() || y.is_zero()) {
-            return big_uint();
-        }
-
-        big_uint result;
-        result.elements.resize(x.elements.size() + y.elements.size(), 0);
-        decltype(x.elements) temp(x.elements.size());
-
-        for (std::size_t y_idx = 0; y_idx < y.elements.size(); ++y_idx) {
-            // Compute y.elements[y_idx] * x and accumulate it into the result
-            for (std::size_t x_idx = 0; x_idx < x.elements.size(); ++x_idx) {
-                auto mul = jkj::dragonbox::detail::wuint::umul128(x.elements[x_idx], y.elements[y_idx]);
-
-                // Add the first half
-                result.elements[x_idx + y_idx] += mul.low();
-                unsigned int carry = result.elements[x_idx + y_idx] < mul.low() ? 1 : 0;
-
-                // Add the second half
-                auto with_carry = mul.high() + carry;
-                carry = with_carry < mul.high() ? 1 : 0;
-                result.elements[x_idx + y_idx + 1] += with_carry;
-
-                // If there is carry,
-                if (result.elements[x_idx + y_idx + 1] < with_carry) {
-                    // Propagate.
-                    assert(x_idx + y_idx + 2 < result.elements.size());
-                    for (auto idx = x_idx + y_idx + 2; idx < result.elements.size(); ++idx) {
-                        ++result.elements[idx];
-                        if (result.elements[idx] != 0) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Remove the last element if it is zero.
-        if (result.elements.back() == 0) {
-            result.elements.pop_back();
-        }
-
-        return result;
-    }
-
-    big_uint big_uint::long_division(big_uint const& n) {
-        assert(!n.is_zero());
-
-        if (this == &n) {
-            elements.clear();
-            return big_uint(1);
-        }
-
-        big_uint quotient;
-        big_uint n_shifted;
-
-        while (true) {
-            // Break if *this is smaller than n.
-            if (elements.size() < n.elements.size()) {
-                break;
-            }
-
-            // Shift n element-wise first.
-            n_shifted.elements.resize(elements.size());
-            std::fill_n(n_shifted.elements.begin(), (elements.size() - n.elements.size()), 0);
-            std::copy(n.elements.cbegin(), n.elements.cend(),
-                      n_shifted.elements.begin() + (elements.size() - n.elements.size()));
-
-            std::size_t total_shift_amount =
-                element_number_of_bits * (elements.size() - n.elements.size());
-
-            // Shift n bit-wise to match the leading 1 position.
-            auto leading_1_pos = log2p1(elements.back());
-            auto n_leading_1_pos = log2p1(n_shifted.elements.back());
-
-            if (leading_1_pos > n_leading_1_pos) {
-                // Shift left.
-                auto shift_amount = leading_1_pos - n_leading_1_pos;
-                total_shift_amount += shift_amount;
-
-                element_type carry = 0;
-                for (std::size_t idx = elements.size() - n.elements.size(); idx < elements.size();
-                     ++idx) {
-                    auto new_element = (n_shifted.elements[idx] << shift_amount) | carry;
-                    carry = (n_shifted.elements[idx] >> (element_number_of_bits - shift_amount));
-                    n_shifted.elements[idx] = new_element;
-                }
-                assert(carry == 0);
-            }
-            else if (leading_1_pos < n_leading_1_pos) {
-                // Break if *this is smaller than n.
-                if (total_shift_amount == 0) {
-                    break;
-                }
-
-                // Shift right.
-                auto shift_amount = n_leading_1_pos - leading_1_pos;
-                assert(total_shift_amount > shift_amount);
-                total_shift_amount -= shift_amount;
-                for (std::size_t idx = elements.size() - n.elements.size(); idx < elements.size();
-                     ++idx) {
-                    n_shifted.elements[idx - 1] |=
-                        (n_shifted.elements[idx] << (element_number_of_bits - shift_amount));
-                    n_shifted.elements[idx] >>= shift_amount;
-                }
-            }
-
-            // Check if n_shifted is bigger than *this; if that's the case, shift one bit to right.
-            if (n_shifted > *this) {
-                // If we actually didn't shift anything,
-                if (total_shift_amount == 0) {
-                    // *this is smaller than n.
-                    break;
-                }
-
-                // Shift right.
-                --total_shift_amount;
-                n_shifted.elements[0] >>= 1;
-                for (std::size_t idx = 1; idx < elements.size(); ++idx) {
-                    n_shifted.elements[idx - 1] |=
-                        (n_shifted.elements[idx] << (element_number_of_bits - 1));
-                    n_shifted.elements[idx] >>= 1;
-                }
-            }
-
-            // Subtract n_shifted from *this.
-            *this -= n_shifted;
-
-            // Update the quotient.
-            auto quotient_element_idx = total_shift_amount / element_number_of_bits;
-            auto quotient_bit_idx = total_shift_amount % element_number_of_bits;
-            if (quotient.elements.size() <= quotient_element_idx) {
-                quotient.elements.resize(quotient_element_idx + 1);
-            }
-            quotient.elements[quotient_element_idx] |= (element_type(1) << quotient_bit_idx);
-        }
-
-        return quotient;
-    }
-
-    std::vector<std::uint64_t> big_uint::to_decimal() const {
-        std::vector<std::uint64_t> ret;
-        auto n = *this;
-        auto divisor = big_uint{1000'0000'0000'0000'0000};
-
-        do {
-            auto quotient = n.long_division(divisor);
-            ret.push_back(n.is_zero() ? 0 : n[0]);
-            n = quotient;
-        } while (!n.is_zero());
-
-        return ret;
-    }
-}

package/vendor/dragonbox/subproject/meta/CMakeLists.txt

@@ -1,41 +0,0 @@
-cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
-
-project(dragonbox_meta LANGUAGES CXX)
-
-include(FetchContent)
-if (NOT TARGET dragonbox)
-    FetchContent_Declare(dragonbox SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
-    FetchContent_MakeAvailable(dragonbox)
-endif()
-if (NOT TARGET common)
-    FetchContent_Declare(common SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../common")
-    FetchContent_MakeAvailable(common)
-endif()
-
-function(meta_exe NAME)
-  add_executable(${NAME} source/${NAME}.cpp)
-
-  target_compile_features(${NAME} PRIVATE cxx_std_17)
-
-  target_link_libraries(${NAME} PRIVATE ${ARGN})
-
-  # ---- MSVC Specifics ----
-  if (MSVC)
-      # No need to not generate PDB
-      # /permissive- should be the default
-      # The compilation will fail without /experimental:newLambdaProcessor
-      # See also https://gitlab.kitware.com/cmake/cmake/-/issues/16478
-      target_compile_options(${NAME} PUBLIC
-              /Zi /permissive-
-              $<$<NOT:$<CXX_COMPILER_ID:Clang>>:/experimental:newLambdaProcessor>
-              $<$<CONFIG:Release>:/GL>)
-      target_link_options(${NAME} PUBLIC /LTCG /DEBUG:FASTLINK)
-      set_target_properties(${NAME} PROPERTIES 
-            VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}")
-  endif()
-endfunction()
-
-meta_exe(generate_cache dragonbox::common)
-meta_exe(live_test dragonbox::dragonbox_to_chars)
-meta_exe(perf_test dragonbox::common dragonbox::dragonbox_to_chars)
-meta_exe(sandbox dragonbox::dragonbox_to_chars dragonbox::common)