sequenzo 0.1.21__cp312-cp312-macosx_11_0_arm64.whl

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

@@ -0,0 +1,265 @@
+/***************************************************************************
+ * 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 complex_power_test
+{
+    using batch_type = B;
+    using real_batch_type = typename B::real_batch;
+    using value_type = typename B::value_type;
+    using real_value_type = typename value_type::value_type;
+    static constexpr size_t size = B::size;
+    using vector_type = std::vector<value_type>;
+    using real_vector_type = std::vector<real_value_type>;
+
+    size_t nb_input;
+    real_vector_type lhs_p;
+    vector_type lhs_nn;
+    vector_type lhs_pn;
+    vector_type lhs_np;
+    vector_type lhs_pp;
+    vector_type rhs;
+    vector_type expected;
+    vector_type res;
+
+    complex_power_test()
+    {
+        nb_input = 10000 * size;
+        lhs_p.resize(nb_input);
+        lhs_nn.resize(nb_input);
+        lhs_pn.resize(nb_input);
+        lhs_np.resize(nb_input);
+        lhs_pp.resize(nb_input);
+        rhs.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            real_value_type real = (real_value_type(i) / 4 + real_value_type(1.2) * std::sqrt(real_value_type(i + 0.25))) / 100;
+            real_value_type imag = (real_value_type(i) / 7 + real_value_type(1.7) * std::sqrt(real_value_type(i + 0.37))) / 100;
+            lhs_p[i] = real;
+            lhs_nn[i] = value_type(-real, -imag);
+            lhs_pn[i] = value_type(real, -imag);
+            lhs_np[i] = value_type(-real, imag);
+            lhs_pp[i] = value_type(real, imag);
+            rhs[i] = value_type(real_value_type(10.2) / (i + 2) + real_value_type(0.25),
+                                real_value_type(9.1) / (i + 3) + real_value_type(0.45));
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_abs()
+    {
+        real_vector_type real_expected(nb_input), real_res(nb_input);
+        std::transform(lhs_np.cbegin(), lhs_np.cend(), real_expected.begin(),
+                       [](const value_type& v)
+                       { using std::abs; return abs(v); });
+        batch_type in;
+        real_batch_type out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_np, i);
+            out = abs(in);
+            detail::store_batch(out, real_res, i);
+        }
+        size_t diff = detail::get_nb_diff(real_res, real_expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_arg()
+    {
+        real_vector_type real_expected(nb_input), real_res(nb_input);
+        std::transform(lhs_np.cbegin(), lhs_np.cend(), real_expected.begin(),
+                       [](const value_type& v)
+                       { using std::arg; return arg(v); });
+        batch_type in;
+        real_batch_type out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_np, i);
+            out = arg(in);
+            detail::store_batch(out, real_res, i);
+        }
+        size_t diff = detail::get_nb_diff(real_res, real_expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_pow()
+    {
+        std::transform(lhs_np.cbegin(), lhs_np.cend(), rhs.cbegin(), expected.begin(),
+                       [](const value_type& l, const value_type& r)
+                       { using std::pow; return 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_np, i);
+            detail::load_batch(rhs_in, rhs, i);
+            out = pow(lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff_near(res, expected, std::numeric_limits<real_value_type>::epsilon());
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_pow_real_complex()
+    {
+        std::transform(lhs_p.cbegin(), lhs_p.cend(), lhs_pp.cbegin(), expected.begin(),
+                       [](const real_value_type& l, const value_type& r)
+                       { using std::pow; return pow(l, r); });
+        batch_type rhs_in, out;
+        real_batch_type lhs_in;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_p, i);
+            detail::load_batch(rhs_in, lhs_pp, i);
+            out = pow(lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff_near(res, expected, std::numeric_limits<real_value_type>::epsilon());
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_pow_complex_real()
+    {
+        std::transform(lhs_pp.cbegin(), lhs_pp.cend(), lhs_p.cbegin(), expected.begin(),
+                       [](const value_type& l, const real_value_type& r)
+                       { using std::pow; return pow(l, r); });
+        batch_type rhs_in, out;
+        real_batch_type lhs_in;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_p, i);
+            detail::load_batch(rhs_in, lhs_pp, i);
+            out = pow(lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff_near(res, expected, std::numeric_limits<real_value_type>::epsilon());
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sqrt_nn()
+    {
+        std::transform(lhs_nn.cbegin(), lhs_nn.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sqrt; return sqrt(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_nn, i);
+            out = sqrt(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sqrt_pn()
+    {
+        std::transform(lhs_pn.cbegin(), lhs_pn.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sqrt; return sqrt(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_pn, i);
+            out = sqrt(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sqrt_np()
+    {
+        std::transform(lhs_np.cbegin(), lhs_np.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sqrt; return sqrt(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_np, i);
+            out = sqrt(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sqrt_pp()
+    {
+        std::transform(lhs_pp.cbegin(), lhs_pp.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sqrt; return sqrt(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, lhs_pp, i);
+            out = sqrt(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+};
+
+TEST_CASE_TEMPLATE("[complex power]", B, BATCH_COMPLEX_TYPES)
+{
+    complex_power_test<B> Test;
+    SUBCASE("abs")
+    {
+        Test.test_abs();
+    }
+
+    SUBCASE("arg")
+    {
+        Test.test_arg();
+    }
+
+    SUBCASE("pow")
+    {
+        Test.test_pow();
+    }
+
+    SUBCASE("pow real complex")
+    {
+        Test.test_pow_real_complex();
+    }
+
+    SUBCASE("pow complex real")
+    {
+        Test.test_pow_complex_real();
+    }
+
+    SUBCASE("sqrt_nn")
+    {
+        Test.test_sqrt_nn();
+    }
+
+    SUBCASE("sqrt_pn")
+    {
+        Test.test_sqrt_pn();
+    }
+
+    SUBCASE("sqrt_np")
+    {
+        Test.test_sqrt_np();
+    }
+
+    SUBCASE("sqrt_pp")
+    {
+        Test.test_sqrt_pp();
+    }
+}
+#endif

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

@@ -0,0 +1,236 @@
+/***************************************************************************
+ * 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 complex_trigonometric_test
+{
+    using batch_type = B;
+    using real_batch_type = typename B::real_batch;
+    using value_type = typename B::value_type;
+    using real_value_type = typename value_type::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;
+
+    complex_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(real_value_type(0.) + i * real_value_type(80.) / nb_input,
+                                  real_value_type(0.1) + i * real_value_type(56.) / nb_input);
+            ainput[i] = value_type(real_value_type(-1.) + real_value_type(2.) * i / nb_input,
+                                   real_value_type(-1.1) + real_value_type(2.1) * i / nb_input);
+            atan_input[i] = value_type(real_value_type(-10.) + i * real_value_type(20.) / nb_input,
+                                       real_value_type(-9.) + i * real_value_type(21.) / nb_input);
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_sin()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sin; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_cos()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::cos; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sincos()
+    {
+        vector_type expected2(nb_input), res2(nb_input);
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sin; return sin(v); });
+        std::transform(input.cbegin(), input.cend(), expected2.begin(),
+                       [](const value_type& v)
+                       { using std::cos; return 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);
+        CHECK_EQ(diff, 0);
+        diff = detail::get_nb_diff(res2, expected2);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_tan()
+    {
+        test_conditional_tan<real_value_type>();
+    }
+
+    void test_asin()
+    {
+        std::transform(ainput.cbegin(), ainput.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::asin; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_acos()
+    {
+        std::transform(ainput.cbegin(), ainput.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::acos; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_atan()
+    {
+        std::transform(atan_input.cbegin(), atan_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::atan; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+private:
+    void test_tan_impl()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::tan; return 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);
+        CHECK_EQ(diff, 0);
+    }
+
+    template <class T, typename std::enable_if<!std::is_same<T, float>::value, int>::type = 0>
+    void test_conditional_tan()
+    {
+        test_tan_impl();
+    }
+
+    template <class T, typename std::enable_if<std::is_same<T, float>::value, int>::type = 0>
+    void test_conditional_tan()
+    {
+#if (XSIMD_ARM_INSTR_SET >= XSIMD_ARM7_NEON_VERSION)
+#if DEBUG_ACCURACY
+        test_tan_impl();
+#endif
+#else
+        test_tan_impl();
+#endif
+    }
+};
+
+TEST_CASE_TEMPLATE("[complex trigonometric]", B, BATCH_COMPLEX_TYPES)
+{
+    complex_trigonometric_test<B> Test;
+    SUBCASE("sin")
+    {
+        Test.test_sin();
+    }
+
+    SUBCASE("cos")
+    {
+        Test.test_cos();
+    }
+
+    SUBCASE("sincos")
+    {
+        Test.test_sincos();
+    }
+
+    SUBCASE("tan")
+    {
+        Test.test_tan();
+    }
+
+    SUBCASE("asin")
+    {
+        Test.test_asin();
+    }
+
+    SUBCASE("acos")
+    {
+        Test.test_acos();
+    }
+
+    SUBCASE("atan")
+    {
+        Test.test_atan();
+    }
+}
+#endif