koffi 2.3.6 → 2.3.8

package/vendor/dragonbox/subproject/benchmark/matlab/plot_digit_benchmark.m

@@ -1,78 +0,0 @@
-% Copyright 2020-2021 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.
-
-function [avg] = plot_digit_benchmark( filename )
-
-output_filename = replace(filename, '.csv', '.pdf');
-
-samples_per_digits = csvread(filename,0,1,[0 1 0 1]);
-table = readtable(filename);
-max_digits = table{size(table,1),2};
-number_of_algorithms = size(table,1) / samples_per_digits / max_digits;
-names = string(zeros(number_of_algorithms, 1));
-for i=1:number_of_algorithms
-    names(i) = string(table{samples_per_digits * i * max_digits,1});
-end
-
-% algorithm index, digits, measured_time
-data = zeros(number_of_algorithms, max_digits, samples_per_digits);
-for algorithm_idx=1:number_of_algorithms
-    for digits_idx=1:max_digits
-        offset = ((algorithm_idx-1) * max_digits + (digits_idx-1)) * samples_per_digits;
-        data(algorithm_idx, digits_idx,:) = table{offset+1:offset+samples_per_digits, 4};
-    end
-end
-
-color_array = {[.8 .06 .1],[.1 .7 .06],[.06 .1 .8],[.6 .2 .8],[.8 .9 0],[.5 .6 .7],[.8 .2 .6]};
-avg = zeros(number_of_algorithms, max_digits);
-for algorithm_idx=1:number_of_algorithms
-    for digits_idx=1:max_digits
-        avg(algorithm_idx,digits_idx) = mean(data(algorithm_idx,digits_idx,:));
-    end
-end
-
-% we will call this function stdshade
-addpath(genpath('shaded_plots'));
-
-% plot
-fig = figure('Color','w');
-fig_handles = zeros(number_of_algorithms,1);
-hold on
-for algorithm_idx=1:number_of_algorithms
-    fig_handles(algorithm_idx) = plot(1:max_digits,squeeze(avg(algorithm_idx,:)), ...
-        'Color', color_array{algorithm_idx}, 'LineWidth', 1.2);
-end
-for algorithm_idx=1:number_of_algorithms
-    plot_distribution_prctile(1:max_digits,squeeze(data(algorithm_idx,:,:))', ...
-        'Color', color_array{algorithm_idx}, 'Alpha', 0.05, ...
-        'Prctile', [30 50 70], 'LineWidth', 0.2);
-end
-legend(fig_handles,names);
-axis([1 max_digits -Inf Inf]);
-xlabel('Number of digits');
-ylabel('Time (ns)');
-h = gca;
-h.XTick = 1:max_digits;
-h.XGrid = 'on';
-h.YGrid = 'on';
-set(gca,'TickLabelInterpreter', 'latex');
-set(gcf, 'Position', [100 100 1200 500]);
-orient(fig,'landscape');
-exportgraphics(fig, output_filename, 'BackgroundColor', 'none');
-hold off
-
-end

package/vendor/dragonbox/subproject/benchmark/matlab/plot_uniform_benchmark.m

@@ -1,95 +0,0 @@
-% Copyright 2020-2021 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.
-
-function [] = plot_uniform_benchmark( filename, bits )
-
-output_filename = replace(filename, '.csv', '.pdf');
-
-samples = csvread(filename,0,1,[0 1 0 1]);
-table = readtable(filename);
-number_of_algorithms = size(table,1) / samples;
-names = string(zeros(number_of_algorithms, 1));
-for i=1:number_of_algorithms
-    names(i) = string(table{samples * i,1});
-end
-
-% algorithm index, measured_time
-measured_times = zeros(number_of_algorithms, samples);
-for algorithm_idx=1:number_of_algorithms
-    offset = (algorithm_idx-1) * samples;
-    measured_times(algorithm_idx,:) = table{offset+1:offset+samples, 4};
-end
-bit_representations = sscanf(strjoin(string(table{1:samples, 3})', ' '), '%lu');
-
-color_array = {[.8 .06 .1],[.1 .7 .06],[.06 .1 .8],[.6 .2 .8],[.8 .9 0],[.5 .6 .7],[.8 .2 .6]};
-
-% compute statistics
-av = mean(measured_times');
-st = std(measured_times');
-me = median(measured_times');
-
-decorated_names = names;
-for algorithm_idx=1:number_of_algorithms
-    decorated_names(algorithm_idx) = sprintf('%s (avg: %.2f, std: %.2f, med: %.2f)', ...
-        names(algorithm_idx), av(algorithm_idx), st(algorithm_idx), me(algorithm_idx));
-end
-
-% sample data for plot
-maximum_plot_size = 10000;
-if samples > maximum_plot_size
-    plot_size = maximum_plot_size;
-    unit = floor(samples / maximum_plot_size);
-    sampled_br = bit_representations(1:unit:unit*plot_size);
-    sampled_mt = measured_times(:,1:unit:unit*plot_size);
-else
-    plot_size = samples;
-    sampled_br = bit_representations;
-    sampled_mt = measured_times;
-end
-
-% plot
-fig = figure('Color','w');
-fig_handles = zeros(number_of_algorithms,1);
-hold on
-sz = ones(plot_size, 1) * 0.4;
-for algorithm_idx=1:number_of_algorithms
-    fig_handles(algorithm_idx) = scatter(sampled_br, ...
-        sampled_mt(algorithm_idx,:), sz, '+', ...
-        'MarkerEdgeColor', color_array{algorithm_idx}, 'LineWidth', 0.1);
-end
-legend(fig_handles,decorated_names);
-xlabel('Bit representation');
-ylabel('Time (ns)');
-range = prctile(measured_times(:), 99.9);
-axis([0 uint64(2)^bits 0 range(1)]);
-if bits==32
-    xticks([0 uint64(2)^30 uint64(2)^31 3*uint64(2)^30 uint64(2)^32]);
-    xticklabels({'$0$','$2^{30}$','$2^{31}$','$3\times2^{30}$','$2^{32}$'});
-elseif bits==64
-    xticks([0 uint64(2)^62 uint64(2)^63 3*uint64(2)^62 uint64(2)^64]);
-    xticklabels({'$0$','$2^{62}$','$2^{63}$','$3\times2^{62}$','$2^{64}$'});
-end
-h = gca;
-h.XGrid = 'off';
-h.YGrid = 'on';
-set(gca,'TickLabelInterpreter', 'latex');
-set(gcf, 'Position', [100 100 1200 500]);
-orient(fig,'landscape');
-exportgraphics(fig, output_filename, 'BackgroundColor', 'none');
-hold off
-
-end

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

@@ -1,238 +0,0 @@
-// Copyright 2020-2021 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 "random_float.h"
-#include "dragonbox/dragonbox_to_chars.h"
-#include <array>
-#include <chrono>
-#include <cstring>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <string_view>
-#include <utility>
-#include <unordered_map>
-#include <vector>
-
-template <class Float>
-class benchmark_holder {
-public:
-    static constexpr auto max_digits = std::size_t(std::numeric_limits<Float>::max_digits10);
-
-    static benchmark_holder& get_instance() {
-        static benchmark_holder<Float> inst;
-        return inst;
-    }
-
-    // Generate random samples
-    void prepare_samples(std::size_t number_of_general_samples,
-                         std::size_t number_of_digits_samples_per_digits) {
-        samples_[0].resize(number_of_general_samples);
-        for (auto& sample : samples_[0])
-            sample = uniformly_randomly_generate_general_float<Float>(rg_);
-
-        for (unsigned int digits = 1; digits <= max_digits; ++digits) {
-            samples_[digits].resize(number_of_digits_samples_per_digits);
-            for (auto& sample : samples_[digits])
-                sample = randomly_generate_float_with_given_digits<Float>(digits, rg_);
-        }
-    }
-
-    // { "name" : [(digits, [(sample, measured_time)])] }
-    // Results for general samples is stored at the position digits=0
-    using output_type =
-        std::unordered_map<std::string,
-                           std::array<std::vector<std::pair<Float, double>>, max_digits + 1>>;
-    void run(std::size_t number_of_iterations, std::string_view float_name, output_type& out) {
-        assert(number_of_iterations >= 1);
-        char buffer[40];
-
-        for (auto const& name_func_pair : name_func_pairs_) {
-            auto [result_array_itr, is_inserted] = out.insert_or_assign(
-                name_func_pair.first,
-                std::array<std::vector<std::pair<Float, double>>, max_digits + 1>{});
-
-            for (unsigned int digits = 0; digits <= max_digits; ++digits) {
-                (*result_array_itr).second[digits].resize(samples_[digits].size());
-                auto out_itr = (*result_array_itr).second[digits].begin();
-
-                if (digits == 0) {
-                    std::cout << "Benchmarking " << name_func_pair.first
-                              << " with uniformly random " << float_name << "'s...\n";
-                }
-                else {
-                    std::cout << "Benchmarking " << name_func_pair.first
-                              << " with (approximately) uniformly random " << float_name << "'s of "
-                              << digits << " digits...\n";
-                }
-
-                for (Float sample : samples_[digits]) {
-                    auto from = std::chrono::high_resolution_clock::now();
-                    for (std::size_t i = 0; i < number_of_iterations; ++i) {
-                        name_func_pair.second(sample, buffer);
-                    }
-                    auto dur = std::chrono::high_resolution_clock::now() - from;
-
-                    *out_itr = {
-                        sample,
-                        double(std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count()) /
-                            double(number_of_iterations)};
-                    ++out_itr;
-                }
-            }
-        }
-    }
-
-    output_type run(std::size_t number_of_iterations, std::string_view float_name) {
-        output_type out;
-        run(number_of_iterations, float_name, out);
-        return out;
-    }
-
-    void register_function(std::string_view name, void (*func)(Float, char*)) {
-        name_func_pairs_.emplace(name, func);
-    }
-
-private:
-    benchmark_holder() : rg_(generate_correctly_seeded_mt19937_64()) {}
-
-    // Digits samples for [1] ~ [max_digits], general samples for [0]
-    std::array<std::vector<Float>, max_digits + 1> samples_;
-    std::mt19937_64 rg_;
-    std::unordered_map<std::string, void (*)(Float, char*)> name_func_pairs_;
-};
-
-register_function_for_benchmark::register_function_for_benchmark(std::string_view name,
-                                                                 void (*func_float)(float, char*)) {
-    benchmark_holder<float>::get_instance().register_function(name, func_float);
-};
-
-register_function_for_benchmark::register_function_for_benchmark(std::string_view name,
-                                                                 void (*func_double)(double,
-                                                                                     char*)) {
-    benchmark_holder<double>::get_instance().register_function(name, func_double);
-};
-
-register_function_for_benchmark::register_function_for_benchmark(
-    std::string_view name, void (*func_float)(float, char*), void (*func_double)(double, char*)) {
-    benchmark_holder<float>::get_instance().register_function(name, func_float);
-    benchmark_holder<double>::get_instance().register_function(name, func_double);
-};
-
-
-#define RUN_MATLAB
-#ifdef RUN_MATLAB
-    #include <cstdlib>
-
-void run_matlab() {
-    struct launcher {
-        ~launcher() { std::system("matlab -nosplash -r \"cd('matlab'); plot_benchmarks\""); }
-    };
-    static launcher l;
-}
-#endif
-
-template <class Float>
-static void benchmark_test(std::string_view float_name, std::size_t number_of_uniform_samples,
-                           std::size_t number_of_digits_samples_per_digits,
-                           std::size_t number_of_iterations) {
-    auto& inst = benchmark_holder<Float>::get_instance();
-    std::cout << "Generating random samples...\n";
-    inst.prepare_samples(number_of_uniform_samples, number_of_digits_samples_per_digits);
-    auto out = inst.run(number_of_iterations, float_name);
-
-    std::cout << "Benchmarking done.\n"
-              << "Now writing to files...\n";
-
-    // Write uniform benchmark results
-    auto filename = std::string("results/uniform_benchmark_");
-    filename += float_name;
-    filename += ".csv";
-    std::ofstream out_file{filename};
-    out_file << "number_of_samples," << number_of_uniform_samples << std::endl;
-    ;
-    out_file << "name,sample,bit_representation,time\n";
-
-    char buffer[64];
-    typename jkj::dragonbox::default_float_traits<Float>::carrier_uint br;
-    for (auto& name_result_pair : out) {
-        for (auto const& data_time_pair : name_result_pair.second[0]) {
-            std::memcpy(&br, &data_time_pair.first, sizeof(Float));
-            jkj::dragonbox::to_chars(data_time_pair.first, buffer);
-            out_file << "\"" << name_result_pair.first << "\"," << buffer << ","
-                     << "0x" << std::hex << std::setfill('0');
-            if constexpr (sizeof(Float) == 4)
-                out_file << std::setw(8);
-            else
-                out_file << std::setw(16);
-            out_file << br << std::dec << "," << data_time_pair.second << "\n";
-        }
-    }
-    out_file.close();
-
-    // Write digits benchmark results
-    filename = std::string("results/digits_benchmark_");
-    filename += float_name;
-    filename += ".csv";
-    out_file.open(filename);
-    out_file << "number_of_samples_per_digits," << number_of_digits_samples_per_digits << std::endl;
-    ;
-    out_file << "name,digits,sample,time\n";
-
-    for (auto& name_result_pair : out) {
-        for (unsigned int digits = 1; digits <= benchmark_holder<Float>::max_digits; ++digits) {
-            for (auto const& data_time_pair : name_result_pair.second[digits]) {
-                jkj::dragonbox::to_chars(data_time_pair.first, buffer);
-                out_file << "\"" << name_result_pair.first << "\"," << digits << "," << buffer
-                         << "," << data_time_pair.second << "\n";
-            }
-        }
-    }
-    out_file.close();
-}
-
-int main() {
-    constexpr bool benchmark_float = true;
-    constexpr std::size_t number_of_uniform_benchmark_samples_float = 1000000;
-    constexpr std::size_t number_of_digits_benchmark_samples_per_digits_float = 100000;
-    constexpr std::size_t number_of_benchmark_iterations_float = 1000;
-
-    constexpr bool benchmark_double = true;
-    constexpr std::size_t number_of_uniform_benchmark_samples_double = 1000000;
-    constexpr std::size_t number_of_digits_benchmark_samples_per_digits_double = 100000;
-    constexpr std::size_t number_of_benchmark_iterations_double = 1000;
-
-    if constexpr (benchmark_float) {
-        std::cout << "[Running benchmark for binary32...]\n";
-        benchmark_test<float>("binary32", number_of_uniform_benchmark_samples_float,
-                              number_of_digits_benchmark_samples_per_digits_float,
-                              number_of_benchmark_iterations_float);
-        std::cout << "Done.\n\n\n";
-    }
-    if constexpr (benchmark_double) {
-        std::cout << "[Running benchmark for binary64...]\n";
-        benchmark_test<double>("binary64", number_of_uniform_benchmark_samples_double,
-                               number_of_digits_benchmark_samples_per_digits_double,
-                               number_of_benchmark_iterations_double);
-        std::cout << "Done.\n\n\n";
-    }
-
-#ifdef RUN_MATLAB
-    run_matlab();
-#endif
-}

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

@@ -1,30 +0,0 @@
-// 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 "dragonbox/dragonbox_to_chars.h"
-
-namespace {
-    void dragonbox_float_to_chars(float x, char* buffer) { jkj::dragonbox::to_chars(x, buffer); }
-    void dragonbox_double_to_chars(double x, char* buffer) { jkj::dragonbox::to_chars(x, buffer); }
-
-#if 1
-    auto dummy = []() -> register_function_for_benchmark {
-        return {"Dragonbox", dragonbox_float_to_chars, dragonbox_double_to_chars};
-    }();
-#endif
-}

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

@@ -1,36 +0,0 @@
-// 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 "fp_to_chars.h"
-
-namespace {
-    void grisu_exact_float_to_chars(float x, char* buffer) {
-        jkj::fp_to_chars(x, buffer, jkj::grisu_exact_rounding_modes::nearest_to_even{},
-                         jkj::grisu_exact_correct_rounding::tie_to_even{});
-    }
-    void grisu_exact_double_to_chars(double x, char* buffer) {
-        jkj::fp_to_chars(x, buffer, jkj::grisu_exact_rounding_modes::nearest_to_even{},
-                         jkj::grisu_exact_correct_rounding::tie_to_even{});
-    }
-
-#if 1
-    auto dummy = []() -> register_function_for_benchmark {
-        return {"Grisu-Exact", grisu_exact_float_to_chars, grisu_exact_double_to_chars};
-    }();
-#endif
-}

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

@@ -1,27 +0,0 @@
-// 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 +0,0 @@
-// 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 +0,0 @@
-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()