sequenzo 0.1.21__cp312-cp312-macosx_11_0_arm64.whl

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

@@ -0,0 +1,61 @@
+/***************************************************************************
+ * 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 <type_traits>
+#include <vector>
+
+#include "doctest/doctest.h"
+
+#include "xsimd/memory/xsimd_aligned_allocator.hpp"
+#include "xsimd/memory/xsimd_alignment.hpp"
+
+struct mock_container
+{
+};
+
+TEST_CASE("[alignment]")
+{
+    using u_vector_type = std::vector<double>;
+    using a_vector_type = std::vector<double, xsimd::default_allocator<double>>;
+
+    using u_vector_align = xsimd::container_alignment_t<u_vector_type>;
+    using a_vector_align = xsimd::container_alignment_t<a_vector_type>;
+    using mock_align = xsimd::container_alignment_t<mock_container>;
+
+    if (xsimd::default_arch::requires_alignment())
+    {
+        CHECK_UNARY((std::is_same<u_vector_align, xsimd::unaligned_mode>::value));
+        CHECK_UNARY((std::is_same<a_vector_align, xsimd::aligned_mode>::value));
+        CHECK_UNARY((std::is_same<mock_align, xsimd::unaligned_mode>::value));
+    }
+}
+
+TEST_CASE("[is_aligned]")
+{
+    float f[100];
+    void* unaligned_f = static_cast<void*>(&f[0]);
+    constexpr std::size_t alignment = xsimd::default_arch::alignment();
+    std::size_t aligned_f_size = sizeof(f);
+    void* aligned_f = std::align(alignment, sizeof(f), unaligned_f, aligned_f_size);
+    CHECK_UNARY(xsimd::is_aligned(aligned_f));
+
+    // GCC does not generate correct alignment on ARM
+    // (see https://godbolt.org/z/obv1n8bWq)
+#if !(XSIMD_WITH_NEON && defined(__GNUC__) && !defined(__clang__))
+    alignas(alignment) char aligned[8];
+    CHECK_UNARY(xsimd::is_aligned(&aligned[0]));
+    CHECK_UNARY(!xsimd::is_aligned(&aligned[3]));
+#endif
+}
+#endif

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

@@ -0,0 +1,64 @@
+/***************************************************************************
+ * 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 "test_utils.hpp"
+
+template <class B>
+struct poly_evaluation_test
+{
+    using batch_type = B;
+    using value_type = typename B::value_type;
+    static constexpr size_t size = B::size;
+    using vector_type = std::vector<value_type>;
+
+    size_t nb_input;
+    vector_type input;
+    vector_type horner_res;
+    vector_type estrin_res;
+
+    poly_evaluation_test()
+    {
+        nb_input = size * 10000;
+        input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
+        }
+        horner_res.resize(nb_input);
+        estrin_res.resize(nb_input);
+    }
+
+    void test_poly_evaluation()
+    {
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, input, i);
+            out = xsimd::kernel::horner<typename batch_type::value_type, typename batch_type::arch_type, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16>(in);
+            detail::store_batch(out, horner_res, i);
+            out = xsimd::kernel::estrin<typename batch_type::value_type, typename batch_type::arch_type, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16>(in);
+            detail::store_batch(out, estrin_res, i);
+        }
+        size_t diff = detail::get_nb_diff(horner_res, estrin_res);
+        CHECK_EQ(diff, 0);
+    }
+};
+
+TEST_CASE_TEMPLATE("[poly evaluation]", B, BATCH_FLOAT_TYPES)
+{
+
+    poly_evaluation_test<B> Test;
+    Test.test_poly_evaluation();
+}
+#endif

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

@@ -0,0 +1,184 @@
+/***************************************************************************
+ * 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 "test_utils.hpp"
+#include <iostream>
+
+template <class B>
+struct power_test
+{
+    using batch_type = B;
+    using value_type = typename B::value_type;
+    static constexpr size_t size = B::size;
+    using vector_type = std::vector<value_type>;
+
+    size_t nb_input;
+    vector_type zero_input;
+    vector_type zlhs_input;
+    vector_type lhs_input;
+    vector_type rhs_input;
+    vector_type expected;
+    vector_type res;
+
+    power_test()
+    {
+        nb_input = size * 10000;
+        zero_input.resize(nb_input);
+        zlhs_input.resize(nb_input);
+        lhs_input.resize(nb_input);
+        rhs_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            zero_input[i] = 0;
+            lhs_input[i] = value_type(i / 4 + 1.2 * std::sqrt(i + 0.25));
+            zlhs_input[i] = lhs_input[i] * (i % 2);
+            rhs_input[i] = value_type(10.2 / (i + 2) + 0.25);
+        }
+
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_power_functions()
+    {
+        // pow
+        {
+            std::transform(lhs_input.cbegin(), lhs_input.cend(), rhs_input.cbegin(), expected.begin(),
+                           [](const value_type& l, const value_type& r)
+                           { return std::pow(l, r); });
+            batch_type lhs_in, rhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(lhs_in, lhs_input, i);
+                detail::load_batch(rhs_in, rhs_input, i);
+                out = pow(lhs_in, rhs_in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("pow");
+            CHECK_EQ(diff, 0);
+        }
+        // pow zero
+        {
+            std::transform(zlhs_input.cbegin(), zlhs_input.cend(), rhs_input.cbegin(), expected.begin(),
+                           [](const value_type& l, const value_type& r)
+                           { return std::pow(l, r); });
+            batch_type zlhs_in, rhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(zlhs_in, zlhs_input, i);
+                detail::load_batch(rhs_in, rhs_input, i);
+                out = pow(zlhs_in, rhs_in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("0 ^ x");
+            CHECK_EQ(diff, 0);
+
+// use of undeclared identifier '_MM_SET_EXCEPTION_MASK for emscripten
+#if defined(__SSE__) && !defined(EMSCRIPTEN)
+            // Test with FE_INVALID...
+            unsigned mask = _MM_GET_EXCEPTION_MASK();
+            _MM_SET_EXCEPTION_MASK(mask & ~_MM_MASK_INVALID);
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(zlhs_in, zlhs_input, i);
+                detail::load_batch(rhs_in, rhs_input, i);
+                out = pow(zlhs_in, rhs_in);
+                detail::store_batch(out, res, i);
+            }
+            _MM_SET_EXCEPTION_MASK(mask);
+            diff = detail::get_nb_diff(res, expected);
+            INFO("0 ^ x with exception");
+            CHECK_EQ(diff, 0);
+#endif
+        }
+#ifndef __FAST_MATH__
+        // pow 0^-x
+        {
+            std::transform(zero_input.cbegin(), zero_input.cend(), rhs_input.cbegin(), expected.begin(),
+                           [](const value_type& z, const value_type& r)
+                           { return std::pow(z, -r); });
+            batch_type zero_in, rhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(zero_in, zero_input, i);
+                detail::load_batch(rhs_in, rhs_input, i);
+                out = pow(zero_in, -rhs_in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("pow(0, -x)");
+            CHECK_EQ(diff, 0);
+        }
+#endif
+        // ipow
+        {
+            long k = 0;
+            std::transform(lhs_input.cbegin(), lhs_input.cend(), expected.begin(),
+                           [&k, this](const value_type& l)
+                           { auto arg = k / size / 8000 - nb_input / size / 8000 / 2; ++k; return std::pow(l, arg); });
+            batch_type lhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(lhs_in, lhs_input, i);
+                out = pow(lhs_in, i / size / 8000 - nb_input / size / 8000 / 2);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("ipow");
+            CHECK_EQ(diff, 0);
+        }
+        // hypot
+        {
+            std::transform(lhs_input.cbegin(), lhs_input.cend(), rhs_input.cbegin(), expected.begin(),
+                           [](const value_type& l, const value_type& r)
+                           { return std::hypot(l, r); });
+            batch_type lhs_in, rhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(lhs_in, lhs_input, i);
+                detail::load_batch(rhs_in, rhs_input, i);
+                out = hypot(lhs_in, rhs_in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("hypot");
+            CHECK_EQ(diff, 0);
+        }
+        // cbrt
+        {
+            std::transform(lhs_input.cbegin(), lhs_input.cend(), expected.begin(),
+                           [](const value_type& l)
+                           { return std::cbrt(l); });
+            batch_type lhs_in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(lhs_in, lhs_input, i);
+                out = cbrt(lhs_in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("cbrt");
+            CHECK_EQ(diff, 0);
+        }
+    }
+};
+
+TEST_CASE_TEMPLATE("[power]", B, BATCH_FLOAT_TYPES)
+{
+    power_test<B> Test;
+    Test.test_power_functions();
+}
+#endif

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

@@ -0,0 +1,199 @@
+/***************************************************************************
+ * 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 "test_utils.hpp"
+
+template <class B>
+struct rounding_test
+{
+    using batch_type = B;
+    using arch_type = typename B::arch_type;
+    using value_type = typename B::value_type;
+    using int_value_type = xsimd::as_integer_t<value_type>;
+    using int_batch_type = xsimd::batch<int_value_type, arch_type>;
+    static constexpr size_t size = B::size;
+    static constexpr size_t nb_input = 8;
+    static constexpr size_t nb_batches = nb_input / size;
+
+    std::array<value_type, nb_input> input;
+    std::array<value_type, nb_input> expected;
+    std::array<value_type, nb_input> res;
+
+    rounding_test()
+    {
+        input[0] = value_type(-3.5);
+        input[1] = value_type(-2.7);
+        input[2] = value_type(-2.5);
+        input[3] = value_type(-2.3);
+        input[4] = value_type(2.3);
+        input[5] = value_type(2.5);
+        input[6] = value_type(2.7);
+        input[7] = value_type(3.5);
+    }
+
+    void test_rounding_functions()
+    {
+        // ceil
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::ceil(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = ceil(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::ceil(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("ceil");
+            CHECK_EQ(diff, 0);
+        }
+        // floor
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::floor(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = floor(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::floor(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("floor");
+            CHECK_EQ(diff, 0);
+        }
+        // trunc
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::trunc(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = trunc(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::trunc(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("trunc");
+            CHECK_EQ(diff, 0);
+        }
+        // round
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::round(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = round(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::round(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("round");
+            CHECK_EQ(diff, 0);
+        }
+        // nearbyint
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::nearbyint(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = nearbyint(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::nearbyint(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("nearbyint");
+            CHECK_EQ(diff, 0);
+        }
+        // nearbyint_as_int
+        {
+            std::array<int_value_type, nb_input> expected;
+            std::array<int_value_type, nb_input> res;
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return xsimd::nearbyint_as_int(v); });
+            batch_type in;
+            int_batch_type out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = nearbyint_as_int(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = xsimd::nearbyint_as_int(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("nearbyint_as_int");
+            CHECK_EQ(diff, 0);
+        }
+        // rint
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::rint(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = rint(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::rint(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("rint");
+            CHECK_EQ(diff, 0);
+        }
+    }
+};
+
+TEST_CASE_TEMPLATE("[rounding]", B, BATCH_FLOAT_TYPES)
+{
+
+    rounding_test<B> Test;
+    Test.test_rounding_functions();
+}
+#endif

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

@@ -0,0 +1,101 @@
+/***************************************************************************
+ * 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 "test_utils.hpp"
+
+template <class B>
+struct select_test
+{
+    using batch_type = B;
+    using value_type = typename B::value_type;
+    using arch_type = typename B::arch_type;
+    static constexpr size_t size = B::size;
+    using vector_type = std::vector<value_type>;
+
+    size_t nb_input;
+    vector_type lhs_input;
+    vector_type rhs_input;
+    vector_type expected;
+    vector_type res;
+
+    select_test()
+    {
+        nb_input = size * 10000;
+        lhs_input.resize(nb_input);
+        rhs_input.resize(nb_input);
+        auto clamp = [](double v)
+        {
+            return static_cast<value_type>(std::min(v, static_cast<double>(std::numeric_limits<value_type>::max())));
+        };
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            lhs_input[i] = clamp(i / 4 + 1.2 * std::sqrt(i + 0.25));
+            rhs_input[i] = clamp(10.2 / (i + 2) + 0.25);
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_select_dynamic()
+    {
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            expected[i] = lhs_input[i] > value_type(3) ? lhs_input[i] : rhs_input[i];
+        }
+
+        batch_type lhs_in, rhs_in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_input, i);
+            detail::load_batch(rhs_in, rhs_input, i);
+            out = xsimd::select(lhs_in > value_type(3), lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+    struct pattern
+    {
+        static constexpr bool get(std::size_t i, std::size_t) { return i % 2; }
+    };
+
+    void test_select_static()
+    {
+        constexpr auto mask = xsimd::make_batch_bool_constant<value_type, pattern, arch_type>();
+
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            expected[i] = mask.get(i % size) ? lhs_input[i] : rhs_input[i];
+        }
+
+        batch_type lhs_in, rhs_in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_input, i);
+            detail::load_batch(rhs_in, rhs_input, i);
+            out = xsimd::select(mask, lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+};
+
+TEST_CASE_TEMPLATE("[select]", B, BATCH_TYPES)
+{
+    select_test<B> Test;
+    SUBCASE("select_dynamic") { Test.test_select_dynamic(); }
+    SUBCASE("select_static") { Test.test_select_static(); }
+}
+#endif