sequenzo 0.1.31__cp310-cp310-macosx_10_9_x86_64.whl

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

@@ -0,0 +1,248 @@
+/***************************************************************************
+ * 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 conversion_test
+{
+    static constexpr size_t N = CP::size;
+    static constexpr size_t A = CP::alignment;
+
+    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 uint8_batch = xsimd::batch<uint8_t>;
+    using uint16_batch = xsimd::batch<uint16_t>;
+    using uint32_batch = xsimd::batch<uint32_t>;
+    using uint64_batch = xsimd::batch<uint64_t>;
+
+    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>>;
+
+    using uint8_vector = std::vector<uint8_t, xsimd::aligned_allocator<uint8_t, A>>;
+
+    /*int32_batch i32pos;
+    int32_batch i32neg;
+    int64_batch i64pos;
+    int64_batch i64neg;
+    float_batch fpos;
+    float_batch fneg;
+    double_batch dpos;
+    double_batch dneg;*/
+
+    int32_vector fposres;
+    int32_vector fnegres;
+    int64_vector dposres;
+    int64_vector dnegres;
+    float_vector i32posres;
+    float_vector i32negres;
+    double_vector i64posres;
+    double_vector i64negres;
+
+    uint8_vector ui8res;
+
+    conversion_test()
+        : fposres(2 * N, 7)
+        , fnegres(2 * N, -6)
+        , dposres(N, 5)
+        , dnegres(N, -1)
+        , i32posres(2 * N, float(2))
+        , i32negres(2 * N, float(-3))
+        , i64posres(N, double(2))
+        , i64negres(N, double(-3))
+        , ui8res(8 * N, 4)
+    {
+    }
+
+    void test_to_int32()
+    {
+        float_batch fpos(float(7.4)), fneg(float(-6.2));
+        int32_vector fvres(int32_batch::size);
+        {
+            int32_batch fbres = to_int(fpos);
+            fbres.store_aligned(fvres.data());
+            INFO("to_int(positive float)");
+            CHECK_VECTOR_EQ(fvres, fposres);
+        }
+        {
+            int32_batch fbres = to_int(fneg);
+            fbres.store_aligned(fvres.data());
+            INFO("to_int(negative float)");
+            CHECK_VECTOR_EQ(fvres, fnegres);
+        }
+    }
+
+    void test_to_int64()
+    {
+        double_batch dpos(double(5.4)), dneg(double(-1.2));
+        int64_vector dvres(int64_batch::size);
+        {
+            int64_batch dbres = to_int(dpos);
+            dbres.store_aligned(dvres.data());
+            INFO("to_int(positive double)");
+            CHECK_VECTOR_EQ(dvres, dposres);
+        }
+        {
+            int64_batch dbres = to_int(dneg);
+            dbres.store_aligned(dvres.data());
+            INFO("to_int(negative double)");
+            CHECK_VECTOR_EQ(dvres, dnegres);
+        }
+    }
+
+    void test_to_float()
+    {
+        int32_batch i32pos(2), i32neg(-3);
+        float_vector i32vres(float_batch::size);
+        {
+            float_batch i32bres = to_float(i32pos);
+            i32bres.store_aligned(i32vres.data());
+            INFO("to_float(positive int32)");
+            CHECK_VECTOR_EQ(i32vres, i32posres);
+        }
+        {
+            float_batch i32bres = to_float(i32neg);
+            i32bres.store_aligned(i32vres.data());
+            INFO("to_float(negative int32)");
+            CHECK_VECTOR_EQ(i32vres, i32negres);
+        }
+    }
+
+    void test_to_double()
+    {
+        int64_batch i64pos(2), i64neg(-3);
+        double_vector i64vres(double_batch::size);
+        {
+            double_batch i64bres = to_float(i64pos);
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_float(positive int64)");
+            CHECK_VECTOR_EQ(i64vres, i64posres);
+        }
+        {
+            double_batch i64bres = to_float(i64neg);
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_float(negative int64)");
+            CHECK_VECTOR_EQ(i64vres, i64negres);
+        }
+    }
+
+    void test_u8_casting()
+    {
+        uint8_batch ui8tmp(4);
+        uint8_vector ui8vres(uint8_batch::size);
+        {
+            uint16_batch ui16casting = xsimd::bitwise_cast<uint16_t>(ui8tmp);
+            uint8_batch ui8casting = xsimd::bitwise_cast<uint8_t>(ui16casting);
+            ui8casting.store_aligned(ui8vres.data());
+            INFO("u8_to_16");
+            CHECK_VECTOR_EQ(ui8vres, ui8res);
+        }
+        {
+            uint32_batch ui32casting = xsimd::bitwise_cast<uint32_t>(ui8tmp);
+            uint8_batch ui8casting = xsimd::bitwise_cast<uint8_t>(ui32casting);
+            ui8casting.store_aligned(ui8vres.data());
+            INFO("u8_to_32");
+            CHECK_VECTOR_EQ(ui8vres, ui8res);
+        }
+        {
+            uint64_batch ui64casting = xsimd::bitwise_cast<uint64_t>(ui8tmp);
+            uint8_batch ui8casting = xsimd::bitwise_cast<uint8_t>(ui64casting);
+            ui8casting.store_aligned(ui8vres.data());
+            INFO("u8_to_64");
+            CHECK_VECTOR_EQ(ui8vres, ui8res);
+        }
+    }
+};
+
+TEST_CASE_TEMPLATE("[conversion]", B, CONVERSION_TYPES)
+{
+    conversion_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();
+    }
+
+    SUBCASE("u8_casting")
+    {
+        Test.test_u8_casting();
+    }
+}
+
+template <class T>
+struct sign_conversion_test
+{
+
+    using unsigned_type = T;
+    using signed_type = typename std::make_signed<T>::type;
+
+    void test_to_signed()
+    {
+        unsigned_type unsigned_value = 3;
+        signed_type signed_value = (signed_type)unsigned_value;
+        xsimd::batch<unsigned_type> unsigned_batch(unsigned_value);
+        auto signed_batch = xsimd::batch_cast<signed_type>(unsigned_batch);
+        CHECK_EQ(unsigned_batch.get(0), unsigned_value);
+        CHECK_EQ(signed_batch.get(0), signed_value);
+    }
+
+    void test_to_unsigned()
+    {
+        signed_type signed_value = 3;
+        unsigned_type unsigned_value = (unsigned_type)signed_value;
+        xsimd::batch<signed_type> signed_batch(signed_value);
+        auto unsigned_batch = xsimd::batch_cast<unsigned_type>(signed_batch);
+        CHECK_EQ(signed_batch.get(0), signed_value);
+        CHECK_EQ(unsigned_batch.get(0), unsigned_value);
+    }
+};
+
+TEST_CASE_TEMPLATE("[conversion]", T, uint8_t, uint16_t, uint32_t, uint64_t)
+{
+    sign_conversion_test<T> Test;
+
+    SUBCASE("to_signed")
+    {
+        Test.test_to_signed();
+    }
+
+    SUBCASE("to_unsigned")
+    {
+        Test.test_to_unsigned();
+    }
+}
+
+#endif
+#endif

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

@@ -0,0 +1,28 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+#ifdef __STSE2__
+
+#define XSIMD_DEFAULT_ARCH xsimd::sse2
+#include "xsimd/xsimd.hpp"
+
+#include "test_utils.hpp"
+
+// Could be different than sse2 if we compile for other architecture avx
+static_assert(std::is_same<xsimd::default_arch, xsimd::sse2>::value, "default arch correctly hooked");
+
+#else
+
+#undef XSIMD_DEFAULT_ARCH
+#define XSIMD_DEFAULT_ARCH xsimd::unsupported
+
+#include "xsimd/xsimd.hpp"
+
+#endif

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

@@ -0,0 +1,170 @@
+/***************************************************************************
+ * 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 error_gamma_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 gamma_input;
+    vector_type gamma_neg_input;
+    vector_type expected;
+    vector_type res;
+
+    error_gamma_test()
+    {
+        nb_input = size * 10000;
+        input.resize(nb_input);
+        gamma_input.resize(nb_input);
+        gamma_neg_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            input[i] = value_type(-1.5) + i * value_type(3) / nb_input;
+            gamma_input[i] = value_type(0.5) + i * value_type(3) / nb_input;
+            gamma_neg_input[i] = value_type(-3.99) + i * value_type(0.9) / nb_input;
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_error_functions()
+    {
+        // erf
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::erf(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = erf(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("erf");
+            CHECK_EQ(diff, 0);
+        }
+        // erfc
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::erfc(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = erfc(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("erfc");
+            CHECK_EQ(diff, 0);
+        }
+    }
+
+    void test_gamma_functions()
+    {
+        // tgamma
+        {
+            std::transform(gamma_input.cbegin(), gamma_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::tgamma(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, gamma_input, i);
+                out = tgamma(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("tgamma");
+            CHECK_EQ(diff, 0);
+        }
+        // tgamma (negative input)
+        {
+            std::transform(gamma_neg_input.cbegin(), gamma_neg_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::tgamma(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, gamma_neg_input, i);
+                out = tgamma(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("tgamma (negative input)");
+            CHECK_EQ(diff, 0);
+        }
+        // lgamma
+        {
+            std::transform(gamma_input.cbegin(), gamma_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::lgamma(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, gamma_input, i);
+                out = lgamma(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("lgamma");
+            CHECK_EQ(diff, 0);
+        }
+#if !(XSIMD_WITH_AVX && !XSIMD_WITH_AVX2)
+
+        // tgamma (negative input)
+        {
+            std::transform(gamma_neg_input.cbegin(), gamma_neg_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::lgamma(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, gamma_neg_input, i);
+                out = lgamma(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("lgamma (negative input)");
+            CHECK_EQ(diff, 0);
+        }
+#endif
+    }
+};
+
+TEST_CASE_TEMPLATE("[error gamma]", B, BATCH_FLOAT_TYPES)
+{
+    error_gamma_test<B> Test;
+
+    SUBCASE("error")
+    {
+        Test.test_error_functions();
+    }
+
+    SUBCASE("gamma")
+    {
+        Test.test_gamma_functions();
+    }
+}
+#endif

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

@@ -0,0 +1,32 @@
+/***************************************************************************
+ * 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
+
+namespace xsimd
+{
+
+    template class batch<char>;
+    template class batch<unsigned char>;
+    template class batch<signed char>;
+    template class batch<unsigned short>;
+    template class batch<signed short>;
+    template class batch<unsigned int>;
+    template class batch<signed int>;
+    template class batch<unsigned long>;
+    template class batch<signed long>;
+    template class batch<float>;
+#if !XSIMD_WITH_NEON || XSIMD_WITH_NEON64
+    template class batch<double>;
+#endif
+}
+#endif

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

@@ -0,0 +1,202 @@
+/***************************************************************************
+ * 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 exponential_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 exp_input;
+    vector_type log_input;
+    vector_type expected;
+    vector_type res;
+
+    exponential_test()
+    {
+        nb_input = size * 10000;
+        exp_input.resize(nb_input);
+        log_input.resize(nb_input);
+        for (size_t i = 0; i < nb_input; ++i)
+        {
+            exp_input[i] = value_type(-1.5) + i * value_type(3) / nb_input;
+            log_input[i] = value_type(0.001 + i * 100 / nb_input);
+        }
+        expected.resize(nb_input);
+        res.resize(nb_input);
+    }
+
+    void test_exponential_functions()
+    {
+        // exp
+        {
+            std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+            INFO("exp");
+            CHECK_EQ(diff, 0);
+        }
+
+        // exp2
+        {
+            std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::exp2(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, exp_input, i);
+                out = exp2(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("exp2");
+            CHECK_EQ(diff, 0);
+        }
+
+        // exp10
+        {
+            std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                           /* imprecise but enough for testing version of exp10 */
+                           [](const value_type& v)
+                           { return exp(log(10) * v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_input; i += size)
+            {
+                detail::load_batch(in, exp_input, i);
+                out = exp10(in);
+                detail::store_batch(out, res, i);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            INFO("exp10");
+            CHECK_EQ(diff, 0);
+        }
+
+        // expm1
+        {
+            std::transform(exp_input.cbegin(), exp_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+            INFO("expm1");
+            CHECK_EQ(diff, 0);
+        }
+    }
+
+    void test_log_functions()
+    {
+        // log
+        {
+            std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+            INFO("log");
+            CHECK_EQ(diff, 0);
+        }
+
+        // log2
+        {
+            std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+            INFO("log2");
+            CHECK_EQ(diff, 0);
+        }
+
+        // log10
+        {
+            std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+            INFO("log10");
+            CHECK_EQ(diff, 0);
+        }
+
+        // log1p
+        {
+            std::transform(log_input.cbegin(), log_input.cend(), expected.begin(),
+                           [](const value_type& v)
+                           { return std::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);
+        }
+    }
+};
+
+TEST_CASE_TEMPLATE("[exponential]", B, BATCH_FLOAT_TYPES)
+{
+    exponential_test<B> Test;
+
+    SUBCASE("exp")
+    {
+        Test.test_exponential_functions();
+    }
+
+    SUBCASE("log")
+    {
+        Test.test_log_functions();
+    }
+}
+#endif