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

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/arch/common/xsimd_common_math.hpp

@@ -116,6 +116,11 @@ namespace xsimd
             {
                 return fast_cast(self, out, A {});
             }
+#if defined(__clang__) || __GNUC__
+            template <class A, class T_out, class T_in>
+            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<common>, with_slow_conversion) noexcept
+                __attribute__((no_sanitize("undefined")));
+#endif
             template <class A, class T_out, class T_in>
             XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<common>, with_slow_conversion) noexcept
             {
@@ -126,7 +131,8 @@ namespace xsimd
                 alignas(A::alignment()) T_in buffer_in[batch_type_in::size];
                 alignas(A::alignment()) T_out buffer_out[batch_type_out::size];
                 self.store_aligned(&buffer_in[0]);
-                std::copy(std::begin(buffer_in), std::end(buffer_in), std::begin(buffer_out));
+                for (size_t i = 0; i < batch_type_in::size; ++i)
+                    buffer_out[i] = static_cast<T_out>(buffer_in[i]);
                 return batch_type_out::load_aligned(buffer_out);
             }
 
@@ -890,7 +896,9 @@ namespace xsimd
                 batch_type k = reducer_t::reduce(self, x);
                 x = reducer_t::approx(x);
                 x = select(self <= reducer_t::minlog(), batch_type(0.), ldexp(x, to_int(k)));
+#ifndef __FAST_MATH__
                 x = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), x);
+#endif
                 return x;
             }
 
@@ -904,7 +912,9 @@ namespace xsimd
                 batch_type c = reducer_t::approx(x);
                 c = reducer_t::finalize(x, c, hi, lo);
                 c = select(self <= reducer_t::minlog(), batch_type(0.), ldexp(c, to_int(k)));
+#ifndef __FAST_MATH__
                 c = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), c);
+#endif
                 return c;
             }
         }
@@ -1008,11 +1018,11 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> expm1(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
-            return select(self < constants::logeps<batch_type>(),
-                          batch_type(-1.),
-                          select(self > constants::maxlog<batch_type>(),
-                                 constants::infinity<batch_type>(),
-                                 detail::expm1(self)));
+            auto x = detail::expm1(self);
+#ifndef __FAST_MATH__
+            x = select(self > constants::maxlog<batch_type>(), constants::infinity<batch_type>(), x);
+#endif
+            return select(self < constants::logeps<batch_type>(), batch_type(-1.), x);
         }
 
         template <class A, class T>
@@ -1077,7 +1087,7 @@ namespace xsimd
         template <class A, class T>
         XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<common>) noexcept
         {
-            return batch<T, A>(self.data) & batch<T, A>(1);
+            return batch<T, A>((typename batch<T, A>::register_type)self.data) & batch<T, A>(1);
         }
 
         // horner
@@ -1239,12 +1249,20 @@ namespace xsimd
                     batch_type r1 = other(q);
                     if (any(ltza))
                     {
+#ifdef __FAST_MATH__
+                        r = negative(q, r1);
+#else
                         r = select(inf_result, constants::infinity<batch_type>(), negative(q, r1));
+#endif
                         if (all(ltza))
                             return r;
                     }
                     batch_type r2 = select(ltza, r, r1);
+#ifdef __FAST_MATH__
+                    return r2;
+#else
                     return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
+#endif
                 }
 
             private:
@@ -1365,7 +1383,11 @@ namespace xsimd
                     }
                     batch_type r1 = other(a);
                     batch_type r2 = select(test, r, r1);
+#ifdef __FAST_MATH__
+                    return r2;
+#else
                     return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
+#endif
                 }
 
             private:
@@ -1473,12 +1495,12 @@ namespace xsimd
             batch_type hfsq = batch_type(0.5) * f * f;
             batch_type dk = to_float(k);
             batch_type r = fma(dk, constants::log_2hi<batch_type>(), fma(s, (hfsq + R), dk * constants::log_2lo<batch_type>()) - hfsq + f);
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A>
@@ -1516,12 +1538,12 @@ namespace xsimd
             batch_type t2 = z * detail::horner<batch_type, 0x3fe5555555555593ll, 0x3fd2492494229359ll, 0x3fc7466496cb03dell, 0x3fc2f112df3e5244ll>(w);
             batch_type R = t2 + t1;
             batch_type r = fma(dk, constants::log_2hi<batch_type>(), fma(s, (hfsq + R), dk * constants::log_2lo<batch_type>()) - hfsq + f);
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A, class T>
@@ -1563,12 +1585,12 @@ namespace xsimd
             batch_type hfsq = batch_type(0.5) * f * f;
             batch_type dk = to_float(k);
             batch_type r = fma(fms(s, hfsq + R, hfsq) + f, constants::invlog_2<batch_type>(), dk);
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A>
@@ -1611,12 +1633,12 @@ namespace xsimd
             val_lo += (dk - w1) + val_hi;
             val_hi = w1;
             batch_type r = val_lo + val_hi;
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         namespace detail
@@ -1694,9 +1716,15 @@ namespace xsimd
 #ifndef XSIMD_NO_INFINITIES
             batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
+            assert(all(isnez) && "Calling log10 on a batch with zero value while XSIMD_NO_INFINITIES is active");
+            batch_type zz = r;
 #endif
+#ifndef XSIMD_NO_NANS
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#else
+            assert(all(self >= batch_type(0.)) && "Calling log10 on a batch with negative value while XSIMD_NO_NANS is active");
+            return zz;
+#endif
         }
 
         template <class A>
@@ -1745,12 +1773,12 @@ namespace xsimd
             val_lo += (y - w1) + val_hi;
             val_hi = w1;
             batch_type r = val_lo + val_hi;
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A, class T>
@@ -1793,12 +1821,12 @@ namespace xsimd
             /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
             batch_type c = select(batch_bool_cast<float>(k >= i_type(2)), batch_type(1.) - (uf - self), self - (uf - batch_type(1.))) / uf;
             batch_type r = fma(dk, constants::log_2hi<batch_type>(), fma(s, (hfsq + R), dk * constants::log_2lo<batch_type>() + c) - hfsq + f);
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A>
@@ -1826,12 +1854,12 @@ namespace xsimd
             batch_type R = t2 + t1;
             batch_type dk = to_float(k);
             batch_type r = fma(dk, constants::log_2hi<batch_type>(), fma(s, hfsq + R, dk * constants::log_2lo<batch_type>() + c) - hfsq + f);
-#ifndef XSIMD_NO_INFINITIES
-            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+#ifdef __FAST_MATH__
+            return r;
 #else
-            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
-#endif
+            batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
             return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
+#endif
         }
 
         template <class A, class T>
@@ -1876,8 +1904,9 @@ namespace xsimd
                 // to v. That's not what we want, so prevent compiler optimization here.
                 // FIXME: it may be better to emit a memory barrier here (?).
 #ifdef __FAST_MATH__
-                volatile batch_type d0 = v + t2n;
-                batch_type d = *(batch_type*)(void*)(&d0) - t2n;
+                batch_type d0 = v + t2n;
+                asm volatile("" ::"r"(&d0) : "memory");
+                batch_type d = d0 - t2n;
 #else
                 batch_type d0 = v + t2n;
                 batch_type d = d0 - t2n;
@@ -1968,13 +1997,21 @@ namespace xsimd
                 static XSIMD_INLINE batch_type next(const batch_type& b) noexcept
                 {
                     batch_type n = ::xsimd::bitwise_cast<T>(::xsimd::bitwise_cast<int_type>(b) + int_type(1));
+#ifdef __FAST_MATH__
+                    return n;
+#else
                     return select(b == constants::infinity<batch_type>(), b, n);
+#endif
                 }
 
                 static XSIMD_INLINE batch_type prev(const batch_type& b) noexcept
                 {
                     batch_type p = ::xsimd::bitwise_cast<T>(::xsimd::bitwise_cast<int_type>(b) - int_type(1));
+#ifdef __FAST_MATH__
+                    return p;
+#else
                     return select(b == constants::minusinfinity<batch_type>(), b, p);
+#endif
                 }
             };
         }
@@ -2066,6 +2103,19 @@ namespace xsimd
             return { reduce_add(self.real()), reduce_add(self.imag()) };
         }
 
+        template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value, void>::type*/>
+        XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            alignas(A::alignment()) T buffer[batch<T, A>::size];
+            self.store_aligned(buffer);
+            T res = 0;
+            for (T val : buffer)
+            {
+                res += val;
+            }
+            return res;
+        }
+
         namespace detail
         {
             template <class T, T N>
@@ -2073,14 +2123,14 @@ namespace xsimd
             {
                 static constexpr T get(T i, T)
                 {
-                    return i >= N ? (i % 2) : i + N;
+                    return i < N ? (i + N) : ((i % N) + N);
                 }
             };
 
             template <class Op, class A, class T>
             XSIMD_INLINE T reduce(Op, batch<T, A> const& self, std::integral_constant<unsigned, 1>) noexcept
             {
-                return self.get(0);
+                return ::xsimd::kernel::first(self, A {});
             }
 
             template <class Op, class A, class T, unsigned Lvl>
@@ -2110,6 +2160,34 @@ namespace xsimd
                                   self, std::integral_constant<unsigned, batch<T, A>::size>());
         }
 
+        // reduce_mul
+        template <class A, class T>
+        XSIMD_INLINE std::complex<T> reduce_mul(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            // FIXME: could do better
+            alignas(A::alignment()) std::complex<T> buffer[batch<std::complex<T>, A>::size];
+            self.store_aligned(buffer);
+            std::complex<T> res = 1;
+            for (auto val : buffer)
+            {
+                res *= val;
+            }
+            return res;
+        }
+
+        template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value, void>::type*/>
+        XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            alignas(A::alignment()) T buffer[batch<T, A>::size];
+            self.store_aligned(buffer);
+            T res = 1;
+            for (T val : buffer)
+            {
+                res *= val;
+            }
+            return res;
+        }
+
         // remainder
         template <class A>
         XSIMD_INLINE batch<float, A> remainder(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
@@ -2343,10 +2421,12 @@ namespace xsimd
                 y *= v;
                 y = select(test, y, y * v);
                 y *= constants::sqrt_2pi<batch_type>() * w;
-#ifndef XSIMD_NO_INFINITIES
+#ifdef __FAST_MATH__
+                return y;
+#else
                 y = select(isinf(x), x, y);
-#endif
                 return select(x > stirlinglargelim, constants::infinity<batch_type>(), y);
+#endif
             }
 
             /* origin: boost/simd/arch/common/detail/common/gamma_kernel.hpp */
@@ -2475,7 +2555,7 @@ namespace xsimd
         {
             using batch_type = batch<T, A>;
             auto nan_result = (self < batch_type(0.) && is_flint(self));
-#ifndef XSIMD_NO_INVALIDS
+#ifndef XSIMD_NO_NANS
             nan_result = isnan(self) || nan_result;
 #endif
             batch_type q = abs(self);
@@ -2489,7 +2569,11 @@ namespace xsimd
             }
             batch_type r1 = detail::tgamma_other(self, test);
             batch_type r2 = select(test, r, r1);
+#ifdef __FAST_MATH__
+            return r2;
+#else
             return select(self == batch_type(0.), copysign(constants::infinity<batch_type>(), self), select(nan_result, constants::nan<batch_type>(), r2));
+#endif
         }
 
     }

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/arch/common/xsimd_common_memory.hpp

@@ -260,6 +260,25 @@ namespace xsimd
             return buffer[i];
         }
 
+        // first
+        template <class A, class T>
+        XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return get(self, 0, common {});
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE T first(batch_bool<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return first(batch<T, A>(self), A {});
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE auto first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        {
+            return { first(self.real(), A {}), first(self.imag(), A {}) };
+        }
+
         // load
         template <class A, class T>
         XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<common>) noexcept
@@ -341,7 +360,7 @@ namespace xsimd
                 }
             };
 
-            return swizzle(self, make_batch_constant<as_unsigned_integer_t<T>, rotate_generator, A>(), A {});
+            return swizzle(self, make_batch_constant<as_unsigned_integer_t<T>, rotate_generator, A>());
         }
 
         template <size_t N, class A, class T>
@@ -362,7 +381,7 @@ namespace xsimd
                 }
             };
 
-            return swizzle(self, make_batch_constant<as_unsigned_integer_t<T>, rotate_generator, A>(), A {});
+            return swizzle(self, make_batch_constant<as_unsigned_integer_t<T>, rotate_generator, A>());
         }
 
         template <size_t N, class A, class T>
@@ -611,6 +630,15 @@ namespace xsimd
             return batch<T, A>::load_aligned(out_buffer);
         }
 
+        template <class A, class T, class ITy, ITy... Is>
+        XSIMD_INLINE batch<T, A> swizzle(batch<T, A> const& self, batch_constant<ITy, A, Is...>, requires_arch<common>) noexcept
+        {
+            constexpr size_t size = batch<T, A>::size;
+            alignas(A::alignment()) T self_buffer[size];
+            store_aligned(&self_buffer[0], self);
+            return { self_buffer[Is]... };
+        }
+
         template <class A, class T, class ITy>
         XSIMD_INLINE batch<std::complex<T>, A> swizzle(batch<std::complex<T>, A> const& self, batch<ITy, A> mask, requires_arch<common>) noexcept
         {

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/arch/common/xsimd_common_swizzle.hpp

@@ -0,0 +1,174 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ * Copyright (c) Marco Barbone                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software.*
+ ****************************************************************************/
+#ifndef XSIMD_COMMON_SWIZZLE_HPP
+#define XSIMD_COMMON_SWIZZLE_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace xsimd
+{
+    template <typename T, class A, T... Values>
+    struct batch_constant;
+
+    namespace kernel
+    {
+        namespace detail
+        {
+            // ────────────────────────────────────────────────────────────────────────
+            //  get_at<I,Values...> → the I-th element of the pack
+            template <typename T, std::size_t I, T V0, T... Vs>
+            struct get_at
+            {
+                static constexpr T value = get_at<T, I - 1, Vs...>::value;
+            };
+            template <typename T, T V0, T... Vs>
+            struct get_at<T, 0, V0, Vs...>
+            {
+                static constexpr T value = V0;
+            };
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  1) identity_impl
+            template <std::size_t /*I*/, typename T>
+            XSIMD_INLINE constexpr bool identity_impl() noexcept { return true; }
+            template <std::size_t I, typename T, T V0, T... Vs>
+            XSIMD_INLINE constexpr bool identity_impl() noexcept
+            {
+                return V0 == static_cast<T>(I)
+                    && identity_impl<I + 1, T, Vs...>();
+            }
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  2) bitmask_impl
+            template <std::size_t /*I*/, std::size_t /*N*/, typename T>
+            XSIMD_INLINE constexpr std::uint32_t bitmask_impl() noexcept { return 0u; }
+            template <std::size_t I, std::size_t N, typename T, T V0, T... Vs>
+            XSIMD_INLINE constexpr std::uint32_t bitmask_impl() noexcept
+            {
+                return (1u << (static_cast<std::uint32_t>(V0) & (N - 1)))
+                    | bitmask_impl<I + 1, N, T, Vs...>();
+            }
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  3) dup_lo_impl
+            template <std::size_t I, std::size_t N, typename T,
+                      T... Vs, typename std::enable_if<I == N / 2, int>::type = 0>
+            XSIMD_INLINE constexpr bool dup_lo_impl() noexcept { return true; }
+
+            template <std::size_t I, std::size_t N, typename T,
+                      T... Vs, typename std::enable_if<(I < N / 2), int>::type = 0>
+            XSIMD_INLINE constexpr bool dup_lo_impl() noexcept
+            {
+                return get_at<T, I, Vs...>::value < static_cast<T>(N / 2)
+                    && get_at<T, I + N / 2, Vs...>::value == get_at<T, I, Vs...>::value
+                    && dup_lo_impl<I + 1, N, T, Vs...>();
+            }
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  4) dup_hi_impl
+            template <std::size_t I, std::size_t N, typename T,
+                      T... Vs, typename std::enable_if<I == N / 2, int>::type = 0>
+            XSIMD_INLINE constexpr bool dup_hi_impl() noexcept { return true; }
+
+            template <std::size_t I, std::size_t N, typename T,
+                      T... Vs, typename std::enable_if<(I < N / 2), int>::type = 0>
+            XSIMD_INLINE constexpr bool dup_hi_impl() noexcept
+            {
+                return get_at<T, I, Vs...>::value >= static_cast<T>(N / 2)
+                    && get_at<T, I, Vs...>::value < static_cast<T>(N)
+                    && get_at<T, I + N / 2, Vs...>::value == get_at<T, I, Vs...>::value
+                    && dup_hi_impl<I + 1, N, T, Vs...>();
+            }
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  1) helper to get the I-th value from the Vs pack
+            template <std::size_t I, uint32_t Head, uint32_t... Tail>
+            struct get_nth_value
+            {
+                static constexpr uint32_t value = get_nth_value<I - 1, Tail...>::value;
+            };
+            template <uint32_t Head, uint32_t... Tail>
+            struct get_nth_value<0, Head, Tail...>
+            {
+                static constexpr uint32_t value = Head;
+            };
+
+            // ────────────────────────────────────────────────────────────────────────
+            //  2) recursive cross‐lane test: true if any output‐lane i pulls from the opposite half
+            template <std::size_t I,
+                      std::size_t N,
+                      std::size_t H,
+                      uint32_t... Vs>
+            struct cross_impl
+            {
+                // does element I cross? (i.e. i<H but V>=H) or (i>=H but V<H)
+                static constexpr uint32_t Vi = get_nth_value<I, Vs...>::value;
+                static constexpr bool curr = (I < H ? (Vi >= H) : (Vi < H));
+                static constexpr bool next = cross_impl<I + 1, N, H, Vs...>::value;
+                static constexpr bool value = curr || next;
+            };
+            template <std::size_t N, std::size_t H, uint32_t... Vs>
+            struct cross_impl<N, N, H, Vs...>
+            {
+                static constexpr bool value = false;
+            };
+            template <std::size_t I, std::size_t N, typename T,
+                      T... Vs>
+            XSIMD_INLINE constexpr bool no_duplicates_impl() noexcept
+            {
+                // build the bitmask of (Vs & (N-1)) across all lanes
+                return detail::bitmask_impl<0, N, T, Vs...>() == ((1u << N) - 1u);
+            }
+            template <uint32_t... Vs>
+            XSIMD_INLINE constexpr bool no_duplicates_v() noexcept
+            {
+                // forward to your existing no_duplicates_impl
+                return no_duplicates_impl<0, sizeof...(Vs), uint32_t, Vs...>();
+            }
+            template <uint32_t... Vs>
+            XSIMD_INLINE constexpr bool is_cross_lane() noexcept
+            {
+                static_assert(sizeof...(Vs) >= 1, "Need at least one lane");
+                return cross_impl<0, sizeof...(Vs), sizeof...(Vs) / 2, Vs...>::value;
+            }
+            template <typename T, T... Vs>
+            XSIMD_INLINE constexpr bool is_identity() noexcept { return detail::identity_impl<0, T, Vs...>(); }
+            template <typename T, T... Vs>
+            XSIMD_INLINE constexpr bool is_all_different() noexcept
+            {
+                return detail::bitmask_impl<0, sizeof...(Vs), T, Vs...>() == ((1u << sizeof...(Vs)) - 1);
+            }
+
+            template <typename T, T... Vs>
+            XSIMD_INLINE constexpr bool is_dup_lo() noexcept { return detail::dup_lo_impl<0, sizeof...(Vs), T, Vs...>(); }
+            template <typename T, T... Vs>
+            XSIMD_INLINE constexpr bool is_dup_hi() noexcept { return detail::dup_hi_impl<0, sizeof...(Vs), T, Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool is_identity(batch_constant<T, A, Vs...>) noexcept { return is_identity<T, Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool is_all_different(batch_constant<T, A, Vs...>) noexcept { return is_all_different<T, Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool is_dup_lo(batch_constant<T, A, Vs...>) noexcept { return is_dup_lo<T, Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool is_dup_hi(batch_constant<T, A, Vs...>) noexcept { return is_dup_hi<T, Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool is_cross_lane(batch_constant<T, A, Vs...>) noexcept { return detail::is_cross_lane<Vs...>(); }
+            template <typename T, class A, T... Vs>
+            XSIMD_INLINE constexpr bool no_duplicates(batch_constant<T, A, Vs...>) noexcept { return no_duplicates_impl<0, sizeof...(Vs), T, Vs...>(); }
+
+        } // namespace detail
+    } // namespace kernel
+} // namespace xsimd
+
+#endif // XSIMD_COMMON_SWIZZLE_HPP

sequenzo/dissimilarity_measures/src/xsimd/include/xsimd/arch/common/xsimd_common_trigo.hpp

@@ -310,10 +310,13 @@ namespace xsimd
             num = x2 + num * num;
             real_batch den = y - one;
             den = x2 + den * den;
-            batch_type res = select((x == real_batch(0.)) && (y == real_batch(1.)),
-                                    batch_type(real_batch(0.), constants::infinity<real_batch>()),
-                                    batch_type(w, 0.25 * log(num / den)));
-            return res;
+#ifdef __FAST_MATH__
+            return batch_type(w, 0.25 * log(num / den));
+#else
+            return select((x == real_batch(0.)) && (y == real_batch(1.)),
+                          batch_type(real_batch(0.), constants::infinity<real_batch>()),
+                          batch_type(w, 0.25 * log(num / den)));
+#endif
         }
 
         // atanh
@@ -583,12 +586,14 @@ namespace xsimd
                         for (std::size_t i = 0; i < size; ++i)
                         {
                             double arg = args[i];
+#ifndef __FAST_MATH__
                             if (arg == std::numeric_limits<value_type>::infinity())
                             {
                                 tmp[i] = 0.;
                                 txr[i] = std::numeric_limits<value_type>::quiet_NaN();
                             }
                             else
+#endif
                             {
                                 double y[2];
                                 std::int32_t n = ::xsimd::detail::__ieee754_rem_pio2(arg, y);
@@ -841,11 +846,15 @@ namespace xsimd
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
             real_batch d = cos(2 * z.real()) + cosh(2 * z.imag());
-            batch_type winf(constants::infinity<real_batch>(), constants::infinity<real_batch>());
             real_batch wreal = sin(2 * z.real()) / d;
             real_batch wimag = sinh(2 * z.imag());
+#ifdef __FAST_MATH__
+            return batch_type(wreal, real_batch(1.)), batch_type(wreal, wimag / d);
+#else
+            batch_type winf(constants::infinity<real_batch>(), constants::infinity<real_batch>());
             batch_type wres = select(isinf(wimag), batch_type(wreal, real_batch(1.)), batch_type(wreal, wimag / d));
             return select(d == real_batch(0.), winf, wres);
+#endif
         }
 
         // tanh