sequenzo 0.1.31__cp310-cp310-macosx_10_9_x86_64.whl

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/xsimd.hpp

@@ -0,0 +1,75 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#ifndef XSIMD_HPP
+#define XSIMD_HPP
+
+#if defined(__FAST_MATH__)
+#define XSIMD_NO_DENORMALS
+#define XSIMD_NO_INFINITIES
+#define XSIMD_NO_NANS
+#endif
+
+#if defined(__has_cpp_attribute)
+// if this check passes, then the compiler supports feature test macros
+#if __has_cpp_attribute(nodiscard) >= 201603L
+// if this check passes, then the compiler supports [[nodiscard]] without a message
+#define XSIMD_NO_DISCARD [[nodiscard]]
+#endif
+#endif
+
+#if !defined(XSIMD_NO_DISCARD) && __cplusplus >= 201703L
+// this means that the previous tests failed, but we are using C++17 or higher
+#define XSIMD_NO_DISCARD [[nodiscard]]
+#endif
+
+#if !defined(XSIMD_NO_DISCARD) && (defined(__GNUC__) || defined(__clang__))
+// this means that the previous checks failed, but we are using GCC or Clang
+#define XSIMD_NO_DISCARD __attribute__((warn_unused_result))
+#endif
+
+#if !defined(XSIMD_NO_DISCARD)
+// this means that all the previous checks failed, so we fallback to doing nothing
+#define XSIMD_NO_DISCARD
+#endif
+
+#ifdef __cpp_if_constexpr
+// this means that the compiler supports the `if constexpr` construct
+#define XSIMD_IF_CONSTEXPR if constexpr
+#endif
+
+#if !defined(XSIMD_IF_CONSTEXPR) && __cplusplus >= 201703L
+// this means that the previous test failed, but we are using C++17 or higher
+#define XSIMD_IF_CONSTEXPR if constexpr
+#endif
+
+#if !defined(XSIMD_IF_CONSTEXPR)
+// this means that all the previous checks failed, so we fallback to a normal `if`
+#define XSIMD_IF_CONSTEXPR if
+#endif
+
+#include "config/xsimd_config.hpp"
+#include "config/xsimd_inline.hpp"
+
+#include "arch/xsimd_scalar.hpp"
+#include "memory/xsimd_aligned_allocator.hpp"
+
+#if defined(XSIMD_NO_SUPPORTED_ARCHITECTURE)
+// to type definition or anything appart from scalar definition and aligned allocator
+#else
+#include "types/xsimd_batch.hpp"
+#include "types/xsimd_batch_constant.hpp"
+#include "types/xsimd_traits.hpp"
+
+// This include must come last
+#include "types/xsimd_api.hpp"
+#endif
+#endif

sequenzo/dissimilarity_measures/src/xsimd/test/architectures/dummy.cpp

@@ -0,0 +1,7 @@
+#include <xsimd/xsimd.hpp>
+
+// Basic check: can we instantiate a batch for the given compiler flags?
+xsimd::batch<int> come_and_get_some(xsimd::batch<int> x, xsimd::batch<int> y)
+{
+    return x + y;
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/explicit_use_of_an_instruction_set.cpp

@@ -0,0 +1,13 @@
+#include "xsimd/xsimd.hpp"
+#include <iostream>
+
+namespace xs = xsimd;
+
+int main(int, char*[])
+{
+    xs::batch<double, xs::avx> a = { 1.5, 2.5, 3.5, 4.5 };
+    xs::batch<double, xs::avx> b = { 2.5, 3.5, 4.5, 5.5 };
+    auto mean = (a + b) / 2;
+    std::cout << mean << std::endl;
+    return 0;
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/explicit_use_of_an_instruction_set_mean.cpp

@@ -0,0 +1,24 @@
+#include "xsimd/xsimd.hpp"
+#include <cstddef>
+#include <vector>
+
+void mean(const std::vector<double>& a, const std::vector<double>& b, std::vector<double>& res)
+{
+    using b_type = xsimd::batch<double, xsimd::avx>;
+    std::size_t inc = b_type::size;
+    std::size_t size = res.size();
+    // size for which the vectorization is possible
+    std::size_t vec_size = size - size % inc;
+    for (std::size_t i = 0; i < vec_size; i += inc)
+    {
+        b_type avec = b_type::load_unaligned(&a[i]);
+        b_type bvec = b_type::load_unaligned(&b[i]);
+        b_type rvec = (avec + bvec) / 2;
+        rvec.store_unaligned(&res[i]);
+    }
+    // Remaining part that cannot be vectorize
+    for (std::size_t i = vec_size; i < size; ++i)
+    {
+        res[i] = (a[i] + b[i]) / 2;
+    }
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/explicit_use_of_an_instruction_set_mean_aligned.cpp

@@ -0,0 +1,25 @@
+#include "xsimd/xsimd.hpp"
+#include <cstddef>
+#include <vector>
+
+using vector_type = std::vector<double, xsimd::default_allocator<double>>;
+void mean(const vector_type& a, const vector_type& b, vector_type& res)
+{
+    using b_type = xsimd::batch<double>;
+    std::size_t inc = b_type::size;
+    std::size_t size = res.size();
+    // size for which the vectorization is possible
+    std::size_t vec_size = size - size % inc;
+    for (std::size_t i = 0; i < vec_size; i += inc)
+    {
+        b_type avec = b_type::load_aligned(&a[i]);
+        b_type bvec = b_type::load_aligned(&b[i]);
+        b_type rvec = (avec + bvec) / 2;
+        rvec.store_aligned(&res[i]);
+    }
+    // Remaining part that cannot be vectorize
+    for (std::size_t i = vec_size; i < size; ++i)
+    {
+        res[i] = (a[i] + b[i]) / 2;
+    }
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/explicit_use_of_an_instruction_set_mean_arch_independent.cpp

@@ -0,0 +1,28 @@
+#include "xsimd/xsimd.hpp"
+#include <cstddef>
+#include <vector>
+
+struct mean
+{
+    template <class C, class Tag, class Arch>
+    void operator()(Arch, const C& a, const C& b, C& res, Tag)
+    {
+        using b_type = xsimd::batch<double, Arch>;
+        std::size_t inc = b_type::size;
+        std::size_t size = res.size();
+        // size for which the vectorization is possible
+        std::size_t vec_size = size - size % inc;
+        for (std::size_t i = 0; i < vec_size; i += inc)
+        {
+            b_type avec = b_type::load(&a[i], Tag());
+            b_type bvec = b_type::load(&b[i], Tag());
+            b_type rvec = (avec + bvec) / 2;
+            xsimd::store(&res[i], rvec, Tag());
+        }
+        // Remaining part that cannot be vectorize
+        for (std::size_t i = vec_size; i < size; ++i)
+        {
+            res[i] = (a[i] + b[i]) / 2;
+        }
+    }
+};

sequenzo/dissimilarity_measures/src/xsimd/test/doc/explicit_use_of_an_instruction_set_mean_tag_dispatch.cpp

@@ -0,0 +1,25 @@
+#include "xsimd/xsimd.hpp"
+#include <cstddef>
+#include <vector>
+
+template <class C, class Tag>
+void mean(const C& a, const C& b, C& res, Tag)
+{
+    using b_type = xsimd::batch<double>;
+    std::size_t inc = b_type::size;
+    std::size_t size = res.size();
+    // size for which the vectorization is possible
+    std::size_t vec_size = size - size % inc;
+    for (std::size_t i = 0; i < vec_size; i += inc)
+    {
+        b_type avec = b_type::load(&a[i], Tag());
+        b_type bvec = b_type::load(&b[i], Tag());
+        b_type rvec = (avec + bvec) / 2;
+        xsimd::store(&res[i], rvec, Tag());
+    }
+    // Remaining part that cannot be vectorize
+    for (std::size_t i = vec_size; i < size; ++i)
+    {
+        res[i] = (a[i] + b[i]) / 2;
+    }
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/manipulating_abstract_batches.cpp

@@ -0,0 +1,7 @@
+#include "xsimd/xsimd.hpp"
+
+namespace xs = xsimd;
+xs::batch<float> mean(xs::batch<float> lhs, xs::batch<float> rhs)
+{
+    return (lhs + rhs) / 2;
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/manipulating_parametric_batches.cpp

@@ -0,0 +1,8 @@
+#include "xsimd/xsimd.hpp"
+
+namespace xs = xsimd;
+template <class T, class Arch>
+xs::batch<T, Arch> mean(xs::batch<T, Arch> lhs, xs::batch<T, Arch> rhs)
+{
+    return (lhs + rhs) / 2;
+}

sequenzo/dissimilarity_measures/src/xsimd/test/doc/sum.hpp

@@ -0,0 +1,31 @@
+#ifndef _SUM_HPP
+#define _SUM_HPP
+#include "xsimd/xsimd.hpp"
+
+// functor with a call method that depends on `Arch`
+struct sum
+{
+    // It's critical not to use an in-class definition here.
+    // In-class and inline definition bypass extern template mechanism.
+    template <class Arch, class T>
+    T operator()(Arch, T const* data, unsigned size);
+};
+
+template <class Arch, class T>
+T sum::operator()(Arch, T const* data, unsigned size)
+{
+    using batch = xsimd::batch<T, Arch>;
+    batch acc(static_cast<T>(0));
+    const unsigned n = size / batch::size * batch::size;
+    for (unsigned i = 0; i != n; i += batch::size)
+        acc += batch::load_unaligned(data + i);
+    T star_acc = xsimd::reduce_add(acc);
+    for (unsigned i = n; i < size; ++i)
+        star_acc += data[i];
+    return star_acc;
+}
+
+// Inform the compiler that sse2 and avx2 implementation are to be found in another compilation unit.
+extern template float sum::operator()<xsimd::avx2, float>(xsimd::avx2, float const*, unsigned);
+extern template float sum::operator()<xsimd::sse2, float>(xsimd::sse2, float const*, unsigned);
+#endif

sequenzo/dissimilarity_measures/src/xsimd/test/doc/sum_avx2.cpp

@@ -0,0 +1,3 @@
+// compile with -mavx2
+#include "sum.hpp"
+template float sum::operator()<xsimd::avx2, float>(xsimd::avx2, float const*, unsigned);

sequenzo/dissimilarity_measures/src/xsimd/test/doc/sum_sse2.cpp

@@ -0,0 +1,3 @@
+// compile with -msse2
+#include "sum.hpp"
+template float sum::operator()<xsimd::sse2, float>(xsimd::sse2, float const*, unsigned);

sequenzo/dissimilarity_measures/src/xsimd/test/doc/writing_vectorized_code.cpp

@@ -0,0 +1,11 @@
+#include <cstddef>
+#include <vector>
+
+void mean(const std::vector<double>& a, const std::vector<double>& b, std::vector<double>& res)
+{
+    std::size_t size = res.size();
+    for (std::size_t i = 0; i < size; ++i)
+    {
+        res[i] = (a[i] + b[i]) / 2;
+    }
+}

sequenzo/dissimilarity_measures/src/xsimd/test/main.cpp

@@ -0,0 +1,31 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+#ifndef EMSCRIPTEN
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include "doctest/doctest.h"
+#else
+
+#define DOCTEST_CONFIG_IMPLEMENT
+#include "doctest/doctest.h"
+#include <emscripten/bind.h>
+
+int run_tests()
+{
+    doctest::Context context;
+    return context.run();
+}
+
+EMSCRIPTEN_BINDINGS(my_module)
+{
+    emscripten::function("run_tests", &run_tests);
+}
+
+#endif

sequenzo/dissimilarity_measures/src/xsimd/test/test_api.cpp

@@ -0,0 +1,230 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#include "xsimd/xsimd.hpp"
+#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
+
+#include <functional>
+#include <numeric>
+#include <random>
+
+#include "test_utils.hpp"
+
+template <class B>
+struct xsimd_api_test
+{
+    using batch_type = B;
+    using batch_bool_type = typename B::batch_bool_type;
+    using arch_type = typename B::arch_type;
+    using value_type = typename B::value_type;
+    static constexpr size_t size = B::size;
+    using array_type = std::array<value_type, size>;
+    using int8_vector_type = std::vector<int8_t, xsimd::default_allocator<int8_t>>;
+    using uint8_vector_type = std::vector<uint8_t, xsimd::default_allocator<uint8_t>>;
+    using int16_vector_type = std::vector<int16_t, xsimd::default_allocator<int16_t>>;
+    using uint16_vector_type = std::vector<uint16_t, xsimd::default_allocator<uint16_t>>;
+    using int32_vector_type = std::vector<int32_t, xsimd::default_allocator<int32_t>>;
+    using uint32_vector_type = std::vector<uint32_t, xsimd::default_allocator<uint32_t>>;
+    using int64_vector_type = std::vector<int64_t, xsimd::default_allocator<int64_t>>;
+    using uint64_vector_type = std::vector<uint64_t, xsimd::default_allocator<uint64_t>>;
+    using float_vector_type = std::vector<float, xsimd::default_allocator<float>>;
+    using double_vector_type = std::vector<double, xsimd::default_allocator<double>>;
+
+    int8_vector_type i8_vec;
+    uint8_vector_type ui8_vec;
+    int16_vector_type i16_vec;
+    uint16_vector_type ui16_vec;
+    int32_vector_type i32_vec;
+    uint32_vector_type ui32_vec;
+    int64_vector_type i64_vec;
+    uint64_vector_type ui64_vec;
+    float_vector_type f_vec;
+    double_vector_type d_vec;
+
+    array_type expected;
+
+    xsimd_api_test()
+    {
+        init_test_vector(i8_vec);
+        init_test_vector(ui8_vec);
+        init_test_vector(i16_vec);
+        init_test_vector(ui16_vec);
+        init_test_vector(i32_vec);
+        init_test_vector(ui32_vec);
+        init_test_vector(i64_vec);
+        init_test_vector(ui64_vec);
+        init_test_vector(f_vec);
+#if XSIMD_WITH_NEON64 || !XSIMD_WITH_NEON
+        init_test_vector(d_vec);
+#endif
+    }
+
+    void test_load()
+    {
+        test_load_impl(i8_vec, "load int8_t");
+        test_load_impl(ui8_vec, "load uint8_t");
+        test_load_impl(i16_vec, "load int16_t");
+        test_load_impl(ui16_vec, "load uint16_t");
+        test_load_impl(i32_vec, "load int32_t");
+        test_load_impl(ui32_vec, "load uint32_t");
+        test_load_impl(i64_vec, "load int64_t");
+        test_load_impl(ui64_vec, "load uint64_t");
+        test_load_impl(f_vec, "load float");
+#if XSIMD_WITH_NEON64 || !XSIMD_WITH_NEON
+        test_load_impl(d_vec, "load double");
+#endif
+    }
+
+    void test_store()
+    {
+        test_store_impl(i8_vec, "store int8_t");
+        test_store_impl(ui8_vec, "store uint8_t");
+        test_store_impl(i16_vec, "store int16_t");
+        test_store_impl(ui16_vec, "store uint16_t");
+        test_store_impl(i32_vec, "store int32_t");
+        test_store_impl(ui32_vec, "store uint32_t");
+        test_store_impl(i64_vec, "store int64_t");
+        test_store_impl(ui64_vec, "store uint64_t");
+        test_store_impl(f_vec, "store float");
+#if XSIMD_WITH_NEON64 || !XSIMD_WITH_NEON
+        test_store_impl(d_vec, "store double");
+#endif
+    }
+
+    void test_set()
+    {
+        test_set_bool("set bool");
+        test_set_impl<int8_t>("set int8_t");
+        test_set_impl<uint8_t>("set uint8_t");
+        test_set_impl<int16_t>("set int16_t");
+        test_set_impl<uint16_t>("set uint16_t");
+        test_set_impl<int32_t>("set int32_t");
+        test_set_impl<uint32_t>("set uint32_t");
+        test_set_impl<int64_t>("set int64_t");
+        test_set_impl<uint64_t>("set uint64_t");
+        test_set_impl<float>("set float");
+#if XSIMD_WITH_NEON64 || !XSIMD_WITH_NEON
+        test_set_impl<double>("set double");
+#endif
+    }
+
+private:
+    template <class V>
+    void test_load_impl(const V& v, const std::string& name)
+    {
+        batch_type b;
+        std::copy(v.cbegin(), v.cend(), expected.begin());
+
+        b = batch_type::load(v.data(), xsimd::unaligned_mode());
+        INFO(name, " unaligned");
+        CHECK_BATCH_EQ(b, expected);
+
+        b = batch_type::load(v.data(), xsimd::aligned_mode());
+        INFO(name, " aligned");
+        CHECK_BATCH_EQ(b, expected);
+    }
+
+    template <class V>
+    void test_store_impl(const V& v, const std::string& name)
+    {
+        batch_type b = batch_type::load(v.data(), xsimd::aligned_mode());
+        V res(size);
+
+        bool* b_data = new bool[size];
+
+        xsimd::store_as(res.data(), b, xsimd::unaligned_mode());
+        INFO(name, " unaligned");
+        CHECK_VECTOR_EQ(res, v);
+
+        std::fill(b_data, b_data + size, false);
+        batch_bool_type bb = (b == b);
+        xsimd::store_as(b_data, bb, xsimd::unaligned_mode());
+        INFO(name, " batch_bool unaligned");
+        CHECK_UNARY(std::accumulate(b_data, b_data + size, true, std::logical_and<bool>()));
+
+        xsimd::store_as(res.data(), b, xsimd::aligned_mode());
+        INFO(name, " aligned");
+        CHECK_VECTOR_EQ(res, v);
+
+        std::fill(b_data, b_data + size, false);
+        bb = (b == b);
+        xsimd::store_as(b_data, bb, xsimd::aligned_mode());
+        INFO(name, " batch_bool aligned");
+        CHECK_UNARY(std::accumulate(b_data, b_data + size, true, std::logical_and<bool>()));
+
+        delete[] b_data;
+    }
+
+    template <class T>
+    void test_set_impl(const std::string& name)
+    {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+        T v = T(1);
+        batch_type expected(v);
+        batch_type res = xsimd::broadcast<value_type>(v);
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+        INFO(name);
+        CHECK_BATCH_EQ(res, expected);
+    }
+
+    void test_set_bool(const std::string& name)
+    {
+        bool v = true;
+        xsimd::batch_bool<uint8_t, arch_type> expected(v);
+        xsimd::batch_bool<uint8_t, arch_type> res = xsimd::broadcast(v);
+        INFO(name);
+        CHECK_BATCH_EQ(res, expected);
+    }
+
+    template <class V>
+    void init_test_vector(V& vec)
+    {
+        vec.resize(size);
+
+        int min = 0;
+        int max = 100;
+
+        std::default_random_engine generator;
+        std::uniform_int_distribution<int> distribution(min, max);
+
+        auto gen = [&distribution, &generator]()
+        {
+            return static_cast<value_type>(distribution(generator));
+        };
+
+        std::generate(vec.begin(), vec.end(), gen);
+    }
+};
+
+TEST_CASE_TEMPLATE("[basic api]", B, BATCH_TYPES)
+{
+    xsimd_api_test<B> Test;
+    SUBCASE("load")
+    {
+        Test.test_load();
+    }
+
+    SUBCASE("store")
+    {
+        Test.test_store();
+    }
+
+    SUBCASE("set")
+    {
+        Test.test_set();
+    }
+}
+#endif