sequenzo 0.1.17__cp39-cp39-win_amd64.whl → 0.1.18__cp39-cp39-win_amd64.whl

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/types/xsimd_vsx_register.hpp

@@ -0,0 +1,77 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#ifndef XSIMD_VSX_REGISTER_HPP
+#define XSIMD_VSX_REGISTER_HPP
+
+#include "./xsimd_common_arch.hpp"
+#include "./xsimd_register.hpp"
+
+#if XSIMD_WITH_VSX
+#include <altivec.h>
+#endif
+
+namespace xsimd
+{
+    /**
+     * @ingroup architectures
+     *
+     * VSX instructions
+     */
+    struct vsx : common
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_VSX; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr bool requires_alignment() noexcept { return true; }
+        static constexpr std::size_t alignment() noexcept { return 16; }
+        static constexpr char const* name() noexcept { return "vmx+vsx"; }
+    };
+
+#if XSIMD_WITH_VSX
+    namespace types
+    {
+
+#define XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(T, Tb)                  \
+    template <>                                                      \
+    struct get_bool_simd_register<T, vsx>                            \
+    {                                                                \
+        struct type                                                  \
+        {                                                            \
+            using register_type = __vector __bool Tb;                \
+            register_type data;                                      \
+            type() = default;                                        \
+            type(register_type r)                                    \
+                : data(r)                                            \
+            {                                                        \
+            }                                                        \
+            operator register_type() const noexcept { return data; } \
+        };                                                           \
+    };                                                               \
+    XSIMD_DECLARE_SIMD_REGISTER(T, vsx, __vector T)
+
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(signed char, char);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(unsigned char, char);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(char, char);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(unsigned short, short);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(short, short);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(unsigned int, int);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(int, int);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(unsigned long, long);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(long, long);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(float, int);
+        XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER(double, long);
+
+#undef XSIMD_DECLARE_SIMD_BOOL_VSX_REGISTER
+    }
+#endif
+}
+
+#endif

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/xsimd.hpp

@@ -12,6 +12,12 @@
 #ifndef XSIMD_HPP
 #define XSIMD_HPP
 
+#if defined(__FAST_MATH__)
+#define XSIMD_NO_DENORMALS
+#define XSIMD_NO_INFINITIES
+#define XSIMD_NO_NANS
+#endif
+
 #if defined(__has_cpp_attribute)
 // if this check passes, then the compiler supports feature test macros
 #if __has_cpp_attribute(nodiscard) >= 201603L

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

@@ -14,6 +14,7 @@
 
 #include "test_utils.hpp"
 
+#ifndef __FAST_MATH__
 namespace detail
 {
     template <class T, bool is_int = std::is_integral<typename T::value_type>::value>
@@ -49,6 +50,7 @@ namespace detail
         }
     };
 }
+#endif
 
 template <class B>
 struct basic_math_test
@@ -120,6 +122,7 @@ struct basic_math_test
         CHECK_BATCH_EQ(res, expected);
     }
 
+#ifndef __FAST_MATH__
     void test_isfinite()
     {
         detail::infinity_tester<batch_type>::test_isfinite();
@@ -129,6 +132,7 @@ struct basic_math_test
     {
         detail::infinity_tester<batch_type>::test_isinf();
     }
+#endif
 
     void test_nextafter()
     {
@@ -170,8 +174,10 @@ TEST_CASE_TEMPLATE("[basic math tests]", B, BATCH_MATH_TYPES)
     SUBCASE("remainder") { Test.test_remainder(); }
     SUBCASE("fdim") { Test.test_fdim(); }
     SUBCASE("clip") { Test.test_clip(); }
+#ifndef __FAST_MATH__
     SUBCASE("isfinite") { Test.test_isfinite(); }
     SUBCASE("isinf") { Test.test_isinf(); }
+#endif
     SUBCASE("nextafter") { Test.test_nextafter(); }
 }
 #endif

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

@@ -152,6 +152,12 @@ struct batch_test
         }
     }
 
+    void test_first_element() const
+    {
+        batch_type res = batch_lhs();
+        CHECK_EQ(res.first(), lhs[0]);
+    }
+
     void test_arithmetic() const
     {
         // +batch
@@ -471,6 +477,11 @@ struct batch_test
             auto res = batch_lhs() < batch_rhs();
             INFO("batch < batch");
             CHECK_BATCH_EQ(res, expected);
+
+            std::fill(expected.begin(), expected.end(), false);
+            res = batch_lhs() < batch_lhs();
+            INFO("batch < (self)");
+            CHECK_BATCH_EQ(res, expected);
         }
         // batch < scalar
         {
@@ -496,6 +507,11 @@ struct batch_test
             auto res = batch_lhs() <= batch_rhs();
             INFO("batch <= batch");
             CHECK_BATCH_EQ(res, expected);
+
+            std::fill(expected.begin(), expected.end(), true);
+            res = batch_lhs() <= batch_lhs();
+            INFO("batch < (self)");
+            CHECK_BATCH_EQ(res, expected);
         }
         // batch <= scalar
         {
@@ -521,6 +537,11 @@ struct batch_test
             auto res = batch_lhs() > batch_rhs();
             INFO("batch > batch");
             CHECK_BATCH_EQ(res, expected);
+
+            std::fill(expected.begin(), expected.end(), false);
+            res = batch_lhs() > batch_lhs();
+            INFO("batch > (self)");
+            CHECK_BATCH_EQ(res, expected);
         }
         // batch > scalar
         {
@@ -545,6 +566,11 @@ struct batch_test
             auto res = batch_lhs() >= batch_rhs();
             INFO("batch >= batch");
             CHECK_BATCH_EQ(res, expected);
+
+            std::fill(expected.begin(), expected.end(), true);
+            res = batch_lhs() >= batch_lhs();
+            INFO("batch >= (self)");
+            CHECK_BATCH_EQ(res, expected);
         }
         // batch >= scalar
         {
@@ -711,6 +737,20 @@ struct batch_test
             INFO("fnms");
             CHECK_BATCH_EQ(res, expected);
         }
+        // fmas
+        {
+            array_type expected;
+            for (std::size_t i = 0; i < expected.size(); ++i)
+            {
+                // even lanes: x*y - z, odd lanes: x*y + z
+                expected[i] = (i & 1u) == 0
+                    ? lhs[i] * rhs[i] - rhs[i]
+                    : lhs[i] * rhs[i] + rhs[i];
+            }
+            batch_type res = fmas(batch_lhs(), batch_rhs(), batch_rhs());
+            INFO("fmas");
+            CHECK_BATCH_EQ(res, expected);
+        }
     }
 
     void test_abs() const
@@ -800,6 +840,13 @@ struct batch_test
             INFO("reduce_min");
             CHECK_SCALAR_EQ(res, expected);
         }
+        // reduce_mul
+        {
+            value_type expected = std::accumulate(lhs.cbegin(), lhs.cend(), value_type(1), std::multiplies<value_type>());
+            value_type res = reduce_mul(batch_lhs());
+            INFO("reduce_mul");
+            CHECK_SCALAR_EQ(res, expected);
+        }
     }
 
     template <size_t N>
@@ -879,12 +926,12 @@ private:
         for (size_t i = 0; i < size; ++i)
         {
             bool negative_lhs = std::is_signed<T>::value && (i % 2 == 1);
-            lhs[i] = value_type(i) * (negative_lhs ? -10 : 10);
+            lhs[i] = value_type(i) * (negative_lhs ? -3 : 3);
             if (lhs[i] == value_type(0))
             {
                 lhs[i] += value_type(1);
             }
-            rhs[i] = value_type(i) + value_type(4);
+            rhs[i] = value_type(i) + value_type(2);
         }
         scalar = value_type(3);
     }
@@ -934,6 +981,11 @@ TEST_CASE_TEMPLATE("[batch]", B, BATCH_TYPES)
         Test.test_access_operator();
     }
 
+    SUBCASE("first element")
+    {
+        Test.test_first_element();
+    }
+
     SUBCASE("arithmetic")
     {
         Test.test_arithmetic();

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

@@ -381,6 +381,10 @@ struct batch_bool_test
             INFO("operator&");
             CHECK_BATCH_EQ(bool_g.half & bool_g.ihalf, bool_g.all_false);
         }
+        {
+            INFO("operator^");
+            CHECK_BATCH_EQ(bool_g.half ^ bool_g.all_true, bool_g.ihalf);
+        }
         // free function version
         {
             INFO("bitwise_not");
@@ -394,6 +398,10 @@ struct batch_bool_test
             INFO("bitwise_and");
             CHECK_BATCH_EQ(xsimd::bitwise_and(bool_g.half, bool_g.ihalf), bool_g.all_false);
         }
+        {
+            INFO("bitwise_xor");
+            CHECK_BATCH_EQ(xsimd::bitwise_xor(bool_g.half, bool_g.all_true), bool_g.ihalf);
+        }
     }
 
     void test_update_operations() const

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

@@ -29,7 +29,7 @@ namespace detail
     is_convertible(T_in value)
     {
         int64_t signed_value = static_cast<int64_t>(value);
-        return signed_value <= static_cast<int64_t>(std::numeric_limits<T_out>::max()) && signed_value >= static_cast<int64_t>(std::numeric_limits<T_out>::lowest());
+        return signed_value < static_cast<int64_t>(std::numeric_limits<T_out>::max()) && signed_value >= static_cast<int64_t>(std::numeric_limits<T_out>::lowest());
     }
 
     template <class T_out, class T_in>
@@ -43,7 +43,7 @@ namespace detail
     inline typename std::enable_if<std::is_floating_point<T_in>::value && std::is_integral<T_out>::value, bool>::type
     is_convertible(T_in value)
     {
-        return value <= static_cast<T_in>(std::numeric_limits<T_out>::max()) && value >= static_cast<T_in>(std::numeric_limits<T_out>::lowest());
+        return value < static_cast<T_in>(std::numeric_limits<T_out>::max()) && value >= static_cast<T_in>(std::numeric_limits<T_out>::lowest());
     }
 
     template <class T_out, class T_in>
@@ -328,12 +328,19 @@ private:
         using B_common_in = xsimd::batch<T_in>;
         using B_common_out = xsimd::batch<T_out>;
 
-        T_in in_test_value = static_cast<T_in>(test_value);
+        auto clamp = [](T v)
+        {
+            return static_cast<T_in>(xsimd::min(v, static_cast<T>(std::numeric_limits<T_in>::max() - 1)));
+        };
+
+        T_in in_test_value = clamp(test_value);
         if (detail::is_convertible<T_out>(in_test_value))
         {
             B_common_out res = xsimd::batch_cast<T_out>(B_common_in(in_test_value));
             INFO(name);
-            CHECK_SCALAR_EQ(res.get(0), static_cast<T_out>(in_test_value));
+            T_out scalar_ref = static_cast<T_out>(in_test_value);
+            T_out scalar_res = res.get(0);
+            CHECK_SCALAR_EQ(scalar_ref, scalar_res);
         }
     }
 

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

@@ -176,6 +176,12 @@ struct batch_complex_test
         }
     }
 
+    void test_first_element() const
+    {
+        batch_type res = batch_lhs();
+        CHECK_EQ(res.first(), lhs[0]);
+    }
+
     void test_arithmetic() const
     {
         // +batch
@@ -572,6 +578,12 @@ struct batch_complex_test
             value_type res = reduce_add(batch_lhs());
             CHECK_SCALAR_EQ(res, expected);
         }
+        // reduce_mul
+        {
+            value_type expected = std::accumulate(lhs.cbegin(), lhs.cend(), value_type(1), std::multiplies<value_type>());
+            value_type res = reduce_mul(batch_lhs());
+            CHECK_SCALAR_EQ(res, expected);
+        }
     }
 
     void test_fused_operations() const
@@ -628,6 +640,7 @@ struct batch_complex_test
         }
     }
 
+#ifndef __FAST_MATH__
     void test_isnan() const
     {
         {
@@ -639,6 +652,7 @@ struct batch_complex_test
             CHECK_BATCH_EQ(res, expected);
         }
     }
+#endif
 
 private:
     batch_type batch_lhs() const
@@ -673,6 +687,8 @@ TEST_CASE_TEMPLATE("[xsimd complex batches]", B, BATCH_COMPLEX_TYPES)
 
     SUBCASE("access_operator") { Test.test_access_operator(); }
 
+    SUBCASE("first element") { Test.test_first_element(); }
+
     SUBCASE("arithmetic") { Test.test_arithmetic(); }
 
     SUBCASE("computed_assignment") { Test.test_computed_assignment(); }
@@ -689,6 +705,8 @@ TEST_CASE_TEMPLATE("[xsimd complex batches]", B, BATCH_COMPLEX_TYPES)
 
     SUBCASE("boolean_conversion") { Test.test_boolean_conversion(); }
 
+#ifndef __FAST_MATH__
     SUBCASE("isnan") { Test.test_isnan(); }
+#endif
 }
 #endif

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

@@ -239,8 +239,8 @@ struct batch_int_test
             array_type expected;
             std::transform(lhs.cbegin(), lhs.cend(), expected.begin(),
                            [nb_sh](const value_type& v)
-                           { return v << nb_sh; });
-            batch_type res = batch_lhs() << nb_sh;
+                           { return xsimd::abs(v) << nb_sh; });
+            batch_type res = abs(batch_lhs()) << nb_sh;
             INFO("batch << scalar");
             CHECK_BATCH_EQ(res, expected);
         }
@@ -249,8 +249,8 @@ struct batch_int_test
             array_type expected;
             std::transform(lhs.cbegin(), lhs.cend(), shift.cbegin(), expected.begin(),
                            [](const value_type& l, const value_type& r)
-                           { return l << r; });
-            batch_type res = batch_lhs() << batch_shift();
+                           { return xsimd::abs(l) << r; });
+            batch_type res = abs(batch_lhs()) << batch_shift();
             INFO("batch << batch");
             CHECK_BATCH_EQ(res, expected);
         }
@@ -285,21 +285,15 @@ struct batch_int_test
         for (int32_t i = 0; i < s; ++i)
         {
             res = lhs << i;
-            value_type expected = value_type(1) << i;
-            for (std::size_t j = 0; j < size; ++j)
-            {
-                CHECK_EQ(res.get(j), expected);
-            }
+            batch_type expected(value_type(1) << i);
+            CHECK_BATCH_EQ(res, expected);
         }
         lhs = batch_type(std::numeric_limits<value_type>::max());
         for (int32_t i = 0; i < s; ++i)
         {
             res = lhs >> i;
-            value_type expected = std::numeric_limits<value_type>::max() >> i;
-            for (std::size_t j = 0; j < size; ++j)
-            {
-                CHECK_EQ(res.get(j), expected);
-            }
+            batch_type expected(std::numeric_limits<value_type>::max() >> i);
+            CHECK_BATCH_EQ(res, expected);
         }
     }