koffi 0.9.4 → 0.9.5

package/vendor/dragonbox/subproject/meta/source/generate_cache.cpp

@@ -1,126 +1,126 @@
-// Copyright 2020-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 "continued_fractions.h"
-#include "dragonbox/dragonbox.h"
-#include <algorithm>
-#include <utility>
-#include <stdexcept>
-#include <vector>
-
-template <class FloatTraits>
-auto generate_cache() {
-    using impl = jkj::dragonbox::detail::impl<typename FloatTraits::type, FloatTraits>;
-
-    std::vector<jkj::big_uint> results;
-    jkj::unsigned_rational<jkj::big_uint> target_number;
-    for (int k = impl::min_k; k <= impl::max_k; ++k) {
-        // (2f_c +- 1) * 2^beta * (2^(k - e_k - Q) * 5^k)
-        // e_k = floor(k log2(10)) - Q + 1, so
-        // k - e_k - Q = k - floor(k log2(10)) - 1.
-        int exp_2 = k - jkj::dragonbox::detail::log::floor_log2_pow10(k) - 1;
-
-        target_number.numerator = 1;
-        target_number.denominator = 1;
-        if (k >= 0) {
-            target_number.numerator = jkj::big_uint::pow(5, k);
-        }
-        else {
-            target_number.denominator = jkj::big_uint::pow(5, -k);
-        }
-        if (exp_2 >= 0) {
-            target_number.numerator *= jkj::big_uint::power_of_2(exp_2);
-        }
-        else {
-            target_number.denominator *= jkj::big_uint::power_of_2(-exp_2);
-        }
-
-        auto div_res = div(jkj::big_uint::power_of_2(impl::cache_bits) * target_number.numerator,
-                           target_number.denominator);
-        auto m = std::move(div_res.quot);
-        if (!div_res.rem.is_zero()) {
-            m += 1;
-        }
-
-        // Recheck that m is in the correct range.
-        if (m < jkj::big_uint::power_of_2(impl::cache_bits - 1) ||
-            m >= jkj::big_uint::power_of_2(impl::cache_bits)) {
-            throw std::logic_error{"Generated cache entry is not in the correct range"};
-        }
-
-        results.push_back(std::move(m));
-    }
-
-    return results;
-}
-
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-
-int main() {
-    std::cout << "[Generating cache...]\n";
-
-    using jkj::dragonbox::detail::impl;
-
-    auto write_file = [](std::ofstream& out, auto type_tag, auto const& cache_array,
-                         auto&& ieee_754_type_name_string, auto&& element_printer) {
-        using float_type = typename decltype(type_tag)::type;
-
-        out << "static constexpr int min_k = " << std::dec << impl<float_type>::min_k << ";\n";
-        out << "static constexpr int max_k = " << std::dec << impl<float_type>::max_k << ";\n";
-        out << "static constexpr cache_entry_type cache[] = {";
-        for (int k = impl<float_type>::min_k; k < impl<float_type>::max_k; ++k) {
-            auto idx = std::size_t(k - impl<float_type>::min_k);
-            out << "\n\t";
-            element_printer(out, cache_array[idx]);
-            out << ",";
-        }
-        out << "\n\t";
-        element_printer(out, cache_array.back());
-        out << "\n};";
-    };
-
-    std::ofstream out;
-
-    try {
-        out.open("results/binary32_generated_cache.txt");
-        auto binary32_cache = generate_cache<jkj::dragonbox::default_float_traits<float>>();
-        write_file(out, jkj::dragonbox::default_float_traits<float>{}, binary32_cache, "binary32",
-                   [](std::ofstream& out, jkj::big_uint const& value) {
-                       out << "0x" << std::hex << std::setw(16) << std::setfill('0') << value[0];
-                   });
-        out.close();
-
-        out.open("results/binary64_generated_cache.txt");
-        auto binary64_cache = generate_cache<jkj::dragonbox::default_float_traits<double>>();
-        write_file(out, jkj::dragonbox::default_float_traits<double>{}, binary64_cache, "binary64",
-                   [](std::ofstream& out, jkj::big_uint const& value) {
-                       out << "{ 0x" << std::hex << std::setw(16) << std::setfill('0') << value[1]
-                           << ", 0x" << std::hex << std::setw(16) << std::setfill('0') << value[0]
-                           << " }";
-                   });
-        out.close();
-    }
-    catch (std::logic_error const& ex) {
-        std::cout << ex.what() << "\n";
-        return -1;
-    }
-
-    std::cout << "Done.\n\n\n";
-}
+// Copyright 2020-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 "continued_fractions.h"
+#include "dragonbox/dragonbox.h"
+#include <algorithm>
+#include <utility>
+#include <stdexcept>
+#include <vector>
+
+template <class FloatTraits>
+auto generate_cache() {
+    using impl = jkj::dragonbox::detail::impl<typename FloatTraits::type, FloatTraits>;
+
+    std::vector<jkj::big_uint> results;
+    jkj::unsigned_rational<jkj::big_uint> target_number;
+    for (int k = impl::min_k; k <= impl::max_k; ++k) {
+        // (2f_c +- 1) * 2^beta * (2^(k - e_k - Q) * 5^k)
+        // e_k = floor(k log2(10)) - Q + 1, so
+        // k - e_k - Q = k - floor(k log2(10)) - 1.
+        int exp_2 = k - jkj::dragonbox::detail::log::floor_log2_pow10(k) - 1;
+
+        target_number.numerator = 1;
+        target_number.denominator = 1;
+        if (k >= 0) {
+            target_number.numerator = jkj::big_uint::pow(5, k);
+        }
+        else {
+            target_number.denominator = jkj::big_uint::pow(5, -k);
+        }
+        if (exp_2 >= 0) {
+            target_number.numerator *= jkj::big_uint::power_of_2(exp_2);
+        }
+        else {
+            target_number.denominator *= jkj::big_uint::power_of_2(-exp_2);
+        }
+
+        auto div_res = div(jkj::big_uint::power_of_2(impl::cache_bits) * target_number.numerator,
+                           target_number.denominator);
+        auto m = std::move(div_res.quot);
+        if (!div_res.rem.is_zero()) {
+            m += 1;
+        }
+
+        // Recheck that m is in the correct range.
+        if (m < jkj::big_uint::power_of_2(impl::cache_bits - 1) ||
+            m >= jkj::big_uint::power_of_2(impl::cache_bits)) {
+            throw std::logic_error{"Generated cache entry is not in the correct range"};
+        }
+
+        results.push_back(std::move(m));
+    }
+
+    return results;
+}
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+
+int main() {
+    std::cout << "[Generating cache...]\n";
+
+    using jkj::dragonbox::detail::impl;
+
+    auto write_file = [](std::ofstream& out, auto type_tag, auto const& cache_array,
+                         auto&& ieee_754_type_name_string, auto&& element_printer) {
+        using float_type = typename decltype(type_tag)::type;
+
+        out << "static constexpr int min_k = " << std::dec << impl<float_type>::min_k << ";\n";
+        out << "static constexpr int max_k = " << std::dec << impl<float_type>::max_k << ";\n";
+        out << "static constexpr cache_entry_type cache[] = {";
+        for (int k = impl<float_type>::min_k; k < impl<float_type>::max_k; ++k) {
+            auto idx = std::size_t(k - impl<float_type>::min_k);
+            out << "\n\t";
+            element_printer(out, cache_array[idx]);
+            out << ",";
+        }
+        out << "\n\t";
+        element_printer(out, cache_array.back());
+        out << "\n};";
+    };
+
+    std::ofstream out;
+
+    try {
+        out.open("results/binary32_generated_cache.txt");
+        auto binary32_cache = generate_cache<jkj::dragonbox::default_float_traits<float>>();
+        write_file(out, jkj::dragonbox::default_float_traits<float>{}, binary32_cache, "binary32",
+                   [](std::ofstream& out, jkj::big_uint const& value) {
+                       out << "0x" << std::hex << std::setw(16) << std::setfill('0') << value[0];
+                   });
+        out.close();
+
+        out.open("results/binary64_generated_cache.txt");
+        auto binary64_cache = generate_cache<jkj::dragonbox::default_float_traits<double>>();
+        write_file(out, jkj::dragonbox::default_float_traits<double>{}, binary64_cache, "binary64",
+                   [](std::ofstream& out, jkj::big_uint const& value) {
+                       out << "{ 0x" << std::hex << std::setw(16) << std::setfill('0') << value[1]
+                           << ", 0x" << std::hex << std::setw(16) << std::setfill('0') << value[0]
+                           << " }";
+                   });
+        out.close();
+    }
+    catch (std::logic_error const& ex) {
+        std::cout << ex.what() << "\n";
+        return -1;
+    }
+
+    std::cout << "Done.\n\n\n";
+}

package/vendor/dragonbox/subproject/meta/source/live_test.cpp

@@ -1,81 +1,81 @@
-// 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 "dragonbox/dragonbox_to_chars.h"
-
-#include <iostream>
-#include <iomanip>
-#include <string>
-
-template <class Float>
-static void live_test() {
-    char buffer[41];
-
-    while (true) {
-        Float x;
-        std::string x_str;
-        while (true) {
-            std::getline(std::cin, x_str);
-            try {
-                if constexpr (std::is_same_v<Float, float>) {
-                    x = std::stof(x_str);
-                }
-                else {
-                    x = std::stod(x_str);
-                }
-            }
-            catch (...) {
-                std::cout << "Not a valid input; input again.\n";
-                continue;
-            }
-            break;
-        }
-
-        auto xx = jkj::dragonbox::float_bits<Float>{x};
-        std::cout << "              sign: " << (xx.is_negative() ? "-" : "+") << std::endl;
-        std::cout << "     exponent bits: "
-                  << "0x" << std::hex << std::setfill('0') << xx.extract_exponent_bits() << std::dec
-                  << " (value: " << xx.binary_exponent() << ")\n";
-        std::cout << "  significand bits: "
-                  << "0x" << std::hex << std::setfill('0');
-        if constexpr (std::is_same_v<Float, float>) {
-            std::cout << std::setw(8);
-        }
-        else {
-            std::cout << std::setw(16);
-        }
-        std::cout << xx.extract_significand_bits() << " (value: 0x" << xx.binary_significand()
-                  << ")\n"
-                  << std::dec;
-
-        jkj::dragonbox::to_chars(x, buffer);
-        std::cout << "  Dragonbox output: " << buffer << "\n\n";
-    }
-}
-
-int main() {
-    constexpr enum { test_float, test_double } test = test_double;
-
-    if constexpr (test == test_float) {
-        std::cout << "[Start live test for float's]\n";
-        live_test<float>();
-    }
-    else if constexpr (test == test_double) {
-        std::cout << "[Start live test for double's]\n";
-        live_test<double>();
-    }
-}
+// 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 "dragonbox/dragonbox_to_chars.h"
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+
+template <class Float>
+static void live_test() {
+    char buffer[41];
+
+    while (true) {
+        Float x;
+        std::string x_str;
+        while (true) {
+            std::getline(std::cin, x_str);
+            try {
+                if constexpr (std::is_same_v<Float, float>) {
+                    x = std::stof(x_str);
+                }
+                else {
+                    x = std::stod(x_str);
+                }
+            }
+            catch (...) {
+                std::cout << "Not a valid input; input again.\n";
+                continue;
+            }
+            break;
+        }
+
+        auto xx = jkj::dragonbox::float_bits<Float>{x};
+        std::cout << "              sign: " << (xx.is_negative() ? "-" : "+") << std::endl;
+        std::cout << "     exponent bits: "
+                  << "0x" << std::hex << std::setfill('0') << xx.extract_exponent_bits() << std::dec
+                  << " (value: " << xx.binary_exponent() << ")\n";
+        std::cout << "  significand bits: "
+                  << "0x" << std::hex << std::setfill('0');
+        if constexpr (std::is_same_v<Float, float>) {
+            std::cout << std::setw(8);
+        }
+        else {
+            std::cout << std::setw(16);
+        }
+        std::cout << xx.extract_significand_bits() << " (value: 0x" << xx.binary_significand()
+                  << ")\n"
+                  << std::dec;
+
+        jkj::dragonbox::to_chars(x, buffer);
+        std::cout << "  Dragonbox output: " << buffer << "\n\n";
+    }
+}
+
+int main() {
+    constexpr enum { test_float, test_double } test = test_double;
+
+    if constexpr (test == test_float) {
+        std::cout << "[Start live test for float's]\n";
+        live_test<float>();
+    }
+    else if constexpr (test == test_double) {
+        std::cout << "[Start live test for double's]\n";
+        live_test<double>();
+    }
+}

package/vendor/dragonbox/subproject/meta/source/perf_test.cpp

@@ -1,104 +1,104 @@
-// 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 "dragonbox/dragonbox_to_chars.h"
-#include "random_float.h"
-#include <chrono>
-#include <iostream>
-
-template <class Float>
-static void uniform_random_perf_test(std::size_t number_of_tests)
-{
-	std::cout << "Generating random samples...\n";
-	auto rg = generate_correctly_seeded_mt19937_64();
-	std::vector<Float> samples(number_of_tests);
-	for (auto& sample : samples) {
-		sample = uniformly_randomly_generate_general_float<Float>(rg);
-	}
-
-	std::cout << "Performing test...\n";
-	char buffer[41];
-	auto from = std::chrono::steady_clock::now();
-	for (auto& sample : samples) {
-		jkj::dragonbox::to_chars(sample, buffer);
-	}
-	auto dur = std::chrono::steady_clock::now() - from;
-	std::cout << "Average time: " <<
-		double(std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count()) / number_of_tests << "ns\n";
-}
-
-template <class Float>
-static void digit_perf_test(unsigned int digits, std::size_t number_of_tests)
-{
-	std::cout << "Generating random samples...\n";
-	auto rg = generate_correctly_seeded_mt19937_64();
-	std::vector<Float> samples(number_of_tests);
-	for (auto& sample : samples) {
-		sample = randomly_generate_float_with_given_digits<Float>(digits, rg);
-	}
-
-	std::cout << "Performing test...\n";
-	char buffer[41];
-	auto from = std::chrono::steady_clock::now();
-	for (auto& sample : samples) {
-		jkj::dragonbox::to_chars(sample, buffer);
-	}
-	auto dur = std::chrono::steady_clock::now() - from;
-	std::cout << "Average time: " <<
-		double(std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count()) / number_of_tests << "ns\n";
-}
-
-int main()
-{
-	constexpr bool run_uniform_random_float = true;
-	constexpr std::size_t number_of_uniform_random_perf_tests_float = 100000000;
-
-	constexpr bool run_uniform_random_double = true;
-	constexpr std::size_t number_of_uniform_random_perf_tests_double = 100000000;
-
-	constexpr bool run_digit_float = false;
-	constexpr unsigned int digits_for_perf_test_float = 6;
-	constexpr std::size_t number_of_digit_perf_tests_float = 40000000;
-
-	constexpr bool run_digit_double = false;
-	constexpr static unsigned int digits_for_perf_test_double = 17;
-	constexpr static std::size_t number_of_digit_perf_tests_double = 6000000;
-
-
-	if constexpr (run_uniform_random_float) {
-		std::cout << "[Running the algorithm with uniformly randomly generated float inputs...]\n";
-		uniform_random_perf_test<float>(number_of_uniform_random_perf_tests_float);
-		std::cout << "Done.\n\n\n";
-	}
-	if constexpr (run_uniform_random_double) {
-		std::cout << "[Running the algorithm with uniformly randomly generated double inputs...]\n";
-		uniform_random_perf_test<double>(number_of_uniform_random_perf_tests_double);
-		std::cout << "Done.\n\n\n";
-	}
-	if constexpr (run_digit_float) {
-		std::cout << "[Running the algorithm with float inputs of digits = "
-			<< digits_for_perf_test_float << "...]\n";
-		digit_perf_test<float>(digits_for_perf_test_float, number_of_digit_perf_tests_float);
-		std::cout << "Done.\n\n\n";
-	}
-	if constexpr (run_digit_double) {
-		std::cout << "[Running the algorithm with double inputs of digits = "
-			<< digits_for_perf_test_double << "...]\n";
-		digit_perf_test<double>(digits_for_perf_test_double, number_of_digit_perf_tests_double);
-		std::cout << "Done.\n\n\n";
-	}
-}
+// 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 "dragonbox/dragonbox_to_chars.h"
+#include "random_float.h"
+#include <chrono>
+#include <iostream>
+
+template <class Float>
+static void uniform_random_perf_test(std::size_t number_of_tests)
+{
+	std::cout << "Generating random samples...\n";
+	auto rg = generate_correctly_seeded_mt19937_64();
+	std::vector<Float> samples(number_of_tests);
+	for (auto& sample : samples) {
+		sample = uniformly_randomly_generate_general_float<Float>(rg);
+	}
+
+	std::cout << "Performing test...\n";
+	char buffer[41];
+	auto from = std::chrono::steady_clock::now();
+	for (auto& sample : samples) {
+		jkj::dragonbox::to_chars(sample, buffer);
+	}
+	auto dur = std::chrono::steady_clock::now() - from;
+	std::cout << "Average time: " <<
+		double(std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count()) / number_of_tests << "ns\n";
+}
+
+template <class Float>
+static void digit_perf_test(unsigned int digits, std::size_t number_of_tests)
+{
+	std::cout << "Generating random samples...\n";
+	auto rg = generate_correctly_seeded_mt19937_64();
+	std::vector<Float> samples(number_of_tests);
+	for (auto& sample : samples) {
+		sample = randomly_generate_float_with_given_digits<Float>(digits, rg);
+	}
+
+	std::cout << "Performing test...\n";
+	char buffer[41];
+	auto from = std::chrono::steady_clock::now();
+	for (auto& sample : samples) {
+		jkj::dragonbox::to_chars(sample, buffer);
+	}
+	auto dur = std::chrono::steady_clock::now() - from;
+	std::cout << "Average time: " <<
+		double(std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count()) / number_of_tests << "ns\n";
+}
+
+int main()
+{
+	constexpr bool run_uniform_random_float = true;
+	constexpr std::size_t number_of_uniform_random_perf_tests_float = 100000000;
+
+	constexpr bool run_uniform_random_double = true;
+	constexpr std::size_t number_of_uniform_random_perf_tests_double = 100000000;
+
+	constexpr bool run_digit_float = false;
+	constexpr unsigned int digits_for_perf_test_float = 6;
+	constexpr std::size_t number_of_digit_perf_tests_float = 40000000;
+
+	constexpr bool run_digit_double = false;
+	constexpr static unsigned int digits_for_perf_test_double = 17;
+	constexpr static std::size_t number_of_digit_perf_tests_double = 6000000;
+
+
+	if constexpr (run_uniform_random_float) {
+		std::cout << "[Running the algorithm with uniformly randomly generated float inputs...]\n";
+		uniform_random_perf_test<float>(number_of_uniform_random_perf_tests_float);
+		std::cout << "Done.\n\n\n";
+	}
+	if constexpr (run_uniform_random_double) {
+		std::cout << "[Running the algorithm with uniformly randomly generated double inputs...]\n";
+		uniform_random_perf_test<double>(number_of_uniform_random_perf_tests_double);
+		std::cout << "Done.\n\n\n";
+	}
+	if constexpr (run_digit_float) {
+		std::cout << "[Running the algorithm with float inputs of digits = "
+			<< digits_for_perf_test_float << "...]\n";
+		digit_perf_test<float>(digits_for_perf_test_float, number_of_digit_perf_tests_float);
+		std::cout << "Done.\n\n\n";
+	}
+	if constexpr (run_digit_double) {
+		std::cout << "[Running the algorithm with double inputs of digits = "
+			<< digits_for_perf_test_double << "...]\n";
+		digit_perf_test<double>(digits_for_perf_test_double, number_of_digit_perf_tests_double);
+		std::cout << "Done.\n\n\n";
+	}
+}