koffi 0.9.0 → 0.9.3

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

@@ -0,0 +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";
+}

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

@@ -0,0 +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>();
+    }
+}

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

@@ -0,0 +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";
+	}
+}

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

@@ -0,0 +1,20 @@
+// 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 "dragonbox/dragonbox.h"
+
+int main() {}

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

@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(dragonboxTests LANGUAGES CXX)
+
+# ---- Add dependencies ----
+
+# We want warnings in tests
+set(dragonbox_INCLUDE_WITHOUT_SYSTEM ON CACHE INTERNAL "")
+
+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()
+if (NOT TARGET ryu)
+    FetchContent_Declare(ryu SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../3rdparty/ryu")
+    FetchContent_MakeAvailable(ryu)
+endif()
+
+# ---- Tests ----
+
+enable_testing()
+
+function(add_test NAME)
+  cmake_parse_arguments(TEST "TO_CHARS;RYU" "NAME" "" ${ARGN})
+  if(TEST_TO_CHARS)
+    set(dragonbox dragonbox::dragonbox_to_chars)
+  else()
+    set(dragonbox dragonbox::dragonbox)
+  endif()
+
+  add_executable(${NAME} source/${NAME}.cpp)
+
+  target_link_libraries(${NAME} PRIVATE ${dragonbox} dragonbox::common)
+
+  if(TEST_RYU)
+    target_link_libraries(${NAME} PRIVATE ryu::ryu)
+  endif()
+
+  target_compile_features(${NAME} PRIVATE cxx_std_17)
+
+  _add_test(NAME ${NAME} COMMAND ${NAME})
+
+  # ---- 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()
+
+add_test(verify_cache_precision)
+add_test(test_all_shorter_interval_cases TO_CHARS RYU)
+add_test(uniform_random_test TO_CHARS RYU)
+add_test(verify_compressed_cache)
+add_test(verify_fast_multiplication)
+add_test(verify_log_computation)
+add_test(verify_magic_division)

package/vendor/dragonbox/subproject/test/results/binary32.csv

@@ -0,0 +1,255 @@
+e,bits_for_multiplication,bits_for_integer_check
+-149,50,61
+-148,54,60
+-147,55,59
+-146,48,57
+-145,54,57
+-144,54,56
+-143,54,57
+-142,56,56
+-141,56,56
+-140,56,57
+-139,46,58
+-138,53,60
+-137,53,60
+-136,52,63
+-135,52,63
+-134,52,63
+-133,52,63
+-132,50,63
+-131,50,63
+-130,53,62
+-129,52,62
+-128,53,61
+-127,53,60
+-126,48,53
+-125,48,53
+-124,61,57
+-123,61,56
+-122,52,59
+-121,55,58
+-120,61,57
+-119,54,57
+-118,54,57
+-117,54,59
+-116,51,59
+-115,53,58
+-114,55,57
+-113,55,60
+-112,55,57
+-111,55,57
+-110,55,58
+-109,51,60
+-108,54,59
+-107,54,58
+-106,52,60
+-105,53,59
+-104,53,58
+-103,54,57
+-102,50,60
+-101,55,59
+-100,55,58
+-99,52,59
+-98,54,58
+-97,54,57
+-96,51,59
+-95,51,58
+-94,52,57
+-93,52,59
+-92,52,59
+-91,52,58
+-90,54,58
+-89,50,56
+-88,54,59
+-87,55,58
+-86,51,58
+-85,52,58
+-84,52,58
+-83,50,57
+-82,53,58
+-81,53,66
+-80,53,66
+-79,52,59
+-78,52,58
+-77,52,57
+-76,52,58
+-75,54,58
+-74,54,58
+-73,45,56
+-72,45,55
+-71,45,55
+-70,54,57
+-69,52,58
+-68,52,58
+-67,52,58
+-66,49,58
+-65,49,57
+-64,49,57
+-63,47,56
+-62,47,57
+-61,47,61
+-60,47,60
+-59,45,57
+-58,45,60
+-57,45,60
+-56,42,58
+-55,42,58
+-54,42,57
+-53,40,59
+-52,40,59
+-51,40,58
+-50,40,57
+-49,38,58
+-48,38,58
+-47,38,57
+-46,35,57
+-45,35,57
+-44,35,60
+-43,33,59
+-42,33,58
+-41,33,60
+-40,33,59
+-39,31,57
+-38,31,57
+-37,31,57
+-36,28,57
+-35,28,56
+-34,28,55
+-33,26,55
+-32,26,54
+-31,26,53
+-30,26,52
+-29,24,52
+-28,24,51
+-27,24,50
+-26,21,50
+-25,21,49
+-24,21,48
+-23,19,48
+-22,19,47
+-21,19,46
+-20,19,45
+-19,17,45
+-18,17,44
+-17,17,43
+-16,14,43
+-15,14,42
+-14,14,41
+-13,12,41
+-12,12,40
+-11,12,39
+-10,12,38
+-9,10,38
+-8,10,37
+-7,10,36
+-6,7,36
+-5,7,35
+-4,7,34
+-3,5,34
+-2,5,33
+-1,5,32
+0,3,32
+1,3,32
+2,3,32
+3,3,32
+4,1,32
+5,1,32
+6,1,32
+7,31,35
+8,31,35
+9,32,35
+10,31,37
+11,33,37
+12,33,37
+13,33,37
+14,36,39
+15,36,39
+16,36,39
+17,37,42
+18,38,42
+19,40,42
+20,38,44
+21,41,44
+22,41,44
+23,43,44
+24,41,46
+25,44,46
+26,44,46
+27,41,49
+28,41,49
+29,46,49
+30,46,51
+31,47,51
+32,47,51
+33,47,51
+34,50,53
+35,50,53
+36,52,53
+37,51,56
+38,51,56
+39,53,56
+40,52,58
+41,54,58
+42,54,57
+43,54,56
+44,54,57
+45,54,57
+46,54,60
+47,51,63
+48,52,62
+49,52,61
+50,51,59
+51,54,58
+52,57,57
+53,57,57
+54,52,58
+55,52,57
+56,55,62
+57,52,64
+58,52,64
+59,53,63
+60,50,57
+61,53,58
+62,53,58
+63,56,58
+64,51,57
+65,51,59
+66,55,58
+67,52,55
+68,52,54
+69,52,53
+70,51,56
+71,51,55
+72,51,55
+73,54,64
+74,49,59
+75,49,59
+76,49,59
+77,50,62
+78,50,62
+79,50,62
+80,51,62
+81,51,62
+82,51,62
+83,51,62
+84,50,62
+85,50,62
+86,50,62
+87,51,62
+88,51,62
+89,51,62
+90,50,62
+91,51,61
+92,51,60
+93,51,59
+94,49,59
+95,56,58
+96,56,57
+97,52,58
+98,54,57
+99,54,58
+100,50,58
+101,50,58
+102,54,57
+103,48,60
+104,48,59