koffi 0.9.4 → 0.9.5

package/vendor/dragonbox/subproject/benchmark/source/ryu.cpp

@@ -1,27 +1,27 @@
-// 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 "benchmark.h"
-#include "ryu/ryu.h"
-
-namespace {
-#if 1
-    auto dummy = []() -> register_function_for_benchmark {
-        return {"Ryu", f2s_buffered, d2s_buffered};
-    }();
-#endif
-}
+// 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 "benchmark.h"
+#include "ryu/ryu.h"
+
+namespace {
+#if 1
+    auto dummy = []() -> register_function_for_benchmark {
+        return {"Ryu", f2s_buffered, d2s_buffered};
+    }();
+#endif
+}

package/vendor/dragonbox/subproject/benchmark/source/schubfach.cpp

@@ -1,31 +1,31 @@
-// 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 "benchmark.h"
-#include "schubfach_32.h"
-#include "schubfach_64.h"
-
-namespace {
-    void schubfach_32(float x, char* buf) { *schubfach::Ftoa(buf, x) = '\0'; }
-    void schubfach_64(double x, char* buf) { *schubfach::Dtoa(buf, x) = '\0'; }
-
-#if 1
-    auto dummy = []() -> register_function_for_benchmark {
-        return {"Schubfach", schubfach_32, schubfach_64};
-    }();
-#endif
-}
+// 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 "benchmark.h"
+#include "schubfach_32.h"
+#include "schubfach_64.h"
+
+namespace {
+    void schubfach_32(float x, char* buf) { *schubfach::Ftoa(buf, x) = '\0'; }
+    void schubfach_64(double x, char* buf) { *schubfach::Dtoa(buf, x) = '\0'; }
+
+#if 1
+    auto dummy = []() -> register_function_for_benchmark {
+        return {"Schubfach", schubfach_32, schubfach_64};
+    }();
+#endif
+}

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

@@ -1,42 +1,42 @@
-cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
-
-project(dragonbox_common LANGUAGES CXX)
-
-include(FetchContent)
-if (NOT TARGET dragonbox)
-    FetchContent_Declare(dragonbox SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
-    FetchContent_MakeAvailable(dragonbox)
-endif()
-
-set(dragonbox_common_headers
-        include/big_uint.h
-	include/continued_fractions.h
-	include/rational_continued_fractions.h
-	include/best_rational_approx.h
-	include/good_rational_approx.h
-        include/random_float.h)
-
-set(dragonbox_common_sources source/big_uint.cpp)
-
-add_library(dragonbox_common STATIC
-        ${dragonbox_common_headers}
-        ${dragonbox_common_sources})
-add_library(dragonbox::common ALIAS dragonbox_common)
-
-target_include_directories(dragonbox_common
-        PUBLIC
-        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
-
-target_compile_features(dragonbox_common PUBLIC cxx_std_17)
-
-target_link_libraries(dragonbox_common PUBLIC dragonbox::dragonbox)
-
-# ---- MSVC Specifics ----
-if (MSVC)
-    # No need to not generate PDB
-    # /permissive- should be the default
-    # The compilation will fail without /experimental:newLambdaProcessor
-    target_compile_options(dragonbox_common PUBLIC
-              /Zi /permissive-
-              $<$<NOT:$<CXX_COMPILER_ID:Clang>>:/experimental:newLambdaProcessor>)
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(dragonbox_common LANGUAGES CXX)
+
+include(FetchContent)
+if (NOT TARGET dragonbox)
+    FetchContent_Declare(dragonbox SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
+    FetchContent_MakeAvailable(dragonbox)
+endif()
+
+set(dragonbox_common_headers
+        include/big_uint.h
+	include/continued_fractions.h
+	include/rational_continued_fractions.h
+	include/best_rational_approx.h
+	include/good_rational_approx.h
+        include/random_float.h)
+
+set(dragonbox_common_sources source/big_uint.cpp)
+
+add_library(dragonbox_common STATIC
+        ${dragonbox_common_headers}
+        ${dragonbox_common_sources})
+add_library(dragonbox::common ALIAS dragonbox_common)
+
+target_include_directories(dragonbox_common
+        PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+
+target_compile_features(dragonbox_common PUBLIC cxx_std_17)
+
+target_link_libraries(dragonbox_common PUBLIC dragonbox::dragonbox)
+
+# ---- MSVC Specifics ----
+if (MSVC)
+    # No need to not generate PDB
+    # /permissive- should be the default
+    # The compilation will fail without /experimental:newLambdaProcessor
+    target_compile_options(dragonbox_common PUBLIC
+              /Zi /permissive-
+              $<$<NOT:$<CXX_COMPILER_ID:Clang>>:/experimental:newLambdaProcessor>)
 endif()

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

@@ -1,97 +1,97 @@
-// 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;
-    }
-}
-
+// 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