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

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

@@ -14,6 +14,13 @@
 
 #include "test_utils.hpp"
 
+#ifdef __linux__
+#include "endian.h"
+#if BYTE_ORDER == BIG_ENDIAN
+#define XSIMD_NO_SLIDE
+#endif
+#endif
+
 #include <numeric>
 
 namespace
@@ -166,7 +173,6 @@ namespace
     };
 }
 
-#if !XSIMD_WITH_AVX512F || XSIMD_WITH_AVX512BW
 template <class B>
 struct slide_test : public init_slide_base<typename B::value_type, B::size>
 {
@@ -198,6 +204,7 @@ struct slide_test : public init_slide_base<typename B::value_type, B::size>
         INFO("slide_left full");
         CHECK_BATCH_EQ(b_res_left_full, b_left_full);
 
+#ifndef XSIMD_NO_SLIDE
         B b_res_left_half = xsimd::slide_left<half_slide>(b_in);
         INFO("slide_left half_slide");
         CHECK_BATCH_EQ(b_res_left_half, b_left_half);
@@ -216,6 +223,7 @@ struct slide_test : public init_slide_base<typename B::value_type, B::size>
             INFO("slide_left below_half_slide");
             CHECK_BATCH_EQ(b_res_left_below_half, b_left_below_half);
         }
+#endif
     }
 
     void slide_right()
@@ -236,6 +244,7 @@ struct slide_test : public init_slide_base<typename B::value_type, B::size>
         INFO("slide_right full");
         CHECK_BATCH_EQ(b_res_right_full, b_right_full);
 
+#ifndef XSIMD_NO_SLIDE
         B b_res_right_half = xsimd::slide_right<half_slide>(b_in);
         INFO("slide_right half_slide");
         CHECK_BATCH_EQ(b_res_right_half, b_right_half);
@@ -254,6 +263,7 @@ struct slide_test : public init_slide_base<typename B::value_type, B::size>
             INFO("slide_right below_half_slide");
             CHECK_BATCH_EQ(b_res_right_below_half, b_right_below_half);
         }
+#endif
     }
 };
 
@@ -270,8 +280,6 @@ TEST_CASE_TEMPLATE("[slide]", B, BATCH_INT_TYPES)
     }
 }
 
-#endif
-
 template <class B>
 struct compress_test
 {
@@ -347,7 +355,9 @@ struct compress_test
     }
 };
 
-TEST_CASE_TEMPLATE("[compress]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint8_t>, xsimd::batch<int8_t>, xsimd::batch<uint16_t>, xsimd::batch<int16_t>, xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>)
+#define XSIMD_COMPRESS_TYPES BATCH_FLOAT_TYPES, xsimd::batch<uint8_t>, xsimd::batch<int8_t>, xsimd::batch<uint16_t>, xsimd::batch<int16_t>, xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>
+
+TEST_CASE_TEMPLATE("[compress]", B, XSIMD_COMPRESS_TYPES)
 {
     compress_test<B> Test;
     SUBCASE("empty")
@@ -443,7 +453,9 @@ struct expand_test
     }
 };
 
-TEST_CASE_TEMPLATE("[expand]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint8_t>, xsimd::batch<int8_t>, xsimd::batch<uint16_t>, xsimd::batch<int16_t>, xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>)
+#define XSIMD_EXPAND_TYPES XSIMD_COMPRESS_TYPES
+
+TEST_CASE_TEMPLATE("[expand]", B, XSIMD_EXPAND_TYPES)
 {
     expand_test<B> Test;
     SUBCASE("empty")
@@ -561,13 +573,13 @@ struct shuffle_test
         CHECK_BATCH_EQ(b_res, b_ref);
     }
 
-    void swizzle()
+    void shuffle()
     {
         B b_lhs = B::load_unaligned(lhs.data());
         B b_rhs = B::load_unaligned(rhs.data());
 
         {
-            struct swizzle_lo_generator
+            struct shuffle_lo_generator
             {
                 static constexpr size_t get(size_t index, size_t size)
                 {
@@ -580,13 +592,13 @@ struct shuffle_test
                 ref[i] = lhs[size - i - 1];
             B b_ref = B::load_unaligned(ref.data());
 
-            INFO("swizzle first batch");
-            B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, swizzle_lo_generator, arch_type>());
+            INFO("shuffle first batch");
+            B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, shuffle_lo_generator, arch_type>());
             CHECK_BATCH_EQ(b_res, b_ref);
         }
 
         {
-            struct swizzle_hi_generator
+            struct shuffle_hi_generator
             {
                 static constexpr size_t get(size_t index, size_t size)
                 {
@@ -599,8 +611,8 @@ struct shuffle_test
                 ref[i] = rhs[size - i - 1];
             B b_ref = B::load_unaligned(ref.data());
 
-            INFO("swizzle second batch");
-            B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, swizzle_hi_generator, arch_type>());
+            INFO("shuffle second batch");
+            B b_res = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, shuffle_hi_generator, arch_type>());
             CHECK_BATCH_EQ(b_res, b_ref);
         }
     }
@@ -690,7 +702,9 @@ struct shuffle_test
     }
 };
 
-TEST_CASE_TEMPLATE("[shuffle]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>)
+#define XSIMD_SHUFFLE_TYPES BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>
+
+TEST_CASE_TEMPLATE("[shuffle]", B, XSIMD_SHUFFLE_TYPES)
 {
     shuffle_test<B> Test;
     SUBCASE("no-op")
@@ -709,9 +723,9 @@ TEST_CASE_TEMPLATE("[shuffle]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, xs
     {
         Test.select();
     }
-    SUBCASE("swizzle")
+    SUBCASE("shuffle")
     {
-        Test.swizzle();
+        Test.shuffle();
     }
     SUBCASE("transpose")
     {
@@ -733,12 +747,12 @@ TEST_CASE_TEMPLATE("[small integer transpose]", B, xsimd::batch<uint16_t>, xsimd
 }
 
 #if (XSIMD_WITH_SSE2 && !XSIMD_WITH_AVX)
-TEST_CASE_TEMPLATE("[small integer swizzle]", B, xsimd::batch<uint16_t>, xsimd::batch<int16_t>)
+TEST_CASE_TEMPLATE("[small integer shuffle]", B, xsimd::batch<uint16_t>, xsimd::batch<int16_t>)
 {
     shuffle_test<B> Test;
-    SUBCASE("swizzle")
+    SUBCASE("shuffle")
     {
-        Test.swizzle();
+        Test.shuffle();
     }
 }
 #endif

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

@@ -152,8 +152,8 @@ namespace xsimd
     template <class T, class A, size_t N>
     inline bool operator==(const batch<T, A>& lhs, const std::array<T, N>& rhs)
     {
-        std::array<T, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<T, N> tmp;
+        lhs.store_aligned(tmp.data());
         return tmp == rhs;
     }
 
@@ -166,8 +166,8 @@ namespace xsimd
     template <class T, class A, size_t N, bool i3ec>
     inline bool operator==(const batch<std::complex<T>, A>& lhs, const std::array<xtl::xcomplex<T, T, i3ec>, N>& rhs)
     {
-        std::array<xtl::xcomplex<T, T, i3ec>, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<xtl::xcomplex<T, T, i3ec>, N> tmp;
+        lhs.store_aligned(tmp.data());
         return tmp == rhs;
     }
 
@@ -181,6 +181,7 @@ namespace xsimd
 
 namespace detail
 {
+#ifndef __FAST_MATH__
     namespace utils
     {
         // define some overloads here as integer versions do not exist for msvc
@@ -208,6 +209,7 @@ namespace detail
             return false;
         }
     }
+#endif
 
     inline unsigned char uabs(unsigned char val)
     {
@@ -289,7 +291,7 @@ namespace detail
             {
                 return lhs == rhs;
             }
-
+#ifndef __FAST_MATH__
             if (utils::isnan(lhs))
             {
                 return utils::isnan(rhs);
@@ -299,6 +301,7 @@ namespace detail
             {
                 return utils::isinf(rhs) && (lhs * rhs > 0) /* same sign */;
             }
+#endif
 
             T relative_precision = precision_t::max * std::numeric_limits<T>::epsilon();
             T absolute_zero_prox = precision_t::max * std::numeric_limits<T>::epsilon();
@@ -398,16 +401,16 @@ namespace detail
     template <class T, size_t N, class A>
     bool expect_batch_near(const ::xsimd::batch<T, A>& lhs, const std::array<T, N>& rhs)
     {
-        std::array<T, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<T, N> tmp;
+        lhs.store_aligned(tmp.data());
         return expect_array_near(tmp, rhs);
     }
 
     template <class T, size_t N, class A>
     bool expect_batch_near(const std::array<T, N>& lhs, const ::xsimd::batch<T, A>& rhs)
     {
-        std::array<T, N> tmp;
-        rhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<T, N> tmp;
+        rhs.store_aligned(tmp.data());
         return expect_array_near(lhs, tmp);
     }
 
@@ -415,24 +418,24 @@ namespace detail
     bool expect_batch_near(const ::xsimd::batch<T, A>& lhs, const ::xsimd::batch<T, A>& rhs)
     {
         constexpr auto N = xsimd::batch<T, A>::size;
-        std::array<T, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<T, N> tmp;
+        lhs.store_aligned(tmp.data());
         return expect_batch_near(tmp, rhs);
     }
 
     template <class T, size_t N, class A>
     bool expect_batch_near(const ::xsimd::batch_bool<T, A>& lhs, const std::array<bool, N>& rhs)
     {
-        std::array<bool, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<bool, N> tmp;
+        lhs.store_aligned(tmp.data());
         return expect_array_near(tmp, rhs);
     }
 
     template <class T, size_t N, class A>
     bool expect_batch_near(const std::array<bool, N>& lhs, const ::xsimd::batch_bool<T, A>& rhs)
     {
-        std::array<bool, N> tmp;
-        rhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<bool, N> tmp;
+        rhs.store_aligned(tmp.data());
         return expect_array_near(lhs, tmp);
     }
 
@@ -440,8 +443,8 @@ namespace detail
     bool expect_batch_near(const ::xsimd::batch_bool<T, A>& lhs, const ::xsimd::batch_bool<T, A>& rhs)
     {
         constexpr auto N = xsimd::batch<T, A>::size;
-        std::array<bool, N> tmp;
-        lhs.store_unaligned(tmp.data());
+        alignas(A::alignment()) std::array<bool, N> tmp;
+        lhs.store_aligned(tmp.data());
         return expect_batch_near(tmp, rhs);
     }
 
@@ -591,13 +594,7 @@ namespace xsimd
 #define BATCH_TYPES BATCH_INT_TYPES, BATCH_FLOAT_TYPES
 #define BATCH_MATH_TYPES xsimd::batch<int32_t>, BATCH_FLOAT_TYPES
 
-#if !XSIMD_WITH_AVX || XSIMD_WITH_AVX2
-#define BATCH_SWIZZLE_TAIL , xsimd::batch<uint32_t>, xsimd::batch<int32_t>, xsimd::batch<uint64_t>, xsimd::batch<int64_t>
-#else
-#define BATCH_SWIZZLE_TAIL
-#endif
-
-#define BATCH_SWIZZLE_TYPES BATCH_FLOAT_TYPES, BATCH_COMPLEX_TYPES BATCH_SWIZZLE_TAIL
+#define BATCH_SWIZZLE_TYPES BATCH_FLOAT_TYPES, BATCH_COMPLEX_TYPES, BATCH_INT_TYPES
 
 /********************
  * conversion utils *

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

@@ -353,18 +353,28 @@ struct xsimd_api_integral_types_functions
 
     void test_bitwise_lshift()
     {
+        constexpr int shift = 3;
         value_type val0(12);
-        value_type val1(3);
+        value_type val1(shift);
         value_type r = val0 << val1;
+        value_type ir = val0 << shift;
+        value_type cr = xsimd::bitwise_lshift<shift>(val0);
         CHECK_EQ(extract(xsimd::bitwise_lshift(T(val0), T(val1))), r);
+        CHECK_EQ(extract(ir), r);
+        CHECK_EQ(extract(cr), r);
     }
 
     void test_bitwise_rshift()
     {
+        constexpr int shift = 3;
         value_type val0(12);
-        value_type val1(3);
+        value_type val1(shift);
         value_type r = val0 >> val1;
+        value_type ir = val0 >> shift;
+        value_type cr = xsimd::bitwise_rshift<shift>(val0);
         CHECK_EQ(extract(xsimd::bitwise_rshift(T(val0), T(val1))), r);
+        CHECK_EQ(extract(ir), r);
+        CHECK_EQ(extract(cr), r);
     }
 
     void test_mod()
@@ -376,20 +386,26 @@ struct xsimd_api_integral_types_functions
 
     void test_rotl()
     {
-        constexpr auto N = std::numeric_limits<value_type>::digits;
+        constexpr auto N = std::numeric_limits<value_type>::digits + std::numeric_limits<value_type>::is_signed;
+        constexpr int count = 3;
         value_type val0(12);
-        value_type val1(3);
+        value_type val1(count);
         value_type r = (val0 << val1) | (val0 >> (N - val1));
+        value_type cr = xsimd::rotl<count>(val0);
         CHECK_EQ(extract(xsimd::rotl(T(val0), T(val1))), r);
+        CHECK_EQ(extract(cr), r);
     }
 
     void test_rotr()
     {
-        constexpr auto N = std::numeric_limits<value_type>::digits;
+        constexpr auto N = std::numeric_limits<value_type>::digits + std::numeric_limits<value_type>::is_signed;
+        constexpr int count = 3;
         value_type val0(12);
-        value_type val1(3);
+        value_type val1(count);
         value_type r = (val0 >> val1) | (val0 << (N - val1));
+        value_type cr = xsimd::rotr<3>(val0);
         CHECK_EQ(extract(xsimd::rotr(T(val0), T(val1))), r);
+        CHECK_EQ(extract(cr), r);
     }
 
     void test_sadd()
@@ -488,8 +504,12 @@ struct xsimd_api_float_types_functions
     }
     void test_atanh()
     {
-        value_type val(1);
-        CHECK_EQ(extract(xsimd::atanh(T(val))), std::atanh(val));
+        value_type val0(0);
+        CHECK_EQ(extract(xsimd::atanh(T(val0))), std::atanh(val0));
+#ifndef __FAST_MATH__
+        value_type val1(1);
+        CHECK_EQ(extract(xsimd::atanh(T(val1))), std::atanh(val1));
+#endif
     }
     void test_cbrt()
     {
@@ -654,6 +674,29 @@ struct xsimd_api_float_types_functions
         value_type val(0);
         CHECK_EQ(extract(xsimd::log1p(T(val))), std::log1p(val));
     }
+
+    void test_max_nan()
+    {
+        value_type val0(2.7818);
+        value_type valN(NAN);
+#if XSIMD_WITH_AVX || XSIMD_WITH_SSE2
+        using isnan = doctest::IsNaN<value_type>;
+        CHECK_EQ(isnan(extract(xsimd::max(T(val0), T(valN)))), isnan(std::max(val0, valN)));
+        CHECK_EQ(isnan(extract(xsimd::max(T(valN), T(val0)))), isnan(std::max(valN, val0)));
+#endif
+    }
+
+    void test_min_nan()
+    {
+        value_type val0(2.7818);
+        value_type valN(NAN);
+#if XSIMD_WITH_AVX || XSIMD_WITH_SSE2
+        using isnan = doctest::IsNaN<value_type>;
+        CHECK_EQ(isnan(extract(xsimd::min(T(val0), T(valN)))), isnan(std::min(val0, valN)));
+        CHECK_EQ(isnan(extract(xsimd::min(T(valN), T(val0)))), isnan(std::min(valN, val0)));
+#endif
+    }
+
     void test_nearbyint()
     {
         value_type val(3.1);
@@ -925,6 +968,16 @@ TEST_CASE_TEMPLATE("[xsimd api | float types functions]", B, FLOAT_TYPES)
         Test.test_log1p();
     }
 
+    SUBCASE("max_nan")
+    {
+        Test.test_max_nan();
+    }
+
+    SUBCASE("min_nan")
+    {
+        Test.test_min_nan();
+    }
+
     SUBCASE("nearbyint")
     {
         Test.test_nearbyint();
@@ -1044,6 +1097,7 @@ struct xsimd_api_complex_types_functions
         CHECK_EQ(extract(xsimd::proj(T(val))), std::proj(val));
     }
 
+#ifndef __FAST_MATH__
     void test_isinf()
     {
         value_type val(4);
@@ -1061,6 +1115,7 @@ struct xsimd_api_complex_types_functions
         value_type val(4);
         CHECK_EQ(extract(xsimd::isnan(T(val))), std::isnan(std::real(val)));
     }
+#endif
 };
 
 TEST_CASE_TEMPLATE("[xsimd api | complex types functions]", B, COMPLEX_TYPES)
@@ -1086,6 +1141,8 @@ TEST_CASE_TEMPLATE("[xsimd api | complex types functions]", B, COMPLEX_TYPES)
         Test.test_proj();
     }
 
+#ifndef __FAST_MATH__
+
     SUBCASE("isinf")
     {
         Test.test_isinf();
@@ -1100,6 +1157,7 @@ TEST_CASE_TEMPLATE("[xsimd api | complex types functions]", B, COMPLEX_TYPES)
     {
         Test.test_isnan();
     }
+#endif
 }
 
 /*
@@ -1194,7 +1252,7 @@ struct xsimd_api_all_types_functions
     void test_div()
     {
         value_type val0(1);
-        value_type val1(3);
+        value_type val1(2);
         CHECK_EQ(extract(xsimd::div(T(val0), T(val1))), val0 / val1);
     }
 
@@ -1345,6 +1403,7 @@ TEST_CASE_TEMPLATE("[xsimd api | all types functions]", B, ALL_TYPES)
 /*
  * Functions that apply only to floating point types
  */
+#ifndef __FAST_MATH__
 template <typename T>
 struct xsimd_api_all_floating_point_types_functions
 {
@@ -1363,6 +1422,7 @@ TEST_CASE_TEMPLATE("[xsimd api | all floating point types functions]", B, ALL_FL
     xsimd_api_all_floating_point_types_functions<B> Test;
     Test.test_neq_nan();
 }
+#endif
 
 /*
  * Functions that apply only to mask type