sequenzo 0.1.21__cp311-cp311-macosx_10_9_x86_64.whl

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

@@ -0,0 +1,4 @@
+#include "test_sum.hpp"
+#if XSIMD_WITH_AVX
+template float sum::operator()(xsimd::avx, float const*, unsigned);
+#endif

sequenzo/dissimilarity_measures/src/xsimd/test/test_sum.hpp

@@ -0,0 +1,34 @@
+#ifndef XSIMD_TEST_SUM_HPP
+#define XSIMD_TEST_SUM_HPP
+#include "xsimd/xsimd.hpp"
+#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
+
+struct sum
+{
+    // NOTE: no inline definition here otherwise extern template instantiation
+    // doesn't prevent implicit instantiation.
+    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;
+}
+
+#if XSIMD_WITH_AVX
+extern template float sum::operator()(xsimd::avx, float const*, unsigned);
+#endif
+
+#endif
+
+#endif

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

@@ -0,0 +1,172 @@
+/***************************************************************************
+ * 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 traits_test
+{
+    using batch_type = B;
+    using value_type = typename B::value_type;
+
+    void test_simd_traits()
+    {
+        using traits_type = xsimd::simd_traits<value_type>;
+        CHECK_EQ(traits_type::size, batch_type::size);
+        constexpr bool same_type = std::is_same<B, typename traits_type::type>::value;
+        CHECK_UNARY(same_type);
+        using batch_bool_type = xsimd::batch_bool<value_type>;
+        constexpr bool same_bool_type = std::is_same<batch_bool_type, typename traits_type::bool_type>::value;
+        CHECK_UNARY(same_bool_type);
+
+        using vector_traits_type = xsimd::simd_traits<std::vector<value_type>>;
+        CHECK_EQ(vector_traits_type::size, 1);
+        constexpr bool vec_same_type = std::is_same<typename vector_traits_type::type, std::vector<value_type>>::value;
+        CHECK_UNARY(vec_same_type);
+    }
+
+    void test_revert_simd_traits()
+    {
+        using traits_type = xsimd::revert_simd_traits<batch_type>;
+        CHECK_EQ(traits_type::size, batch_type::size);
+        constexpr bool same_type = std::is_same<value_type, typename traits_type::type>::value;
+        CHECK_UNARY(same_type);
+    }
+
+    void test_simd_return_type()
+    {
+        using rtype1 = xsimd::simd_return_type<value_type, float>;
+        constexpr bool res1 = std::is_same<rtype1, xsimd::batch<float>>::value;
+        CHECK_UNARY(res1);
+
+        using rtype2 = xsimd::simd_return_type<bool, value_type>;
+        constexpr bool res2 = std::is_same<rtype2, xsimd::batch_bool<value_type>>::value;
+        CHECK_UNARY(res2);
+    }
+
+    void test_mask_type()
+    {
+        using mtype0 = xsimd::mask_type_t<batch_type>;
+        constexpr bool res0 = std::is_same<mtype0, xsimd::batch_bool<xsimd::scalar_type_t<batch_type>>>::value;
+        CHECK_UNARY(res0);
+
+        using mtype1 = xsimd::mask_type_t<value_type>;
+        constexpr bool res1 = std::is_same<mtype1, bool>::value;
+        CHECK_UNARY(res1);
+    }
+};
+
+TEST_CASE_TEMPLATE("[traits]", B, BATCH_TYPES)
+{
+    traits_test<B> Test;
+
+    SUBCASE("simd_traits")
+    {
+        Test.test_simd_traits();
+    }
+
+    SUBCASE("revert_simd_traits")
+    {
+        Test.test_revert_simd_traits();
+    }
+
+    SUBCASE("simd_return_type")
+    {
+        Test.test_simd_return_type();
+    }
+
+    SUBCASE("mask_type")
+    {
+        Test.test_mask_type();
+    }
+}
+
+template <class B>
+struct complex_traits_test
+{
+    using batch_type = B;
+    using value_type = typename B::value_type;
+
+    void test_simd_traits()
+    {
+        using traits_type = xsimd::simd_traits<value_type>;
+        CHECK_EQ(traits_type::size, batch_type::size);
+        constexpr bool same_type = std::is_same<B, typename traits_type::type>::value;
+        CHECK_UNARY(same_type);
+        using batch_bool_type = xsimd::batch_bool<typename value_type::value_type>;
+        constexpr bool same_bool_type = std::is_same<batch_bool_type, typename traits_type::bool_type>::value;
+        CHECK_UNARY(same_bool_type);
+
+        using vector_traits_type = xsimd::simd_traits<std::vector<value_type>>;
+        CHECK_EQ(vector_traits_type::size, 1);
+        constexpr bool vec_same_type = std::is_same<typename vector_traits_type::type, std::vector<value_type>>::value;
+        CHECK_UNARY(vec_same_type);
+    }
+
+    void test_revert_simd_traits()
+    {
+        using traits_type = xsimd::revert_simd_traits<batch_type>;
+        CHECK_EQ(traits_type::size, batch_type::size);
+        constexpr bool same_type = std::is_same<value_type, typename traits_type::type>::value;
+        CHECK_UNARY(same_type);
+    }
+
+    void test_simd_return_type()
+    {
+        using rtype1 = xsimd::simd_return_type<value_type, float>;
+        constexpr bool res1 = std::is_same<rtype1, xsimd::batch<std::complex<float>>>::value;
+        CHECK_UNARY(res1);
+
+        using rtype2 = xsimd::simd_return_type<bool, value_type>;
+        constexpr bool res2 = std::is_same<rtype2, xsimd::batch_bool<typename value_type::value_type>>::value;
+        CHECK_UNARY(res2);
+    }
+
+    void test_mask_type()
+    {
+        using mtype0 = xsimd::mask_type_t<batch_type>;
+        constexpr bool res0 = std::is_same<mtype0, xsimd::batch_bool<xsimd::scalar_type_t<typename batch_type::real_batch::value_type>>>::value;
+        CHECK_UNARY(res0);
+
+        using mtype1 = xsimd::mask_type_t<value_type>;
+        constexpr bool res1 = std::is_same<mtype1, bool>::value;
+        CHECK_UNARY(res1);
+    }
+};
+
+TEST_CASE_TEMPLATE("[complex traits]", B, BATCH_COMPLEX_TYPES)
+{
+    complex_traits_test<B> Test;
+
+    SUBCASE("simd_traits")
+    {
+        Test.test_simd_traits();
+    }
+
+    SUBCASE("revert_simd_traits")
+    {
+        Test.test_revert_simd_traits();
+    }
+
+    SUBCASE("simd_return_type")
+    {
+        Test.test_simd_return_type();
+    }
+
+    SUBCASE("mask_type")
+    {
+        Test.test_mask_type();
+    }
+}
+#endif

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

@@ -0,0 +1,208 @@
+/***************************************************************************
+ * 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 trigonometric_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 ainput;
+    vector_type atan_input;
+    vector_type expected;
+    vector_type res;
+
+    trigonometric_test()
+    {
+        nb_input = size * 10000;
+        input.resize(nb_input);
+        ainput.resize(nb_input);
+        atan_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            input[i] = value_type(0.) + i * value_type(80.) / nb_input;
+            ainput[i] = value_type(-1.) + value_type(2.) * i / nb_input;
+            atan_input[i] = value_type(-10.) + i * value_type(20.) / nb_input;
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_trigonometric_functions()
+    {
+        // sin
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::sin(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = sin(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("sin");
+            CHECK_EQ(diff, 0);
+        }
+        // cos
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::cos(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = cos(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("cos");
+            CHECK_EQ(diff, 0);
+        }
+        // sincos
+        {
+            vector_type expected2(nb_input), res2(nb_input);
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::sin(v); });
+            std::transform(input.cbegin(), input.cend(), expected2.begin(),
+                           [](const value_type& v)
+                           { return std::cos(v); });
+            batch_type in, out1, out2;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                std::tie(out1, out2) = sincos(in);
+                detail::store_batch(out1, res, i);
+                detail::store_batch(out2, res2, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("sincos(sin)");
+            CHECK_EQ(diff, 0);
+            diff = detail::get_nb_diff(res2, expected2);
+            INFO("sincos(cos)");
+            CHECK_EQ(diff, 0);
+        }
+        // tan
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::tan(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = tan(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("tan");
+            CHECK_EQ(diff, 0);
+        }
+    }
+
+    void test_reciprocal_functions()
+    {
+
+        // asin
+        {
+            std::transform(ainput.cbegin(), ainput.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::asin(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, ainput, i);
+                out = asin(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("asin");
+            CHECK_EQ(diff, 0);
+        }
+        // acos
+        {
+            std::transform(ainput.cbegin(), ainput.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::acos(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, ainput, i);
+                out = acos(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("acos");
+            CHECK_EQ(diff, 0);
+        }
+        // atan
+        {
+            std::transform(atan_input.cbegin(), atan_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::atan(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, atan_input, i);
+                out = atan(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("atan");
+            CHECK_EQ(diff, 0);
+        }
+        // atan2
+        {
+            std::transform(atan_input.cbegin(), atan_input.cend(), input.cbegin(), expected.begin(),
+                           [](const value_type& v, const value_type& r)
+                           { return std::atan2(v, r); });
+            batch_type in, rhs, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, atan_input, i);
+                detail::load_batch(rhs, input, i);
+                out = atan2(in, rhs);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("atan2");
+            CHECK_EQ(diff, 0);
+        }
+    }
+};
+
+TEST_CASE_TEMPLATE("[trigonometric]", B, BATCH_FLOAT_TYPES)
+{
+    trigonometric_test<B> Test;
+    SUBCASE("trigonometric")
+    {
+        Test.test_trigonometric_functions();
+    }
+
+    SUBCASE("reciprocal")
+    {
+        Test.test_reciprocal_functions();
+    }
+}
+#endif