sequenzo 0.1.24__cp311-cp311-macosx_10_9_x86_64.whl

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

@@ -0,0 +1,222 @@
+/***************************************************************************
+ * 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"
+
+#if !XSIMD_WITH_NEON || XSIMD_WITH_NEON64
+template <class CP>
+struct bitwise_cast_test
+{
+    static constexpr size_t N = CP::size;
+
+    using int32_batch = xsimd::batch<int32_t>;
+    using int64_batch = xsimd::batch<int64_t>;
+    using float_batch = xsimd::batch<float>;
+    using double_batch = xsimd::batch<double>;
+
+    using int32_vector = std::vector<int32_t, xsimd::default_allocator<int32_t>>;
+    using int64_vector = std::vector<int64_t, xsimd::default_allocator<int64_t>>;
+    using float_vector = std::vector<float, xsimd::default_allocator<float>>;
+    using double_vector = std::vector<double, xsimd::default_allocator<double>>;
+
+    int32_vector ftoi32_res;
+    int32_vector dtoi32_res;
+    int64_vector ftoi64_res;
+    int64_vector dtoi64_res;
+    float_vector i32tof_res;
+    float_vector i64tof_res;
+    float_vector dtof_res;
+    double_vector i32tod_res;
+    double_vector i64tod_res;
+    double_vector ftod_res;
+
+    bitwise_cast_test()
+        : ftoi32_res(2 * N)
+        , dtoi32_res(2 * N)
+        , ftoi64_res(N)
+        , dtoi64_res(N)
+        , i32tof_res(2 * N)
+        , i64tof_res(2 * N)
+        , dtof_res(2 * N)
+        , i32tod_res(N)
+        , i64tod_res(N)
+        , ftod_res(N)
+    {
+        {
+            int32_batch input = i32_input();
+            bitcast b;
+            b.i32[0] = input.get(0);
+            b.i32[1] = input.get(1);
+            std::fill(i32tof_res.begin(), i32tof_res.end(), b.f[0]);
+            std::fill(i32tod_res.begin(), i32tod_res.end(), b.d);
+        }
+        {
+            int64_batch input = i64_input();
+            bitcast b;
+            b.i64 = input.get(0);
+            std::fill(i64tod_res.begin(), i64tod_res.end(), b.d);
+            for (size_t i = 0; i < N; ++i)
+            {
+                i64tof_res[2 * i] = b.f[0];
+                i64tof_res[2 * i + 1] = b.f[1];
+            }
+        }
+        {
+            float_batch input = f_input();
+            bitcast b;
+            b.f[0] = input.get(0);
+            b.f[1] = input.get(1);
+            std::fill(ftoi32_res.begin(), ftoi32_res.end(), b.i32[0]);
+            std::fill(ftoi64_res.begin(), ftoi64_res.end(), b.i64);
+            std::fill(ftod_res.begin(), ftod_res.end(), b.d);
+        }
+        {
+            double_batch input = d_input();
+            bitcast b;
+            b.d = input.get(0);
+            // std::fill(dtoi32_res.begin(), dtoi32_res.end(), b.i32[0]);
+            std::fill(dtoi64_res.begin(), dtoi64_res.end(), b.i64);
+            for (size_t i = 0; i < N; ++i)
+            {
+                dtoi32_res[2 * i] = b.i32[0];
+                dtoi32_res[2 * i + 1] = b.i32[1];
+                dtof_res[2 * i] = b.f[0];
+                dtof_res[2 * i + 1] = b.f[1];
+            }
+        }
+    }
+
+    void test_to_int32()
+    {
+        int32_vector i32vres(int32_batch::size);
+        {
+            int32_batch i32bres = xsimd::bitwise_cast<int32_t>(f_input());
+            i32bres.store_aligned(i32vres.data());
+            INFO("to_int32(float)");
+            CHECK_VECTOR_EQ(i32vres, ftoi32_res);
+        }
+        {
+            int32_batch i32bres = xsimd::bitwise_cast<int32_t>(d_input());
+            i32bres.store_aligned(i32vres.data());
+            INFO("to_int32(double)");
+            CHECK_VECTOR_EQ(i32vres, dtoi32_res);
+        }
+    }
+
+    void test_to_int64()
+    {
+        int64_vector i64vres(int64_batch::size);
+        {
+            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(f_input());
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_int64(float)");
+            CHECK_VECTOR_EQ(i64vres, ftoi64_res);
+        }
+        {
+            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(d_input());
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_int64(double)");
+            CHECK_VECTOR_EQ(i64vres, dtoi64_res);
+        }
+    }
+
+    void test_to_float()
+    {
+        float_vector fvres(float_batch::size);
+        {
+            float_batch fbres = xsimd::bitwise_cast<float>(i32_input());
+            fbres.store_aligned(fvres.data());
+            INFO("to_float(int32_t)");
+            CHECK_VECTOR_EQ(fvres, i32tof_res);
+        }
+        {
+            float_batch fbres = xsimd::bitwise_cast<float>(i64_input());
+            fbres.store_aligned(fvres.data());
+            INFO("to_float(int64_t)");
+            CHECK_VECTOR_EQ(fvres, i64tof_res);
+        }
+        {
+            float_batch fbres = xsimd::bitwise_cast<float>(d_input());
+            fbres.store_aligned(fvres.data());
+            INFO("to_float(double)");
+            CHECK_VECTOR_EQ(fvres, dtof_res);
+        }
+    }
+
+    void test_to_double()
+    {
+        double_vector dvres(double_batch::size);
+        {
+            double_batch dbres = xsimd::bitwise_cast<double>(i32_input());
+            dbres.store_aligned(dvres.data());
+            INFO("to_double(int32_t)");
+            CHECK_VECTOR_EQ(dvres, i32tod_res);
+        }
+        {
+            double_batch dbres = xsimd::bitwise_cast<double>(i64_input());
+            dbres.store_aligned(dvres.data());
+            INFO("to_double(int64_t)");
+            CHECK_VECTOR_EQ(dvres, i64tod_res);
+        }
+        {
+            double_batch dbres = xsimd::bitwise_cast<double>(f_input());
+            dbres.store_aligned(dvres.data());
+            INFO("to_double(float)");
+            CHECK_VECTOR_EQ(dvres, ftod_res);
+        }
+    }
+
+private:
+    int32_batch i32_input() const
+    {
+        return int32_batch(2);
+    }
+
+    int64_batch i64_input() const
+    {
+        return int64_batch(2);
+    }
+
+    float_batch f_input() const
+    {
+        return float_batch(3.);
+    }
+
+    double_batch d_input() const
+    {
+        return double_batch(2.5e17);
+    }
+
+    union bitcast
+    {
+        float f[2];
+        int32_t i32[2];
+        int64_t i64;
+        double d;
+    };
+};
+
+TEST_CASE_TEMPLATE("[bitwise cast]", B, CONVERSION_TYPES)
+{
+    bitwise_cast_test<B> Test;
+    SUBCASE("to_int32") { Test.test_to_int32(); }
+
+    SUBCASE("to_int64") { Test.test_to_int64(); }
+
+    SUBCASE("to_float") { Test.test_to_float(); }
+
+    SUBCASE("to_double") { Test.test_to_double(); }
+}
+#endif
+#endif

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

@@ -0,0 +1,226 @@
+/***************************************************************************
+ * 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_exponential_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 exp_input;
+    vector_type huge_exp_input;
+    vector_type log_input;
+    vector_type expected;
+    vector_type res;
+
+    complex_exponential_test()
+    {
+        nb_input = 10000 * size;
+        exp_input.resize(nb_input);
+        huge_exp_input.resize(nb_input);
+        log_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            exp_input[i] = value_type(real_value_type(-1.5) + i * real_value_type(3) / nb_input,
+                                      real_value_type(-1.3) + i * real_value_type(2) / nb_input);
+            huge_exp_input[i] = value_type(real_value_type(0), real_value_type(102.12) + i * real_value_type(100.) / nb_input);
+            log_input[i] = value_type(real_value_type(0.001 + i * 100 / nb_input),
+                                      real_value_type(0.002 + i * 110 / nb_input));
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_exp()
+    {
+        std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::exp; return exp(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, exp_input, i);
+            out = exp(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_expm1()
+    {
+        std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using xsimd::expm1; return expm1(v); });
+
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, exp_input, i);
+            out = expm1(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_huge_exp()
+    {
+        std::transform(huge_exp_input.cbegin(), huge_exp_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::exp; return exp(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, huge_exp_input, i);
+            out = exp(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_log()
+    {
+        std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::log; return log(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, log_input, i);
+            out = log(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_log2()
+    {
+        std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using xsimd::log2; return log2(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, log_input, i);
+            out = log2(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_log10()
+    {
+        std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::log10; return log10(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, log_input, i);
+            out = log10(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_log1p()
+    {
+        std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using xsimd::log1p; return log1p(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, log_input, i);
+            out = log1p(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_sign()
+    {
+        std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using xsimd::sign; return sign(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, log_input, i);
+            out = sign(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+};
+
+TEST_CASE_TEMPLATE("[complex exponential]", B, BATCH_COMPLEX_TYPES)
+{
+    complex_exponential_test<B> Test;
+
+    SUBCASE("exp")
+    {
+        Test.test_exp();
+    }
+
+    SUBCASE("expm1")
+    {
+        Test.test_expm1();
+    }
+
+    SUBCASE("huge_exp")
+    {
+        Test.test_huge_exp();
+    }
+
+    SUBCASE("log")
+    {
+        Test.test_log();
+    }
+
+    SUBCASE("log2")
+    {
+        Test.test_log2();
+    }
+
+    SUBCASE("log10")
+    {
+        Test.test_log10();
+    }
+
+    SUBCASE("log1p")
+    {
+        Test.test_log1p();
+    }
+
+    SUBCASE("sign")
+    {
+        Test.test_sign();
+    }
+}
+#endif

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

@@ -0,0 +1,183 @@
+/***************************************************************************
+ * 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_hyperbolic_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 acosh_input;
+    vector_type atanh_input;
+    vector_type expected;
+    vector_type res;
+
+    complex_hyperbolic_test()
+    {
+        nb_input = 10000 * size;
+        input.resize(nb_input);
+        acosh_input.resize(nb_input);
+        atanh_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            input[i] = value_type(real_value_type(-1.5) + i * real_value_type(3) / nb_input,
+                                  real_value_type(-1.3) + i * real_value_type(2.5) / nb_input);
+            acosh_input[i] = value_type(real_value_type(1.) + i * real_value_type(3) / nb_input,
+                                        real_value_type(1.2) + i * real_value_type(2.7) / nb_input);
+            atanh_input[i] = value_type(real_value_type(-0.95) + i * real_value_type(1.9) / nb_input,
+                                        real_value_type(-0.94) + i * real_value_type(1.8) / nb_input);
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_sinh()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::sinh; return sinh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, input, i);
+            out = sinh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_cosh()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::cosh; return cosh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, input, i);
+            out = cosh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_tanh()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::tanh; return tanh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, input, i);
+            out = tanh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_asinh()
+    {
+        std::transform(input.cbegin(), input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::asinh; return asinh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, input, i);
+            out = asinh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_acosh()
+    {
+        std::transform(acosh_input.cbegin(), acosh_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::acosh; return acosh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, acosh_input, i);
+            out = acosh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_atanh()
+    {
+        std::transform(atanh_input.cbegin(), atanh_input.cend(), expected.begin(),
+                       [](const value_type& v)
+                       { using std::atanh; return atanh(v); });
+        batch_type in, out;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(in, atanh_input, i);
+            out = atanh(in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff(res, expected);
+        CHECK_EQ(diff, 0);
+    }
+};
+
+TEST_CASE_TEMPLATE("[complex hyperbolic]", B, BATCH_COMPLEX_TYPES)
+{
+    complex_hyperbolic_test<B> Test;
+    SUBCASE("sinh")
+    {
+        Test.test_sinh();
+    }
+
+    SUBCASE("cosh")
+    {
+        Test.test_cosh();
+    }
+
+    SUBCASE("tanh")
+    {
+        Test.test_tanh();
+    }
+
+    SUBCASE("asinh")
+    {
+        Test.test_asinh();
+    }
+
+    SUBCASE("acosh")
+    {
+        Test.test_acosh();
+    }
+
+    SUBCASE("atanh")
+    {
+        Test.test_atanh();
+    }
+}
+#endif