diff --git a/third_party/xsimd/arch/generic/xsimd_generic_arithmetic.hpp b/third_party/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
index a927ba975..7fc09e561 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_ARITHMETIC_HPP
 #define XSIMD_GENERIC_ARITHMETIC_HPP
@@ -17,85 +17,112 @@
 
 #include "./xsimd_generic_details.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // bitwise_lshift
+        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x << y; },
+                                 self, other);
+        }
+
+        // bitwise_rshift
+        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x >> y; },
+                                 self, other);
+        }
+
+        // div
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept -> T
+                                 { return x / y; },
+                                 self, other);
+        }
+
+        // fma
+        template <class A, class T>
+        inline batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        {
+            return x * y + z;
+        }
+
+        template <class A, class T>
+        inline batch<std::complex<T>, A> fma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            auto res_r = fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
+            auto res_i = fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
+            return { res_r, res_i };
+        }
+
+        // fms
+        template <class A, class T>
+        inline batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        {
+            return x * y - z;
+        }
+
+        template <class A, class T>
+        inline batch<std::complex<T>, A> fms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            auto res_r = fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
+            auto res_i = fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
+            return { res_r, res_i };
+        }
+
+        // fnma
+        template <class A, class T>
+        inline batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        {
+            return -x * y + z;
+        }
+
+        template <class A, class T>
+        inline batch<std::complex<T>, A> fnma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            auto res_r = -fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
+            auto res_i = -fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
+            return { res_r, res_i };
+        }
+
+        // fnms
+        template <class A, class T>
+        inline batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) noexcept
+        {
+            return -x * y - z;
+        }
+
+        template <class A, class T>
+        inline batch<std::complex<T>, A> fnms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            auto res_r = -fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
+            auto res_i = -fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
+            return { res_r, res_i };
+        }
+
+        // mul
+        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept -> T
+                                 { return x * y; },
+                                 self, other);
+        }
 
-  namespace kernel {
-
-    using namespace types;
-
-    // bitwise_lshift
-    template<class A, class T, class/*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) { return x << y;}, self, other);
-    }
-
-    // bitwise_rshift
-    template<class A, class T, class/*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) { return x >> y;}, self, other);
-    }
-
-    // div
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) -> T { return x / y;}, self, other);
-    }
-
-    // fma
-    template<class A, class T> batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) {
-      return x * y + z;
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> fma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      auto res_r = fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
-      auto res_i = fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
-      return {res_r, res_i};
-    }
-
-    // fms
-    template<class A, class T> batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) {
-      return x * y - z;
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> fms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      auto res_r = fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
-      auto res_i = fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
-      return {res_r, res_i};
     }
 
-    // fnma
-    template<class A, class T> batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) {
-      return -x * y + z;
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> fnma(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      auto res_r = - fms(x.real(), y.real(), fma(x.imag(), y.imag(), z.real()));
-      auto res_i = - fma(x.real(), y.imag(), fms(x.imag(), y.real(), z.imag()));
-      return {res_r, res_i};
-    }
-
-    // fnms
-    template<class A, class T> batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<generic>) {
-      return -x * y - z;
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> fnms(batch<std::complex<T>, A> const& x, batch<std::complex<T>, A> const& y, batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      auto res_r = - fms(x.real(), y.real(), fms(x.imag(), y.imag(), z.real()));
-      auto res_i = - fma(x.real(), y.imag(), fma(x.imag(), y.real(), z.imag()));
-      return {res_r, res_i};
-    }
-
-
-
-    // mul
-    template<class A, class T, class/*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) -> T { return x * y;}, self, other);
-    }
-
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_complex.hpp b/third_party/xsimd/arch/generic/xsimd_generic_complex.hpp
index 79fd0f1e7..ede95ee93 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_complex.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_complex.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_COMPLEX_HPP
 #define XSIMD_GENERIC_COMPLEX_HPP
@@ -16,71 +16,81 @@
 
 #include "./xsimd_generic_details.hpp"
 
-namespace xsimd {
-
-  namespace kernel {
-
-    using namespace types;
-
-    // real
-    template <class A, class T>
-    batch<T, A> real(batch<T, A> const& self, requires_arch<generic>) {
-      return self;
-    }
-
-    template <class A, class T>
-    batch<T, A> real(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      return self.real();
-    }
-
-    // imag
-    template <class A, class T>
-    batch<T, A> imag(batch<T, A> const& /*self*/, requires_arch<generic>) {
-      return batch<T, A>(T(0));
-    }
-
-    template <class A, class T>
-    batch<T, A> imag(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      return self.imag();
-    }
-    
-    // arg
-    template<class A, class T>
-    real_batch_type_t<batch<T, A>> arg(batch<T, A> const& self, requires_arch<generic>) {
-      return atan2(imag(self), real(self));
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // real
+        template <class A, class T>
+        inline batch<T, A> real(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self;
+        }
+
+        template <class A, class T>
+        inline batch<T, A> real(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self.real();
+        }
+
+        // imag
+        template <class A, class T>
+        inline batch<T, A> imag(batch<T, A> const& /*self*/, requires_arch<generic>) noexcept
+        {
+            return batch<T, A>(T(0));
+        }
+
+        template <class A, class T>
+        inline batch<T, A> imag(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self.imag();
+        }
+
+        // arg
+        template <class A, class T>
+        inline real_batch_type_t<batch<T, A>> arg(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return atan2(imag(self), real(self));
+        }
+
+        // conj
+        template <class A, class T>
+        inline complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return { real(self), -imag(self) };
+        }
+
+        // norm
+        template <class A, class T>
+        inline real_batch_type_t<batch<T, A>> norm(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return { fma(real(self), real(self), imag(self) * imag(self)) };
+        }
+
+        // proj
+        template <class A, class T>
+        inline complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = complex_batch_type_t<batch<T, A>>;
+            using real_batch = typename batch_type::real_batch;
+            using real_value_type = typename real_batch::value_type;
+            auto cond = xsimd::isinf(real(self)) || xsimd::isinf(imag(self));
+            return select(cond,
+                          batch_type(constants::infinity<real_batch>(),
+                                     copysign(real_batch(real_value_type(0)), imag(self))),
+                          batch_type(self));
+        }
+
+        template <class A, class T>
+        inline batch_bool<T, A> isnan(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            return batch_bool<T, A>(isnan(self.real()) || isnan(self.imag()));
+        }
     }
-
-    // conj
-    template<class A, class T>
-    complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& self, requires_arch<generic>) {
-      return {real(self), - imag(self)};
-    }
-
-    // norm
-    template<class A, class T>
-    real_batch_type_t<batch<T, A>> norm(batch<T, A> const& self, requires_arch<generic>) {
-      return {fma(real(self), real(self), imag(self) * imag(self))};
-    }
-
-    // proj
-    template<class A, class T>
-    complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = complex_batch_type_t<batch<T, A>>;
-      using real_batch = typename batch_type::real_batch;
-      using real_value_type = typename real_batch::value_type;
-      auto cond = xsimd::isinf(real(self)) || xsimd::isinf(imag(self));
-      return select(cond,
-                    batch_type(constants::infinity<real_batch>(),
-                               copysign(real_batch(real_value_type(0)), imag(self))),
-                    batch_type(self));
-    }
-
-    template <class A, class T>
-    batch_bool<T, A> isnan(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      return batch_bool<T, A>(isnan(self.real()) || isnan(self.imag()));
-    }
-  }
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_details.hpp b/third_party/xsimd/arch/generic/xsimd_generic_details.hpp
index c14ba3d85..153ca0b4e 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_details.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_details.hpp
@@ -1,217 +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. *
-****************************************************************************/
+ * 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_GENERIC_DETAILS_HPP
 #define XSIMD_GENERIC_DETAILS_HPP
 
 #include <complex>
 
+#include "../../math/xsimd_rem_pio2.hpp"
 #include "../../types/xsimd_generic_arch.hpp"
 #include "../../types/xsimd_utils.hpp"
-#include "../../math/xsimd_rem_pio2.hpp"
 #include "../xsimd_constants.hpp"
 
-namespace xsimd {
-  // Forward declaration. Should we put them in a separate file?
-  template<class T, class A>
-  batch<T, A> abs(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> abs(batch<std::complex<T>, A> const& self);
-  template<class T, class A>
-  bool any(batch_bool<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other);
-  template<class T, class A>
-  batch<T, A> bitofsign(batch<T, A> const& self);
-  template<class B, class T, class A>
-  B bitwise_cast(batch<T, A> const& self);
-  template<class A>
-  batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self);
-  template<class A>
-  batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self);
-  template<class A>
-  batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self);
-  template<class A>
-  batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self);
-  template<class T, class A>
-  batch<T, A> cos(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> cosh(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> exp(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z);
-  template<class T, class A>
-  batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z);
-  template<class T, class A>
-  batch<T, A> frexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& e);
-  template<class T, class A>
-  T hadd(batch<T, A> const&);
-  template <class T, class A, uint64_t... Coefs>
-  batch<T, A> horner(const batch<T, A>& self);
-  template <class T, class A>
-  batch<T, A> hypot(const batch<T, A>& self);
-  template<class T, class A>
-  batch_bool<T, A> is_even(batch<T, A> const& self);
-  template<class T, class A>
-  batch_bool<T, A> is_flint(batch<T, A> const& self);
-  template<class T, class A>
-  batch_bool<T, A> is_odd(batch<T, A> const& self);
-  template<class T, class A>
-  batch_bool<T, A> isinf(batch<T, A> const& self);
-  template<class T, class A>
-  typename batch<T, A>::batch_bool_type isnan(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& e);
-  template<class T, class A>
-  batch<T, A> log(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> nearbyint(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> select(batch_bool<T, A> const&, batch<T, A> const& , batch<T, A> const& );
-  template<class T, class A>
-  batch<std::complex<T>, A> select(batch_bool<T, A> const&, batch<std::complex<T>, A> const& , batch<std::complex<T>, A> const& );
-  template<class T, class A>
-  batch<T, A> sign(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> signnz(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> sin(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> sinh(batch<T, A> const& self);
-  template<class T, class A>
-  std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> sqrt(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> tan(batch<T, A> const& self);
-  template<class T, class A>
-  batch<as_float_t<T>, A> to_float(batch<T, A> const& self);
-  template<class T, class A>
-  batch<as_integer_t<T>, A> to_int(batch<T, A> const& self);
-  template<class T, class A>
-  batch<T, A> trunc(batch<T, A> const& self);
-
-
-  namespace kernel {
-
-    namespace detail {
-      template<class F, class A, class T, class... Batches>
-      batch<T, A> apply(F&& func, batch<T, A> const& self, batch<T, A> const& other) {
-        constexpr std::size_t size = batch<T, A>::size;
-        alignas(A::alignment()) T self_buffer[size];
-        alignas(A::alignment()) T other_buffer[size];
-        self.store_aligned(&self_buffer[0]);
-        other.store_aligned(&other_buffer[0]);
-        for(std::size_t i = 0; i < size; ++i) {
-          self_buffer[i] = func(self_buffer[i], other_buffer[i]);
-        }
-        return batch<T, A>::load_aligned(self_buffer);
-      }
-    }
-
-    namespace detail {
-      // Generic conversion handling machinery. Each architecture must define
-      // conversion function when such conversions exits in the form of
-      // intrinsic. Then we use that information to automatically decide whether
-      // to use scalar or vector conversion when doing load / store / batch_cast
-      struct with_fast_conversion{};
-      struct with_slow_conversion{};
-
-      template <class A, class From, class To, class = void>
-      struct conversion_type_impl
-      {
-          using type = with_slow_conversion;
-      };
-
-      using xsimd::detail::void_t;
-
-      template <class A, class From, class To>
-      struct conversion_type_impl<A, From, To,
-                void_t<decltype(fast_cast(std::declval<const From&>(), std::declval<const To&>(), std::declval<const A&>()))>>
-      {
-          using type = with_fast_conversion;
-      };
-
-      template <class A, class From, class To>
-      using conversion_type = typename conversion_type_impl<A, From, To>::type;
-    }
-
-    namespace detail {
-    /* origin: boost/simdfunction/horn.hpp*/
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-        template <class B, uint64_t c>
-        inline B coef() noexcept
-        {
-            using value_type = typename B::value_type;
-            return B(bit_cast<value_type>(as_unsigned_integer_t<value_type>(c)));
-        }
-        template <class B>
-        inline B horner(const B&) noexcept
+namespace xsimd
+{
+    // Forward declaration. Should we put them in a separate file?
+    template <class T, class A>
+    inline batch<T, A> abs(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> abs(batch<std::complex<T>, A> const& self) noexcept;
+    template <class T, class A>
+    inline bool any(batch_bool<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other) noexcept;
+    template <class T, class A>
+    inline batch<T, A> bitofsign(batch<T, A> const& self) noexcept;
+    template <class B, class T, class A>
+    inline B bitwise_cast(batch<T, A> const& self) noexcept;
+    template <class A>
+    inline batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self) noexcept;
+    template <class A>
+    inline batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self) noexcept;
+    template <class A>
+    inline batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self) noexcept;
+    template <class A>
+    inline batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> cos(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> cosh(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> exp(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept;
+    template <class T, class A>
+    inline batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept;
+    template <class T, class A>
+    inline batch<T, A> frexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& e) noexcept;
+    template <class T, class A>
+    inline T hadd(batch<T, A> const&) noexcept;
+    template <class T, class A, uint64_t... Coefs>
+    inline batch<T, A> horner(const batch<T, A>& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> hypot(const batch<T, A>& self) noexcept;
+    template <class T, class A>
+    inline batch_bool<T, A> is_even(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch_bool<T, A> is_flint(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch_bool<T, A> is_odd(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch_bool<T, A> isinf(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline typename batch<T, A>::batch_bool_type isnan(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& e) noexcept;
+    template <class T, class A>
+    inline batch<T, A> log(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> nearbyint(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> select(batch_bool<T, A> const&, batch<T, A> const&, batch<T, A> const&) noexcept;
+    template <class T, class A>
+    inline batch<std::complex<T>, A> select(batch_bool<T, A> const&, batch<std::complex<T>, A> const&, batch<std::complex<T>, A> const&) noexcept;
+    template <class T, class A>
+    inline batch<T, A> sign(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> signnz(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> sin(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> sinh(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> sqrt(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> tan(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<as_float_t<T>, A> to_float(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<as_integer_t<T>, A> to_int(batch<T, A> const& self) noexcept;
+    template <class T, class A>
+    inline batch<T, A> trunc(batch<T, A> const& self) noexcept;
+
+    namespace kernel
+    {
+
+        namespace detail
         {
-            return B(typename B::value_type(0.));
+            template <class F, class A, class T, class... Batches>
+            inline batch<T, A> apply(F&& func, batch<T, A> const& self, batch<T, A> const& other) noexcept
+            {
+                constexpr std::size_t size = batch<T, A>::size;
+                alignas(A::alignment()) T self_buffer[size];
+                alignas(A::alignment()) T other_buffer[size];
+                self.store_aligned(&self_buffer[0]);
+                other.store_aligned(&other_buffer[0]);
+                for (std::size_t i = 0; i < size; ++i)
+                {
+                    self_buffer[i] = func(self_buffer[i], other_buffer[i]);
+                }
+                return batch<T, A>::load_aligned(self_buffer);
+            }
         }
 
-        template <class B, uint64_t c0>
-        inline B horner(const B&) noexcept
+        namespace detail
         {
-            return coef<B, c0>();
+            // Generic conversion handling machinery. Each architecture must define
+            // conversion function when such conversions exits in the form of
+            // intrinsic. Then we use that information to automatically decide whether
+            // to use scalar or vector conversion when doing load / store / batch_cast
+            struct with_fast_conversion
+            {
+            };
+            struct with_slow_conversion
+            {
+            };
+
+            template <class A, class From, class To, class = void>
+            struct conversion_type_impl
+            {
+                using type = with_slow_conversion;
+            };
+
+            using xsimd::detail::void_t;
+
+            template <class A, class From, class To>
+            struct conversion_type_impl<A, From, To,
+                                        void_t<decltype(fast_cast(std::declval<const batch<From, A>&>(),
+                                                                  std::declval<const batch<To, A>&>(),
+                                                                  std::declval<const A&>()))>>
+            {
+                using type = with_fast_conversion;
+            };
+
+            template <class A, class From, class To>
+            using conversion_type = typename conversion_type_impl<A, From, To>::type;
         }
 
-        template <class B, uint64_t c0, uint64_t c1, uint64_t... args>
-        inline B horner(const B& self) noexcept
+        namespace detail
         {
-            return fma(self, horner<B, c1, args...>(self), coef<B, c0>());
+            /* origin: boost/simdfunction/horn.hpp*/
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B, uint64_t c>
+            inline B coef() noexcept
+            {
+                using value_type = typename B::value_type;
+                return B(bit_cast<value_type>(as_unsigned_integer_t<value_type>(c)));
+            }
+            template <class B>
+            inline B horner(const B&) noexcept
+            {
+                return B(typename B::value_type(0.));
+            }
+
+            template <class B, uint64_t c0>
+            inline B horner(const B&) noexcept
+            {
+                return coef<B, c0>();
+            }
+
+            template <class B, uint64_t c0, uint64_t c1, uint64_t... args>
+            inline B horner(const B& self) noexcept
+            {
+                return fma(self, horner<B, c1, args...>(self), coef<B, c0>());
+            }
+
+            /* origin: boost/simdfunction/horn1.hpp*/
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            inline B horner1(const B&) noexcept
+            {
+                return B(1.);
+            }
+
+            template <class B, uint64_t c0>
+            inline B horner1(const B& x) noexcept
+            {
+                return x + detail::coef<B, c0>();
+            }
+
+            template <class B, uint64_t c0, uint64_t c1, uint64_t... args>
+            inline B horner1(const B& x) noexcept
+            {
+                return fma(x, horner1<B, c1, args...>(x), detail::coef<B, c0>());
+            }
         }
 
-    /* origin: boost/simdfunction/horn1.hpp*/
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-        template <class B>
-        inline B horner1(const B&) noexcept
-        {
-            return B(1.);
-        }
-
-        template <class B, uint64_t c0>
-        inline B horner1(const B& x) noexcept
-        {
-            return x + detail::coef<B, c0>();
-        }
-
-        template <class B, uint64_t c0, uint64_t c1, uint64_t... args>
-        inline B horner1(const B& x) noexcept
-        {
-            return fma(x, horner1<B, c1, args...>(x), detail::coef<B, c0>());
-        }
     }
 
-
-
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_logical.hpp b/third_party/xsimd/arch/generic/xsimd_generic_logical.hpp
index fb8110b97..d535e36c5 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_logical.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_logical.hpp
@@ -1,107 +1,136 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_LOGICAL_HPP
 #define XSIMD_GENERIC_LOGICAL_HPP
 
 #include "./xsimd_generic_details.hpp"
 
-
-namespace xsimd {
-
-  namespace kernel {
-
-    using namespace types;
-
-    // ge
-    template<class A, class T> batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return other <= self;
-    }
-
-    // gt
-    template<class A, class T> batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return other < self;
-    }
-
-    // is_even
-    template<class A, class T> batch_bool<T, A> is_even(batch<T, A> const& self, requires_arch<generic>) {
-      return is_flint(self * T(0.5));
-    }
-
-    // is_flint
-    template<class A, class T> batch_bool<T, A> is_flint(batch<T, A> const& self, requires_arch<generic>) {
-      auto frac = select(isnan(self - self), constants::nan<batch<T, A>>(), self - trunc(self));
-      return frac == T(0.);
-    }
-
-    // is_odd
-    template<class A, class T> batch_bool<T, A> is_odd(batch<T, A> const& self, requires_arch<generic>) {
-      return is_even(self - T(1.));
-    }
-
-    // isinf
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> isinf(batch<T, A> const& , requires_arch<generic>) {
-      return batch_bool<T, A>(false);
-    }
-    template<class A> batch_bool<float, A> isinf(batch<float, A> const& self, requires_arch<generic>) {
-      return abs(self) == std::numeric_limits<float>::infinity();
-    }
-    template<class A> batch_bool<double, A> isinf(batch<double, A> const& self, requires_arch<generic>) {
-      return abs(self) == std::numeric_limits<double>::infinity();
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // ge
+        template <class A, class T>
+        inline batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return other <= self;
+        }
+
+        // gt
+        template <class A, class T>
+        inline batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return other < self;
+        }
+
+        // is_even
+        template <class A, class T>
+        inline batch_bool<T, A> is_even(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return is_flint(self * T(0.5));
+        }
+
+        // is_flint
+        template <class A, class T>
+        inline batch_bool<T, A> is_flint(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            auto frac = select(isnan(self - self), constants::nan<batch<T, A>>(), self - trunc(self));
+            return frac == T(0.);
+        }
+
+        // is_odd
+        template <class A, class T>
+        inline batch_bool<T, A> is_odd(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return is_even(self - T(1.));
+        }
+
+        // isinf
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> isinf(batch<T, A> const&, requires_arch<generic>) noexcept
+        {
+            return batch_bool<T, A>(false);
+        }
+        template <class A>
+        inline batch_bool<float, A> isinf(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return abs(self) == std::numeric_limits<float>::infinity();
+        }
+        template <class A>
+        inline batch_bool<double, A> isinf(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return abs(self) == std::numeric_limits<double>::infinity();
+        }
+
+        // isfinite
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> isfinite(batch<T, A> const&, requires_arch<generic>) noexcept
+        {
+            return batch_bool<T, A>(true);
+        }
+        template <class A>
+        inline batch_bool<float, A> isfinite(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return (self - self) == 0;
+        }
+        template <class A>
+        inline batch_bool<double, A> isfinite(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return (self - self) == 0;
+        }
+
+        // isnan
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> isnan(batch<T, A> const&, requires_arch<generic>) noexcept
+        {
+            return batch_bool<T, A>(false);
+        }
+
+        // le
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return (self < other) || (self == other);
+        }
+
+        // neq
+        template <class A, class T>
+        inline batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return !(other == self);
+        }
+
+        // logical_and
+        template <class A, class T>
+        inline batch<T, A> logical_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x && y; },
+                                 self, other);
+        }
+
+        // logical_or
+        template <class A, class T>
+        inline batch<T, A> logical_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x || y; },
+                                 self, other);
+        }
     }
-
-    // isfinite
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> isfinite(batch<T, A> const& , requires_arch<generic>) {
-      return batch_bool<T, A>(true);
-    }
-    template<class A> batch_bool<float, A> isfinite(batch<float, A> const& self, requires_arch<generic>) {
-      return (self - self) == 0;
-    }
-    template<class A> batch_bool<double, A> isfinite(batch<double, A> const& self, requires_arch<generic>) {
-      return (self - self) == 0;
-    }
-
-    // isnan
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> isnan(batch<T, A> const& , requires_arch<generic>) {
-      return batch_bool<T, A>(false);
-    }
-
-    // le
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return (self < other) || (self == other);
-    }
-
-
-    // neq
-    template<class A, class T> batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return !(other == self);
-    }
-
-    // logical_and
-    template <class A, class T>
-    batch<T, A> logical_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) { return x && y;}, self, other);
-    }
-
-    // logical_or
-    template <class A, class T>
-    batch<T, A> logical_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) { return x || y;}, self, other);
-    }
-  }
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_math.hpp b/third_party/xsimd/arch/generic/xsimd_generic_math.hpp
index 2b8562b73..d236b410d 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_math.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_math.hpp
@@ -1,95 +1,109 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_MATH_HPP
 #define XSIMD_GENERIC_MATH_HPP
 
-#include <type_traits>
-
+#include "../xsimd_scalar.hpp"
 #include "./xsimd_generic_details.hpp"
 #include "./xsimd_generic_trigo.hpp"
-#include "../xsimd_scalar.hpp"
 
+#include <type_traits>
 
-namespace xsimd {
-
-  namespace kernel {
+namespace xsimd
+{
 
-    using namespace types;
-    // abs
-    template<class A, class T, class/*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>)
+    namespace kernel
     {
-      if(std::is_unsigned<T>::value)
-        return self;
-      else {
-        auto sign = bitofsign(self);
-        auto inv = self ^ sign;
-        return inv - sign;
-      }
-    }
 
-    template<class A, class T>
-    batch<T, A> abs(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      return hypot(z.real(), z.imag());
-    }
+        using namespace types;
+        // abs
+        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            if (std::is_unsigned<T>::value)
+                return self;
+            else
+            {
+                auto sign = bitofsign(self);
+                auto inv = self ^ sign;
+                return inv - sign;
+            }
+        }
 
-    // batch_cast
-    template<class A, class T> batch<T, A> batch_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<generic>) {
-      return self;
-    }
+        template <class A, class T>
+        inline batch<T, A> abs(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            return hypot(z.real(), z.imag());
+        }
 
-    namespace detail {
-    template<class A, class T_out, class T_in>
-    batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>, with_fast_conversion) {
-      return fast_cast(self, out, A{});
-    }
-    template<class A, class T_out, class T_in>
-    batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<generic>, with_slow_conversion) {
-      static_assert(!std::is_same<T_in, T_out>::value, "there should be no conversion for this type combination");
-      using batch_type_in = batch<T_in, A>;
-      using batch_type_out = batch<T_out, A>;
-      static_assert(batch_type_in::size == batch_type_out::size, "compatible sizes");
-      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));
-      return batch_type_out::load_aligned(buffer_out);
-    }
+        // batch_cast
+        template <class A, class T>
+        inline batch<T, A> batch_cast(batch<T, A> const& self, batch<T, A> const&, requires_arch<generic>) noexcept
+        {
+            return self;
+        }
 
-    }
+        namespace detail
+        {
+            template <class A, class T_out, class T_in>
+            inline batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>, with_fast_conversion) noexcept
+            {
+                return fast_cast(self, out, A {});
+            }
+            template <class A, class T_out, class T_in>
+            inline batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<generic>, with_slow_conversion) noexcept
+            {
+                static_assert(!std::is_same<T_in, T_out>::value, "there should be no conversion for this type combination");
+                using batch_type_in = batch<T_in, A>;
+                using batch_type_out = batch<T_out, A>;
+                static_assert(batch_type_in::size == batch_type_out::size, "compatible sizes");
+                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));
+                return batch_type_out::load_aligned(buffer_out);
+            }
 
-    template<class A, class T_out, class T_in>
-    batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>) {
-      return detail::batch_cast(self, out, A{}, detail::conversion_type<A, T_in, T_out>{});
-    }
+        }
 
-    // bitofsign
-    template<class A, class T> batch<T, A> bitofsign(batch<T, A> const& self, requires_arch<generic>) {
-      static_assert(std::is_integral<T>::value, "int type implementation");
-      if(std::is_unsigned<T>::value)
-        return batch<T, A>(0);
-      else
-        return self >> (T)(8 * sizeof(T) - 1);
-    }
+        template <class A, class T_out, class T_in>
+        inline batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const& out, requires_arch<generic>) noexcept
+        {
+            return detail::batch_cast(self, out, A {}, detail::conversion_type<A, T_in, T_out> {});
+        }
 
-    template<class A> batch<float, A> bitofsign(batch<float, A> const& self, requires_arch<generic>) {
-      return self & constants::minuszero<batch<float, A>>();
-    }
-    template<class A> batch<double, A> bitofsign(batch<double, A> const& self, requires_arch<generic>) {
-      return self & constants::minuszero<batch<double, A>>();
-    }
+        // bitofsign
+        template <class A, class T>
+        inline batch<T, A> bitofsign(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            static_assert(std::is_integral<T>::value, "int type implementation");
+            if (std::is_unsigned<T>::value)
+                return batch<T, A>(0);
+            else
+                return self >> (T)(8 * sizeof(T) - 1);
+        }
 
+        template <class A>
+        inline batch<float, A> bitofsign(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self & constants::minuszero<batch<float, A>>();
+        }
+        template <class A>
+        inline batch<double, A> bitofsign(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self & constants::minuszero<batch<double, A>>();
+        }
 
-    // cbrt
+        // cbrt
         /* origin: boost/simd/arch/common/simd/function/cbrt.hpp */
         /*
          * ====================================================
@@ -99,112 +113,280 @@ namespace xsimd {
          * (See copy at http://boost.org/LICENSE_1_0.txt)
          * ====================================================
          */
-    template<class A> batch<float, A> cbrt(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                batch_type z = abs(self);
+        template <class A>
+        inline batch<float, A> cbrt(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            batch_type z = abs(self);
 #ifndef XSIMD_NO_DENORMALS
-                auto denormal = z < constants::smallestposval<batch_type>();
-                z = select(denormal, z * constants::twotonmb<batch_type>(), z);
-                batch_type f = select(denormal, constants::twotonmbo3<batch_type>(), batch_type(1.));
+            auto denormal = z < constants::smallestposval<batch_type>();
+            z = select(denormal, z * constants::twotonmb<batch_type>(), z);
+            batch_type f = select(denormal, constants::twotonmbo3<batch_type>(), batch_type(1.));
 #endif
-                const batch_type CBRT2 (bit_cast<float>(0x3fa14518));
-                const batch_type CBRT4 (bit_cast<float>(0x3fcb2ff5));
-                const batch_type CBRT2I (bit_cast<float>(0x3f4b2ff5));
-                const batch_type CBRT4I (bit_cast<float>(0x3f214518));
-                using i_type = as_integer_t<batch_type>;
-                i_type e;
-                batch_type x = frexp(z, e);
-                x = detail::horner<batch_type,
-                           0x3ece0609,
-                           0x3f91eb77,
-                           0xbf745265,
-                           0x3f0bf0fe,
-                           0xbe09e49a>(x);
-                auto flag = e >= i_type(0);
-                i_type e1 = abs(e);
-                i_type rem = e1;
-                e1 /= i_type(3);
-                rem -= e1 * i_type(3);
-                e = e1 * sign(e);
-                const batch_type cbrt2 = select(bool_cast(flag), CBRT2, CBRT2I);
-                const batch_type cbrt4 = select(bool_cast(flag), CBRT4, CBRT4I);
-                batch_type fact = select(bool_cast(rem == i_type(1)), cbrt2, batch_type(1.));
-                fact = select(bool_cast(rem == i_type(2)), cbrt4, fact);
-                x = ldexp(x * fact, e);
-                x -= (x - z / (x * x)) * batch_type(1.f / 3.f);
+            const batch_type CBRT2(bit_cast<float>(0x3fa14518));
+            const batch_type CBRT4(bit_cast<float>(0x3fcb2ff5));
+            const batch_type CBRT2I(bit_cast<float>(0x3f4b2ff5));
+            const batch_type CBRT4I(bit_cast<float>(0x3f214518));
+            using i_type = as_integer_t<batch_type>;
+            i_type e;
+            batch_type x = frexp(z, e);
+            x = detail::horner<batch_type,
+                               0x3ece0609,
+                               0x3f91eb77,
+                               0xbf745265,
+                               0x3f0bf0fe,
+                               0xbe09e49a>(x);
+            auto flag = e >= i_type(0);
+            i_type e1 = abs(e);
+            i_type rem = e1;
+            e1 /= i_type(3);
+            rem -= e1 * i_type(3);
+            e = e1 * sign(e);
+            const batch_type cbrt2 = select(bool_cast(flag), CBRT2, CBRT2I);
+            const batch_type cbrt4 = select(bool_cast(flag), CBRT4, CBRT4I);
+            batch_type fact = select(bool_cast(rem == i_type(1)), cbrt2, batch_type(1.));
+            fact = select(bool_cast(rem == i_type(2)), cbrt4, fact);
+            x = ldexp(x * fact, e);
+            x -= (x - z / (x * x)) * batch_type(1.f / 3.f);
 #ifndef XSIMD_NO_DENORMALS
-                x = (x | bitofsign(self)) * f;
+            x = (x | bitofsign(self)) * f;
 #else
-                x = x | bitofsign(self);
+            x = x | bitofsign(self);
 #endif
 #ifndef XSIMD_NO_INFINITIES
-                return select(self == batch_type(0.) || isinf(self), self, x);
+            return select(self == batch_type(0.) || isinf(self), self, x);
 #else
-                return select(self == batch_type(0.), self, x);
+            return select(self == batch_type(0.), self, x);
 #endif
-    }
-    template<class A> batch<double, A> cbrt(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                batch_type z = abs(self);
+        }
+
+        template <class A>
+        inline batch<double, A> cbrt(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            batch_type z = abs(self);
 #ifndef XSIMD_NO_DENORMALS
-                auto denormal = z < constants::smallestposval<batch_type>();
-                z = select(denormal, z * constants::twotonmb<batch_type>(), z);
-                batch_type f = select(denormal, constants::twotonmbo3<batch_type>(), batch_type(1.));
+            auto denormal = z < constants::smallestposval<batch_type>();
+            z = select(denormal, z * constants::twotonmb<batch_type>(), z);
+            batch_type f = select(denormal, constants::twotonmbo3<batch_type>(), batch_type(1.));
 #endif
-                const batch_type CBRT2(bit_cast<double>(int64_t(0x3ff428a2f98d728b)));
-                const batch_type CBRT4(bit_cast<double>(int64_t(0x3ff965fea53d6e3d)));
-                const batch_type CBRT2I(bit_cast<double>(int64_t(0x3fe965fea53d6e3d)));
-                const batch_type CBRT4I(bit_cast<double>(int64_t(0x3fe428a2f98d728b)));
-                using i_type = as_integer_t<batch_type>;
-                i_type e;
-                batch_type x = frexp(z, e);
-                x = detail::horner<batch_type,
-                           0x3fd9c0c12122a4feull,
-                           0x3ff23d6ee505873aull,
-                           0xbfee8a4ca3ba37b8ull,
-                           0x3fe17e1fc7e59d58ull,
-                           0xbfc13c93386fdff6ull>(x);
-                auto flag = e >= typename i_type::value_type(0);
-                i_type e1 = abs(e);
-                i_type rem = e1;
-                e1 /= i_type(3);
-                rem -= e1 * i_type(3);
-                e = e1 * sign(e);
-                const batch_type cbrt2 = select(bool_cast(flag), CBRT2, CBRT2I);
-                const batch_type cbrt4 = select(bool_cast(flag), CBRT4, CBRT4I);
-                batch_type fact = select(bool_cast(rem == i_type(1)), cbrt2, batch_type(1.));
-                fact = select(bool_cast(rem == i_type(2)), cbrt4, fact);
-                x = ldexp(x * fact, e);
-                x -= (x - z / (x * x)) * batch_type(1. / 3.);
-                x -= (x - z / (x * x)) * batch_type(1. / 3.);
+            const batch_type CBRT2(bit_cast<double>(int64_t(0x3ff428a2f98d728b)));
+            const batch_type CBRT4(bit_cast<double>(int64_t(0x3ff965fea53d6e3d)));
+            const batch_type CBRT2I(bit_cast<double>(int64_t(0x3fe965fea53d6e3d)));
+            const batch_type CBRT4I(bit_cast<double>(int64_t(0x3fe428a2f98d728b)));
+            using i_type = as_integer_t<batch_type>;
+            i_type e;
+            batch_type x = frexp(z, e);
+            x = detail::horner<batch_type,
+                               0x3fd9c0c12122a4feull,
+                               0x3ff23d6ee505873aull,
+                               0xbfee8a4ca3ba37b8ull,
+                               0x3fe17e1fc7e59d58ull,
+                               0xbfc13c93386fdff6ull>(x);
+            auto flag = e >= typename i_type::value_type(0);
+            i_type e1 = abs(e);
+            i_type rem = e1;
+            e1 /= i_type(3);
+            rem -= e1 * i_type(3);
+            e = e1 * sign(e);
+            const batch_type cbrt2 = select(bool_cast(flag), CBRT2, CBRT2I);
+            const batch_type cbrt4 = select(bool_cast(flag), CBRT4, CBRT4I);
+            batch_type fact = select(bool_cast(rem == i_type(1)), cbrt2, batch_type(1.));
+            fact = select(bool_cast(rem == i_type(2)), cbrt4, fact);
+            x = ldexp(x * fact, e);
+            x -= (x - z / (x * x)) * batch_type(1. / 3.);
+            x -= (x - z / (x * x)) * batch_type(1. / 3.);
 #ifndef XSIMD_NO_DENORMALS
-                x = (x | bitofsign(self)) * f;
+            x = (x | bitofsign(self)) * f;
 #else
-                x = x | bitofsign(self);
+            x = x | bitofsign(self);
 #endif
 #ifndef XSIMD_NO_INFINITIES
-                return select(self == batch_type(0.) || isinf(self), self, x);
+            return select(self == batch_type(0.) || isinf(self), self, x);
 #else
-                return select(self == batch_type(0.), self, x);
+            return select(self == batch_type(0.), self, x);
 #endif
-    }
+        }
 
-    // clip
-    template<class A, class T> batch<T, A> clip(batch<T, A> const& self, batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<generic>) {
-      return min(hi, max(self, lo));
-    }
+        // clip
+        template <class A, class T>
+        inline batch<T, A> clip(batch<T, A> const& self, batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<generic>) noexcept
+        {
+            return min(hi, max(self, lo));
+        }
 
+        // copysign
+        template <class A, class T>
+        inline batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return abs(self) | bitofsign(other);
+        }
 
-    // copysign
-    template<class A, class T> batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return abs(self) | bitofsign(other);
-    }
+        // erf
 
+        namespace detail
+        {
+            /* origin: boost/simd/arch/common/detail/generic/erf_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            struct erf_kernel;
+
+            template <class A>
+            struct erf_kernel<batch<float, A>>
+            {
+                using batch_type = batch<float, A>;
+                // computes erf(a0)/a0
+                // x is sqr(a0) and 0 <= abs(a0) <= 2/3
+                static inline batch_type erf1(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0x3f906eba, //   1.128379154774254e+00
+                                          0xbec0937e, //  -3.761252839094832e-01
+                                          0x3de70f22, //   1.128218315189123e-01
+                                          0xbcdb61f4, //  -2.678010670585737e-02
+                                          0x3ba4468d, //   5.013293006147870e-03
+                                          0xba1fc83b //  -6.095205117313012e-04
+                                          >(x);
+                }
+
+                // computes erfc(x)*exp(sqr(x))
+                // x >=  2/3
+                static inline batch_type erfc2(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0x3f0a0e8b, //   5.392844046572836e-01
+                                          0xbf918a62, //  -1.137035586823118e+00
+                                          0x3e243828, //   1.603704761054187e-01
+                                          0x3ec4ca6e, //   3.843569094305250e-01
+                                          0x3e1175c7, //   1.420508523645926e-01
+                                          0x3e2006f0, //   1.562764709849380e-01
+                                          0xbfaea865, //  -1.364514006347145e+00
+                                          0x4050b063, //   3.260765682222576e+00
+                                          0xc0cd1a85, //  -6.409487379234005e+00
+                                          0x40d67e3b, //   6.702908785399893e+00
+                                          0xc0283611 //  -2.628299919293280e+00
+                                          >(x);
+                }
 
-    // erf
+                static inline batch_type erfc3(const batch_type& x) noexcept
+                {
+                    return (batch_type(1.) - x) * detail::horner<batch_type,
+                                                                 0x3f7ffffe, //   9.9999988e-01
+                                                                 0xbe036d7e, //  -1.2834737e-01
+                                                                 0xbfa11698, //  -1.2585020e+00
+                                                                 0xbffc9284, //  -1.9732213e+00
+                                                                 0xc016c985, //  -2.3560498e+00
+                                                                 0x3f2cff3b, //   6.7576951e-01
+                                                                 0xc010d956, //  -2.2632651e+00
+                                                                 0x401b5680, //   2.4271545e+00
+                                                                 0x41aa8e55 //   2.1319498e+01
+                                                                 >(x);
+                }
+            };
+
+            template <class A>
+            struct erf_kernel<batch<double, A>>
+            {
+                using batch_type = batch<double, A>;
+                // computes erf(a0)/a0
+                // x is sqr(a0) and 0 <= abs(a0) <= 0.65
+                static inline batch_type erf1(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0x3ff20dd750429b61ull, // 1.12837916709551
+                                          0x3fc16500f106c0a5ull, // 0.135894887627278
+                                          0x3fa4a59a4f02579cull, // 4.03259488531795E-02
+                                          0x3f53b7664358865aull, // 1.20339380863079E-03
+                                          0x3f110512d5b20332ull // 6.49254556481904E-05
+                                          >(x)
+                        / detail::horner<batch_type,
+                                         0x3ff0000000000000ull, // 1
+                                         0x3fdd0a84eb1ca867ull, // 0.453767041780003
+                                         0x3fb64536ca92ea2full, // 8.69936222615386E-02
+                                         0x3f8166f75999dbd1ull, // 8.49717371168693E-03
+                                         0x3f37ea4332348252ull // 3.64915280629351E-04
+                                         >(x);
+                }
+
+                // computes erfc(x)*exp(x*x)
+                // 0.65 <= abs(x) <= 2.2
+                static inline batch_type erfc2(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0x3feffffffbbb552bull, // 0.999999992049799
+                                          0x3ff54dfe9b258a60ull, // 1.33154163936765
+                                          0x3fec1986509e687bull, // 0.878115804155882
+                                          0x3fd53dd7a67c7e9full, // 0.331899559578213
+                                          0x3fb2488a6b5cb5e5ull, // 7.14193832506776E-02
+                                          0x3f7cf4cfe0aacbb4ull, // 7.06940843763253E-03
+                                          0x0ull // 0
+                                          >(x)
+                        / detail::horner<batch_type,
+                                         0x3ff0000000000000ull, // 1
+                                         0x4003adeae79b9708ull, // 2.45992070144246
+                                         0x40053b1052dca8bdull, // 2.65383972869776
+                                         0x3ff9e677c2777c3cull, // 1.61876655543871
+                                         0x3fe307622fcff772ull, // 0.594651311286482
+                                         0x3fc033c113a7deeeull, // 0.126579413030178
+                                         0x3f89a996639b0d00ull // 1.25304936549413E-02
+                                         >(x);
+                }
+
+                // computes erfc(x)*exp(x*x)
+                // 2.2 <= abs(x) <= 6
+                static inline batch_type erfc3(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0x3fefff5a9e697ae2ull, // 0.99992114009714
+                                          0x3ff9fa202deb88e5ull, // 1.62356584489367
+                                          0x3ff44744306832aeull, // 1.26739901455873
+                                          0x3fe29be1cff90d94ull, // 0.581528574177741
+                                          0x3fc42210f88b9d43ull, // 0.157289620742839
+                                          0x3f971d0907ea7a92ull, // 2.25716982919218E-02
+                                          0x0ll // 0
+                                          >(x)
+                        / detail::horner<batch_type,
+                                         0x3ff0000000000000ull, // 1
+                                         0x400602f24bf3fdb6ull, // 2.75143870676376
+                                         0x400afd487397568full, // 3.37367334657285
+                                         0x400315ffdfd5ce91ull, // 2.38574194785344
+                                         0x3ff0cfd4cb6cde9full, // 1.05074004614827
+                                         0x3fd1d7ab774bb837ull, // 0.278788439273629
+                                         0x3fa47bd61bbb3843ull // 4.00072964526861E-02
+                                         >(x);
+                }
 
-    namespace detail {
-        /* origin: boost/simd/arch/common/detail/generic/erf_kernel.hpp */
+                // computes erfc(rx)*exp(rx*rx)
+                // x >=  6 rx = 1/x
+                static inline batch_type erfc4(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0xbc7e4ad1ec7d0000ll, // -2.627435221016534e-17
+                                          0x3fe20dd750429a16ll, // 5.641895835477182e-01
+                                          0x3db60000e984b501ll, // 2.000889609806154e-11
+                                          0xbfd20dd753ae5dfdll, // -2.820947949598745e-01
+                                          0x3e907e71e046a820ll, // 2.457786367990903e-07
+                                          0x3fdb1494cac06d39ll, // 4.231311779019112e-01
+                                          0x3f34a451701654f1ll, // 3.149699042180451e-04
+                                          0xbff105e6b8ef1a63ll, // -1.063940737150596e+00
+                                          0x3fb505a857e9ccc8ll, // 8.211757799454056e-02
+                                          0x40074fbabc514212ll, // 2.913930388669777e+00
+                                          0x4015ac7631f7ac4fll, // 5.418419628850713e+00
+                                          0xc0457e03041e9d8bll, // -4.298446704382794e+01
+                                          0x4055803d26c4ec4fll, // 8.600373238783617e+01
+                                          0xc0505fce04ec4ec5ll // -6.549694941594051e+01
+                                          >(x);
+                }
+            };
+        }
+        /* origin: boost/simd/arch/common/simd/function/erf.hpp */
         /*
          * ====================================================
          * copyright 2016 NumScale SAS
@@ -213,624 +395,486 @@ namespace xsimd {
          * (See copy at http://boost.org/LICENSE_1_0.txt)
          * ====================================================
          */
-        template <class B>
-        struct erf_kernel;
 
         template <class A>
-        struct erf_kernel<batch<float, A>>
+        inline batch<float, A> erf(batch<float, A> const& self, requires_arch<generic>) noexcept
         {
             using batch_type = batch<float, A>;
-            // computes erf(a0)/a0
-            // x is sqr(a0) and 0 <= abs(a0) <= 2/3
-            static inline batch_type erf1(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0x3f906eba,  //   1.128379154774254e+00
-                              0xbec0937e,  //  -3.761252839094832e-01
-                              0x3de70f22,  //   1.128218315189123e-01
-                              0xbcdb61f4,  //  -2.678010670585737e-02
-                              0x3ba4468d,  //   5.013293006147870e-03
-                              0xba1fc83b  //  -6.095205117313012e-04
-                              >(x);
-            }
+            batch_type x = abs(self);
+            batch_type r1(0.);
+            auto test1 = x < batch_type(2.f / 3.f);
+            if (any(test1))
+            {
+                r1 = self * detail::erf_kernel<batch_type>::erf1(x * x);
+                if (all(test1))
+                    return r1;
+            }
+            batch_type z = x / (batch_type(1.) + x);
+            z -= batch_type(0.4f);
+            batch_type r2 = batch_type(1.) - exp(-x * x) * detail::erf_kernel<batch_type>::erfc2(z);
+            r2 = select(self < batch_type(0.), -r2, r2);
+            r1 = select(test1, r1, r2);
+#ifndef XSIMD_NO_INFINITIES
+            r1 = select(xsimd::isinf(self), sign(self), r1);
+#endif
+            return r1;
+        }
 
-            // computes erfc(x)*exp(sqr(x))
-            // x >=  2/3
-            static inline batch_type erfc2(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0x3f0a0e8b,  //   5.392844046572836e-01
-                              0xbf918a62,  //  -1.137035586823118e+00
-                              0x3e243828,  //   1.603704761054187e-01
-                              0x3ec4ca6e,  //   3.843569094305250e-01
-                              0x3e1175c7,  //   1.420508523645926e-01
-                              0x3e2006f0,  //   1.562764709849380e-01
-                              0xbfaea865,  //  -1.364514006347145e+00
-                              0x4050b063,  //   3.260765682222576e+00
-                              0xc0cd1a85,  //  -6.409487379234005e+00
-                              0x40d67e3b,  //   6.702908785399893e+00
-                              0xc0283611  //  -2.628299919293280e+00
-                              >(x);
+        template <class A>
+        inline batch<double, A> erf(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            batch_type x = abs(self);
+            batch_type xx = x * x;
+            batch_type lim1(0.65);
+            batch_type lim2(2.2);
+            auto test1 = x < lim1;
+            batch_type r1(0.);
+            if (any(test1))
+            {
+                r1 = self * detail::erf_kernel<batch_type>::erf1(xx);
+                if (all(test1))
+                    return r1;
+            }
+            auto test2 = x < lim2;
+            auto test3 = test2 && !test1;
+            batch_type ex = exp(-xx);
+            if (any(test3))
+            {
+                batch_type z = batch_type(1.) - ex * detail::erf_kernel<batch_type>::erfc2(x);
+                batch_type r2 = select(self < batch_type(0.), -z, z);
+                r1 = select(test1, r1, r2);
+                if (all(test1 || test3))
+                    return r1;
             }
+            batch_type z = batch_type(1.) - ex * detail::erf_kernel<batch_type>::erfc3(x);
+            z = select(self < batch_type(0.), -z, z);
+#ifndef XSIMD_NO_INFINITIES
+            z = select(xsimd::isinf(self), sign(self), z);
+#endif
+            return select(test2, r1, z);
+        }
 
-            static inline batch_type erfc3(const batch_type& x)
-            {
-                return (batch_type(1.) - x) * detail::horner<batch_type,
-                                            0x3f7ffffe,  //   9.9999988e-01
-                                            0xbe036d7e,  //  -1.2834737e-01
-                                            0xbfa11698,  //  -1.2585020e+00
-                                            0xbffc9284,  //  -1.9732213e+00
-                                            0xc016c985,  //  -2.3560498e+00
-                                            0x3f2cff3b,  //   6.7576951e-01
-                                            0xc010d956,  //  -2.2632651e+00
-                                            0x401b5680,  //   2.4271545e+00
-                                            0x41aa8e55  //   2.1319498e+01
-                                            >(x);
-            }
-        };
+        // erfc
+        template <class A>
+        inline batch<float, A> erfc(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            batch_type x = abs(self);
+            auto test0 = self < batch_type(0.);
+            batch_type r1(0.);
+            auto test1 = x < batch_type(2.f / 3.f);
+            batch_type z = x / (batch_type(1.) + x);
+            if (any(test1))
+            {
+                r1 = detail::erf_kernel<batch_type>::erfc3(z);
+                if (all(test1))
+                    return select(test0, batch_type(2.) - r1, r1);
+            }
+            z -= batch_type(0.4f);
+            batch_type r2 = exp(-x * x) * detail::erf_kernel<batch_type>::erfc2(z);
+            r1 = select(test1, r1, r2);
+#ifndef XSIMD_NO_INFINITIES
+            r1 = select(x == constants::infinity<batch_type>(), batch_type(0.), r1);
+#endif
+            return select(test0, batch_type(2.) - r1, r1);
+        }
 
         template <class A>
-        struct erf_kernel<batch<double, A>>
+        inline batch<double, A> erfc(batch<double, A> const& self, requires_arch<generic>) noexcept
         {
             using batch_type = batch<double, A>;
-            // computes erf(a0)/a0
-            // x is sqr(a0) and 0 <= abs(a0) <= 0.65
-            static inline batch_type erf1(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0x3ff20dd750429b61ull,  // 1.12837916709551
-                              0x3fc16500f106c0a5ull,  // 0.135894887627278
-                              0x3fa4a59a4f02579cull,  // 4.03259488531795E-02
-                              0x3f53b7664358865aull,  // 1.20339380863079E-03
-                              0x3f110512d5b20332ull  // 6.49254556481904E-05
-                              >(x) /
-                    detail::horner<batch_type,
-                           0x3ff0000000000000ull,  // 1
-                           0x3fdd0a84eb1ca867ull,  // 0.453767041780003
-                           0x3fb64536ca92ea2full,  // 8.69936222615386E-02
-                           0x3f8166f75999dbd1ull,  // 8.49717371168693E-03
-                           0x3f37ea4332348252ull  // 3.64915280629351E-04
-                           >(x);
-            }
+            batch_type x = abs(self);
+            batch_type xx = x * x;
+            batch_type lim1(0.65);
+            batch_type lim2(2.2);
+            auto test0 = self < batch_type(0.);
+            auto test1 = x < lim1;
+            batch_type r1(0.);
+            if (any(test1))
+            {
+                r1 = batch_type(1.) - x * detail::erf_kernel<batch_type>::erf1(xx);
+                if (all(test1))
+                    return select(test0, batch_type(2.) - r1, r1);
+            }
+            auto test2 = x < lim2;
+            auto test3 = test2 && !test1;
+            batch_type ex = exp(-xx);
+            if (any(test3))
+            {
+                batch_type z = ex * detail::erf_kernel<batch_type>::erfc2(x);
+                r1 = select(test1, r1, z);
+                if (all(test1 || test3))
+                    return select(test0, batch_type(2.) - r1, r1);
+            }
+            batch_type z = ex * detail::erf_kernel<batch_type>::erfc3(x);
+            r1 = select(test2, r1, z);
+#ifndef XSIMD_NO_INFINITIES
+            r1 = select(x == constants::infinity<batch_type>(), batch_type(0.), r1);
+#endif
+            return select(test0, batch_type(2.) - r1, r1);
+        }
 
-            // computes erfc(x)*exp(x*x)
-            // 0.65 <= abs(x) <= 2.2
-            static inline batch_type erfc2(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0x3feffffffbbb552bull,  // 0.999999992049799
-                              0x3ff54dfe9b258a60ull,  // 1.33154163936765
-                              0x3fec1986509e687bull,  // 0.878115804155882
-                              0x3fd53dd7a67c7e9full,  // 0.331899559578213
-                              0x3fb2488a6b5cb5e5ull,  // 7.14193832506776E-02
-                              0x3f7cf4cfe0aacbb4ull,  // 7.06940843763253E-03
-                              0x0ull  // 0
-                              >(x) /
-                    detail::horner<batch_type,
-                           0x3ff0000000000000ull,  // 1
-                           0x4003adeae79b9708ull,  // 2.45992070144246
-                           0x40053b1052dca8bdull,  // 2.65383972869776
-                           0x3ff9e677c2777c3cull,  // 1.61876655543871
-                           0x3fe307622fcff772ull,  // 0.594651311286482
-                           0x3fc033c113a7deeeull,  // 0.126579413030178
-                           0x3f89a996639b0d00ull  // 1.25304936549413E-02
-                           >(x);
-            }
+        // estrin
+        namespace detail
+        {
 
-            // computes erfc(x)*exp(x*x)
-            // 2.2 <= abs(x) <= 6
-            static inline batch_type erfc3(const batch_type& x)
+            template <class B>
+            struct estrin
             {
-                return detail::horner<batch_type,
-                              0x3fefff5a9e697ae2ull,  //0.99992114009714
-                              0x3ff9fa202deb88e5ull,  //1.62356584489367
-                              0x3ff44744306832aeull,  //1.26739901455873
-                              0x3fe29be1cff90d94ull,  //0.581528574177741
-                              0x3fc42210f88b9d43ull,  //0.157289620742839
-                              0x3f971d0907ea7a92ull,  //2.25716982919218E-02
-                              0x0ll  //0
-                              >(x) /
-                    detail::horner<batch_type,
-                           0x3ff0000000000000ull,  //1
-                           0x400602f24bf3fdb6ull,  //2.75143870676376
-                           0x400afd487397568full,  //3.37367334657285
-                           0x400315ffdfd5ce91ull,  //2.38574194785344
-                           0x3ff0cfd4cb6cde9full,  //1.05074004614827
-                           0x3fd1d7ab774bb837ull,  //0.278788439273629
-                           0x3fa47bd61bbb3843ull  //4.00072964526861E-02
-                           >(x);
-            }
+                B x;
 
-            // computes erfc(rx)*exp(rx*rx)
-            // x >=  6 rx = 1/x
-            static inline batch_type erfc4(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0xbc7e4ad1ec7d0000ll,  // -2.627435221016534e-17
-                              0x3fe20dd750429a16ll,  // 5.641895835477182e-01
-                              0x3db60000e984b501ll,  // 2.000889609806154e-11
-                              0xbfd20dd753ae5dfdll,  // -2.820947949598745e-01
-                              0x3e907e71e046a820ll,  // 2.457786367990903e-07
-                              0x3fdb1494cac06d39ll,  // 4.231311779019112e-01
-                              0x3f34a451701654f1ll,  // 3.149699042180451e-04
-                              0xbff105e6b8ef1a63ll,  // -1.063940737150596e+00
-                              0x3fb505a857e9ccc8ll,  // 8.211757799454056e-02
-                              0x40074fbabc514212ll,  // 2.913930388669777e+00
-                              0x4015ac7631f7ac4fll,  // 5.418419628850713e+00
-                              0xc0457e03041e9d8bll,  // -4.298446704382794e+01
-                              0x4055803d26c4ec4fll,  // 8.600373238783617e+01
-                              0xc0505fce04ec4ec5ll  // -6.549694941594051e+01
-                              >(x);
-            }
-        };
-    }
-        /* origin: boost/simd/arch/common/simd/function/erf.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
+                template <typename... Ts>
+                inline B operator()(const Ts&... coefs) noexcept
+                {
+                    return eval(coefs...);
+                }
 
-    template<class A>
-    batch<float, A> erf(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                batch_type x = abs(self);
-                batch_type r1(0.);
-                auto test1 = x < batch_type(2.f / 3.f);
-                if (any(test1))
+            private:
+                inline B eval(const B& c0) noexcept
                 {
-                    r1 = self * detail::erf_kernel<batch_type>::erf1(x * x);
-                    if (all(test1))
-                        return r1;
+                    return c0;
                 }
-                batch_type z = x / (batch_type(1.) + x);
-                z -= batch_type(0.4f);
-                batch_type r2 = batch_type(1.) - exp(-x * x) * detail::erf_kernel<batch_type>::erfc2(z);
-                r2 = select(self < batch_type(0.), -r2, r2);
-                r1 = select(test1, r1, r2);
-#ifndef XSIMD_NO_INFINITIES
-                r1 = select(xsimd::isinf(self), sign(self), r1);
-#endif
-                return r1;
-            }
-    template<class A> batch<double, A> erf(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                batch_type x = abs(self);
-                batch_type xx = x * x;
-                batch_type lim1 (0.65);
-                batch_type lim2 (2.2);
-                auto test1 = x < lim1;
-                batch_type r1 (0.);
-                if (any(test1))
+
+                inline B eval(const B& c0, const B& c1) noexcept
                 {
-                    r1 = self * detail::erf_kernel<batch_type>::erf1(xx);
-                    if (all(test1))
-                        return r1;
+                    return fma(x, c1, c0);
                 }
-                auto test2 = x < lim2;
-                auto test3 = test2 && !test1;
-                batch_type ex = exp(-xx);
-                if (any(test3))
+
+                template <size_t... Is, class Tuple>
+                inline B eval(::xsimd::detail::index_sequence<Is...>, const Tuple& tuple)
                 {
-                    batch_type z = batch_type(1.) - ex * detail::erf_kernel<batch_type>::erfc2(x);
-                    batch_type r2 = select(self < batch_type(0.), -z, z);
-                    r1 = select(test1, r1, r2);
-                    if (all(test1 || test3))
-                        return r1;
+                    return estrin { x * x }(std::get<Is>(tuple)...);
                 }
-                batch_type z = batch_type(1.) - ex * detail::erf_kernel<batch_type>::erfc3(x);
-                z = select(self < batch_type(0.), -z, z);
-#ifndef XSIMD_NO_INFINITIES
-                z = select(xsimd::isinf(self), sign(self), z);
-#endif
-                return select(test2, r1, z);
-    }
 
-    // erfc
-    template<class A> batch<float, A> erfc(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                batch_type x = abs(self);
-                auto test0 = self < batch_type(0.);
-                batch_type r1 (0.);
-                auto test1 = x < batch_type(2.f / 3.f);
-                batch_type z = x / (batch_type(1.) + x);
-                if (any(test1))
+                template <class... Args>
+                inline B eval(const std::tuple<Args...>& tuple) noexcept
                 {
-                    r1 = detail::erf_kernel<batch_type>::erfc3(z);
-                    if (all(test1))
-                        return select(test0, batch_type(2.) - r1, r1);
+                    return eval(::xsimd::detail::make_index_sequence<sizeof...(Args)>(), tuple);
                 }
-                z -= batch_type(0.4f);
-                batch_type r2 = exp(-x * x) * detail::erf_kernel<batch_type>::erfc2(z);
-                r1 = select(test1, r1, r2);
-#ifndef XSIMD_NO_INFINITIES
-                r1 = select(x == constants::infinity<batch_type>(), batch_type(0.), r1);
-#endif
-                return select(test0, batch_type(2.) - r1, r1);
-    }
-    template<class A> batch<double, A> erfc(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                batch_type x = abs(self);
-                batch_type xx = x * x;
-                batch_type lim1 (0.65);
-                batch_type lim2 (2.2);
-                auto test0 = self < batch_type(0.);
-                auto test1 = x < lim1;
-                batch_type r1 (0.);
-                if (any(test1))
+
+                template <class... Args>
+                inline B eval(const std::tuple<Args...>& tuple, const B& c0) noexcept
                 {
-                    r1 = batch_type(1.) - x * detail::erf_kernel<batch_type>::erf1(xx);
-                    if (all(test1))
-                        return select(test0, batch_type(2.) - r1, r1);
+                    return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0))));
                 }
-                auto test2 = x < lim2;
-                auto test3 = test2 && !test1;
-                batch_type ex = exp(-xx);
-                if (any(test3))
+
+                template <class... Args>
+                inline B eval(const std::tuple<Args...>& tuple, const B& c0, const B& c1) noexcept
                 {
-                    batch_type z = ex * detail::erf_kernel<batch_type>::erfc2(x);
-                    r1 = select(test1, r1, z);
-                    if (all(test1 || test3))
-                        return select(test0, batch_type(2.) - r1, r1);
+                    return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0, c1))));
                 }
-                batch_type z = ex * detail::erf_kernel<batch_type>::erfc3(x);
-                r1 = select(test2, r1, z);
-#ifndef XSIMD_NO_INFINITIES
-                r1 = select(x == constants::infinity<batch_type>(), batch_type(0.), r1);
-#endif
-                return select(test0, batch_type(2.) - r1, r1);
-    }
 
-    // estrin
-    namespace detail
-    {
+                template <class... Args, class... Ts>
+                inline B eval(const std::tuple<Args...>& tuple, const B& c0, const B& c1, const Ts&... coefs) noexcept
+                {
+                    return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0, c1))), coefs...);
+                }
+
+                template <class... Ts>
+                inline B eval(const B& c0, const B& c1, const Ts&... coefs) noexcept
+                {
+                    return eval(std::make_tuple(eval(c0, c1)), coefs...);
+                }
+            };
+        }
 
-        template <class B>
-        struct estrin
+        template <class T, class A, uint64_t... Coefs>
+        inline batch<T, A> estrin(const batch<T, A>& self) noexcept
         {
-            B x;
+            using batch_type = batch<T, A>;
+            return detail::estrin<batch_type> { self }(detail::coef<batch_type, Coefs>()...);
+        }
 
-            template <typename... Ts>
-            inline B operator()(const Ts&... coefs) noexcept
+        // exp
+        /* origin: boost/simd/arch/common/detail/simd/expo_base.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        namespace detail
+        {
+            enum exp_reduction_tag
             {
-                return eval(coefs...);
-            }
+                exp_tag,
+                exp2_tag,
+                exp10_tag
+            };
 
-          private:
-            inline B eval(const B& c0) noexcept
-            {
-                return c0;
-            }
+            template <class B, exp_reduction_tag Tag>
+            struct exp_reduction_base;
 
-            inline B eval(const B& c0, const B& c1) noexcept
+            template <class B>
+            struct exp_reduction_base<B, exp_tag>
             {
-                return fma(x, c1, c0);
-            }
+                static constexpr B maxlog() noexcept
+                {
+                    return constants::maxlog<B>();
+                }
 
-            template <size_t... Is, class Tuple>
-            inline B eval(::xsimd::detail::index_sequence<Is...>, const Tuple& tuple)
-            {
-                return estrin{x * x}(std::get<Is>(tuple)...);
-            }
+                static constexpr B minlog() noexcept
+                {
+                    return constants::minlog<B>();
+                }
+            };
 
-            template <class... Args>
-            inline B eval(const std::tuple<Args...>& tuple) noexcept
+            template <class B>
+            struct exp_reduction_base<B, exp10_tag>
             {
-                return eval(::xsimd::detail::make_index_sequence<sizeof...(Args)>(), tuple);
-            }
+                static constexpr B maxlog() noexcept
+                {
+                    return constants::maxlog10<B>();
+                }
 
-            template <class... Args>
-            inline B eval(const std::tuple<Args...>& tuple, const B& c0) noexcept
-            {
-                return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0))));
-            }
+                static constexpr B minlog() noexcept
+                {
+                    return constants::minlog10<B>();
+                }
+            };
 
-            template <class... Args>
-            inline B eval(const std::tuple<Args...>& tuple, const B& c0, const B& c1) noexcept
+            template <class B>
+            struct exp_reduction_base<B, exp2_tag>
             {
-                return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0, c1))));
-            }
+                static constexpr B maxlog() noexcept
+                {
+                    return constants::maxlog2<B>();
+                }
 
-            template <class... Args, class... Ts>
-            inline B eval(const std::tuple<Args...>& tuple, const B& c0, const B& c1, const Ts&... coefs) noexcept
-            {
-                return eval(std::tuple_cat(tuple, std::make_tuple(eval(c0, c1))), coefs...);
-            }
+                static constexpr B minlog() noexcept
+                {
+                    return constants::minlog2<B>();
+                }
+            };
 
-            template <class... Ts>
-            inline B eval(const B& c0, const B& c1, const Ts&... coefs) noexcept
-            {
-                return eval(std::make_tuple(eval(c0, c1)), coefs...);
-            }
-        };
-    }
-    template <class T, class A, uint64_t... Coefs>
-    batch<T, A> estrin(const batch<T, A>& self) {
-      using batch_type = batch<T, A>;
-      return detail::estrin<batch_type>{self}(detail::coef<batch_type, Coefs>()...);
-    }
+            template <class T, class A, exp_reduction_tag Tag>
+            struct exp_reduction;
 
-    // exp
-            /* origin: boost/simd/arch/common/detail/simd/expo_base.hpp */
-            /*
-             * ====================================================
-             * copyright 2016 NumScale SAS
-             *
-             * Distributed under the Boost Software License, Version 1.0.
-             * (See copy at http://boost.org/LICENSE_1_0.txt)
-             * ====================================================
-             */
-    namespace detail
-    {
-        enum exp_reduction_tag { exp_tag, exp2_tag, exp10_tag };
+            template <class A>
+            struct exp_reduction<float, A, exp_tag> : exp_reduction_base<batch<float, A>, exp_tag>
+            {
+                using batch_type = batch<float, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    batch_type y = detail::horner<batch_type,
+                                                  0x3f000000, //  5.0000000e-01
+                                                  0x3e2aa9a5, //  1.6666277e-01
+                                                  0x3d2aa957, //  4.1665401e-02
+                                                  0x3c098d8b, //  8.3955629e-03
+                                                  0x3ab778cf //  1.3997796e-03
+                                                  >(x);
+                    return ++fma(y, x * x, x);
+                }
 
-        template <class B, exp_reduction_tag Tag>
-        struct exp_reduction_base;
+                static inline batch_type reduce(const batch_type& a, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
+                    x = fnma(k, constants::log_2hi<batch_type>(), a);
+                    x = fnma(k, constants::log_2lo<batch_type>(), x);
+                    return k;
+                }
+            };
 
-        template <class B>
-        struct exp_reduction_base<B, exp_tag>
-        {
-            static constexpr B maxlog() noexcept
+            template <class A>
+            struct exp_reduction<float, A, exp10_tag> : exp_reduction_base<batch<float, A>, exp10_tag>
             {
-                return constants::maxlog<B>();
-            }
+                using batch_type = batch<float, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    return ++(detail::horner<batch_type,
+                                             0x40135d8e, //    2.3025851e+00
+                                             0x4029a926, //    2.6509490e+00
+                                             0x400237da, //    2.0346589e+00
+                                             0x3f95eb4c, //    1.1712432e+00
+                                             0x3f0aacef, //    5.4170126e-01
+                                             0x3e54dff1 //    2.0788552e-01
+                                             >(x)
+                              * x);
+                }
 
-            static constexpr B minlog() noexcept
-            {
-                return constants::minlog<B>();
-            }
-        };
+                static inline batch_type reduce(const batch_type& a, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(constants::invlog10_2<batch_type>() * a);
+                    x = fnma(k, constants::log10_2hi<batch_type>(), a);
+                    x -= k * constants::log10_2lo<batch_type>();
+                    return k;
+                }
+            };
 
-        template <class B>
-        struct exp_reduction_base<B, exp10_tag>
-        {
-            static constexpr B maxlog() noexcept
+            template <class A>
+            struct exp_reduction<float, A, exp2_tag> : exp_reduction_base<batch<float, A>, exp2_tag>
             {
-                return constants::maxlog10<B>();
-            }
+                using batch_type = batch<float, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    batch_type y = detail::horner<batch_type,
+                                                  0x3e75fdf1, //    2.4022652e-01
+                                                  0x3d6356eb, //    5.5502813e-02
+                                                  0x3c1d9422, //    9.6178371e-03
+                                                  0x3ab01218, //    1.3433127e-03
+                                                  0x3922c8c4 //    1.5524315e-04
+                                                  >(x);
+                    return ++fma(y, x * x, x * constants::log_2<batch_type>());
+                }
 
-            static constexpr B minlog() noexcept
-            {
-                return constants::minlog10<B>();
-            }
-        };
+                static inline batch_type reduce(const batch_type& a, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(a);
+                    x = (a - k);
+                    return k;
+                }
+            };
 
-        template <class B>
-        struct exp_reduction_base<B, exp2_tag>
-        {
-            static constexpr B maxlog() noexcept
+            template <class A>
+            struct exp_reduction<double, A, exp_tag> : exp_reduction_base<batch<double, A>, exp_tag>
             {
-                return constants::maxlog2<B>();
-            }
+                using batch_type = batch<double, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    batch_type t = x * x;
+                    return fnma(t,
+                                detail::horner<batch_type,
+                                               0x3fc555555555553eull,
+                                               0xbf66c16c16bebd93ull,
+                                               0x3f11566aaf25de2cull,
+                                               0xbebbbd41c5d26bf1ull,
+                                               0x3e66376972bea4d0ull>(t),
+                                x);
+                }
 
-            static constexpr B minlog() noexcept
-            {
-                return constants::minlog2<B>();
-            }
-        };
+                static inline batch_type reduce(const batch_type& a, batch_type& hi, batch_type& lo, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
+                    hi = fnma(k, constants::log_2hi<batch_type>(), a);
+                    lo = k * constants::log_2lo<batch_type>();
+                    x = hi - lo;
+                    return k;
+                }
 
-        template <class T, class A, exp_reduction_tag Tag>
-        struct exp_reduction;
+                static inline batch_type finalize(const batch_type& x, const batch_type& c, const batch_type& hi, const batch_type& lo) noexcept
+                {
+                    return batch_type(1.) - (((lo - (x * c) / (batch_type(2.) - c)) - hi));
+                }
+            };
 
-        template <class A>
-        struct exp_reduction<float, A, exp_tag> : exp_reduction_base<batch<float, A>, exp_tag>
-        {
-          using batch_type = batch<float, A>;
-            static inline batch_type approx(const batch_type& x)
+            template <class A>
+            struct exp_reduction<double, A, exp10_tag> : exp_reduction_base<batch<double, A>, exp10_tag>
             {
-                batch_type y = detail::horner<batch_type,
-                             0x3f000000,  //  5.0000000e-01
-                             0x3e2aa9a5,  //  1.6666277e-01
-                             0x3d2aa957,  //  4.1665401e-02
-                             0x3c098d8b,  //  8.3955629e-03
-                             0x3ab778cf  //  1.3997796e-03
-                             >(x);
-                return ++fma(y, x * x, x);
-            }
+                using batch_type = batch<double, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    batch_type xx = x * x;
+                    batch_type px = x * detail::horner<batch_type, 0x40a2b4798e134a01ull, 0x40796b7a050349e4ull, 0x40277d9474c55934ull, 0x3fa4fd75f3062dd4ull>(xx);
+                    batch_type x2 = px / (detail::horner1<batch_type, 0x40a03f37650df6e2ull, 0x4093e05eefd67782ull, 0x405545fdce51ca08ull>(xx) - px);
+                    return ++(x2 + x2);
+                }
 
-            static inline batch_type reduce(const batch_type& a, batch_type& x)
-            {
-                batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
-                x = fnma(k, constants::log_2hi<batch_type>(), a);
-                x = fnma(k, constants::log_2lo<batch_type>(), x);
-                return k;
-            }
-        };
+                static inline batch_type reduce(const batch_type& a, batch_type&, batch_type&, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(constants::invlog10_2<batch_type>() * a);
+                    x = fnma(k, constants::log10_2hi<batch_type>(), a);
+                    x = fnma(k, constants::log10_2lo<batch_type>(), x);
+                    return k;
+                }
 
-        template <class A>
-        struct exp_reduction<float, A, exp10_tag> : exp_reduction_base<batch<float, A>, exp10_tag>
-        {
-          using batch_type = batch<float, A>;
-            static inline batch_type approx(const batch_type& x)
-            {
-                return ++(detail::horner<batch_type,
-                                 0x40135d8e,  //    2.3025851e+00
-                                 0x4029a926,  //    2.6509490e+00
-                                 0x400237da,  //    2.0346589e+00
-                                 0x3f95eb4c,  //    1.1712432e+00
-                                 0x3f0aacef,  //    5.4170126e-01
-                                 0x3e54dff1  //    2.0788552e-01
-                                 >(x) *
-                          x);
-            }
+                static inline batch_type finalize(const batch_type&, const batch_type& c, const batch_type&, const batch_type&) noexcept
+                {
+                    return c;
+                }
+            };
 
-            static inline batch_type reduce(const batch_type& a, batch_type& x)
+            template <class A>
+            struct exp_reduction<double, A, exp2_tag> : exp_reduction_base<batch<double, A>, exp2_tag>
             {
-                batch_type k = nearbyint(constants::invlog10_2<batch_type>() * a);
-                x = fnma(k, constants::log10_2hi<batch_type>(), a);
-                x -= k * constants::log10_2lo<batch_type>();
-                return k;
-            }
-        };
+                using batch_type = batch<double, A>;
+                static inline batch_type approx(const batch_type& x) noexcept
+                {
+                    batch_type t = x * x;
+                    return fnma(t,
+                                detail::horner<batch_type,
+                                               0x3fc555555555553eull,
+                                               0xbf66c16c16bebd93ull,
+                                               0x3f11566aaf25de2cull,
+                                               0xbebbbd41c5d26bf1ull,
+                                               0x3e66376972bea4d0ull>(t),
+                                x);
+                }
 
-        template <class A>
-        struct exp_reduction<float, A, exp2_tag> : exp_reduction_base<batch<float, A>, exp2_tag>
-        {
-            using batch_type = batch<float, A>;
-            static inline batch_type approx(const batch_type& x)
-            {
-                batch_type y = detail::horner<batch_type,
-                             0x3e75fdf1,  //    2.4022652e-01
-                             0x3d6356eb,  //    5.5502813e-02
-                             0x3c1d9422,  //    9.6178371e-03
-                             0x3ab01218,  //    1.3433127e-03
-                             0x3922c8c4  //    1.5524315e-04
-                             >(x);
-                return ++fma(y, x * x, x * constants::log_2<batch_type>());
-            }
+                static inline batch_type reduce(const batch_type& a, batch_type&, batch_type&, batch_type& x) noexcept
+                {
+                    batch_type k = nearbyint(a);
+                    x = (a - k) * constants::log_2<batch_type>();
+                    return k;
+                }
 
-            static inline batch_type reduce(const batch_type& a, batch_type& x)
-            {
-                batch_type k = nearbyint(a);
-                x = (a - k);
-                return k;
+                static inline batch_type finalize(const batch_type& x, const batch_type& c, const batch_type&, const batch_type&) noexcept
+                {
+                    return batch_type(1.) + x + x * c / (batch_type(2.) - c);
+                }
+            };
+
+            template <exp_reduction_tag Tag, class A>
+            inline batch<float, A> exp(batch<float, A> const& self) noexcept
+            {
+                using batch_type = batch<float, A>;
+                using reducer_t = exp_reduction<float, A, Tag>;
+                batch_type x;
+                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)));
+                x = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), x);
+                return x;
+            }
+
+            template <exp_reduction_tag Tag, class A>
+            inline batch<double, A> exp(batch<double, A> const& self) noexcept
+            {
+                using batch_type = batch<double, A>;
+                using reducer_t = exp_reduction<double, A, Tag>;
+                batch_type hi, lo, x;
+                batch_type k = reducer_t::reduce(self, hi, lo, x);
+                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)));
+                c = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), c);
+                return c;
             }
-        };
+        }
 
-        template <class A>
-        struct exp_reduction<double, A, exp_tag> : exp_reduction_base<batch<double, A>, exp_tag>
+        template <class A, class T>
+        inline batch<T, A> exp(batch<T, A> const& self, requires_arch<generic>) noexcept
         {
-          using batch_type = batch<double, A>;
-            static inline batch_type approx(const batch_type& x)
-            {
-                batch_type t = x * x;
-                return fnma(t,
-                            detail::horner<batch_type,
-                                   0x3fc555555555553eull,
-                                   0xbf66c16c16bebd93ull,
-                                   0x3f11566aaf25de2cull,
-                                   0xbebbbd41c5d26bf1ull,
-                                   0x3e66376972bea4d0ull>(t),
-                            x);
-            }
-
-            static inline batch_type reduce(const batch_type& a, batch_type& hi, batch_type& lo, batch_type& x)
-            {
-                batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
-                hi = fnma(k, constants::log_2hi<batch_type>(), a);
-                lo = k * constants::log_2lo<batch_type>();
-                x = hi - lo;
-                return k;
-            }
-
-            static inline batch_type finalize(const batch_type& x, const batch_type& c, const batch_type& hi, const batch_type& lo)
-            {
-                return batch_type(1.) - (((lo - (x * c) / (batch_type(2.) - c)) - hi));
-            }
-        };
+            return detail::exp<detail::exp_tag>(self);
+        }
 
-        template <class A>
-        struct exp_reduction<double, A, exp10_tag> : exp_reduction_base<batch<double, A>, exp10_tag>
+        template <class A, class T>
+        inline batch<std::complex<T>, A> exp(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
         {
-          using batch_type = batch<double, A>;
-            static inline batch_type approx(const batch_type& x)
-            {
-                batch_type xx = x * x;
-                batch_type px = x * detail::horner<batch_type,
-                                  0x40a2b4798e134a01ull,
-                                  0x40796b7a050349e4ull,
-                                  0x40277d9474c55934ull,
-                                  0x3fa4fd75f3062dd4ull>(xx);
-                batch_type x2 = px / (detail::horner1<batch_type,
-                                     0x40a03f37650df6e2ull,
-                                     0x4093e05eefd67782ull,
-                                     0x405545fdce51ca08ull>(xx) -
-                             px);
-                return ++(x2 + x2);
-            }
-
-            static inline batch_type reduce(const batch_type& a, batch_type&, batch_type&, batch_type& x)
-            {
-                batch_type k = nearbyint(constants::invlog10_2<batch_type>() * a);
-                x = fnma(k, constants::log10_2hi<batch_type>(), a);
-                x = fnma(k, constants::log10_2lo<batch_type>(), x);
-                return k;
-            }
-
-            static inline batch_type finalize(const batch_type&, const batch_type& c, const batch_type&, const batch_type&)
-            {
-                return c;
-            }
-        };
+            using batch_type = batch<std::complex<T>, A>;
+            auto isincos = sincos(self.imag());
+            return exp(self.real()) * batch_type(std::get<1>(isincos), std::get<0>(isincos));
+        }
 
-        template <class A>
-        struct exp_reduction<double, A, exp2_tag> : exp_reduction_base<batch<double, A>, exp2_tag>
+        // exp10
+        template <class A, class T>
+        inline batch<T, A> exp10(batch<T, A> const& self, requires_arch<generic>) noexcept
         {
-          using batch_type = batch<double, A>;
-            static inline batch_type approx(const batch_type& x)
-            {
-                batch_type t = x * x;
-                return fnma(t,
-                            detail::horner<batch_type,
-                                   0x3fc555555555553eull,
-                                   0xbf66c16c16bebd93ull,
-                                   0x3f11566aaf25de2cull,
-                                   0xbebbbd41c5d26bf1ull,
-                                   0x3e66376972bea4d0ull>(t),
-                            x);
-            }
-
-            static inline batch_type reduce(const batch_type& a, batch_type&, batch_type&, batch_type& x)
-            {
-                batch_type k = nearbyint(a);
-                x = (a - k) * constants::log_2<batch_type>();
-                return k;
-            }
-
-            static inline batch_type finalize(const batch_type& x, const batch_type& c, const batch_type&, const batch_type&)
-            {
-                return batch_type(1.) + x + x * c / (batch_type(2.) - c);
-            }
-        };
-
-      template<exp_reduction_tag Tag, class A> batch<float, A> exp(batch<float, A> const& self) {
-        using batch_type = batch<float, A>;
-        using reducer_t = exp_reduction<float, A, Tag>;
-        batch_type x;
-        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)));
-        x = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), x);
-        return x;
-      }
-      template<exp_reduction_tag Tag, class A> batch<double, A> exp(batch<double, A> const& self) {
-        using batch_type = batch<double, A>;
-        using reducer_t = exp_reduction<double, A, Tag>;
-        batch_type hi, lo, x;
-        batch_type k = reducer_t::reduce(self, hi, lo, x);
-        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)));
-        c = select(self >= reducer_t::maxlog(), constants::infinity<batch_type>(), c);
-        return c;
-      }
-    }
-
-    template<class A, class T> batch<T, A> exp(batch<T, A> const& self, requires_arch<generic>) {
-      return detail::exp<detail::exp_tag>(self);
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> exp(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<std::complex<T>, A>;
-      auto isincos = sincos(self.imag());
-      return exp(self.real()) * batch_type(std::get<1>(isincos), std::get<0>(isincos));
-    }
-
-    // exp10
-    template<class A, class T> batch<T, A> exp10(batch<T, A> const& self, requires_arch<generic>) {
-      return detail::exp<detail::exp10_tag>(self);
-    }
+            return detail::exp<detail::exp10_tag>(self);
+        }
 
-    // exp2
-    template<class A, class T> batch<T, A> exp2(batch<T, A> const& self, requires_arch<generic>) {
-      return detail::exp<detail::exp2_tag>(self);
-    }
+        // exp2
+        template <class A, class T>
+        inline batch<T, A> exp2(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::exp<detail::exp2_tag>(self);
+        }
 
-    // expm1
-    namespace detail {
+        // expm1
+        namespace detail
+        {
             /* origin: boost/simd/arch/common/detail/generic/expm1_kernel.hpp */
             /*
              * ====================================================
@@ -840,20 +884,20 @@ namespace xsimd {
              * (See copy at http://boost.org/LICENSE_1_0.txt)
              * ====================================================
              */
-          template<class A>
-          static inline batch<float, A> expm1(const batch<float, A>& a)
+            template <class A>
+            static inline batch<float, A> expm1(const batch<float, A>& a) noexcept
             {
-              using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
                 batch_type x = fnma(k, constants::log_2hi<batch_type>(), a);
                 x = fnma(k, constants::log_2lo<batch_type>(), x);
                 batch_type hx = x * batch_type(0.5);
                 batch_type hxs = x * hx;
                 batch_type r = detail::horner<batch_type,
-                             0X3F800000UL,  // 1
-                             0XBD08887FUL,  // -3.3333298E-02
-                             0X3ACF6DB4UL  // 1.582554
-                             >(hxs);
+                                              0X3F800000UL, // 1
+                                              0XBD08887FUL, // -3.3333298E-02
+                                              0X3ACF6DB4UL // 1.582554
+                                              >(hxs);
                 batch_type t = fnma(r, hx, batch_type(3.));
                 batch_type e = hxs * ((r - t) / (batch_type(6.) - x * t));
                 e = fms(x, e, hxs);
@@ -864,22 +908,22 @@ namespace xsimd {
                 return ldexp(y, ik);
             }
 
-            template<class A>
-            static inline batch<double, A> expm1(const batch<double, A>& a)
+            template <class A>
+            static inline batch<double, A> expm1(const batch<double, A>& a) noexcept
             {
-              using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type k = nearbyint(constants::invlog_2<batch_type>() * a);
                 batch_type hi = fnma(k, constants::log_2hi<batch_type>(), a);
                 batch_type lo = k * constants::log_2lo<batch_type>();
                 batch_type x = hi - lo;
                 batch_type hxs = x * x * batch_type(0.5);
                 batch_type r = detail::horner<batch_type,
-                             0X3FF0000000000000ULL,
-                             0XBFA11111111110F4ULL,
-                             0X3F5A01A019FE5585ULL,
-                             0XBF14CE199EAADBB7ULL,
-                             0X3ED0CFCA86E65239ULL,
-                             0XBE8AFDB76E09C32DULL>(hxs);
+                                              0X3FF0000000000000ULL,
+                                              0XBFA11111111110F4ULL,
+                                              0X3F5A01A019FE5585ULL,
+                                              0XBF14CE199EAADBB7ULL,
+                                              0X3ED0CFCA86E65239ULL,
+                                              0XBE8AFDB76E09C32DULL>(hxs);
                 batch_type t = batch_type(3.) - r * batch_type(0.5) * x;
                 batch_type e = hxs * ((r - t) / (batch_type(6) - x * t));
                 batch_type c = (hi - x) - lo;
@@ -893,946 +937,973 @@ namespace xsimd {
                 return ldexp(y, ik);
             }
 
-    }
+        }
 
-    template<class A, class T> batch<T, A> expm1(batch<T, A> const& self, requires_arch<generic>) {
-      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)));
-    }
+        template <class A, class T>
+        inline batch<T, A> expm1(batch<T, A> const& self, requires_arch<generic>) 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)));
+        }
 
-    template <class A, class T>
-    batch<std::complex<T>, A> expm1(const batch<std::complex<T>, A>& z, requires_arch<generic>)
-    {
-        using batch_type = batch<std::complex<T>, A>;
-        using real_batch = typename batch_type::real_batch;
-        real_batch isin = sin(z.imag());
-        real_batch rem1 = expm1(z.real());
-        real_batch re = rem1 + 1.;
-        real_batch si = sin(z.imag() * 0.5);
-        return {rem1 - 2. * re * si * si, re * isin};
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> expm1(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<std::complex<T>, A>;
+            using real_batch = typename batch_type::real_batch;
+            real_batch isin = sin(z.imag());
+            real_batch rem1 = expm1(z.real());
+            real_batch re = rem1 + 1.;
+            real_batch si = sin(z.imag() * 0.5);
+            return { rem1 - 2. * re * si * si, re * isin };
+        }
 
-    // fdim
-    template<class A, class T> batch<T, A> fdim(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return fmax(batch<T, A>(0), self - other);
-    }
+        // fdim
+        template <class A, class T>
+        inline batch<T, A> fdim(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return fmax(batch<T, A>(0), self - other);
+        }
 
-    // fmod
-    template<class A, class T> batch<T, A> fmod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return fnma(trunc(self / other), other, self);
-    }
+        // fmod
+        template <class A, class T>
+        inline batch<T, A> fmod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return fnma(trunc(self / other), other, self);
+        }
 
-    // frexp
-    /* origin: boost/simd/arch/common/simd/function/ifrexp.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template <class A, class T>
-    batch<T, A> frexp(const batch<T, A>& self, batch<as_integer_t<T>, A>& exp, requires_arch<generic>) {
-        using batch_type = batch<T, A>;
-        using i_type = batch<as_integer_t<T>, A>;
-        i_type m1f = constants::mask1frexp<batch_type>();
-        i_type r1 = m1f & ::xsimd::bitwise_cast<i_type>(self);
-        batch_type x = self & ::xsimd::bitwise_cast<batch_type>(~m1f);
-        exp = (r1 >> constants::nmb<batch_type>()) - constants::maxexponentm1<batch_type>();
-        exp = select(bool_cast(self != batch_type(0.)), exp, i_type(typename i_type::value_type(0)));
-        return select((self != batch_type(0.)), x | ::xsimd::bitwise_cast<batch_type>(constants::mask2frexp<batch_type>()), batch_type(0.));
-    }
+        // frexp
+        /* origin: boost/simd/arch/common/simd/function/ifrexp.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A, class T>
+        inline batch<T, A> frexp(const batch<T, A>& self, batch<as_integer_t<T>, A>& exp, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            using i_type = batch<as_integer_t<T>, A>;
+            i_type m1f = constants::mask1frexp<batch_type>();
+            i_type r1 = m1f & ::xsimd::bitwise_cast<i_type>(self);
+            batch_type x = self & ::xsimd::bitwise_cast<batch_type>(~m1f);
+            exp = (r1 >> constants::nmb<batch_type>()) - constants::maxexponentm1<batch_type>();
+            exp = select(bool_cast(self != batch_type(0.)), exp, i_type(typename i_type::value_type(0)));
+            return select((self != batch_type(0.)), x | ::xsimd::bitwise_cast<batch_type>(constants::mask2frexp<batch_type>()), batch_type(0.));
+        }
 
-    // from bool
-    template<class A, class T>
-    batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<generic>) {
-      return batch<T, A>(self.data) & batch<T,A>(1);
-    }
+        // from bool
+        template <class A, class T>
+        inline batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return batch<T, A>(self.data) & batch<T, A>(1);
+        }
 
-    // hadd
-    template<class A, class T> std::complex<T> hadd(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      return {hadd(self.real()), hadd(self.imag())};
-    }
+        // hadd
+        template <class A, class T>
+        inline std::complex<T> hadd(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            return { hadd(self.real()), hadd(self.imag()) };
+        }
 
-    // horner
-    template <class T, class A, uint64_t... Coefs>
-    batch<T, A> horner(const batch<T, A>& self) {
-      return detail::horner<batch<T, A>, Coefs...>(self);
-    }
+        // horner
+        template <class T, class A, uint64_t... Coefs>
+        inline batch<T, A> horner(const batch<T, A>& self) noexcept
+        {
+            return detail::horner<batch<T, A>, Coefs...>(self);
+        }
 
-    // hypot
-    template<class A, class T> batch<T, A> hypot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return sqrt(fma(self, self, other * other));
-    }
+        // hypot
+        template <class A, class T>
+        inline batch<T, A> hypot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return sqrt(fma(self, self, other * other));
+        }
 
-    // ipow
-    template<class A, class T, class ITy> batch<T, A> ipow(batch<T, A> const& self, ITy other, requires_arch<generic>) {
-      return ::xsimd::detail::ipow(self, other);
-    }
+        // ipow
+        template <class A, class T, class ITy>
+        inline batch<T, A> ipow(batch<T, A> const& self, ITy other, requires_arch<generic>) noexcept
+        {
+            return ::xsimd::detail::ipow(self, other);
+        }
 
+        // ldexp
+        /* origin: boost/simd/arch/common/simd/function/ldexp.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A, class T>
+        inline batch<T, A> ldexp(const batch<T, A>& self, const batch<as_integer_t<T>, A>& other, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            using itype = as_integer_t<batch_type>;
+            itype ik = other + constants::maxexponent<T>();
+            ik = ik << constants::nmb<T>();
+            return self * ::xsimd::bitwise_cast<batch_type>(ik);
+        }
 
-    // ldexp
-    /* origin: boost/simd/arch/common/simd/function/ldexp.hpp */
-    /*
-      * ====================================================
-      * copyright 2016 NumScale SAS
-      *
-      * Distributed under the Boost Software License, Version 1.0.
-      * (See copy at http://boost.org/LICENSE_1_0.txt)
-      * ====================================================
-      */
-    template <class A, class T>
-    batch<T, A> ldexp(const batch<T, A>& self, const batch<as_integer_t<T>, A>& other, requires_arch<generic>) {
-        using batch_type = batch<T, A>;
-        using itype = as_integer_t<batch_type>;
-        itype ik = other + constants::maxexponent<T>();
-        ik = ik << constants::nmb<T>();
-        return self * ::xsimd::bitwise_cast<batch_type>(ik);
-    }
+        // lgamma
+        template <class A, class T>
+        inline batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>) noexcept;
 
-    // lgamma
-    template<class A, class T> batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>);
-
-    namespace detail {
-    /* origin: boost/simd/arch/common/detail/generic/gammaln_kernel.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A>
-            static inline batch<float, A> gammalnB(const batch<float, A>& x)
+        namespace detail
+        {
+            /* origin: boost/simd/arch/common/detail/generic/gammaln_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class A>
+            static inline batch<float, A> gammalnB(const batch<float, A>& x) noexcept
             {
                 return horner<batch<float, A>,
-                              0x3ed87730,  //    4.227843421859038E-001
-                              0x3ea51a64,  //    3.224669577325661E-001,
-                              0xbd89f07e,  //   -6.735323259371034E-002,
-                              0x3ca89ed8,  //    2.058355474821512E-002,
-                              0xbbf164fd,  //   -7.366775108654962E-003,
-                              0x3b3ba883,  //    2.863437556468661E-003,
-                              0xbaabeab1,  //   -1.311620815545743E-003,
-                              0x3a1ebb94  //    6.055172732649237E-004
+                              0x3ed87730, //    4.227843421859038E-001
+                              0x3ea51a64, //    3.224669577325661E-001,
+                              0xbd89f07e, //   -6.735323259371034E-002,
+                              0x3ca89ed8, //    2.058355474821512E-002,
+                              0xbbf164fd, //   -7.366775108654962E-003,
+                              0x3b3ba883, //    2.863437556468661E-003,
+                              0xbaabeab1, //   -1.311620815545743E-003,
+                              0x3a1ebb94 //    6.055172732649237E-004
                               >(x);
             }
 
-    template<class A>
-            static inline batch<float, A> gammalnC(const batch<float, A>& x)
+            template <class A>
+            static inline batch<float, A> gammalnC(const batch<float, A>& x) noexcept
             {
                 return horner<batch<float, A>,
-                              0xbf13c468,  //   -5.772156501719101E-001
-                              0x3f528d34,  //    8.224670749082976E-001,
-                              0xbecd27a8,  //   -4.006931650563372E-001,
-                              0x3e8a898b,  //    2.705806208275915E-001,
-                              0xbe53c04f,  //   -2.067882815621965E-001,
-                              0x3e2d4dab,  //    1.692415923504637E-001,
-                              0xbe22d329,  //   -1.590086327657347E-001,
-                              0x3e0c3c4f  //    1.369488127325832E-001
+                              0xbf13c468, //   -5.772156501719101E-001
+                              0x3f528d34, //    8.224670749082976E-001,
+                              0xbecd27a8, //   -4.006931650563372E-001,
+                              0x3e8a898b, //    2.705806208275915E-001,
+                              0xbe53c04f, //   -2.067882815621965E-001,
+                              0x3e2d4dab, //    1.692415923504637E-001,
+                              0xbe22d329, //   -1.590086327657347E-001,
+                              0x3e0c3c4f //    1.369488127325832E-001
                               >(x);
             }
 
-    template<class A>
-            static inline batch<float, A> gammaln2(const batch<float, A>& x)
+            template <class A>
+            static inline batch<float, A> gammaln2(const batch<float, A>& x) noexcept
             {
                 return horner<batch<float, A>,
-                              0x3daaaa94,  //   8.333316229807355E-002f
-                              0xbb358701,  //  -2.769887652139868E-003f,
-                              0x3a31fd69  //   6.789774945028216E-004f
+                              0x3daaaa94, //   8.333316229807355E-002f
+                              0xbb358701, //  -2.769887652139868E-003f,
+                              0x3a31fd69 //   6.789774945028216E-004f
                               >(x);
             }
-    template<class A>
-            static inline batch<double, A> gammaln1(const batch<double, A>& x)
+
+            template <class A>
+            static inline batch<double, A> gammaln1(const batch<double, A>& x) noexcept
             {
                 return horner<batch<double, A>,
-                              0xc12a0c675418055eull,  //  -8.53555664245765465627E5
-                              0xc13a45890219f20bull,  //  -1.72173700820839662146E6,
-                              0xc131bc82f994db51ull,  //  -1.16237097492762307383E6,
-                              0xc1143d73f89089e5ull,  //  -3.31612992738871184744E5,
-                              0xc0e2f234355bb93eull,  //  -3.88016315134637840924E4,
-                              0xc09589018ff36761ull  //  -1.37825152569120859100E3
-                              >(x) /
-                    horner<batch<double, A>,
-                           0xc13ece4b6a11e14aull,  //  -2.01889141433532773231E6
-                           0xc1435255892ff34cull,  //  -2.53252307177582951285E6,
-                           0xc131628671950043ull,  //  -1.13933444367982507207E6,
-                           0xc10aeb84b9744c9bull,  //  -2.20528590553854454839E5,
-                           0xc0d0aa0d7b89d757ull,  //  -1.70642106651881159223E4,
-                           0xc075fd0d1cf312b2ull,  //  -3.51815701436523470549E2,
-                           0x3ff0000000000000ull  //   1.00000000000000000000E0
-                           >(x);
+                              0xc12a0c675418055eull, //  -8.53555664245765465627E5
+                              0xc13a45890219f20bull, //  -1.72173700820839662146E6,
+                              0xc131bc82f994db51ull, //  -1.16237097492762307383E6,
+                              0xc1143d73f89089e5ull, //  -3.31612992738871184744E5,
+                              0xc0e2f234355bb93eull, //  -3.88016315134637840924E4,
+                              0xc09589018ff36761ull //  -1.37825152569120859100E3
+                              >(x)
+                    / horner<batch<double, A>,
+                             0xc13ece4b6a11e14aull, //  -2.01889141433532773231E6
+                             0xc1435255892ff34cull, //  -2.53252307177582951285E6,
+                             0xc131628671950043ull, //  -1.13933444367982507207E6,
+                             0xc10aeb84b9744c9bull, //  -2.20528590553854454839E5,
+                             0xc0d0aa0d7b89d757ull, //  -1.70642106651881159223E4,
+                             0xc075fd0d1cf312b2ull, //  -3.51815701436523470549E2,
+                             0x3ff0000000000000ull //   1.00000000000000000000E0
+                             >(x);
             }
 
-    template<class A>
-            static inline batch<double, A> gammalnA(const batch<double, A>& x)
+            template <class A>
+            static inline batch<double, A> gammalnA(const batch<double, A>& x) noexcept
             {
                 return horner<batch<double, A>,
-                              0x3fb555555555554bull,  //    8.33333333333331927722E-2
-                              0xbf66c16c16b0a5a1ull,  //   -2.77777777730099687205E-3,
-                              0x3f4a019f20dc5ebbull,  //    7.93650340457716943945E-4,
-                              0xbf437fbdb580e943ull,  //   -5.95061904284301438324E-4,
-                              0x3f4a985027336661ull  //    8.11614167470508450300E-4
+                              0x3fb555555555554bull, //    8.33333333333331927722E-2
+                              0xbf66c16c16b0a5a1ull, //   -2.77777777730099687205E-3,
+                              0x3f4a019f20dc5ebbull, //    7.93650340457716943945E-4,
+                              0xbf437fbdb580e943ull, //   -5.95061904284301438324E-4,
+                              0x3f4a985027336661ull //    8.11614167470508450300E-4
                               >(x);
             }
-    /* origin: boost/simd/arch/common/simd/function/gammaln.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-        template <class B>
-        struct lgamma_impl;
 
-        template <class A>
-        struct lgamma_impl<batch<float, A>>
-        {
-          using batch_type = batch<float, A>;
-            static inline batch_type compute(const batch_type& a)
+            /* origin: boost/simd/arch/common/simd/function/gammaln.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            struct lgamma_impl;
+
+            template <class A>
+            struct lgamma_impl<batch<float, A>>
             {
-                auto inf_result = (a <= batch_type(0.)) && is_flint(a);
-                batch_type x = select(inf_result, constants::nan<batch_type>(), a);
-                batch_type q = abs(x);
+                using batch_type = batch<float, A>;
+                static inline batch_type compute(const batch_type& a) noexcept
+                {
+                    auto inf_result = (a <= batch_type(0.)) && is_flint(a);
+                    batch_type x = select(inf_result, constants::nan<batch_type>(), a);
+                    batch_type q = abs(x);
 #ifndef XSIMD_NO_INFINITIES
-                inf_result = (x == constants::infinity<batch_type>()) || inf_result;
+                    inf_result = (x == constants::infinity<batch_type>()) || inf_result;
 #endif
-                auto ltza = a < batch_type(0.);
-                batch_type r;
-                batch_type r1 = other(q);
-                if (any(ltza))
-                {
-                    r = select(inf_result, constants::infinity<batch_type>(), negative(q, r1));
-                    if (all(ltza))
-                        return r;
+                    auto ltza = a < batch_type(0.);
+                    batch_type r;
+                    batch_type r1 = other(q);
+                    if (any(ltza))
+                    {
+                        r = select(inf_result, constants::infinity<batch_type>(), negative(q, r1));
+                        if (all(ltza))
+                            return r;
+                    }
+                    batch_type r2 = select(ltza, r, r1);
+                    return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
                 }
-                batch_type r2 = select(ltza, r, r1);
-                return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
-            }
 
-        private:
-
-            static inline batch_type negative(const batch_type& q, const batch_type& w)
-            {
-                batch_type p = floor(q);
-                batch_type z = q - p;
-                auto test2 = z < batch_type(0.5);
-                z = select(test2, z - batch_type(1.), z);
-                z = q * sin(z, trigo_pi_tag());
-                return -log(constants::invpi<batch_type>() * abs(z)) - w;
-            }
+            private:
+                static inline batch_type negative(const batch_type& q, const batch_type& w) noexcept
+                {
+                    batch_type p = floor(q);
+                    batch_type z = q - p;
+                    auto test2 = z < batch_type(0.5);
+                    z = select(test2, z - batch_type(1.), z);
+                    z = q * sin(z, trigo_pi_tag());
+                    return -log(constants::invpi<batch_type>() * abs(z)) - w;
+                }
 
-            static inline batch_type other(const batch_type& x)
-            {
-                auto xlt650 = (x < batch_type(6.5));
-                batch_type r0x = x;
-                batch_type r0z = x;
-                batch_type r0s = batch_type(1.);
-                batch_type r1 = batch_type(0.);
-                batch_type p = constants::nan<batch_type>();
-                if (any(xlt650))
+                static inline batch_type other(const batch_type& x) noexcept
                 {
-                    batch_type z = batch_type(1.);
-                    batch_type tx = select(xlt650, x, batch_type(0.));
-                    batch_type nx = batch_type(0.);
-                    const batch_type _075 = batch_type(0.75);
-                    const batch_type _150 = batch_type(1.50);
-                    const batch_type _125 = batch_type(1.25);
-                    const batch_type _250 = batch_type(2.50);
-                    auto xge150 = (x >= _150);
-                    auto txgt250 = (tx > _250);
-
-                    // x >= 1.5
-                    while (any(xge150 && txgt250))
-                    {
-                        nx = select(txgt250, nx - batch_type(1.), nx);
-                        tx = select(txgt250, x + nx, tx);
-                        z = select(txgt250, z * tx, z);
-                        txgt250 = (tx > _250);
-                    }
-                    r0x = select(xge150, x + nx - batch_type(2.), x);
-                    r0z = select(xge150, z, r0z);
-                    r0s = select(xge150, batch_type(1.), r0s);
-
-                    // x >= 1.25 && x < 1.5
-                    auto xge125 = (x >= _125);
-                    auto xge125t = xge125 && !xge150;
-                    if (any(xge125))
+                    auto xlt650 = (x < batch_type(6.5));
+                    batch_type r0x = x;
+                    batch_type r0z = x;
+                    batch_type r0s = batch_type(1.);
+                    batch_type r1 = batch_type(0.);
+                    batch_type p = constants::nan<batch_type>();
+                    if (any(xlt650))
                     {
-                        r0x = select(xge125t, x - batch_type(1.), r0x);
-                        r0z = select(xge125t, z * x, r0z);
-                        r0s = select(xge125t, batch_type(-1.), r0s);
-                    }
+                        batch_type z = batch_type(1.);
+                        batch_type tx = select(xlt650, x, batch_type(0.));
+                        batch_type nx = batch_type(0.);
+                        const batch_type _075 = batch_type(0.75);
+                        const batch_type _150 = batch_type(1.50);
+                        const batch_type _125 = batch_type(1.25);
+                        const batch_type _250 = batch_type(2.50);
+                        auto xge150 = (x >= _150);
+                        auto txgt250 = (tx > _250);
+
+                        // x >= 1.5
+                        while (any(xge150 && txgt250))
+                        {
+                            nx = select(txgt250, nx - batch_type(1.), nx);
+                            tx = select(txgt250, x + nx, tx);
+                            z = select(txgt250, z * tx, z);
+                            txgt250 = (tx > _250);
+                        }
+                        r0x = select(xge150, x + nx - batch_type(2.), x);
+                        r0z = select(xge150, z, r0z);
+                        r0s = select(xge150, batch_type(1.), r0s);
+
+                        // x >= 1.25 && x < 1.5
+                        auto xge125 = (x >= _125);
+                        auto xge125t = xge125 && !xge150;
+                        if (any(xge125))
+                        {
+                            r0x = select(xge125t, x - batch_type(1.), r0x);
+                            r0z = select(xge125t, z * x, r0z);
+                            r0s = select(xge125t, batch_type(-1.), r0s);
+                        }
 
-                    // x >= 0.75 && x < 1.5
-                    batch_bool<float, A> kernelC(false);
-                    auto xge075 = (x >= _075);
-                    auto xge075t = xge075 && !xge125;
-                    if (any(xge075t))
-                    {
-                        kernelC = xge075t;
-                        r0x = select(xge075t, x - batch_type(1.), x);
-                        r0z = select(xge075t, batch_type(1.), r0z);
-                        r0s = select(xge075t, batch_type(-1.), r0s);
-                        p = gammalnC(r0x);
-                    }
+                        // x >= 0.75 && x < 1.5
+                        batch_bool<float, A> kernelC(false);
+                        auto xge075 = (x >= _075);
+                        auto xge075t = xge075 && !xge125;
+                        if (any(xge075t))
+                        {
+                            kernelC = xge075t;
+                            r0x = select(xge075t, x - batch_type(1.), x);
+                            r0z = select(xge075t, batch_type(1.), r0z);
+                            r0s = select(xge075t, batch_type(-1.), r0s);
+                            p = gammalnC(r0x);
+                        }
 
-                    // tx < 1.5 && x < 0.75
-                    auto txlt150 = (tx < _150) && !xge075;
-                    if (any(txlt150))
-                    {
-                        auto orig = txlt150;
-                        while (any(txlt150))
+                        // tx < 1.5 && x < 0.75
+                        auto txlt150 = (tx < _150) && !xge075;
+                        if (any(txlt150))
                         {
-                            z = select(txlt150, z * tx, z);
-                            nx = select(txlt150, nx + batch_type(1.), nx);
-                            tx = select(txlt150, x + nx, tx);
-                            txlt150 = (tx < _150) && !xge075;
+                            auto orig = txlt150;
+                            while (any(txlt150))
+                            {
+                                z = select(txlt150, z * tx, z);
+                                nx = select(txlt150, nx + batch_type(1.), nx);
+                                tx = select(txlt150, x + nx, tx);
+                                txlt150 = (tx < _150) && !xge075;
+                            }
+                            r0x = select(orig, r0x + nx - batch_type(2.), r0x);
+                            r0z = select(orig, z, r0z);
+                            r0s = select(orig, batch_type(-1.), r0s);
                         }
-                        r0x = select(orig, r0x + nx - batch_type(2.), r0x);
-                        r0z = select(orig, z, r0z);
-                        r0s = select(orig, batch_type(-1.), r0s);
+                        p = select(kernelC, p, gammalnB(r0x));
+                        if (all(xlt650))
+                            return fma(r0x, p, r0s * log(abs(r0z)));
                     }
-                    p = select(kernelC, p, gammalnB(r0x));
-                    if (all(xlt650))
-                        return fma(r0x, p, r0s * log(abs(r0z)));
+                    r0z = select(xlt650, abs(r0z), x);
+                    batch_type m = log(r0z);
+                    r1 = fma(r0x, p, r0s * m);
+                    batch_type r2 = fma(x - batch_type(0.5), m, constants::logsqrt2pi<batch_type>() - x);
+                    r2 += gammaln2(batch_type(1.) / (x * x)) / x;
+                    return select(xlt650, r1, r2);
                 }
-                r0z = select(xlt650, abs(r0z), x);
-                batch_type m = log(r0z);
-                r1 = fma(r0x, p, r0s * m);
-                batch_type r2 = fma(x - batch_type(0.5), m, constants::logsqrt2pi<batch_type>() - x);
-                r2 += gammaln2(batch_type(1.) / (x * x)) / x;
-                return select(xlt650, r1, r2);
-            }
-        };
-
-        template <class A>
-        struct lgamma_impl<batch<double, A>>
-        {
-          using batch_type = batch<double, A>;
+            };
 
-            static inline batch_type compute(const batch_type& a)
+            template <class A>
+            struct lgamma_impl<batch<double, A>>
             {
-                auto inf_result = (a <= batch_type(0.)) && is_flint(a);
-                batch_type x = select(inf_result, constants::nan<batch_type>(), a);
-                batch_type q = abs(x);
+                using batch_type = batch<double, A>;
+
+                static inline batch_type compute(const batch_type& a) noexcept
+                {
+                    auto inf_result = (a <= batch_type(0.)) && is_flint(a);
+                    batch_type x = select(inf_result, constants::nan<batch_type>(), a);
+                    batch_type q = abs(x);
 #ifndef XSIMD_NO_INFINITIES
-                inf_result = (q == constants::infinity<batch_type>());
+                    inf_result = (q == constants::infinity<batch_type>());
 #endif
-                auto test = (a < batch_type(-34.));
-                batch_type r = constants::nan<batch_type>();
-                if (any(test))
-                {
-                    r = large_negative(q);
-                    if (all(test))
-                        return select(inf_result, constants::nan<batch_type>(), r);
+                    auto test = (a < batch_type(-34.));
+                    batch_type r = constants::nan<batch_type>();
+                    if (any(test))
+                    {
+                        r = large_negative(q);
+                        if (all(test))
+                            return select(inf_result, constants::nan<batch_type>(), r);
+                    }
+                    batch_type r1 = other(a);
+                    batch_type r2 = select(test, r, r1);
+                    return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
                 }
-                batch_type r1 = other(a);
-                batch_type r2 = select(test, r, r1);
-                return select(a == constants::minusinfinity<batch_type>(), constants::nan<batch_type>(), select(inf_result, constants::infinity<batch_type>(), r2));
-            }
-
-        private:
 
-            static inline batch_type large_negative(const batch_type& q)
-            {
-                batch_type w = lgamma(q);
-                batch_type p = floor(q);
-                batch_type z = q - p;
-                auto test2 = (z < batch_type(0.5));
-                z = select(test2, z - batch_type(1.), z);
-                z = q * sin(z, trigo_pi_tag());
-                z = abs(z);
-                return constants::logpi<batch_type>() - log(z) - w;
-            }
+            private:
+                static inline batch_type large_negative(const batch_type& q) noexcept
+                {
+                    batch_type w = lgamma(q);
+                    batch_type p = floor(q);
+                    batch_type z = q - p;
+                    auto test2 = (z < batch_type(0.5));
+                    z = select(test2, z - batch_type(1.), z);
+                    z = q * sin(z, trigo_pi_tag());
+                    z = abs(z);
+                    return constants::logpi<batch_type>() - log(z) - w;
+                }
 
-            static inline batch_type other(const batch_type& xx)
-            {
-                batch_type x = xx;
-                auto test = (x < batch_type(13.));
-                batch_type r1 = batch_type(0.);
-                if (any(test))
+                static inline batch_type other(const batch_type& xx) noexcept
                 {
-                    batch_type z = batch_type(1.);
-                    batch_type p = batch_type(0.);
-                    batch_type u = select(test, x, batch_type(0.));
-                    auto test1 = (u >= batch_type(3.));
-                    while (any(test1))
+                    batch_type x = xx;
+                    auto test = (x < batch_type(13.));
+                    batch_type r1 = batch_type(0.);
+                    if (any(test))
                     {
-                        p = select(test1, p - batch_type(1.), p);
-                        u = select(test1, x + p, u);
-                        z = select(test1, z * u, z);
-                        test1 = (u >= batch_type(3.));
-                    }
+                        batch_type z = batch_type(1.);
+                        batch_type p = batch_type(0.);
+                        batch_type u = select(test, x, batch_type(0.));
+                        auto test1 = (u >= batch_type(3.));
+                        while (any(test1))
+                        {
+                            p = select(test1, p - batch_type(1.), p);
+                            u = select(test1, x + p, u);
+                            z = select(test1, z * u, z);
+                            test1 = (u >= batch_type(3.));
+                        }
 
-                    auto test2 = (u < batch_type(2.));
-                    while (any(test2))
-                    {
-                        z = select(test2, z / u, z);
-                        p = select(test2, p + batch_type(1.), p);
-                        u = select(test2, x + p, u);
-                        test2 = (u < batch_type(2.));
-                    }
+                        auto test2 = (u < batch_type(2.));
+                        while (any(test2))
+                        {
+                            z = select(test2, z / u, z);
+                            p = select(test2, p + batch_type(1.), p);
+                            u = select(test2, x + p, u);
+                            test2 = (u < batch_type(2.));
+                        }
 
-                    z = abs(z);
-                    x += p - batch_type(2.);
-                    r1 = x * gammaln1(x) + log(z);
-                    if (all(test))
-                        return r1;
+                        z = abs(z);
+                        x += p - batch_type(2.);
+                        r1 = x * gammaln1(x) + log(z);
+                        if (all(test))
+                            return r1;
+                    }
+                    batch_type r2 = fma(xx - batch_type(0.5), log(xx), constants::logsqrt2pi<batch_type>() - xx);
+                    batch_type p = batch_type(1.) / (xx * xx);
+                    r2 += gammalnA(p) / xx;
+                    return select(test, r1, r2);
                 }
-                batch_type r2 = fma(xx - batch_type(0.5), log(xx), constants::logsqrt2pi<batch_type>() - xx);
-                batch_type p = batch_type(1.) / (xx * xx);
-                r2 += gammalnA(p) / xx;
-                return select(test, r1, r2);
-            }
-        };
-    }
-
-    template<class A, class T> batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>) {
-      return detail::lgamma_impl<batch<T, A>>::compute(self);
-    }
+            };
+        }
 
+        template <class A, class T>
+        inline batch<T, A> lgamma(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::lgamma_impl<batch<T, A>>::compute(self);
+        }
 
-    // log
-            /* origin: boost/simd/arch/common/simd/function/log.hpp */
-            /*
-             * ====================================================
-             * copyright 2016 NumScale SAS
-             *
-             * Distributed under the Boost Software License, Version 1.0.
-             * (See copy at http://boost.org/LICENSE_1_0.txt)
-             * ====================================================
-             */
-    template<class A> batch<float, A> log(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-      using i_type = as_integer_t<batch_type>;
-      batch_type x = self;
-      i_type k(0);
-      auto isnez = (self != batch_type(0.));
+        // log
+        /* origin: boost/simd/arch/common/simd/function/log.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A>
+        inline batch<float, A> log(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            using i_type = as_integer_t<batch_type>;
+            batch_type x = self;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-      auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-      if (any(test))
-      {
-          k = select(bool_cast(test), k - i_type(23), k);
-          x = select(test, x * batch_type(8388608ul), x);
-      }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(23), k);
+                x = select(test, x * batch_type(8388608ul), x);
+            }
 #endif
-      i_type ix = ::xsimd::bitwise_cast<i_type>(x);
-      ix += 0x3f800000 - 0x3f3504f3;
-      k += (ix >> 23) - 0x7f;
-      ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
-      x = ::xsimd::bitwise_cast<batch_type>(ix);
-      batch_type f = --x;
-      batch_type s = f / (batch_type(2.) + f);
-      batch_type z = s * s;
-      batch_type w = z * z;
-      batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
-      batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
-      batch_type R = t2 + t1;
-      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);
+            i_type ix = ::xsimd::bitwise_cast<i_type>(x);
+            ix += 0x3f800000 - 0x3f3504f3;
+            k += (ix >> 23) - 0x7f;
+            ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
+            x = ::xsimd::bitwise_cast<batch_type>(ix);
+            batch_type f = --x;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
+            batch_type R = t2 + t1;
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-      return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
 
-    template<class A> batch<double, A> log(batch<double, A> const& self, requires_arch<generic>) {
-               using batch_type = batch<double, A>;
-                using i_type = as_integer_t<batch_type>;
+        template <class A>
+        inline batch<double, A> log(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            using i_type = as_integer_t<batch_type>;
 
-                batch_type x = self;
-                i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
-                i_type k(0);
-                auto isnez = (self != batch_type(0.));
+            batch_type x = self;
+            i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-                auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-                if (any(test))
-                {
-                    k = select(bool_cast(test), k - i_type(54), k);
-                    x = select(test, x * batch_type(18014398509481984ull), x);
-                }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(54), k);
+                x = select(test, x * batch_type(18014398509481984ull), x);
+            }
 #endif
-                hx += 0x3ff00000 - 0x3fe6a09e;
-                k += (hx >> 20) - 0x3ff;
-                batch_type dk = to_float(k);
-                hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
-                x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
-
-                batch_type f = --x;
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-
-                batch_type t1 = w * detail::horner<batch_type,
-                                  0x3fd999999997fa04ll,
-                                  0x3fcc71c51d8e78afll,
-                                  0x3fc39a09d078c69fll>(w);
-                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);
+            hx += 0x3ff00000 - 0x3fe6a09e;
+            k += (hx >> 20) - 0x3ff;
+            batch_type dk = to_float(k);
+            hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
+            x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
+
+            batch_type f = --x;
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+
+            batch_type t1 = w * detail::horner<batch_type, 0x3fd999999997fa04ll, 0x3fcc71c51d8e78afll, 0x3fc39a09d078c69fll>(w);
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
 
-    template <class A, class T>
-    batch<std::complex<T>, A> log(const batch<std::complex<T>, A>& z, requires_arch<generic>)
-    {
-        return batch<std::complex<T>, A>(log(abs(z)), atan2(z.imag(), z.real()));
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> log(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        {
+            return batch<std::complex<T>, A>(log(abs(z)), atan2(z.imag(), z.real()));
+        }
 
-    // log2
-    template<class A> batch<float, A> log2(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                using i_type = as_integer_t<batch_type>;
-                batch_type x = self;
-                i_type k(0);
-                auto isnez = (self != batch_type(0.));
+        // log2
+        template <class A>
+        inline batch<float, A> log2(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            using i_type = as_integer_t<batch_type>;
+            batch_type x = self;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-                auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-                if (any(test))
-                {
-                    k = select(bool_cast(test), k - i_type(25), k);
-                    x = select(test, x * batch_type(33554432ul), x);
-                }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(25), k);
+                x = select(test, x * batch_type(33554432ul), x);
+            }
 #endif
-                i_type ix = ::xsimd::bitwise_cast<i_type>(x);
-                ix += 0x3f800000 - 0x3f3504f3;
-                k += (ix >> 23) - 0x7f;
-                ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
-                x = ::xsimd::bitwise_cast<batch_type>(ix);
-                batch_type f = --x;
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
-                batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
-                batch_type R = t1 + t2;
-                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);
+            i_type ix = ::xsimd::bitwise_cast<i_type>(x);
+            ix += 0x3f800000 - 0x3f3504f3;
+            k += (ix >> 23) - 0x7f;
+            ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
+            x = ::xsimd::bitwise_cast<batch_type>(ix);
+            batch_type f = --x;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
+            batch_type R = t1 + t2;
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
-    template<class A> batch<double, A> log2(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                using i_type = as_integer_t<batch_type>;
-                batch_type x = self;
-                i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
-                i_type k(0);
-                auto isnez = (self != batch_type(0.));
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
+
+        template <class A>
+        inline batch<double, A> log2(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            using i_type = as_integer_t<batch_type>;
+            batch_type x = self;
+            i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-                auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-                if (any(test))
-                {
-                    k = select(bool_cast(test), k - i_type(54), k);
-                    x = select(test, x * batch_type(18014398509481984ull), x);
-                }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(54), k);
+                x = select(test, x * batch_type(18014398509481984ull), x);
+            }
 #endif
-                hx += 0x3ff00000 - 0x3fe6a09e;
-                k += (hx >> 20) - 0x3ff;
-                hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
-                x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
-                batch_type f = --x;
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type,
-                                  0x3fd999999997fa04ll,
-                                  0x3fcc71c51d8e78afll,
-                                  0x3fc39a09d078c69fll>(w);
-                batch_type t2 = z * detail::horner<batch_type,
-                                  0x3fe5555555555593ll,
-                                  0x3fd2492494229359ll,
-                                  0x3fc7466496cb03dell,
-                                  0x3fc2f112df3e5244ll>(w);
-                batch_type R = t2 + t1;
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type hi = f - hfsq;
-                hi = hi & ::xsimd::bitwise_cast<batch_type>((constants::allbits<i_type>() << 32));
-                batch_type lo = fma(s, hfsq + R, f - hi - hfsq);
-                batch_type val_hi = hi * constants::invlog_2hi<batch_type>();
-                batch_type val_lo = fma(lo + hi, constants::invlog_2lo<batch_type>(), lo * constants::invlog_2hi<batch_type>());
-                batch_type dk = to_float(k);
-                batch_type w1 = dk + val_hi;
-                val_lo += (dk - w1) + val_hi;
-                val_hi = w1;
-                batch_type r = val_lo + val_hi;
+            hx += 0x3ff00000 - 0x3fe6a09e;
+            k += (hx >> 20) - 0x3ff;
+            hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
+            x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
+            batch_type f = --x;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3fd999999997fa04ll, 0x3fcc71c51d8e78afll, 0x3fc39a09d078c69fll>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3fe5555555555593ll, 0x3fd2492494229359ll, 0x3fc7466496cb03dell, 0x3fc2f112df3e5244ll>(w);
+            batch_type R = t2 + t1;
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type hi = f - hfsq;
+            hi = hi & ::xsimd::bitwise_cast<batch_type>((constants::allbits<i_type>() << 32));
+            batch_type lo = fma(s, hfsq + R, f - hi - hfsq);
+            batch_type val_hi = hi * constants::invlog_2hi<batch_type>();
+            batch_type val_lo = fma(lo + hi, constants::invlog_2lo<batch_type>(), lo * constants::invlog_2hi<batch_type>());
+            batch_type dk = to_float(k);
+            batch_type w1 = dk + val_hi;
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
-    namespace detail {
-        template <class T, class A>
-        inline batch<T, A> logN_complex_impl(const batch<T, A>& z, typename batch<T, A>::value_type base)
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
+
+        namespace detail
         {
-            using batch_type = batch<T, A>;
-            using rv_type = typename batch_type::value_type;
-            return log(z) / batch_type(rv_type(base));
+            template <class T, class A>
+            inline batch<T, A> logN_complex_impl(const batch<T, A>& z, typename batch<T, A>::value_type base) noexcept
+            {
+                using batch_type = batch<T, A>;
+                using rv_type = typename batch_type::value_type;
+                return log(z) / batch_type(rv_type(base));
+            }
         }
-  }
 
-    template<class A, class T> batch<std::complex<T>, A> log2(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-      return detail::logN_complex_impl(self, std::log(2));
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> log2(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::logN_complex_impl(self, std::log(2));
+        }
 
-    // log10
-            /* origin: FreeBSD /usr/src/lib/msun/src/e_log10f.c */
-            /*
-             * ====================================================
-             * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
-             *
-             * Developed at SunPro, a Sun Microsystems, Inc. business.
-             * Permission to use, copy, modify, and distribute this
-             * software is freely granted, provided that this notice
-             * is preserved.
-             * ====================================================
-             */
-    template<class A> batch<float, A> log10(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                const batch_type
-                    ivln10hi(4.3432617188e-01f),
-                    ivln10lo(-3.1689971365e-05f),
-                    log10_2hi(3.0102920532e-01f),
-                    log10_2lo(7.9034151668e-07f);
-                using i_type = as_integer_t<batch_type>;
-                batch_type x = self;
-                i_type k(0);
-                auto isnez = (self != batch_type(0.));
+        // log10
+        /* origin: FreeBSD /usr/src/lib/msun/src/e_log10f.c */
+        /*
+         * ====================================================
+         * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+         *
+         * Developed at SunPro, a Sun Microsystems, Inc. business.
+         * Permission to use, copy, modify, and distribute this
+         * software is freely granted, provided that this notice
+         * is preserved.
+         * ====================================================
+         */
+        template <class A>
+        inline batch<float, A> log10(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            const batch_type
+                ivln10hi(4.3432617188e-01f),
+                ivln10lo(-3.1689971365e-05f),
+                log10_2hi(3.0102920532e-01f),
+                log10_2lo(7.9034151668e-07f);
+            using i_type = as_integer_t<batch_type>;
+            batch_type x = self;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-                auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-                if (any(test))
-                {
-                    k = select(bool_cast(test), k - i_type(25), k);
-                    x = select(test, x * batch_type(33554432ul), x);
-                }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(25), k);
+                x = select(test, x * batch_type(33554432ul), x);
+            }
 #endif
-                i_type ix = ::xsimd::bitwise_cast<i_type>(x);
-                ix += 0x3f800000 - 0x3f3504f3;
-                k += (ix >> 23) - 0x7f;
-                ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
-                x = ::xsimd::bitwise_cast<batch_type>(ix);
-                batch_type f = --x;
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
-                batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
-                batch_type R = t2 + t1;
-                batch_type dk = to_float(k);
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type hibits = f - hfsq;
-                hibits &= ::xsimd::bitwise_cast<batch_type>(i_type(0xfffff000));
-                batch_type lobits = fma(s, hfsq + R, f - hibits - hfsq);
-                batch_type r = fma(dk, log10_2hi,
-                          fma(hibits, ivln10hi,
-                              fma(lobits, ivln10hi,
-                                  fma(lobits + hibits, ivln10lo, dk * log10_2lo))));
+            i_type ix = ::xsimd::bitwise_cast<i_type>(x);
+            ix += 0x3f800000 - 0x3f3504f3;
+            k += (ix >> 23) - 0x7f;
+            ix = (ix & i_type(0x007fffff)) + 0x3f3504f3;
+            x = ::xsimd::bitwise_cast<batch_type>(ix);
+            batch_type f = --x;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
+            batch_type R = t2 + t1;
+            batch_type dk = to_float(k);
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type hibits = f - hfsq;
+            hibits &= ::xsimd::bitwise_cast<batch_type>(i_type(0xfffff000));
+            batch_type lobits = fma(s, hfsq + R, f - hibits - hfsq);
+            batch_type r = fma(dk, log10_2hi,
+                               fma(hibits, ivln10hi,
+                                   fma(lobits, ivln10hi,
+                                       fma(lobits + hibits, ivln10lo, dk * log10_2lo))));
 #ifndef XSIMD_NO_INFINITIES
-                batch_type zz = select(isnez, select(self == constants::infinity<batch_type>(), constants::infinity<batch_type>(), r), constants::minusinfinity<batch_type>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
-    template<class A> batch<double, A> log10(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                const batch_type
-                    ivln10hi(4.34294481878168880939e-01),
-                    ivln10lo(2.50829467116452752298e-11),
-                    log10_2hi(3.01029995663611771306e-01),
-                    log10_2lo(3.69423907715893078616e-13);
-                using i_type = as_integer_t<batch_type>;
-                batch_type x = self;
-                i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
-                i_type k(0);
-                auto isnez = (self != batch_type(0.));
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
+
+        template <class A>
+        inline batch<double, A> log10(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            const batch_type
+                ivln10hi(4.34294481878168880939e-01),
+                ivln10lo(2.50829467116452752298e-11),
+                log10_2hi(3.01029995663611771306e-01),
+                log10_2lo(3.69423907715893078616e-13);
+            using i_type = as_integer_t<batch_type>;
+            batch_type x = self;
+            i_type hx = ::xsimd::bitwise_cast<i_type>(x) >> 32;
+            i_type k(0);
+            auto isnez = (self != batch_type(0.));
 #ifndef XSIMD_NO_DENORMALS
-                auto test = (self < constants::smallestposval<batch_type>()) && isnez;
-                if (any(test))
-                {
-                    k = select(bool_cast(test), k - i_type(54), k);
-                    x = select(test, x * batch_type(18014398509481984ull), x);
-                }
+            auto test = (self < constants::smallestposval<batch_type>()) && isnez;
+            if (any(test))
+            {
+                k = select(bool_cast(test), k - i_type(54), k);
+                x = select(test, x * batch_type(18014398509481984ull), x);
+            }
 #endif
-                hx += 0x3ff00000 - 0x3fe6a09e;
-                k += (hx >> 20) - 0x3ff;
-                hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
-                x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
-                batch_type f = --x;
-                batch_type dk = to_float(k);
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type,
-                                  0x3fd999999997fa04ll,
-                                  0x3fcc71c51d8e78afll,
-                                  0x3fc39a09d078c69fll>(w);
-                batch_type t2 = z * detail::horner<batch_type,
-                                  0x3fe5555555555593ll,
-                                  0x3fd2492494229359ll,
-                                  0x3fc7466496cb03dell,
-                                  0x3fc2f112df3e5244ll>(w);
-                batch_type R = t2 + t1;
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type hi = f - hfsq;
-                hi = hi & ::xsimd::bitwise_cast<batch_type>(constants::allbits<i_type>() << 32);
-                batch_type lo = f - hi - hfsq + s * (hfsq + R);
-                batch_type val_hi = hi * ivln10hi;
-                batch_type y = dk * log10_2hi;
-                batch_type val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;
-                batch_type w1 = y + val_hi;
-                val_lo += (y - w1) + val_hi;
-                val_hi = w1;
-                batch_type r = val_lo + val_hi;
+            hx += 0x3ff00000 - 0x3fe6a09e;
+            k += (hx >> 20) - 0x3ff;
+            hx = (hx & i_type(0x000fffff)) + 0x3fe6a09e;
+            x = ::xsimd::bitwise_cast<batch_type>(hx << 32 | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(x)));
+            batch_type f = --x;
+            batch_type dk = to_float(k);
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3fd999999997fa04ll, 0x3fcc71c51d8e78afll, 0x3fc39a09d078c69fll>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3fe5555555555593ll, 0x3fd2492494229359ll, 0x3fc7466496cb03dell, 0x3fc2f112df3e5244ll>(w);
+            batch_type R = t2 + t1;
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type hi = f - hfsq;
+            hi = hi & ::xsimd::bitwise_cast<batch_type>(constants::allbits<i_type>() << 32);
+            batch_type lo = f - hi - hfsq + s * (hfsq + R);
+            batch_type val_hi = hi * ivln10hi;
+            batch_type y = dk * log10_2hi;
+            batch_type val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;
+            batch_type w1 = y + val_hi;
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
+            return select(!(self >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
 
         template <class A, class T>
-            batch<std::complex<T>, A> log10(const batch<std::complex<T>, A>& z, requires_arch<generic>)
-            {
-                return detail::logN_complex_impl(z, std::log(10));
-            }
+        inline batch<std::complex<T>, A> log10(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        {
+            return detail::logN_complex_impl(z, std::log(10));
+        }
 
-    // log1p
-            /* origin: boost/simd/arch/common/simd/function/log1p.hpp */
-            /*
-             * ====================================================
-             * copyright 2016 NumScale SAS
-             *
-             * Distributed under the Boost Software License, Version 1.0.
-             * (See copy at http://boost.org/LICENSE_1_0.txt)
-             * ====================================================
-             */
-    template<class A> batch<float, A> log1p(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                using i_type = as_integer_t<batch_type>;
-                const batch_type uf = self + batch_type(1.);
-                auto isnez = (uf != batch_type(0.));
-                i_type iu = ::xsimd::bitwise_cast<i_type>(uf);
-                iu += 0x3f800000 - 0x3f3504f3;
-                i_type k = (iu >> 23) - 0x7f;
-                iu = (iu & i_type(0x007fffff)) + 0x3f3504f3;
-                batch_type f = --(::xsimd::bitwise_cast<batch_type>(iu));
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
-                batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
-                batch_type R = t2 + t1;
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type dk = to_float(k);
-                /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
-                batch_type c = select(bool_cast(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);
+        // log1p
+        /* origin: boost/simd/arch/common/simd/function/log1p.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A>
+        inline batch<float, A> log1p(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            using i_type = as_integer_t<batch_type>;
+            const batch_type uf = self + batch_type(1.);
+            auto isnez = (uf != batch_type(0.));
+            i_type iu = ::xsimd::bitwise_cast<i_type>(uf);
+            iu += 0x3f800000 - 0x3f3504f3;
+            i_type k = (iu >> 23) - 0x7f;
+            iu = (iu & i_type(0x007fffff)) + 0x3f3504f3;
+            batch_type f = --(::xsimd::bitwise_cast<batch_type>(iu));
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3eccce13, 0x3e789e26>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3f2aaaaa, 0x3e91e9ee>(w);
+            batch_type R = t2 + t1;
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type dk = to_float(k);
+            /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+            batch_type c = select(bool_cast(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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
-    template<class A> batch<double, A> log1p(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                using i_type = as_integer_t<batch_type>;
-                const batch_type uf = self + batch_type(1.);
-                auto isnez = (uf != batch_type(0.));
-                i_type hu = ::xsimd::bitwise_cast<i_type>(uf) >> 32;
-                hu += 0x3ff00000 - 0x3fe6a09e;
-                i_type k = (hu >> 20) - 0x3ff;
-                /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
-                batch_type c = select(bool_cast(k >= i_type(2)), batch_type(1.) - (uf - self), self - (uf - batch_type(1.))) / uf;
-                hu = (hu & i_type(0x000fffff)) + 0x3fe6a09e;
-                batch_type f = ::xsimd::bitwise_cast<batch_type>((hu << 32) | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(uf)));
-                f = --f;
-                batch_type hfsq = batch_type(0.5) * f * f;
-                batch_type s = f / (batch_type(2.) + f);
-                batch_type z = s * s;
-                batch_type w = z * z;
-                batch_type t1 = w * detail::horner<batch_type,
-                                  0x3fd999999997fa04ll,
-                                  0x3fcc71c51d8e78afll,
-                                  0x3fc39a09d078c69fll>(w);
-                batch_type t2 = z * detail::horner<batch_type,
-                                  0x3fe5555555555593ll,
-                                  0x3fd2492494229359ll,
-                                  0x3fc7466496cb03dell,
-                                  0x3fc2f112df3e5244ll>(w);
-                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);
+            return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
+
+        template <class A>
+        inline batch<double, A> log1p(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            using i_type = as_integer_t<batch_type>;
+            const batch_type uf = self + batch_type(1.);
+            auto isnez = (uf != batch_type(0.));
+            i_type hu = ::xsimd::bitwise_cast<i_type>(uf) >> 32;
+            hu += 0x3ff00000 - 0x3fe6a09e;
+            i_type k = (hu >> 20) - 0x3ff;
+            /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+            batch_type c = select(bool_cast(k >= i_type(2)), batch_type(1.) - (uf - self), self - (uf - batch_type(1.))) / uf;
+            hu = (hu & i_type(0x000fffff)) + 0x3fe6a09e;
+            batch_type f = ::xsimd::bitwise_cast<batch_type>((hu << 32) | (i_type(0xffffffff) & ::xsimd::bitwise_cast<i_type>(uf)));
+            f = --f;
+            batch_type hfsq = batch_type(0.5) * f * f;
+            batch_type s = f / (batch_type(2.) + f);
+            batch_type z = s * s;
+            batch_type w = z * z;
+            batch_type t1 = w * detail::horner<batch_type, 0x3fd999999997fa04ll, 0x3fcc71c51d8e78afll, 0x3fc39a09d078c69fll>(w);
+            batch_type t2 = z * detail::horner<batch_type, 0x3fe5555555555593ll, 0x3fd2492494229359ll, 0x3fc7466496cb03dell, 0x3fc2f112df3e5244ll>(w);
+            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>());
+            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>());
+            batch_type zz = select(isnez, r, constants::minusinfinity<batch_type>());
 #endif
-                return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
-    }
-
-    template<class A, class T> batch<std::complex<T>, A> log1p(batch<std::complex<T>, A> const& self, requires_arch<generic>) {
-        using batch_type = batch<std::complex<T>, A>;
-        using real_batch = typename batch_type::real_batch;
-        batch_type u = 1 + self;
-        batch_type logu = log(u);
-        return select(u == batch_type(1.),
-                      self,
-                      select(u.real() <= real_batch(0.),
-                             logu,
-                             logu * self / (u - batch_type(1.))));
-    }
-
+            return select(!(uf >= batch_type(0.)), constants::nan<batch_type>(), zz);
+        }
 
-    // mod
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      return detail::apply([](T x, T y) -> T { return x % y;}, self, other);
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> log1p(batch<std::complex<T>, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<std::complex<T>, A>;
+            using real_batch = typename batch_type::real_batch;
+            batch_type u = 1 + self;
+            batch_type logu = log(u);
+            return select(u == batch_type(1.),
+                          self,
+                          select(u.real() <= real_batch(0.),
+                                 logu,
+                                 logu * self / (u - batch_type(1.))));
+        }
 
+        // mod
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept -> T
+                                 { return x % y; },
+                                 self, other);
+        }
 
-    // nearbyint
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<generic>) {
-      return self;
-    }
-    namespace detail {
-      template<class A, class T> batch<T, A> nearbyintf(batch<T, A> const& self) {
-        using batch_type = batch<T, A>;
-        batch_type s = bitofsign(self);
-        batch_type v = self ^ s;
-        batch_type t2n = constants::twotonmb<batch_type>();
-        // Under fast-math, reordering is possible and the compiler optimizes d
-        // to v. That's not what we want, so prevent compiler optimization here.
-        // FIXME: it may be better to emit a memory barrier here (?).
+        // nearbyint
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self;
+        }
+        namespace detail
+        {
+            template <class A, class T>
+            inline batch<T, A> nearbyintf(batch<T, A> const& self) noexcept
+            {
+                using batch_type = batch<T, A>;
+                batch_type s = bitofsign(self);
+                batch_type v = self ^ s;
+                batch_type t2n = constants::twotonmb<batch_type>();
+                // Under fast-math, reordering is possible and the compiler optimizes d
+                // 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;
+                volatile batch_type d0 = v + t2n;
+                batch_type d = *(batch_type*)(void*)(&d0) - t2n;
 #else
-        batch_type d0 = v + t2n;
-        batch_type d = d0 - t2n;
+                batch_type d0 = v + t2n;
+                batch_type d = d0 - t2n;
 #endif
-        return s ^ select(v < t2n, d, v);
-      }
-    }
-    template<class A> batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<generic>) {
-      return detail::nearbyintf(self);
-    }
-    template<class A> batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<generic>) {
-      return detail::nearbyintf(self);
-    }
-
-    // nextafter
-    namespace detail
-    {
-        template <class T, class A, bool is_int = std::is_integral<T>::value>
-        struct nextafter_kernel
-        {
-            using batch_type = batch<T, A>;
-
-            static inline batch_type next(batch_type const& b) noexcept
-            {
-                return b;
-            }
-
-            static inline batch_type prev(batch_type const& b) noexcept
-            {
-                return b;
+                return s ^ select(v < t2n, d, v);
             }
-        };
-
-        template <class T, class A>
-        struct bitwise_cast_batch;
-
+        }
         template <class A>
-        struct bitwise_cast_batch<float, A>
+        inline batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<generic>) noexcept
         {
-            using type = batch<int32_t, A>;
-        };
-
+            return detail::nearbyintf(self);
+        }
         template <class A>
-        struct bitwise_cast_batch<double, A>
+        inline batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<generic>) noexcept
         {
-            using type = batch<int64_t, A>;
-        };
+            return detail::nearbyintf(self);
+        }
 
-        template <class T, class A>
-        struct nextafter_kernel<T, A, false>
+        // nextafter
+        namespace detail
         {
-            using batch_type = batch<T, A>;
-            using int_batch = typename bitwise_cast_batch<T, A>::type;
-            using int_type = typename int_batch::value_type;
+            template <class T, class A, bool is_int = std::is_integral<T>::value>
+            struct nextafter_kernel
+            {
+                using batch_type = batch<T, A>;
 
-            static inline batch_type next(const batch_type& b) noexcept
+                static inline batch_type next(batch_type const& b) noexcept
+                {
+                    return b;
+                }
+
+                static inline batch_type prev(batch_type const& b) noexcept
+                {
+                    return b;
+                }
+            };
+
+            template <class T, class A>
+            struct bitwise_cast_batch;
+
+            template <class A>
+            struct bitwise_cast_batch<float, A>
             {
-                batch_type n = ::xsimd::bitwise_cast<batch_type>(::xsimd::bitwise_cast<int_batch>(b) + int_type(1));
-                return select(b == constants::infinity<batch_type>(), b, n);
-            }
+                using type = batch<int32_t, A>;
+            };
 
-            static inline batch_type prev(const batch_type& b) noexcept
+            template <class A>
+            struct bitwise_cast_batch<double, A>
             {
-                batch_type p = ::xsimd::bitwise_cast<batch_type>(::xsimd::bitwise_cast<int_batch>(b) - int_type(1));
-                return select(b == constants::minusinfinity<batch_type>(), b, p);
-            }
-        };
-    }
-    template<class A, class T> batch<T, A> nextafter(batch<T, A> const& from, batch<T, A> const& to, requires_arch<generic>) {
-      using kernel = detail::nextafter_kernel<T, A>;
-      return select(from == to, from,
-                    select(to > from, kernel::next(from), kernel::prev(from)));
-    }
+                using type = batch<int64_t, A>;
+            };
+
+            template <class T, class A>
+            struct nextafter_kernel<T, A, false>
+            {
+                using batch_type = batch<T, A>;
+                using int_batch = typename bitwise_cast_batch<T, A>::type;
+                using int_type = typename int_batch::value_type;
 
+                static inline batch_type next(const batch_type& b) noexcept
+                {
+                    batch_type n = ::xsimd::bitwise_cast<batch_type>(::xsimd::bitwise_cast<int_batch>(b) + int_type(1));
+                    return select(b == constants::infinity<batch_type>(), b, n);
+                }
 
-    // pow
-    /* origin: boost/simd/arch/common/simd/function/pow.hpp*/
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A, class T> batch<T, A> pow(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-        using batch_type = batch<T, A>;
-        auto negx = self < batch_type(0.);
-        batch_type z = exp(other * log(abs(self)));
-        z = select(is_odd(other) && negx, -z, z);
-        auto invalid = negx && !(is_flint(other) || isinf(other));
-        return select(invalid, constants::nan<batch_type>(), z);
-    }
+                static inline batch_type prev(const batch_type& b) noexcept
+                {
+                    batch_type p = ::xsimd::bitwise_cast<batch_type>(::xsimd::bitwise_cast<int_batch>(b) - int_type(1));
+                    return select(b == constants::minusinfinity<batch_type>(), b, p);
+                }
+            };
+        }
+        template <class A, class T>
+        inline batch<T, A> nextafter(batch<T, A> const& from, batch<T, A> const& to, requires_arch<generic>) noexcept
+        {
+            using kernel = detail::nextafter_kernel<T, A>;
+            return select(from == to, from,
+                          select(to > from, kernel::next(from), kernel::prev(from)));
+        }
+
+        // pow
+        /* origin: boost/simd/arch/common/simd/function/pow.hpp*/
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A, class T>
+        inline batch<T, A> pow(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            auto negx = self < batch_type(0.);
+            batch_type z = exp(other * log(abs(self)));
+            z = select(is_odd(other) && negx, -z, z);
+            auto invalid = negx && !(is_flint(other) || isinf(other));
+            return select(invalid, constants::nan<batch_type>(), z);
+        }
 
         template <class A, class T>
-        inline batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using cplx_batch = batch<std::complex<T>, A>;
             using real_batch = typename cplx_batch::real_batch;
@@ -1849,55 +1920,67 @@ namespace xsimd {
             return select(absa == ze, cplx_batch(ze), cplx_batch(r * cos(theta), r * sin(theta)));
         }
 
+        // remainder
+        template <class A>
+        inline batch<float, A> remainder(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        {
+            return fnma(nearbyint(self / other), other, self);
+        }
+        template <class A>
+        inline batch<double, A> remainder(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        {
+            return fnma(nearbyint(self / other), other, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            auto mod = self % other;
+            return select(mod <= other / 2, mod, mod - other);
+        }
 
-    // remainder
-    template<class A>
-    batch<float, A> remainder(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) {
-      return fnma(nearbyint(self / other), other, self);
-    }
-    template<class A>
-    batch<double, A> remainder(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) {
-      return fnma(nearbyint(self / other), other, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      auto mod = self % other;
-      return select(mod <= other / 2, mod, mod - other);
-    }
-
-    // select
-    template<class A, class T>
-    batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br, requires_arch<generic>) {
-      return {select(cond, true_br.real(), false_br.real()), select(cond, true_br.imag(), false_br.imag())};
-    }
+        // select
+        template <class A, class T>
+        inline batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br, requires_arch<generic>) noexcept
+        {
+            return { select(cond, true_br.real(), false_br.real()), select(cond, true_br.imag(), false_br.imag()) };
+        }
 
-    // sign
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type> batch<T, A> sign(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-      batch_type res = select(self > batch_type(0), batch_type(1), batch_type(0)) - select(self < batch_type(0), batch_type(1), batch_type(0));
-      return res;
-    }
+        // sign
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sign(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type res = select(self > batch_type(0), batch_type(1), batch_type(0)) - select(self < batch_type(0), batch_type(1), batch_type(0));
+            return res;
+        }
 
-    namespace detail {
-    template<class T, class A> batch<T, A> signf(batch<T, A> const& self) {
-      using batch_type = batch<T, A>;
-      batch_type res = select(self > batch_type(0.f), batch_type(1.f), batch_type(0.f)) - select(self < batch_type(0.f), batch_type(1.f), batch_type(0.f));
+        namespace detail
+        {
+            template <class T, class A>
+            inline batch<T, A> signf(batch<T, A> const& self) noexcept
+            {
+                using batch_type = batch<T, A>;
+                batch_type res = select(self > batch_type(0.f), batch_type(1.f), batch_type(0.f)) - select(self < batch_type(0.f), batch_type(1.f), batch_type(0.f));
 #ifdef XSIMD_NO_NANS
-      return res;
+                return res;
 #else
-      return select(isnan(self), constants::nan<batch_type>(), res);
+                return select(isnan(self), constants::nan<batch_type>(), res);
 #endif
-    }
-    }
+            }
+        }
 
-    template<class A> batch<float, A> sign(batch<float, A> const& self, requires_arch<generic>) {
-      return detail::signf(self);
-    }
-    template<class A> batch<double, A> sign(batch<double, A> const& self, requires_arch<generic>) {
-      return detail::signf(self);
-    }
+        template <class A>
+        inline batch<float, A> sign(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::signf(self);
+        }
+        template <class A>
+        inline batch<double, A> sign(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::signf(self);
+        }
         template <class A, class T>
-        inline batch<std::complex<T>, A> sign(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> sign(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -1908,286 +1991,299 @@ namespace xsimd {
                           batch_type(sign(iz)));
         }
 
-    // signnz
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type> batch<T, A> signnz(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-      return (self >> (sizeof(T) * 8 - 1)) | batch_type(1.);
-    }
+        // signnz
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> signnz(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            return (self >> (sizeof(T) * 8 - 1)) | batch_type(1.);
+        }
 
-    namespace detail {
-    template<class T, class A> batch<T, A> signnzf(batch<T, A> const& self) {
-      using batch_type = batch<T, A>;
+        namespace detail
+        {
+            template <class T, class A>
+            inline batch<T, A> signnzf(batch<T, A> const& self) noexcept
+            {
+                using batch_type = batch<T, A>;
 #ifndef XSIMD_NO_NANS
                 return select(isnan(self), constants::nan<batch_type>(), batch_type(1.) | (constants::signmask<batch_type>() & self));
 #else
                 return batch_type(1.) | (constants::signmask<batch_type>() & self);
 #endif
-    }
-    }
-
-    template<class A> batch<float, A> signnz(batch<float, A> const& self, requires_arch<generic>) {
-      return detail::signnzf(self);
-    }
-    template<class A> batch<double, A> signnz(batch<double, A> const& self, requires_arch<generic>) {
-      return detail::signnzf(self);
-    }
+            }
+        }
 
-    // sqrt
-    template<class A, class T> batch<std::complex<T>, A> sqrt(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-
-                constexpr T csqrt_scale_factor = std::is_same<T, float>::value?6.7108864e7f:1.8014398509481984e16;
-                constexpr T csqrt_scale = std::is_same<T, float>::value?1.220703125e-4f:7.450580596923828125e-9;
-                using batch_type = batch<std::complex<T>, A>;
-                using real_batch = batch<T, A>;
-                real_batch x = z.real();
-                real_batch y = z.imag();
-                real_batch sqrt_x = sqrt(fabs(x));
-                real_batch sqrt_hy = sqrt(0.5 * fabs(y));
-                auto cond = (fabs(x) > real_batch(4.) || fabs(y) > real_batch(4.));
-                x = select(cond, x * 0.25, x * csqrt_scale_factor);
-                y = select(cond, y * 0.25, y * csqrt_scale_factor);
-                real_batch scale = select(cond, real_batch(2.), real_batch(csqrt_scale));
-                real_batch r = abs(batch_type(x, y));
-
-                auto condxp = x > real_batch(0.);
-                real_batch t0 = select(condxp, xsimd::sqrt(0.5 * (r + x)), xsimd::sqrt(0.5 * (r - x)));
-                real_batch r0 = scale * fabs((0.5 * y) / t0);
-                t0 *= scale;
-                real_batch t = select(condxp, t0, r0);
-                r = select(condxp, r0, t0);
-                batch_type resg = select(y < real_batch(0.), batch_type(t, -r), batch_type(t, r));
-                real_batch ze(0.);
-
-                return select(y == ze,
-                              select(x == ze,
-                                     batch_type(ze, ze),
-                                     select(x < ze, batch_type(ze, sqrt_x), batch_type(sqrt_x, ze))),
-                              select(x == ze,
-                                     select(y > ze, batch_type(sqrt_hy, sqrt_hy), batch_type(sqrt_hy, -sqrt_hy)),
-                                     resg));
+        template <class A>
+        inline batch<float, A> signnz(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::signnzf(self);
+        }
+        template <class A>
+        inline batch<double, A> signnz(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::signnzf(self);
+        }
 
-    }
+        // sqrt
+        template <class A, class T>
+        inline batch<std::complex<T>, A> sqrt(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
 
-    // tgamma
+            constexpr T csqrt_scale_factor = std::is_same<T, float>::value ? 6.7108864e7f : 1.8014398509481984e16;
+            constexpr T csqrt_scale = std::is_same<T, float>::value ? 1.220703125e-4f : 7.450580596923828125e-9;
+            using batch_type = batch<std::complex<T>, A>;
+            using real_batch = batch<T, A>;
+            real_batch x = z.real();
+            real_batch y = z.imag();
+            real_batch sqrt_x = sqrt(fabs(x));
+            real_batch sqrt_hy = sqrt(0.5 * fabs(y));
+            auto cond = (fabs(x) > real_batch(4.) || fabs(y) > real_batch(4.));
+            x = select(cond, x * 0.25, x * csqrt_scale_factor);
+            y = select(cond, y * 0.25, y * csqrt_scale_factor);
+            real_batch scale = select(cond, real_batch(2.), real_batch(csqrt_scale));
+            real_batch r = abs(batch_type(x, y));
+
+            auto condxp = x > real_batch(0.);
+            real_batch t0 = select(condxp, xsimd::sqrt(0.5 * (r + x)), xsimd::sqrt(0.5 * (r - x)));
+            real_batch r0 = scale * fabs((0.5 * y) / t0);
+            t0 *= scale;
+            real_batch t = select(condxp, t0, r0);
+            r = select(condxp, r0, t0);
+            batch_type resg = select(y < real_batch(0.), batch_type(t, -r), batch_type(t, r));
+            real_batch ze(0.);
+
+            return select(y == ze,
+                          select(x == ze,
+                                 batch_type(ze, ze),
+                                 select(x < ze, batch_type(ze, sqrt_x), batch_type(sqrt_x, ze))),
+                          select(x == ze,
+                                 select(y > ze, batch_type(sqrt_hy, sqrt_hy), batch_type(sqrt_hy, -sqrt_hy)),
+                                 resg));
+        }
 
-    namespace detail {
-        /* origin: boost/simd/arch/common/detail/generic/stirling_kernel.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
-        template <class B>
-        struct stirling_kernel;
+        // tgamma
 
-        template <class A>
-        struct stirling_kernel<batch<float, A>>
+        namespace detail
         {
-          using batch_type = batch<float, A>;
-            static inline batch_type compute(const batch_type& x)
-            {
-                return horner<batch_type,
-                              0x3daaaaab,
-                              0x3b638e39,
-                              0xbb2fb930,
-                              0xb970b359>(x);
-            }
+            /* origin: boost/simd/arch/common/detail/generic/stirling_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            struct stirling_kernel;
 
-            static inline batch_type split_limit()
+            template <class A>
+            struct stirling_kernel<batch<float, A>>
             {
-                return batch_type(bit_cast<float>(uint32_t(0x41d628f6)));
-            }
+                using batch_type = batch<float, A>;
+                static inline batch_type compute(const batch_type& x) noexcept
+                {
+                    return horner<batch_type,
+                                  0x3daaaaab,
+                                  0x3b638e39,
+                                  0xbb2fb930,
+                                  0xb970b359>(x);
+                }
 
-            static inline batch_type large_limit()
-            {
-                return batch_type(bit_cast<float>(uint32_t(0x420c28f3)));
-            }
-        };
+                static inline batch_type split_limit() noexcept
+                {
+                    return batch_type(bit_cast<float>(uint32_t(0x41d628f6)));
+                }
 
-        template <class A>
-        struct stirling_kernel<batch<double, A>>
-        {
-          using batch_type = batch<double, A>;
-            static inline batch_type compute(const batch_type& x)
-            {
-                return horner<batch_type,
-                              0x3fb5555555555986ull,  //   8.33333333333482257126E-2
-                              0x3f6c71c71b98c5fdull,  //   3.47222221605458667310E-3
-                              0xbf65f72607d44fd7ull,  //  -2.68132617805781232825E-3
-                              0xbf2e166b27e61d7cull,  //  -2.29549961613378126380E-4
-                              0x3f49cc72592d7293ull   //   7.87311395793093628397E-4
-                              >(x);
-            }
+                static inline batch_type large_limit() noexcept
+                {
+                    return batch_type(bit_cast<float>(uint32_t(0x420c28f3)));
+                }
+            };
 
-            static inline batch_type split_limit()
+            template <class A>
+            struct stirling_kernel<batch<double, A>>
             {
-                return batch_type(bit_cast<double>(uint64_t(0x4061e083ba3443d4)));
-            }
+                using batch_type = batch<double, A>;
+                static inline batch_type compute(const batch_type& x) noexcept
+                {
+                    return horner<batch_type,
+                                  0x3fb5555555555986ull, //   8.33333333333482257126E-2
+                                  0x3f6c71c71b98c5fdull, //   3.47222221605458667310E-3
+                                  0xbf65f72607d44fd7ull, //  -2.68132617805781232825E-3
+                                  0xbf2e166b27e61d7cull, //  -2.29549961613378126380E-4
+                                  0x3f49cc72592d7293ull //   7.87311395793093628397E-4
+                                  >(x);
+                }
 
-            static inline batch_type large_limit()
-            {
-                return batch_type(bit_cast<double>(uint64_t(0x4065800000000000)));
-            }
-        };
+                static inline batch_type split_limit() noexcept
+                {
+                    return batch_type(bit_cast<double>(uint64_t(0x4061e083ba3443d4)));
+                }
 
-        /* origin: boost/simd/arch/common/simd/function/stirling.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
-        template <class T, class A>
-        inline batch<T, A> stirling(const batch<T, A>& a)
-        {
-          using batch_type = batch<T, A>;
-            const batch_type stirlingsplitlim = stirling_kernel<batch_type>::split_limit();
-            const batch_type stirlinglargelim = stirling_kernel<batch_type>::large_limit();
-            batch_type x = select(a >= batch_type(0.), a, constants::nan<batch_type>());
-            batch_type w = batch_type(1.) / x;
-            w = fma(w, stirling_kernel<batch_type>::compute(w), batch_type(1.));
-            batch_type y = exp(-x);
-            auto test = (x < stirlingsplitlim);
-            batch_type z = x - batch_type(0.5);
-            z = select(test, z, batch_type(0.5) * z);
-            batch_type v = exp(z * log(abs(x)));
-            y *= v;
-            y = select(test, y, y * v);
-            y *= constants::sqrt_2pi<batch_type>() * w;
+                static inline batch_type large_limit() noexcept
+                {
+                    return batch_type(bit_cast<double>(uint64_t(0x4065800000000000)));
+                }
+            };
+
+            /* origin: boost/simd/arch/common/simd/function/stirling.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class T, class A>
+            inline batch<T, A> stirling(const batch<T, A>& a) noexcept
+            {
+                using batch_type = batch<T, A>;
+                const batch_type stirlingsplitlim = stirling_kernel<batch_type>::split_limit();
+                const batch_type stirlinglargelim = stirling_kernel<batch_type>::large_limit();
+                batch_type x = select(a >= batch_type(0.), a, constants::nan<batch_type>());
+                batch_type w = batch_type(1.) / x;
+                w = fma(w, stirling_kernel<batch_type>::compute(w), batch_type(1.));
+                batch_type y = exp(-x);
+                auto test = (x < stirlingsplitlim);
+                batch_type z = x - batch_type(0.5);
+                z = select(test, z, batch_type(0.5) * z);
+                batch_type v = exp(z * log(abs(x)));
+                y *= v;
+                y = select(test, y, y * v);
+                y *= constants::sqrt_2pi<batch_type>() * w;
 #ifndef XSIMD_NO_INFINITIES
-            y = select(isinf(x), x, y);
+                y = select(isinf(x), x, y);
 #endif
-            return select(x > stirlinglargelim, constants::infinity<batch_type>(), y);
-        }
+                return select(x > stirlinglargelim, constants::infinity<batch_type>(), y);
+            }
 
-    /* origin: boost/simd/arch/common/detail/generic/gamma_kernel.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-        template <class B>
-        struct tgamma_kernel;
+            /* origin: boost/simd/arch/common/detail/generic/gamma_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            struct tgamma_kernel;
 
-        template <class A>
-        struct tgamma_kernel<batch<float, A>>
-        {
-          using batch_type = batch<float, A>;
-            static inline batch_type compute(const batch_type& x)
+            template <class A>
+            struct tgamma_kernel<batch<float, A>>
             {
-                return horner<batch_type,
-                              0x3f800000UL,  //  9.999999757445841E-01
-                              0x3ed87799UL,  //  4.227874605370421E-01
-                              0x3ed2d411UL,  //  4.117741948434743E-01
-                              0x3da82a34UL,  //  8.211174403261340E-02
-                              0x3d93ae7cUL,  //  7.211014349068177E-02
-                              0x3b91db14UL,  //  4.451165155708328E-03
-                              0x3ba90c99UL,  //  5.158972571345137E-03
-                              0x3ad28b22UL   //  1.606319369134976E-03
-                              >(x);
-            }
-        };
+                using batch_type = batch<float, A>;
+                static inline batch_type compute(const batch_type& x) noexcept
+                {
+                    return horner<batch_type,
+                                  0x3f800000UL, //  9.999999757445841E-01
+                                  0x3ed87799UL, //  4.227874605370421E-01
+                                  0x3ed2d411UL, //  4.117741948434743E-01
+                                  0x3da82a34UL, //  8.211174403261340E-02
+                                  0x3d93ae7cUL, //  7.211014349068177E-02
+                                  0x3b91db14UL, //  4.451165155708328E-03
+                                  0x3ba90c99UL, //  5.158972571345137E-03
+                                  0x3ad28b22UL //  1.606319369134976E-03
+                                  >(x);
+                }
+            };
 
-        template <class A>
-        struct tgamma_kernel<batch<double, A>>
-        {
-          using batch_type = batch<double, A>;
-            static inline batch_type compute(const batch_type& x)
+            template <class A>
+            struct tgamma_kernel<batch<double, A>>
             {
-                return horner<batch_type,
-                              0x3ff0000000000000ULL,  // 9.99999999999999996796E-1
-                              0x3fdfa1373993e312ULL,  // 4.94214826801497100753E-1
-                              0x3fca8da9dcae7d31ULL,  // 2.07448227648435975150E-1
-                              0x3fa863d918c423d3ULL,  // 4.76367800457137231464E-2
-                              0x3f8557cde9db14b0ULL,  // 1.04213797561761569935E-2
-                              0x3f5384e3e686bfabULL,  // 1.19135147006586384913E-3
-                              0x3f24fcb839982153ULL   // 1.60119522476751861407E-4
-                              >(x) /
-                    horner<batch_type,
-                           0x3ff0000000000000ULL,  //  1.00000000000000000320E00
-                           0x3fb24944c9cd3c51ULL,  //  7.14304917030273074085E-2
-                           0xbfce071a9d4287c2ULL,  // -2.34591795718243348568E-1
-                           0x3fa25779e33fde67ULL,  //  3.58236398605498653373E-2
-                           0x3f8831ed5b1bb117ULL,  //  1.18139785222060435552E-2
-                           0xBf7240e4e750b44aULL,  // -4.45641913851797240494E-3
-                           0x3f41ae8a29152573ULL,  //  5.39605580493303397842E-4
-                           0xbef8487a8400d3aFULL   // -2.31581873324120129819E-5
-                           >(x);
+                using batch_type = batch<double, A>;
+                static inline batch_type compute(const batch_type& x) noexcept
+                {
+                    return horner<batch_type,
+                                  0x3ff0000000000000ULL, // 9.99999999999999996796E-1
+                                  0x3fdfa1373993e312ULL, // 4.94214826801497100753E-1
+                                  0x3fca8da9dcae7d31ULL, // 2.07448227648435975150E-1
+                                  0x3fa863d918c423d3ULL, // 4.76367800457137231464E-2
+                                  0x3f8557cde9db14b0ULL, // 1.04213797561761569935E-2
+                                  0x3f5384e3e686bfabULL, // 1.19135147006586384913E-3
+                                  0x3f24fcb839982153ULL // 1.60119522476751861407E-4
+                                  >(x)
+                        / horner<batch_type,
+                                 0x3ff0000000000000ULL, //  1.00000000000000000320E00
+                                 0x3fb24944c9cd3c51ULL, //  7.14304917030273074085E-2
+                                 0xbfce071a9d4287c2ULL, // -2.34591795718243348568E-1
+                                 0x3fa25779e33fde67ULL, //  3.58236398605498653373E-2
+                                 0x3f8831ed5b1bb117ULL, //  1.18139785222060435552E-2
+                                 0xBf7240e4e750b44aULL, // -4.45641913851797240494E-3
+                                 0x3f41ae8a29152573ULL, //  5.39605580493303397842E-4
+                                 0xbef8487a8400d3aFULL // -2.31581873324120129819E-5
+                                 >(x);
+                }
+            };
+
+            /* origin: boost/simd/arch/common/simd/function/gamma.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            inline B tgamma_large_negative(const B& a) noexcept
+            {
+                B st = stirling(a);
+                B p = floor(a);
+                B sgngam = select(is_even(p), -B(1.), B(1.));
+                B z = a - p;
+                auto test2 = z < B(0.5);
+                z = select(test2, z - B(1.), z);
+                z = a * sin(z, trigo_pi_tag());
+                z = abs(z);
+                return sgngam * constants::pi<B>() / (z * st);
             }
-        };
-
-    /* origin: boost/simd/arch/common/simd/function/gamma.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-        template <class B>
-        B tgamma_large_negative(const B& a)
-        {
-            B st = stirling(a);
-            B p = floor(a);
-            B sgngam = select(is_even(p), -B(1.), B(1.));
-            B z = a - p;
-            auto test2 = z < B(0.5);
-            z = select(test2, z - B(1.), z);
-            z = a * sin(z, trigo_pi_tag());
-            z = abs(z);
-            return sgngam * constants::pi<B>() / (z * st);
-        }
-
-        template <class B, class BB>
-        B tgamma_other(const B& a, const BB& test)
-        {
-            B x = select(test, B(2.), a);
+
+            template <class B, class BB>
+            inline B tgamma_other(const B& a, const BB& test) noexcept
+            {
+                B x = select(test, B(2.), a);
 #ifndef XSIMD_NO_INFINITIES
-            auto inf_result = (a == constants::infinity<B>());
-            x = select(inf_result, B(2.), x);
+                auto inf_result = (a == constants::infinity<B>());
+                x = select(inf_result, B(2.), x);
 #endif
-            B z = B(1.);
-            auto test1 = (x >= B(3.));
-            while (any(test1))
-            {
-                x = select(test1, x - B(1.), x);
-                z = select(test1, z * x, z);
-                test1 = (x >= B(3.));
-            }
-            test1 = (x < B(0.));
-            while (any(test1))
-            {
-                z = select(test1, z / x, z);
-                x = select(test1, x + B(1.), x);
+                B z = B(1.);
+                auto test1 = (x >= B(3.));
+                while (any(test1))
+                {
+                    x = select(test1, x - B(1.), x);
+                    z = select(test1, z * x, z);
+                    test1 = (x >= B(3.));
+                }
                 test1 = (x < B(0.));
-            }
-            auto test2 = (x < B(2.));
-            while (any(test2))
-            {
-                z = select(test2, z / x, z);
-                x = select(test2, x + B(1.), x);
-                test2 = (x < B(2.));
-            }
-            x = z * tgamma_kernel<B>::compute(x - B(2.));
+                while (any(test1))
+                {
+                    z = select(test1, z / x, z);
+                    x = select(test1, x + B(1.), x);
+                    test1 = (x < B(0.));
+                }
+                auto test2 = (x < B(2.));
+                while (any(test2))
+                {
+                    z = select(test2, z / x, z);
+                    x = select(test2, x + B(1.), x);
+                    test2 = (x < B(2.));
+                }
+                x = z * tgamma_kernel<B>::compute(x - B(2.));
 #ifndef XSIMD_NO_INFINITIES
-            return select(inf_result, a, x);
+                return select(inf_result, a, x);
 #else
-            return x;
+                return x;
 #endif
+            }
         }
-    }
 
-    template<class A, class T> batch<T, A> tgamma(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
+        template <class A, class T>
+        inline batch<T, A> tgamma(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
             auto nan_result = (self < batch_type(0.) && is_flint(self));
 #ifndef XSIMD_NO_INVALIDS
             nan_result = isnan(self) || nan_result;
@@ -2204,12 +2300,10 @@ namespace xsimd {
             batch_type r1 = detail::tgamma_other(self, test);
             batch_type r2 = select(test, r, r1);
             return select(self == batch_type(0.), copysign(constants::infinity<batch_type>(), self), select(nan_result, constants::nan<batch_type>(), r2));
-    }
-
+        }
 
-  }
+    }
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_memory.hpp b/third_party/xsimd/arch/generic/xsimd_generic_memory.hpp
index 39f4c102c..5f4b1c79b 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_memory.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_memory.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_MEMORY_HPP
 #define XSIMD_GENERIC_MEMORY_HPP
@@ -18,171 +18,189 @@
 
 #include "./xsimd_generic_details.hpp"
 
+namespace xsimd
+{
 
-namespace xsimd {
-
-  namespace kernel {
-
-    using namespace types;
-
-    // extract_pair
-    template<class A, class T> batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<generic>) {
-      constexpr std::size_t size = batch<T, A>::size;
-      assert(0<= i && i< size && "index in bounds");
-
-          alignas(A::alignment()) T self_buffer[size];
-          self.store_aligned(self_buffer);
-
-          alignas(A::alignment()) T other_buffer[size];
-          other.store_aligned(other_buffer);
-
-          alignas(A::alignment()) T concat_buffer[size];
-
-          for (std::size_t j = 0 ; j < (size - i); ++j)
-          {
-              concat_buffer[j] = other_buffer[i + j];
-              if(j < i)
-              {
-                  concat_buffer[size - 1 - j] = self_buffer[i - 1 - j];
-              }
-          }
-          return batch<T, A>::load_aligned(concat_buffer);
-    }
+    namespace kernel
+    {
 
-    // load_aligned
-    namespace detail {
-      template<class A, class T_in, class T_out>
-      batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) {
-        using batch_type_in = batch<T_in, A>;
-        using batch_type_out = batch<T_out, A>;
-        return fast_cast(batch_type_in::load_aligned(mem), batch_type_out(), A{});
-      }
-      template<class A, class T_in, class T_out>
-      batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_slow_conversion) {
-        static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
-        using batch_type_out = batch<T_out, A>;
-        alignas(A::alignment()) T_out buffer[batch_type_out::size];
-        std::copy(mem, mem + batch_type_out::size, std::begin(buffer));
-        return batch_type_out::load_aligned(buffer);
-      }
-    }
-    template<class A, class T_in, class T_out>
-    batch<T_out, A> load_aligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) {
-      return detail::load_aligned<A>(mem, cvt, A{}, detail::conversion_type<A, T_in, T_out>{});
-    }
+        using namespace types;
 
-    // load_unaligned
-    namespace detail {
-      template<class A, class T_in, class T_out>
-      batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) {
-        using batch_type_in = batch<T_in, A>;
-        using batch_type_out = batch<T_out, A>;
-        return fast_cast(batch_type_in::load_unaligned(mem), batch_type_out(), A{});
-      }
-
-      template<class A, class T_in, class T_out>
-      batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>, with_slow_conversion) {
-        static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
-        return load_aligned<A>(mem, cvt, generic{}, with_slow_conversion{});
-      }
-    }
-    template<class A, class T_in, class T_out>
-    batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) {
-      return detail::load_unaligned<A>(mem, cvt, generic{}, detail::conversion_type<A, T_in, T_out>{});
-    }
+        // extract_pair
+        template <class A, class T>
+        inline batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<generic>) noexcept
+        {
+            constexpr std::size_t size = batch<T, A>::size;
+            assert(0 <= i && i < size && "index in bounds");
+
+            alignas(A::alignment()) T self_buffer[size];
+            self.store_aligned(self_buffer);
+
+            alignas(A::alignment()) T other_buffer[size];
+            other.store_aligned(other_buffer);
+
+            alignas(A::alignment()) T concat_buffer[size];
+
+            for (std::size_t j = 0; j < (size - i); ++j)
+            {
+                concat_buffer[j] = other_buffer[i + j];
+                if (j < i)
+                {
+                    concat_buffer[size - 1 - j] = self_buffer[i - 1 - j];
+                }
+            }
+            return batch<T, A>::load_aligned(concat_buffer);
+        }
 
-    // store
-    template<class T, class A>
-    void store(batch_bool<T, A> const& self, bool* mem, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-      constexpr auto size = batch_bool<T, A>::size;
-      alignas(A::alignment()) T buffer[size];
-      kernel::store_aligned<A>(&buffer[0], batch_type(self), A{});
-      for(std::size_t i = 0; i < size; ++i)
-        mem[i] = bool(buffer[i]);
-    }
+        // load_aligned
+        namespace detail
+        {
+            template <class A, class T_in, class T_out>
+            inline batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) noexcept
+            {
+                using batch_type_in = batch<T_in, A>;
+                using batch_type_out = batch<T_out, A>;
+                return fast_cast(batch_type_in::load_aligned(mem), batch_type_out(), A {});
+            }
+            template <class A, class T_in, class T_out>
+            inline batch<T_out, A> load_aligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_slow_conversion) noexcept
+            {
+                static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
+                using batch_type_out = batch<T_out, A>;
+                alignas(A::alignment()) T_out buffer[batch_type_out::size];
+                std::copy(mem, mem + batch_type_out::size, std::begin(buffer));
+                return batch_type_out::load_aligned(buffer);
+            }
+        }
+        template <class A, class T_in, class T_out>
+        inline batch<T_out, A> load_aligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) noexcept
+        {
+            return detail::load_aligned<A>(mem, cvt, A {}, detail::conversion_type<A, T_in, T_out> {});
+        }
 
+        // load_unaligned
+        namespace detail
+        {
+            template <class A, class T_in, class T_out>
+            inline batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out>, requires_arch<generic>, with_fast_conversion) noexcept
+            {
+                using batch_type_in = batch<T_in, A>;
+                using batch_type_out = batch<T_out, A>;
+                return fast_cast(batch_type_in::load_unaligned(mem), batch_type_out(), A {});
+            }
+
+            template <class A, class T_in, class T_out>
+            inline batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>, with_slow_conversion) noexcept
+            {
+                static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct load for this type combination");
+                return load_aligned<A>(mem, cvt, generic {}, with_slow_conversion {});
+            }
+        }
+        template <class A, class T_in, class T_out>
+        inline batch<T_out, A> load_unaligned(T_in const* mem, convert<T_out> cvt, requires_arch<generic>) noexcept
+        {
+            return detail::load_unaligned<A>(mem, cvt, generic {}, detail::conversion_type<A, T_in, T_out> {});
+        }
 
-    // store_aligned
-    template<class A, class T_in, class T_out> void store_aligned(T_out *mem, batch<T_in, A> const& self, requires_arch<generic>) {
-      static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
-      alignas(A::alignment()) T_in buffer[batch<T_in, A>::size];
-      store_aligned(&buffer[0], self);
-      std::copy(std::begin(buffer), std::end(buffer), mem);
-    }
+        // store
+        template <class T, class A>
+        inline void store(batch_bool<T, A> const& self, bool* mem, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            constexpr auto size = batch_bool<T, A>::size;
+            alignas(A::alignment()) T buffer[size];
+            kernel::store_aligned<A>(&buffer[0], batch_type(self), A {});
+            for (std::size_t i = 0; i < size; ++i)
+                mem[i] = bool(buffer[i]);
+        }
 
-    // store_unaligned
-    template<class A, class T_in, class T_out> void store_unaligned(T_out *mem, batch<T_in, A> const& self, requires_arch<generic>) {
-      static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
-      return store_aligned<A>(mem, self, generic{});
-    }
+        // store_aligned
+        template <class A, class T_in, class T_out>
+        inline void store_aligned(T_out* mem, batch<T_in, A> const& self, requires_arch<generic>) noexcept
+        {
+            static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
+            alignas(A::alignment()) T_in buffer[batch<T_in, A>::size];
+            store_aligned(&buffer[0], self);
+            std::copy(std::begin(buffer), std::end(buffer), mem);
+        }
 
-    namespace detail
-    {
-        template <class A, class T>
-        batch<std::complex<T>, A> load_complex(batch<T, A> const& /*hi*/, batch<T, A> const& /*lo*/, requires_arch<generic>)
+        // store_unaligned
+        template <class A, class T_in, class T_out>
+        inline void store_unaligned(T_out* mem, batch<T_in, A> const& self, requires_arch<generic>) noexcept
         {
-            static_assert(std::is_same<T, void>::value, "load_complex not implemented for the required architecture");
+            static_assert(!std::is_same<T_in, T_out>::value, "there should be a direct store for this type combination");
+            return store_aligned<A>(mem, self, generic {});
         }
 
-        template <class A, class T>
-        batch<T, A> complex_high(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>)
+        namespace detail
         {
-            static_assert(std::is_same<T, void>::value, "complex_high not implemented for the required architecture");
+            template <class A, class T>
+            inline batch<std::complex<T>, A> load_complex(batch<T, A> const& /*hi*/, batch<T, A> const& /*lo*/, requires_arch<generic>) noexcept
+            {
+                static_assert(std::is_same<T, void>::value, "load_complex not implemented for the required architecture");
+            }
+
+            template <class A, class T>
+            inline batch<T, A> complex_high(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>) noexcept
+            {
+                static_assert(std::is_same<T, void>::value, "complex_high not implemented for the required architecture");
+            }
+
+            template <class A, class T>
+            inline batch<T, A> complex_low(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>) noexcept
+            {
+                static_assert(std::is_same<T, void>::value, "complex_low not implemented for the required architecture");
+            }
         }
 
-        template <class A, class T>
-        batch<T, A> complex_low(batch<std::complex<T>, A> const& /*src*/, requires_arch<generic>)
+        // load_complex_aligned
+        template <class A, class T_out, class T_in>
+        inline batch<std::complex<T_out>, A> load_complex_aligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<generic>) noexcept
         {
-            static_assert(std::is_same<T, void>::value, "complex_low not implemented for the required architecture");
+            using real_batch = batch<T_out, A>;
+            T_in const* buffer = reinterpret_cast<T_in const*>(mem);
+            real_batch hi = real_batch::load_aligned(buffer),
+                       lo = real_batch::load_aligned(buffer + real_batch::size);
+            return detail::load_complex(hi, lo, A {});
         }
-    }
 
-    // load_complex_aligned
-    template <class A, class T_out, class T_in>
-    batch<std::complex<T_out>, A> load_complex_aligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<generic>) {
-      using real_batch = batch<T_out, A>;
-      T_in const* buffer = reinterpret_cast<T_in const*>(mem);
-      real_batch hi = real_batch::load_aligned(buffer),
-                 lo = real_batch::load_aligned(buffer + real_batch::size);
-      return detail::load_complex(hi, lo, A{});
-    }
+        // load_complex_unaligned
+        template <class A, class T_out, class T_in>
+        inline batch<std::complex<T_out>, A> load_complex_unaligned(std::complex<T_in> const* mem, convert<std::complex<T_out>>, requires_arch<generic>) noexcept
+        {
+            using real_batch = batch<T_out, A>;
+            T_in const* buffer = reinterpret_cast<T_in const*>(mem);
+            real_batch hi = real_batch::load_unaligned(buffer),
+                       lo = real_batch::load_unaligned(buffer + real_batch::size);
+            return detail::load_complex(hi, lo, A {});
+        }
 
-    // load_complex_unaligned
-    template <class A, class T_out, class T_in>
-    batch<std::complex<T_out>, A> load_complex_unaligned(std::complex<T_in> const* mem, convert<std::complex<T_out>> ,requires_arch<generic>) {
-      using real_batch = batch<T_out, A>;
-      T_in const* buffer = reinterpret_cast<T_in const*>(mem);
-      real_batch hi = real_batch::load_unaligned(buffer),
-                 lo = real_batch::load_unaligned(buffer + real_batch::size);
-      return detail::load_complex(hi, lo, A{});
-    }
+        // store_complex_aligned
+        template <class A, class T_out, class T_in>
+        inline void store_complex_aligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) noexcept
+        {
+            using real_batch = batch<T_in, A>;
+            real_batch hi = detail::complex_high(src, A {});
+            real_batch lo = detail::complex_low(src, A {});
+            T_out* buffer = reinterpret_cast<T_out*>(dst);
+            lo.store_aligned(buffer);
+            hi.store_aligned(buffer + real_batch::size);
+        }
 
-    // store_complex_aligned
-    template <class A, class T_out, class T_in>
-    void store_complex_aligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) {
-        using real_batch = batch<T_in, A>;
-        real_batch hi = detail::complex_high(src, A{});
-        real_batch lo = detail::complex_low(src, A{});
-        T_out* buffer = reinterpret_cast<T_out*>(dst);
-        lo.store_aligned(buffer);
-        hi.store_aligned(buffer + real_batch::size);
-    }
+        // store_compelx_unaligned
+        template <class A, class T_out, class T_in>
+        inline void store_complex_unaligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) noexcept
+        {
+            using real_batch = batch<T_in, A>;
+            real_batch hi = detail::complex_high(src, A {});
+            real_batch lo = detail::complex_low(src, A {});
+            T_out* buffer = reinterpret_cast<T_out*>(dst);
+            lo.store_unaligned(buffer);
+            hi.store_unaligned(buffer + real_batch::size);
+        }
 
-    // store_compelx_unaligned
-    template <class A, class T_out, class T_in>
-    void store_complex_unaligned(std::complex<T_out>* dst, batch<std::complex<T_in>, A> const& src, requires_arch<generic>) {
-        using real_batch = batch<T_in, A>;
-        real_batch hi = detail::complex_high(src, A{});
-        real_batch lo = detail::complex_low(src, A{});
-        T_out* buffer = reinterpret_cast<T_out*>(dst);
-        lo.store_unaligned(buffer);
-        hi.store_unaligned(buffer + real_batch::size);
     }
 
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_rounding.hpp b/third_party/xsimd/arch/generic/xsimd_generic_rounding.hpp
index b1c988101..b6a79a451 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_rounding.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_rounding.hpp
@@ -1,64 +1,72 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_ROUNDING_HPP
 #define XSIMD_GENERIC_ROUNDING_HPP
 
 #include "./xsimd_generic_details.hpp"
 
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // ceil
+        template <class A, class T>
+        inline batch<T, A> ceil(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            batch<T, A> truncated_self = trunc(self);
+            return select(truncated_self < self, truncated_self + 1, truncated_self);
+        }
+
+        // floor
+        template <class A, class T>
+        inline batch<T, A> floor(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            batch<T, A> truncated_self = trunc(self);
+            return select(truncated_self > self, truncated_self - 1, truncated_self);
+        }
+
+        // round
+        template <class A, class T>
+        inline batch<T, A> round(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            auto v = abs(self);
+            auto c = ceil(v);
+            auto cp = select(c - 0.5 > v, c - 1, c);
+            return select(v > constants::maxflint<batch<T, A>>(), self, copysign(cp, self));
+        }
+
+        // trunc
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> trunc(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return self;
+        }
+        template <class A>
+        inline batch<float, A> trunc(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            return select(abs(self) < constants::maxflint<batch<float, A>>(), to_float(to_int(self)), self);
+        }
+        template <class A>
+        inline batch<double, A> trunc(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            return select(abs(self) < constants::maxflint<batch<double, A>>(), to_float(to_int(self)), self);
+        }
 
-namespace xsimd {
-
-  namespace kernel {
-
-
-    using namespace types;
-
-    // ceil
-    template<class A, class T> batch<T, A> ceil(batch<T, A> const& self, requires_arch<generic>) {
-      batch<T, A> truncated_self = trunc(self);
-      return select(truncated_self < self, truncated_self + 1, truncated_self);
-    }
-
-
-    // floor
-    template<class A, class T> batch<T, A> floor(batch<T, A> const& self, requires_arch<generic>) {
-      batch<T, A> truncated_self = trunc(self);
-      return select(truncated_self > self, truncated_self - 1, truncated_self);
-    }
-
-    // round
-    template<class A, class T> batch<T, A> round(batch<T, A> const& self, requires_arch<generic>) {
-      auto v = abs(self);
-      auto c = ceil(v);
-      auto cp = select(c - 0.5 > v, c - 1, c);
-      return select(v > constants::maxflint<batch<T, A>>(), self, copysign(cp, self));
-    }
-
-    // trunc
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> trunc(batch<T, A> const& self, requires_arch<generic>) {
-      return self;
-    }
-    template<class A> batch<float, A> trunc(batch<float, A> const& self, requires_arch<generic>) {
-      return select(abs(self) < constants::maxflint<batch<float, A>>(), to_float(to_int(self)), self);
     }
-    template<class A> batch<double, A> trunc(batch<double, A> const& self, requires_arch<generic>) {
-      return select(abs(self) < constants::maxflint<batch<double, A>>(), to_float(to_int(self)), self);
-    }
-
-
-  }
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/generic/xsimd_generic_trigo.hpp b/third_party/xsimd/arch/generic/xsimd_generic_trigo.hpp
index f649c6c25..e274c413f 100644
--- a/third_party/xsimd/arch/generic/xsimd_generic_trigo.hpp
+++ b/third_party/xsimd/arch/generic/xsimd_generic_trigo.hpp
@@ -1,22 +1,24 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_TRIGO_HPP
 #define XSIMD_GENERIC_TRIGO_HPP
 
 #include "./xsimd_generic_details.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
+    namespace kernel
+    {
         /* origin: boost/simd/arch/common/detail/simd/trig_base.hpp */
         /*
          * ====================================================
@@ -27,48 +29,52 @@ namespace xsimd {
          * ====================================================
          */
 
-    using namespace types;
-
-    // acos
-    template<class A, class T> batch<T, A> acos(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-        batch_type x = abs(self);
-        auto x_larger_05 = x > batch_type(0.5);
-        x = select(x_larger_05, sqrt(fma(batch_type(-0.5), x, batch_type(0.5))), self);
-        x = asin(x);
-        x = select(x_larger_05, x + x, x);
-        x = select(self < batch_type(-0.5), constants::pi<batch_type>() - x, x);
-        return select(x_larger_05, x, constants::pio2<batch_type>() - x);
-    }
+        using namespace types;
+
+        // acos
+        template <class A, class T>
+        inline batch<T, A> acos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type x = abs(self);
+            auto x_larger_05 = x > batch_type(0.5);
+            x = select(x_larger_05, sqrt(fma(batch_type(-0.5), x, batch_type(0.5))), self);
+            x = asin(x);
+            x = select(x_larger_05, x + x, x);
+            x = select(self < batch_type(-0.5), constants::pi<batch_type>() - x, x);
+            return select(x_larger_05, x, constants::pio2<batch_type>() - x);
+        }
         template <class A, class T>
-        batch<std::complex<T>, A> acos(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> acos(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
             batch_type tmp = asin(z);
-            return {constants::pio2<real_batch>() - tmp.real(), -tmp.imag()};
-        }
-
-    // acosh
-    /* origin: boost/simd/arch/common/simd/function/acosh.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A, class T> batch<T, A> acosh(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                batch_type x = self - batch_type(1.);
-                auto test = x > constants::oneotwoeps<batch_type>();
-                batch_type z = select(test, self, x + sqrt(x + x + x * x));
-                batch_type l1pz = log1p(z);
-                return select(test, l1pz + constants::log_2<batch_type>(), l1pz);
-    }
+            return { constants::pio2<real_batch>() - tmp.real(), -tmp.imag() };
+        }
+
+        // acosh
+        /* origin: boost/simd/arch/common/simd/function/acosh.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
+        template <class A, class T>
+        inline batch<T, A> acosh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type x = self - batch_type(1.);
+            auto test = x > constants::oneotwoeps<batch_type>();
+            batch_type z = select(test, self, x + sqrt(x + x + x * x));
+            batch_type l1pz = log1p(z);
+            return select(test, l1pz + constants::log_2<batch_type>(), l1pz);
+        }
         template <class A, class T>
-        inline batch<std::complex<T>, A> acosh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> acosh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = acos(z);
@@ -76,68 +82,50 @@ namespace xsimd {
             return w;
         }
 
-    // asin
-    template<class A> batch<float, A> asin(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                batch_type x = abs(self);
-                batch_type sign = bitofsign(self);
-                auto x_larger_05 = x > batch_type(0.5);
-                batch_type z = select(x_larger_05, batch_type(0.5) * (batch_type(1.) - x), x * x);
-                x = select(x_larger_05, sqrt(z), x);
-                batch_type z1 = detail::horner<batch_type,
-                              0x3e2aaae4,
-                              0x3d9980f6,
-                              0x3d3a3ec7,
-                              0x3cc617e3,
-                              0x3d2cb352>(z);
-                z1 = fma(z1, z * x, x);
-                z = select(x_larger_05, constants::pio2<batch_type>() - (z1 + z1), z1);
-                return z ^ sign;
-    }
-    template<class A> batch<double, A> asin(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                batch_type x = abs(self);
-                auto small_cond = x < constants::sqrteps<batch_type>();
-                batch_type ct1 = batch_type(bit_cast<double>(int64_t(0x3fe4000000000000)));
-                batch_type zz1 = batch_type(1.) - x;
-                batch_type vp = zz1 * detail::horner<batch_type,
-                                    0x403c896240f3081dull,
-                                    0xc03991aaac01ab68ull,
-                                    0x401bdff5baf33e6aull,
-                                    0xbfe2079259f9290full,
-                                    0x3f684fc3988e9f08ull>(zz1) /
-                    detail::horner1<batch_type,
-                            0x40756709b0b644beull,
-                            0xc077fe08959063eeull,
-                            0x40626219af6a7f42ull,
-                            0xc035f2a2b6bf5d8cull>(zz1);
-                zz1 = sqrt(zz1 + zz1);
-                batch_type z = constants::pio4<batch_type>() - zz1;
-                zz1 = fms(zz1, vp, constants::pio_2lo<batch_type>());
-                z = z - zz1;
-                zz1 = z + constants::pio4<batch_type>();
-                batch_type zz2 = self * self;
-                z = zz2 * detail::horner<batch_type,
-                                 0xc020656c06ceafd5ull,
-                                 0x40339007da779259ull,
-                                 0xc0304331de27907bull,
-                                 0x4015c74b178a2dd9ull,
-                                 0xbfe34341333e5c16ull,
-                                 0x3f716b9b0bd48ad3ull>(zz2) /
-                    detail::horner1<batch_type,
-                            0xc04898220a3607acull,
-                            0x4061705684ffbf9dull,
-                            0xc06265bb6d3576d7ull,
-                            0x40519fc025fe9054ull,
-                            0xc02d7b590b5e0eabull>(zz2);
-                zz2 = fma(x, z, x);
-                return select(x > batch_type(1.), constants::nan<batch_type>(),
-                              select(small_cond, x,
-                                     select(x > ct1, zz1, zz2)) ^
-                                  bitofsign(self));
-    }
+        // asin
+        template <class A>
+        inline batch<float, A> asin(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            batch_type x = abs(self);
+            batch_type sign = bitofsign(self);
+            auto x_larger_05 = x > batch_type(0.5);
+            batch_type z = select(x_larger_05, batch_type(0.5) * (batch_type(1.) - x), x * x);
+            x = select(x_larger_05, sqrt(z), x);
+            batch_type z1 = detail::horner<batch_type,
+                                           0x3e2aaae4,
+                                           0x3d9980f6,
+                                           0x3d3a3ec7,
+                                           0x3cc617e3,
+                                           0x3d2cb352>(z);
+            z1 = fma(z1, z * x, x);
+            z = select(x_larger_05, constants::pio2<batch_type>() - (z1 + z1), z1);
+            return z ^ sign;
+        }
+        template <class A>
+        inline batch<double, A> asin(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            batch_type x = abs(self);
+            auto small_cond = x < constants::sqrteps<batch_type>();
+            batch_type ct1 = batch_type(bit_cast<double>(int64_t(0x3fe4000000000000)));
+            batch_type zz1 = batch_type(1.) - x;
+            batch_type vp = zz1 * detail::horner<batch_type, 0x403c896240f3081dull, 0xc03991aaac01ab68ull, 0x401bdff5baf33e6aull, 0xbfe2079259f9290full, 0x3f684fc3988e9f08ull>(zz1) / detail::horner1<batch_type, 0x40756709b0b644beull, 0xc077fe08959063eeull, 0x40626219af6a7f42ull, 0xc035f2a2b6bf5d8cull>(zz1);
+            zz1 = sqrt(zz1 + zz1);
+            batch_type z = constants::pio4<batch_type>() - zz1;
+            zz1 = fms(zz1, vp, constants::pio_2lo<batch_type>());
+            z = z - zz1;
+            zz1 = z + constants::pio4<batch_type>();
+            batch_type zz2 = self * self;
+            z = zz2 * detail::horner<batch_type, 0xc020656c06ceafd5ull, 0x40339007da779259ull, 0xc0304331de27907bull, 0x4015c74b178a2dd9ull, 0xbfe34341333e5c16ull, 0x3f716b9b0bd48ad3ull>(zz2) / detail::horner1<batch_type, 0xc04898220a3607acull, 0x4061705684ffbf9dull, 0xc06265bb6d3576d7ull, 0x40519fc025fe9054ull, 0xc02d7b590b5e0eabull>(zz2);
+            zz2 = fma(x, z, x);
+            return select(x > batch_type(1.), constants::nan<batch_type>(),
+                          select(small_cond, x,
+                                 select(x > ct1, zz1, zz2))
+                              ^ bitofsign(self));
+        }
         template <class A, class T>
-        batch<std::complex<T>, A> asin(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> asin(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -156,7 +144,7 @@ namespace xsimd {
                           resg);
         }
 
-    // asinh
+        // asinh
         /* origin: boost/simd/arch/common/simd/function/asinh.hpp */
         /*
          * ====================================================
@@ -166,70 +154,77 @@ namespace xsimd {
          * (See copy at http://boost.org/LICENSE_1_0.txt)
          * ====================================================
          */
-    namespace detail {
-        template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-          batch<T, A>
-            average(const batch<T, A>& x1, const batch<T, A>& x2)
+        namespace detail
+        {
+            template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+            inline batch<T, A>
+            average(const batch<T, A>& x1, const batch<T, A>& x2) noexcept
             {
                 return (x1 & x2) + ((x1 ^ x2) >> 1);
             }
 
-        template <class A, class T>
-          batch<T, A>
-            averagef(const batch<T, A>& x1, const batch<T, A>& x2)
+            template <class A, class T>
+            inline batch<T, A>
+            averagef(const batch<T, A>& x1, const batch<T, A>& x2) noexcept
             {
-              using batch_type = batch<T, A>;
+                using batch_type = batch<T, A>;
                 return fma(x1, batch_type(0.5), x2 * batch_type(0.5));
             }
-        template<class A>
-          batch<float, A> average(batch<float, A> const & x1, batch<float, A> const & x2) {
-            return averagef(x1, x2);
-          }
-        template<class A>
-          batch<double, A> average(batch<double, A> const & x1, batch<double, A> const & x2) {
-            return averagef(x1, x2);
-          }
-    }
-    template<class A> batch<float, A> asinh(batch<float, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<float, A>;
-                batch_type x = abs(self);
-                auto lthalf = x < batch_type(0.5);
-                batch_type x2 = x * x;
-                batch_type bts = bitofsign(self);
-                batch_type z(0.);
-                if (any(lthalf))
-                {
-                    z = detail::horner<batch_type,
-                               0x3f800000,
-                               0xbe2aa9ad,
-                               0x3d9949b1,
-                               0xbd2ee581,
-                               0x3ca4d6e6>(x2) *
-                        x;
-                    if (all(lthalf))
-                        return z ^ bts;
-                }
-                batch_type tmp = select(x > constants::oneosqrteps<batch_type>(), x, detail::average(x, hypot(batch_type(1.), x)));
+            template <class A>
+            inline batch<float, A> average(batch<float, A> const& x1, batch<float, A> const& x2) noexcept
+            {
+                return averagef(x1, x2);
+            }
+            template <class A>
+            inline batch<double, A> average(batch<double, A> const& x1, batch<double, A> const& x2) noexcept
+            {
+                return averagef(x1, x2);
+            }
+        }
+        template <class A>
+        inline batch<float, A> asinh(batch<float, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<float, A>;
+            batch_type x = abs(self);
+            auto lthalf = x < batch_type(0.5);
+            batch_type x2 = x * x;
+            batch_type bts = bitofsign(self);
+            batch_type z(0.);
+            if (any(lthalf))
+            {
+                z = detail::horner<batch_type,
+                                   0x3f800000,
+                                   0xbe2aa9ad,
+                                   0x3d9949b1,
+                                   0xbd2ee581,
+                                   0x3ca4d6e6>(x2)
+                    * x;
+                if (all(lthalf))
+                    return z ^ bts;
+            }
+            batch_type tmp = select(x > constants::oneosqrteps<batch_type>(), x, detail::average(x, hypot(batch_type(1.), x)));
 #ifndef XSIMD_NO_NANS
-                return select(isnan(self), constants::nan<batch_type>(), select(lthalf, z, log(tmp) + constants::log_2<batch_type>()) ^ bts);
+            return select(isnan(self), constants::nan<batch_type>(), select(lthalf, z, log(tmp) + constants::log_2<batch_type>()) ^ bts);
 #else
-                return select(lthalf, z, log(tmp) + constants::log_2<batch_type>()) ^ bts;
+            return select(lthalf, z, log(tmp) + constants::log_2<batch_type>()) ^ bts;
 #endif
-    }
-    template<class A> batch<double, A> asinh(batch<double, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<double, A>;
-                batch_type x = abs(self);
-                auto test = x > constants::oneosqrteps<batch_type>();
-                batch_type z = select(test, x - batch_type(1.), x + x * x / (batch_type(1.) + hypot(batch_type(1.), x)));
+        }
+        template <class A>
+        inline batch<double, A> asinh(batch<double, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<double, A>;
+            batch_type x = abs(self);
+            auto test = x > constants::oneosqrteps<batch_type>();
+            batch_type z = select(test, x - batch_type(1.), x + x * x / (batch_type(1.) + hypot(batch_type(1.), x)));
 #ifndef XSIMD_NO_INFINITIES
-                z = select(x == constants::infinity<batch_type>(), x, z);
+            z = select(x == constants::infinity<batch_type>(), x, z);
 #endif
-                batch_type l1pz = log1p(z);
-                z = select(test, l1pz + constants::log_2<batch_type>(), l1pz);
-                return bitofsign(self) ^ z;
-    }
+            batch_type l1pz = log1p(z);
+            z = select(test, l1pz + constants::log_2<batch_type>(), l1pz);
+            return bitofsign(self) ^ z;
+        }
         template <class A, class T>
-        inline batch<std::complex<T>, A> asinh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> asinh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = asin(batch_type(-z.imag(), z.real()));
@@ -237,12 +232,13 @@ namespace xsimd {
             return w;
         }
 
-    // atan
-    namespace detail {
-    template<class A>
-            static inline batch<float, A> kernel_atan(const batch<float, A>& x, const batch<float, A>& recx)
+        // atan
+        namespace detail
+        {
+            template <class A>
+            static inline batch<float, A> kernel_atan(const batch<float, A>& x, const batch<float, A>& recx) noexcept
             {
-              using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 const auto flag1 = x < constants::tan3pio8<batch_type>();
                 const auto flag2 = (x >= batch_type(bit_cast<float>((uint32_t)0x3ed413cd))) && flag1;
                 batch_type yy = select(flag1, batch_type(0.), constants::pio2<batch_type>());
@@ -251,19 +247,19 @@ namespace xsimd {
                 xx = select(flag2, (x - batch_type(1.)) / (x + batch_type(1.)), xx);
                 const batch_type z = xx * xx;
                 batch_type z1 = detail::horner<batch_type,
-                              0xbeaaaa2aul,
-                              0x3e4c925ful,
-                              0xbe0e1b85ul,
-                              0x3da4f0d1ul>(z);
+                                               0xbeaaaa2aul,
+                                               0x3e4c925ful,
+                                               0xbe0e1b85ul,
+                                               0x3da4f0d1ul>(z);
                 z1 = fma(xx, z1 * z, xx);
                 z1 = select(flag2, z1 + constants::pio_4lo<batch_type>(), z1);
                 z1 = select(!flag1, z1 + constants::pio_2lo<batch_type>(), z1);
                 return yy + z1;
             }
-    template<class A>
-            static inline batch<double, A> kernel_atan(const batch<double, A>& x, const batch<double, A>& recx)
+            template <class A>
+            static inline batch<double, A> kernel_atan(const batch<double, A>& x, const batch<double, A>& recx) noexcept
             {
-              using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 const auto flag1 = x < constants::tan3pio8<batch_type>();
                 const auto flag2 = (x >= constants::tanpio8<batch_type>()) && flag1;
                 batch_type yy = select(flag1, batch_type(0.), constants::pio2<batch_type>());
@@ -272,31 +268,33 @@ namespace xsimd {
                 xx = select(flag2, (x - batch_type(1.)) / (x + batch_type(1.)), xx);
                 batch_type z = xx * xx;
                 z *= detail::horner<batch_type,
-                            0xc0503669fd28ec8eull,
-                            0xc05eb8bf2d05ba25ull,
-                            0xc052c08c36880273ull,
-                            0xc03028545b6b807aull,
-                            0xbfec007fa1f72594ull>(z) /
-                    detail::horner1<batch_type,
-                            0x4068519efbbd62ecull,
-                            0x407e563f13b049eaull,
-                            0x407b0e18d2e2be3bull,
-                            0x4064a0dd43b8fa25ull,
-                            0x4038dbc45b14603cull>(z);
+                                    0xc0503669fd28ec8eull,
+                                    0xc05eb8bf2d05ba25ull,
+                                    0xc052c08c36880273ull,
+                                    0xc03028545b6b807aull,
+                                    0xbfec007fa1f72594ull>(z)
+                    / detail::horner1<batch_type,
+                                      0x4068519efbbd62ecull,
+                                      0x407e563f13b049eaull,
+                                      0x407b0e18d2e2be3bull,
+                                      0x4064a0dd43b8fa25ull,
+                                      0x4038dbc45b14603cull>(z);
                 z = fma(xx, z, xx);
                 z = select(flag2, z + constants::pio_4lo<batch_type>(), z);
                 z = z + select(flag1, batch_type(0.), constants::pio_2lo<batch_type>());
                 return yy + z;
             }
-    }
-    template<class A, class T> batch<T, A> atan(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                const batch_type absa = abs(self);
-                const batch_type x = detail::kernel_atan(absa, batch_type(1.) / absa);
-                return x ^ bitofsign(self);
-    }
+        }
+        template <class A, class T>
+        inline batch<T, A> atan(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            const batch_type absa = abs(self);
+            const batch_type x = detail::kernel_atan(absa, batch_type(1.) / absa);
+            return x ^ bitofsign(self);
+        }
         template <class A, class T>
-        batch<std::complex<T>, A> atan(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> atan(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
@@ -311,32 +309,34 @@ namespace xsimd {
             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)));
+                                    batch_type(real_batch(0.), constants::infinity<real_batch>()),
+                                    batch_type(w, 0.25 * log(num / den)));
             return res;
         }
 
-    // atanh
-    /* origin: boost/simd/arch/common/simd/function/acosh.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A, class T> batch<T, A> atanh(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                batch_type x = abs(self);
-                batch_type t = x + x;
-                batch_type z = batch_type(1.) - x;
-                auto test = x < batch_type(0.5);
-                batch_type tmp = select(test, x, t) / z;
-                return bitofsign(self) ^ (batch_type(0.5) * log1p(select(test, fma(t, tmp, t), tmp)));
-    }
+        // atanh
+        /* origin: boost/simd/arch/common/simd/function/acosh.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
         template <class A, class T>
-        inline batch<std::complex<T>, A> atanh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<T, A> atanh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type x = abs(self);
+            batch_type t = x + x;
+            batch_type z = batch_type(1.) - x;
+            auto test = x < batch_type(0.5);
+            batch_type tmp = select(test, x, t) / z;
+            return bitofsign(self) ^ (batch_type(0.5) * log1p(select(test, fma(t, tmp, t), tmp)));
+        }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> atanh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using batch_type = batch<std::complex<T>, A>;
             batch_type w = atan(batch_type(-z.imag(), z.real()));
@@ -344,325 +344,337 @@ namespace xsimd {
             return w;
         }
 
-    // atan2
-    template<class A, class T> batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                const batch_type q = abs(self / other);
-                const batch_type z = detail::kernel_atan(q, batch_type(1.) / q);
-                return select(other > batch_type(0.), z, constants::pi<batch_type>() - z) * signnz(self);
-    }
-
-
-    // cos
-    namespace detail
-    {
-        template <class T, class A>
-        batch<T, A> quadrant(const batch<T, A>& x) {
-          return x & batch<T, A>(3);
+        // atan2
+        template <class A, class T>
+        inline batch<T, A> atan2(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            const batch_type q = abs(self / other);
+            const batch_type z = detail::kernel_atan(q, batch_type(1.) / q);
+            return select(other > batch_type(0.), z, constants::pi<batch_type>() - z) * signnz(self);
         }
 
-        template <class A>
-        batch<float, A> quadrant(const batch<float, A>& x) {
-          return to_float(quadrant(to_int(x)));
-        }
+        // cos
+        namespace detail
+        {
+            template <class T, class A>
+            inline batch<T, A> quadrant(const batch<T, A>& x) noexcept
+            {
+                return x & batch<T, A>(3);
+            }
 
-        template <class A>
-        batch<double, A> quadrant(const batch<double, A>& x) {
-          using batch_type = batch<double, A>;
+            template <class A>
+            inline batch<float, A> quadrant(const batch<float, A>& x) noexcept
+            {
+                return to_float(quadrant(to_int(x)));
+            }
+
+            template <class A>
+            inline batch<double, A> quadrant(const batch<double, A>& x) noexcept
+            {
+                using batch_type = batch<double, A>;
                 batch_type a = x * batch_type(0.25);
                 return (a - floor(a)) * batch_type(4.);
-        }
-        /* origin: boost/simd/arch/common/detail/simd/f_trig_evaluation.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
-
-        template<class A>
-        inline batch<float, A> cos_eval(const batch<float, A>& z)
-        {
-          using batch_type = batch<float, A>;
-            batch_type y = detail::horner<batch_type,
-                         0x3d2aaaa5,
-                         0xbab60619,
-                         0x37ccf5ce>(z);
-            return batch_type(1.) + fma(z, batch_type(-0.5), y * z * z);
-        }
+            }
+            /* origin: boost/simd/arch/common/detail/simd/f_trig_evaluation.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+
+            template <class A>
+            inline batch<float, A> cos_eval(const batch<float, A>& z) noexcept
+            {
+                using batch_type = batch<float, A>;
+                batch_type y = detail::horner<batch_type,
+                                              0x3d2aaaa5,
+                                              0xbab60619,
+                                              0x37ccf5ce>(z);
+                return batch_type(1.) + fma(z, batch_type(-0.5), y * z * z);
+            }
 
-        template<class A>
-        inline batch<float, A> sin_eval(const batch<float, A>& z, const batch<float, A>& x)
+            template <class A>
+            inline batch<float, A> sin_eval(const batch<float, A>& z, const batch<float, A>& x) noexcept
             {
-          using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 batch_type y = detail::horner<batch_type,
-                             0xbe2aaaa2,
-                             0x3c08839d,
-                             0xb94ca1f9>(z);
+                                              0xbe2aaaa2,
+                                              0x3c08839d,
+                                              0xb94ca1f9>(z);
                 return fma(y * z, x, x);
             }
 
-        template<class A>
-            static inline batch<float, A> base_tancot_eval(const batch<float, A>& z)
+            template <class A>
+            static inline batch<float, A> base_tancot_eval(const batch<float, A>& z) noexcept
             {
-          using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 batch_type zz = z * z;
                 batch_type y = detail::horner<batch_type,
-                             0x3eaaaa6f,
-                             0x3e0896dd,
-                             0x3d5ac5c9,
-                             0x3cc821b5,
-                             0x3b4c779c,
-                             0x3c19c53b>(zz);
+                                              0x3eaaaa6f,
+                                              0x3e0896dd,
+                                              0x3d5ac5c9,
+                                              0x3cc821b5,
+                                              0x3b4c779c,
+                                              0x3c19c53b>(zz);
                 return fma(y, zz * z, z);
             }
 
             template <class A, class BB>
-            static inline batch<float, A> tan_eval(const batch<float, A>& z, const BB& test)
+            static inline batch<float, A> tan_eval(const batch<float, A>& z, const BB& test) noexcept
             {
-          using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 batch_type y = base_tancot_eval(z);
                 return select(test, y, -batch_type(1.) / y);
             }
 
             template <class A, class BB>
-            static inline batch<float, A> cot_eval(const batch<float, A>& z, const BB& test)
+            static inline batch<float, A> cot_eval(const batch<float, A>& z, const BB& test) noexcept
             {
-          using batch_type = batch<float, A>;
+                using batch_type = batch<float, A>;
                 batch_type y = base_tancot_eval(z);
                 return select(test, batch_type(1.) / y, -y);
             }
 
-        /* origin: boost/simd/arch/common/detail/simd/d_trig_evaluation.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
-            template<class A>
-            static inline batch<double, A> cos_eval(const batch<double, A>& z)
+            /* origin: boost/simd/arch/common/detail/simd/d_trig_evaluation.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class A>
+            static inline batch<double, A> cos_eval(const batch<double, A>& z) noexcept
             {
-          using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type y = detail::horner<batch_type,
-                             0x3fe0000000000000ull,
-                             0xbfa5555555555551ull,
-                             0x3f56c16c16c15d47ull,
-                             0xbefa01a019ddbcd9ull,
-                             0x3e927e4f8e06d9a5ull,
-                             0xbe21eea7c1e514d4ull,
-                             0x3da8ff831ad9b219ull>(z);
+                                              0x3fe0000000000000ull,
+                                              0xbfa5555555555551ull,
+                                              0x3f56c16c16c15d47ull,
+                                              0xbefa01a019ddbcd9ull,
+                                              0x3e927e4f8e06d9a5ull,
+                                              0xbe21eea7c1e514d4ull,
+                                              0x3da8ff831ad9b219ull>(z);
                 return batch_type(1.) - y * z;
             }
 
-            template<class A>
-            static inline batch<double, A> sin_eval(const batch<double, A>& z, const batch<double, A>& x)
+            template <class A>
+            static inline batch<double, A> sin_eval(const batch<double, A>& z, const batch<double, A>& x) noexcept
             {
-          using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type y = detail::horner<batch_type,
-                             0xbfc5555555555548ull,
-                             0x3f8111111110f7d0ull,
-                             0xbf2a01a019bfdf03ull,
-                             0x3ec71de3567d4896ull,
-                             0xbe5ae5e5a9291691ull,
-                             0x3de5d8fd1fcf0ec1ull>(z);
+                                              0xbfc5555555555548ull,
+                                              0x3f8111111110f7d0ull,
+                                              0xbf2a01a019bfdf03ull,
+                                              0x3ec71de3567d4896ull,
+                                              0xbe5ae5e5a9291691ull,
+                                              0x3de5d8fd1fcf0ec1ull>(z);
                 return fma(y * z, x, x);
             }
 
-            template<class A>
-            static inline batch<double, A> base_tancot_eval(const batch<double, A>& z)
+            template <class A>
+            static inline batch<double, A> base_tancot_eval(const batch<double, A>& z) noexcept
             {
-          using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type zz = z * z;
                 batch_type num = detail::horner<batch_type,
-                               0xc1711fead3299176ull,
-                               0x413199eca5fc9dddull,
-                               0xc0c992d8d24f3f38ull>(zz);
+                                                0xc1711fead3299176ull,
+                                                0x413199eca5fc9dddull,
+                                                0xc0c992d8d24f3f38ull>(zz);
                 batch_type den = detail::horner1<batch_type,
-                                0xc189afe03cbe5a31ull,
-                                0x4177d98fc2ead8efull,
-                                0xc13427bc582abc96ull,
-                                0x40cab8a5eeb36572ull>(zz);
+                                                 0xc189afe03cbe5a31ull,
+                                                 0x4177d98fc2ead8efull,
+                                                 0xc13427bc582abc96ull,
+                                                 0x40cab8a5eeb36572ull>(zz);
                 return fma(z, (zz * (num / den)), z);
             }
 
             template <class A, class BB>
-            static inline batch<double, A> tan_eval(const batch<double, A>& z, const BB& test)
+            static inline batch<double, A> tan_eval(const batch<double, A>& z, const BB& test) noexcept
             {
-          using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type y = base_tancot_eval(z);
                 return select(test, y, -batch_type(1.) / y);
             }
 
             template <class A, class BB>
-            static inline batch<double, A> cot_eval(const batch<double, A>& z, const BB& test)
+            static inline batch<double, A> cot_eval(const batch<double, A>& z, const BB& test) noexcept
             {
-          using batch_type = batch<double, A>;
+                using batch_type = batch<double, A>;
                 batch_type y = base_tancot_eval(z);
                 return select(test, batch_type(1.) / y, -y);
             }
-        /* origin: boost/simd/arch/common/detail/simd/trig_reduction.hpp */
-        /*
-         * ====================================================
-         * copyright 2016 NumScale SAS
-         *
-         * Distributed under the Boost Software License, Version 1.0.
-         * (See copy at http://boost.org/LICENSE_1_0.txt)
-         * ====================================================
-         */
-
-        struct trigo_radian_tag
-        {
-        };
-        struct trigo_pi_tag
-        {
-        };
+            /* origin: boost/simd/arch/common/detail/simd/trig_reduction.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+
+            struct trigo_radian_tag
+            {
+            };
+            struct trigo_pi_tag
+            {
+            };
 
-        template <class B, class Tag = trigo_radian_tag>
-        struct trigo_reducer
-        {
-            static inline B reduce(const B& x, B& xr)
+            template <class B, class Tag = trigo_radian_tag>
+            struct trigo_reducer
             {
-                if (all(x <= constants::pio4<B>()))
+                static inline B reduce(const B& x, B& xr) noexcept
                 {
-                    xr = x;
-                    return B(0.);
-                }
-                else if (all(x <= constants::pio2<B>()))
-                {
-                    auto test = x > constants::pio4<B>();
-                    xr = x - constants::pio2_1<B>();
-                    xr -= constants::pio2_2<B>();
-                    xr -= constants::pio2_3<B>();
-                    xr = select(test, xr, x);
-                    return select(test, B(1.), B(0.));
-                }
-                else if (all(x <= constants::twentypi<B>()))
-                {
-                    B xi = nearbyint(x * constants::twoopi<B>());
-                    xr = fnma(xi, constants::pio2_1<B>(), x);
-                    xr -= xi * constants::pio2_2<B>();
-                    xr -= xi * constants::pio2_3<B>();
-                    return quadrant(xi);
-                }
-                else if (all(x <= constants::mediumpi<B>()))
-                {
-                    B fn = nearbyint(x * constants::twoopi<B>());
-                    B r = x - fn * constants::pio2_1<B>();
-                    B w = fn * constants::pio2_1t<B>();
-                    B t = r;
-                    w = fn * constants::pio2_2<B>();
-                    r = t - w;
-                    w = fn * constants::pio2_2t<B>() - ((t - r) - w);
-                    t = r;
-                    w = fn * constants::pio2_3<B>();
-                    r = t - w;
-                    w = fn * constants::pio2_3t<B>() - ((t - r) - w);
-                    xr = r - w;
-                    return quadrant(fn);
-                }
-                else
-                {
-                    static constexpr std::size_t size = B::size;
-                    using value_type = typename B::value_type;
-                    alignas(B) std::array<value_type, size> tmp;
-                    alignas(B) std::array<value_type, size> txr;
-                    alignas(B) std::array<value_type, size> args;
-                    x.store_aligned(args.data());
-
-                    for (std::size_t i = 0; i < size; ++i)
+                    if (all(x <= constants::pio4<B>()))
                     {
-                        double arg = args[i];
-                        if (arg == std::numeric_limits<value_type>::infinity())
-                        {
-                            tmp[i] = 0.;
-                            txr[i] = std::numeric_limits<value_type>::quiet_NaN();
-                        }
-                        else
+                        xr = x;
+                        return B(0.);
+                    }
+                    else if (all(x <= constants::pio2<B>()))
+                    {
+                        auto test = x > constants::pio4<B>();
+                        xr = x - constants::pio2_1<B>();
+                        xr -= constants::pio2_2<B>();
+                        xr -= constants::pio2_3<B>();
+                        xr = select(test, xr, x);
+                        return select(test, B(1.), B(0.));
+                    }
+                    else if (all(x <= constants::twentypi<B>()))
+                    {
+                        B xi = nearbyint(x * constants::twoopi<B>());
+                        xr = fnma(xi, constants::pio2_1<B>(), x);
+                        xr -= xi * constants::pio2_2<B>();
+                        xr -= xi * constants::pio2_3<B>();
+                        return quadrant(xi);
+                    }
+                    else if (all(x <= constants::mediumpi<B>()))
+                    {
+                        B fn = nearbyint(x * constants::twoopi<B>());
+                        B r = x - fn * constants::pio2_1<B>();
+                        B w = fn * constants::pio2_1t<B>();
+                        B t = r;
+                        w = fn * constants::pio2_2<B>();
+                        r = t - w;
+                        w = fn * constants::pio2_2t<B>() - ((t - r) - w);
+                        t = r;
+                        w = fn * constants::pio2_3<B>();
+                        r = t - w;
+                        w = fn * constants::pio2_3t<B>() - ((t - r) - w);
+                        xr = r - w;
+                        return quadrant(fn);
+                    }
+                    else
+                    {
+                        static constexpr std::size_t size = B::size;
+                        using value_type = typename B::value_type;
+                        alignas(B) std::array<value_type, size> tmp;
+                        alignas(B) std::array<value_type, size> txr;
+                        alignas(B) std::array<value_type, size> args;
+                        x.store_aligned(args.data());
+
+                        for (std::size_t i = 0; i < size; ++i)
                         {
-                            double y[2];
-                            std::int32_t n = ::xsimd::detail::__ieee754_rem_pio2(arg, y);
-                            tmp[i] = value_type(n & 3);
-                            txr[i] = value_type(y[0]);
+                            double arg = args[i];
+                            if (arg == std::numeric_limits<value_type>::infinity())
+                            {
+                                tmp[i] = 0.;
+                                txr[i] = std::numeric_limits<value_type>::quiet_NaN();
+                            }
+                            else
+                            {
+                                double y[2];
+                                std::int32_t n = ::xsimd::detail::__ieee754_rem_pio2(arg, y);
+                                tmp[i] = value_type(n & 3);
+                                txr[i] = value_type(y[0]);
+                            }
                         }
+                        xr = B::load_aligned(&txr[0]);
+                        B res = B::load_aligned(&tmp[0]);
+                        return res;
                     }
-                    xr = B::load_aligned(&txr[0]);
-                    B res = B::load_aligned(&tmp[0]);
-                    return res;
                 }
-            }
-        };
+            };
 
-        template <class B>
-        struct trigo_reducer<B, trigo_pi_tag>
-        {
-            static inline B reduce(const B& x, B& xr)
+            template <class B>
+            struct trigo_reducer<B, trigo_pi_tag>
             {
-                B xi = nearbyint(x * B(2.));
-                B x2 = x - xi * B(0.5);
-                xr = x2 * constants::pi<B>();
-                return quadrant(xi);
-            }
-        };
+                static inline B reduce(const B& x, B& xr) noexcept
+                {
+                    B xi = nearbyint(x * B(2.));
+                    B x2 = x - xi * B(0.5);
+                    xr = x2 * constants::pi<B>();
+                    return quadrant(xi);
+                }
+            };
 
-    }
-    template<class A, class T> batch<T, A> cos(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                const batch_type x = abs(self);
-                batch_type xr = constants::nan<batch_type>();
-                const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
-                auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
-                auto swap_bit = fma(batch_type(-2.), tmp, n);
-                auto sign_bit = select((swap_bit ^ tmp) != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
-                const batch_type z = xr * xr;
-                const batch_type se = detail::sin_eval(z, xr);
-                const batch_type ce = detail::cos_eval(z);
-                const batch_type z1 = select(swap_bit != batch_type(0.), se, ce);
-                return z1 ^ sign_bit;
-    }
+        }
+        template <class A, class T>
+        inline batch<T, A> cos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            const batch_type x = abs(self);
+            batch_type xr = constants::nan<batch_type>();
+            const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
+            auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
+            auto swap_bit = fma(batch_type(-2.), tmp, n);
+            auto sign_bit = select((swap_bit ^ tmp) != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
+            const batch_type z = xr * xr;
+            const batch_type se = detail::sin_eval(z, xr);
+            const batch_type ce = detail::cos_eval(z);
+            const batch_type z1 = select(swap_bit != batch_type(0.), se, ce);
+            return z1 ^ sign_bit;
+        }
 
-    template<class A, class T> batch<std::complex<T>, A> cos(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      return {cos(z.real()) * cosh(z.imag()), -sin(z.real()) * sinh(z.imag())};
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> cos(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            return { cos(z.real()) * cosh(z.imag()), -sin(z.real()) * sinh(z.imag()) };
+        }
+
+        // cosh
+
+        /* origin: boost/simd/arch/common/simd/function/cosh.hpp */
+        /*
+         * ====================================================
+         * copyright 2016 NumScale SAS
+         *
+         * Distributed under the Boost Software License, Version 1.0.
+         * (See copy at http://boost.org/LICENSE_1_0.txt)
+         * ====================================================
+         */
 
-    // cosh
-
-    /* origin: boost/simd/arch/common/simd/function/cosh.hpp */
-    /*
-      * ====================================================
-      * copyright 2016 NumScale SAS
-      *
-      * Distributed under the Boost Software License, Version 1.0.
-      * (See copy at http://boost.org/LICENSE_1_0.txt)
-      * ====================================================
-      */
-
-    template<class A, class T> batch<T, A> cosh(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                batch_type x = abs(self);
-                auto test1 = x > (constants::maxlog<batch_type>() - constants::log_2<batch_type>());
-                batch_type fac = select(test1, batch_type(0.5), batch_type(1.));
-                batch_type tmp = exp(x * fac);
-                batch_type tmp1 = batch_type(0.5) * tmp;
-                return select(test1, tmp1 * tmp, detail::average(tmp, batch_type(1.) / tmp));
-    }
         template <class A, class T>
-        inline batch<std::complex<T>, A> cosh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<T, A> cosh(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type x = abs(self);
+            auto test1 = x > (constants::maxlog<batch_type>() - constants::log_2<batch_type>());
+            batch_type fac = select(test1, batch_type(0.5), batch_type(1.));
+            batch_type tmp = exp(x * fac);
+            batch_type tmp1 = batch_type(0.5) * tmp;
+            return select(test1, tmp1 * tmp, detail::average(tmp, batch_type(1.) / tmp));
+        }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> cosh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             auto x = z.real();
             auto y = z.imag();
-            return {cosh(x) * cos(y), sinh(x) * sin(y)};
+            return { cosh(x) * cos(y), sinh(x) * sin(y) };
         }
 
-
-    // sin
-    namespace detail {
-    template<class A, class T, class Tag=trigo_radian_tag> batch<T, A> sin(batch<T, A> const& self, Tag = Tag()) {
-      using batch_type = batch<T, A>;
+        // sin
+        namespace detail
+        {
+            template <class A, class T, class Tag = trigo_radian_tag>
+            inline batch<T, A> sin(batch<T, A> const& self, Tag = Tag()) noexcept
+            {
+                using batch_type = batch<T, A>;
                 const batch_type x = abs(self);
                 batch_type xr = constants::nan<batch_type>();
                 const batch_type n = detail::trigo_reducer<batch_type, Tag>::reduce(x, xr);
@@ -674,38 +686,45 @@ namespace xsimd {
                 const batch_type ce = detail::cos_eval(z);
                 const batch_type z1 = select(swap_bit == batch_type(0.), se, ce);
                 return z1 ^ sign_bit;
-    }
-    }
+            }
+        }
 
-    template<class A, class T> batch<T, A> sin(batch<T, A> const& self, requires_arch<generic>) {
-      return detail::sin(self);
-    }
+        template <class A, class T>
+        inline batch<T, A> sin(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            return detail::sin(self);
+        }
 
-    template<class A, class T> batch<std::complex<T>, A> sin(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
-      return {sin(z.real()) * cosh(z.imag()), cos(z.real()) * sinh(z.imag())};
-    }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> sin(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
+            return { sin(z.real()) * cosh(z.imag()), cos(z.real()) * sinh(z.imag()) };
+        }
 
-    // sincos
-    template<class A, class T> std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                const batch_type x = abs(self);
-                batch_type xr = constants::nan<batch_type>();
-                const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
-                auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
-                auto swap_bit = fma(batch_type(-2.), tmp, n);
-                const batch_type z = xr * xr;
-                const batch_type se = detail::sin_eval(z, xr);
-                const batch_type ce = detail::cos_eval(z);
-                auto sin_sign_bit = bitofsign(self) ^ select(tmp != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
-                const batch_type sin_z1 = select(swap_bit == batch_type(0.), se, ce);
-                auto cos_sign_bit = select((swap_bit ^ tmp) != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
-                const batch_type cos_z1 = select(swap_bit != batch_type(0.), se, ce);
-                return std::make_pair(sin_z1 ^ sin_sign_bit, cos_z1 ^ cos_sign_bit);
-    }
+        // sincos
+        template <class A, class T>
+        inline std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            const batch_type x = abs(self);
+            batch_type xr = constants::nan<batch_type>();
+            const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
+            auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
+            auto swap_bit = fma(batch_type(-2.), tmp, n);
+            const batch_type z = xr * xr;
+            const batch_type se = detail::sin_eval(z, xr);
+            const batch_type ce = detail::cos_eval(z);
+            auto sin_sign_bit = bitofsign(self) ^ select(tmp != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
+            const batch_type sin_z1 = select(swap_bit == batch_type(0.), se, ce);
+            auto cos_sign_bit = select((swap_bit ^ tmp) != batch_type(0.), constants::signmask<batch_type>(), batch_type(0.));
+            const batch_type cos_z1 = select(swap_bit != batch_type(0.), se, ce);
+            return std::make_pair(sin_z1 ^ sin_sign_bit, cos_z1 ^ cos_sign_bit);
+        }
 
-    template<class A, class T>
-    std::pair<batch<std::complex<T>, A>, batch<std::complex<T>, A>>
-    sincos(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
+        template <class A, class T>
+        inline std::pair<batch<std::complex<T>, A>, batch<std::complex<T>, A>>
+        sincos(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
             using batch_type = batch<std::complex<T>, A>;
             using real_batch = typename batch_type::real_batch;
             real_batch rcos = cos(z.real());
@@ -713,11 +732,55 @@ namespace xsimd {
             real_batch icosh = cosh(z.imag());
             real_batch isinh = sinh(z.imag());
             return std::make_pair(batch_type(rsin * icosh, rcos * isinh), batch_type(rcos * icosh, -rsin * isinh));
-    }
+        }
+
+        // sinh
+        namespace detail
+        {
+            /* origin: boost/simd/arch/common/detail/generic/sinh_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class A>
+            inline batch<float, A> sinh_kernel(batch<float, A> const& self) noexcept
+            {
+                using batch_type = batch<float, A>;
+                batch_type sqr_self = self * self;
+                return detail::horner<batch_type,
+                                      0x3f800000, // 1.0f
+                                      0x3e2aaacc, // 1.66667160211E-1f
+                                      0x3c087bbe, // 8.33028376239E-3f
+                                      0x39559e2f // 2.03721912945E-4f
+                                      >(sqr_self)
+                    * self;
+            }
 
-    // sinh
-    namespace detail {
-        /* origin: boost/simd/arch/common/detail/generic/sinh_kernel.hpp */
+            template <class A>
+            inline batch<double, A> sinh_kernel(batch<double, A> const& self) noexcept
+            {
+                using batch_type = batch<double, A>;
+                batch_type sqrself = self * self;
+                return fma(self, (detail::horner<batch_type,
+                                                 0xc115782bdbf6ab05ull, //  -3.51754964808151394800E5
+                                                 0xc0c694b8c71d6182ull, //  -1.15614435765005216044E4,
+                                                 0xc064773a398ff4feull, //  -1.63725857525983828727E2,
+                                                 0xbfe9435fe8bb3cd6ull //  -7.89474443963537015605E-1
+                                                 >(sqrself)
+                                  / detail::horner1<batch_type,
+                                                    0xc1401a20e4f90044ull, //  -2.11052978884890840399E6
+                                                    0x40e1a7ba7ed72245ull, //   3.61578279834431989373E4,
+                                                    0xc0715b6096e96484ull //  -2.77711081420602794433E2,
+                                                    >(sqrself))
+                               * sqrself,
+                           self);
+            }
+        }
+        /* origin: boost/simd/arch/common/simd/function/sinh.hpp */
         /*
          * ====================================================
          * copyright 2016 NumScale SAS
@@ -726,86 +789,53 @@ namespace xsimd {
          * (See copy at http://boost.org/LICENSE_1_0.txt)
          * ====================================================
          */
-    template<class A> batch<float, A> sinh_kernel(batch<float, A> const& self) {
-      using batch_type = batch<float, A>;
-                batch_type sqr_self = self * self;
-                return detail::horner<batch_type,
-                              0x3f800000,  // 1.0f
-                              0x3e2aaacc,  // 1.66667160211E-1f
-                              0x3c087bbe,  // 8.33028376239E-3f
-                              0x39559e2f  // 2.03721912945E-4f
-                              >(sqr_self) *
-                    self;
-    }
-
-    template<class A> batch<double, A> sinh_kernel(batch<double, A> const& self) {
-      using batch_type = batch<double, A>;
-                batch_type sqrself = self * self;
-                return fma(self, (detail::horner<batch_type,
-                                      0xc115782bdbf6ab05ull,  //  -3.51754964808151394800E5
-                                      0xc0c694b8c71d6182ull,  //  -1.15614435765005216044E4,
-                                      0xc064773a398ff4feull,  //  -1.63725857525983828727E2,
-                                      0xbfe9435fe8bb3cd6ull  //  -7.89474443963537015605E-1
-                                      >(sqrself) /
-                               detail::horner1<batch_type,
-                                       0xc1401a20e4f90044ull,  //  -2.11052978884890840399E6
-                                       0x40e1a7ba7ed72245ull,  //   3.61578279834431989373E4,
-                                       0xc0715b6096e96484ull  //  -2.77711081420602794433E2,
-                                       >(sqrself)) *
-                               sqrself,
-                           self);
-    }
-    }
-    /* origin: boost/simd/arch/common/simd/function/sinh.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A, class T> batch<T, A> sinh(batch<T, A> const& a, requires_arch<generic>) {
-                using batch_type = batch<T, A>;
-                batch_type half(0.5);
-                batch_type x = abs(a);
-                auto lt1 = x < batch_type(1.);
-                batch_type bts = bitofsign(a);
-                batch_type z(0.);
-                if (any(lt1))
-                {
-                    z = detail::sinh_kernel(x);
-                    if (all(lt1))
-                        return z ^ bts;
-                }
-                auto test1 = x >( constants::maxlog<batch_type>() -  constants::log_2<batch_type>());
-                batch_type fac = select(test1, half, batch_type(1.));
-                batch_type tmp = exp(x * fac);
-                batch_type tmp1 = half * tmp;
-                batch_type r = select(test1, tmp1 * tmp, tmp1 - half / tmp);
-                return select(lt1, z, r) ^ bts;
-    }
         template <class A, class T>
-        inline batch<std::complex<T>, A> sinh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<T, A> sinh(batch<T, A> const& a, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type half(0.5);
+            batch_type x = abs(a);
+            auto lt1 = x < batch_type(1.);
+            batch_type bts = bitofsign(a);
+            batch_type z(0.);
+            if (any(lt1))
+            {
+                z = detail::sinh_kernel(x);
+                if (all(lt1))
+                    return z ^ bts;
+            }
+            auto test1 = x > (constants::maxlog<batch_type>() - constants::log_2<batch_type>());
+            batch_type fac = select(test1, half, batch_type(1.));
+            batch_type tmp = exp(x * fac);
+            batch_type tmp1 = half * tmp;
+            batch_type r = select(test1, tmp1 * tmp, tmp1 - half / tmp);
+            return select(lt1, z, r) ^ bts;
+        }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> sinh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             auto x = z.real();
             auto y = z.imag();
-            return {sinh(x) * cos(y), cosh(x) * sin(y)};
+            return { sinh(x) * cos(y), cosh(x) * sin(y) };
         }
 
-    // tan
-    template<class A, class T> batch<T, A> tan(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                const batch_type x = abs(self);
-                batch_type xr = constants::nan<batch_type>();
-                const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
-                auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
-                auto swap_bit = fma(batch_type(-2.), tmp, n);
-                auto test = (swap_bit == batch_type(0.));
-                const batch_type y = detail::tan_eval(xr, test);
-                return y ^ bitofsign(self);
-    }
-    template<class A, class T> batch<std::complex<T>, A> tan(batch<std::complex<T>, A> const& z, requires_arch<generic>) {
+        // tan
+        template <class A, class T>
+        inline batch<T, A> tan(batch<T, A> const& self, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            const batch_type x = abs(self);
+            batch_type xr = constants::nan<batch_type>();
+            const batch_type n = detail::trigo_reducer<batch_type>::reduce(x, xr);
+            auto tmp = select(n >= batch_type(2.), batch_type(1.), batch_type(0.));
+            auto swap_bit = fma(batch_type(-2.), tmp, n);
+            auto test = (swap_bit == batch_type(0.));
+            const batch_type y = detail::tan_eval(xr, test);
+            return y ^ bitofsign(self);
+        }
+        template <class A, class T>
+        inline batch<std::complex<T>, A> tan(batch<std::complex<T>, A> const& z, requires_arch<generic>) noexcept
+        {
             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());
@@ -814,12 +844,85 @@ namespace xsimd {
             real_batch wimag = sinh(2 * z.imag());
             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);
+        }
 
-    }
+        // tanh
+        namespace detail
+        {
+            /* origin: boost/simd/arch/common/detail/generic/tanh_kernel.hpp */
+            /*
+             * ====================================================
+             * copyright 2016 NumScale SAS
+             *
+             * Distributed under the Boost Software License, Version 1.0.
+             * (See copy at http://boost.org/LICENSE_1_0.txt)
+             * ====================================================
+             */
+            template <class B>
+            struct tanh_kernel;
+
+            template <class A>
+            struct tanh_kernel<batch<float, A>>
+            {
+                using batch_type = batch<float, A>;
+                static inline batch_type tanh(const batch_type& x) noexcept
+                {
+                    batch_type sqrx = x * x;
+                    return fma(detail::horner<batch_type,
+                                              0xbeaaaa99, //    -3.33332819422E-1F
+                                              0x3e088393, //    +1.33314422036E-1F
+                                              0xbd5c1e2d, //    -5.37397155531E-2F
+                                              0x3ca9134e, //    +2.06390887954E-2F
+                                              0xbbbaf0ea //    -5.70498872745E-3F
+                                              >(sqrx)
+                                   * sqrx,
+                               x, x);
+                }
 
-    // tanh
-    namespace detail {
-        /* origin: boost/simd/arch/common/detail/generic/tanh_kernel.hpp */
+                static inline batch_type cotanh(const batch_type& x) noexcept
+                {
+                    return batch_type(1.) / tanh(x);
+                }
+            };
+
+            template <class A>
+            struct tanh_kernel<batch<double, A>>
+            {
+                using batch_type = batch<double, A>;
+                static inline batch_type tanh(const batch_type& x) noexcept
+                {
+                    batch_type sqrx = x * x;
+                    return fma(sqrx * p(sqrx) / q(sqrx), x, x);
+                }
+
+                static inline batch_type cotanh(const batch_type& x) noexcept
+                {
+                    batch_type sqrx = x * x;
+                    batch_type qval = q(sqrx);
+                    return qval / (x * fma(p(sqrx), sqrx, qval));
+                }
+
+                static inline batch_type p(const batch_type& x) noexcept
+                {
+                    return detail::horner<batch_type,
+                                          0xc0993ac030580563, // -1.61468768441708447952E3
+                                          0xc058d26a0e26682d, // -9.92877231001918586564E1,
+                                          0xbfeedc5baafd6f4b // -9.64399179425052238628E-1
+                                          >(x);
+                }
+
+                static inline batch_type q(const batch_type& x) noexcept
+                {
+                    return detail::horner1<batch_type,
+                                           0x40b2ec102442040c, //  4.84406305325125486048E3
+                                           0x40a176fa0e5535fa, //  2.23548839060100448583E3,
+                                           0x405c33f28a581B86 //  1.12811678491632931402E2,
+                                           >(x);
+                }
+            };
+
+        }
+        /* origin: boost/simd/arch/common/simd/function/tanh.hpp */
         /*
          * ====================================================
          * copyright 2016 NumScale SAS
@@ -828,109 +931,37 @@ namespace xsimd {
          * (See copy at http://boost.org/LICENSE_1_0.txt)
          * ====================================================
          */
-        template <class B>
-        struct tanh_kernel;
-
-        template <class A>
-        struct tanh_kernel<batch<float, A>>
-        {
-          using batch_type = batch<float, A>;
-            static inline batch_type tanh(const batch_type& x)
-            {
-                batch_type sqrx = x * x;
-                return fma(detail::horner<batch_type,
-                                  0xbeaaaa99,  //    -3.33332819422E-1F
-                                  0x3e088393,  //    +1.33314422036E-1F
-                                  0xbd5c1e2d,  //    -5.37397155531E-2F
-                                  0x3ca9134e,  //    +2.06390887954E-2F
-                                  0xbbbaf0ea  //    -5.70498872745E-3F
-                                  >(sqrx) *
-                               sqrx,
-                           x, x);
-            }
-
-            static inline batch_type cotanh(const batch_type& x)
-            {
-                return batch_type(1.) / tanh(x);
-            }
-        };
-
-        template <class A>
-        struct tanh_kernel<batch<double, A>>
+        template <class A, class T>
+        inline batch<T, A> tanh(batch<T, A> const& self, requires_arch<generic>) noexcept
         {
-          using batch_type = batch<double, A>;
-            static inline batch_type tanh(const batch_type& x)
+            using batch_type = batch<T, A>;
+            batch_type one(1.);
+            batch_type x = abs(self);
+            auto test = x < (batch_type(5.) / batch_type(8.));
+            batch_type bts = bitofsign(self);
+            batch_type z = one;
+            if (any(test))
             {
-                batch_type sqrx = x * x;
-                return fma(sqrx * p(sqrx) / q(sqrx), x, x);
+                z = detail::tanh_kernel<batch_type>::tanh(x);
+                if (all(test))
+                    return z ^ bts;
             }
-
-            static inline batch_type cotanh(const batch_type& x)
-            {
-                batch_type sqrx = x * x;
-                batch_type qval = q(sqrx);
-                return qval / (x * fma(p(sqrx), sqrx, qval));
-            }
-
-            static inline batch_type p(const batch_type& x)
-            {
-                return detail::horner<batch_type,
-                              0xc0993ac030580563,  // -1.61468768441708447952E3
-                              0xc058d26a0e26682d,  // -9.92877231001918586564E1,
-                              0xbfeedc5baafd6f4b  // -9.64399179425052238628E-1
-                              >(x);
-            }
-
-            static inline batch_type q(const batch_type& x)
-            {
-                return detail::horner1<batch_type,
-                               0x40b2ec102442040c,  //  4.84406305325125486048E3
-                               0x40a176fa0e5535fa,  //  2.23548839060100448583E3,
-                               0x405c33f28a581B86  //  1.12811678491632931402E2,
-                               >(x);
-            }
-        };
-
-    }
-    /* origin: boost/simd/arch/common/simd/function/tanh.hpp */
-    /*
-     * ====================================================
-     * copyright 2016 NumScale SAS
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     * (See copy at http://boost.org/LICENSE_1_0.txt)
-     * ====================================================
-     */
-    template<class A, class T> batch<T, A> tanh(batch<T, A> const& self, requires_arch<generic>) {
-      using batch_type = batch<T, A>;
-                batch_type one(1.);
-                batch_type x = abs(self);
-                auto test = x < (batch_type(5.) / batch_type(8.));
-                batch_type bts = bitofsign(self);
-                batch_type z = one;
-                if (any(test))
-                {
-                    z = detail::tanh_kernel<batch_type>::tanh(x);
-                    if (all(test))
-                        return z ^ bts;
-                }
-                batch_type r = fma(batch_type(-2.), one / (one + exp(x + x)), one);
-                return select(test, z, r) ^ bts;
-    }
+            batch_type r = fma(batch_type(-2.), one / (one + exp(x + x)), one);
+            return select(test, z, r) ^ bts;
+        }
         template <class A, class T>
-        inline batch<std::complex<T>, A> tanh(const batch<std::complex<T>, A>& z, requires_arch<generic>)
+        inline batch<std::complex<T>, A> tanh(const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
         {
             using real_batch = typename batch<std::complex<T>, A>::real_batch;
             auto x = z.real();
             auto y = z.imag();
             real_batch two(2);
             auto d = cosh(two * x) + cos(two * y);
-            return {sinh(two * x) / d, sin(two * y) / d};
+            return { sinh(two * x) / d, sin(two * y) / d };
         }
 
-  }
+    }
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_avx.hpp b/third_party/xsimd/arch/xsimd_avx.hpp
index 3634cbedc..ea2e8ce30 100644
--- a/third_party/xsimd/arch/xsimd_avx.hpp
+++ b/third_party/xsimd/arch/xsimd_avx.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX_HPP
 #define XSIMD_AVX_HPP
@@ -18,897 +18,1212 @@
 
 #include "../types/xsimd_avx_register.hpp"
 
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    namespace detail {
-    inline void split_avx(__m256i val, __m128i& low, __m128i& high) {
-        low =_mm256_castsi256_si128(val);
-        high =_mm256_extractf128_si256(val, 1);
-      }
-      inline __m256i merge_sse(__m128i low, __m128i high) {
-        return _mm256_insertf128_si256(_mm256_castsi128_si256(low), high, 1);
-      }
-      template <class F>
-      __m256i fwd_to_sse(F f, __m256i self) {
-        __m128i self_low, self_high;
-        split_avx(self, self_low, self_high);
-        __m128i res_low = f(self_low);
-        __m128i res_high = f(self_high);
-        return merge_sse(res_low, res_high);
-      }
-      template<class F>
-      __m256i fwd_to_sse(F f, __m256i self, __m256i other) {
-        __m128i self_low, self_high, other_low, other_high;
-        split_avx(self, self_low, self_high);
-        split_avx(other, other_low, other_high);
-        __m128i res_low = f(self_low, other_low);
-        __m128i res_high = f(self_high, other_high);
-        return merge_sse(res_low, res_high);
-      }
-      template<class F>
-      __m256i fwd_to_sse(F f, __m256i self, int32_t other) {
-        __m128i self_low, self_high;
-        split_avx(self, self_low, self_high);
-        __m128i res_low = f(self_low, other);
-        __m128i res_high = f(self_high, other);
-        return merge_sse(res_low, res_high);
-      }
-    }
-
-    // abs
-    template<class A> batch<float, A> abs(batch<float, A> const& self, requires_arch<avx>) {
-      __m256 sign_mask = _mm256_set1_ps(-0.f);  // -0.f = 1 << 31
-      return _mm256_andnot_ps(sign_mask, self);
-    }
-    template<class A> batch<double, A> abs(batch<double, A> const& self, requires_arch<avx>) {
-      __m256d sign_mask = _mm256_set1_pd(-0.f);  // -0.f = 1 << 31
-      return _mm256_andnot_pd(sign_mask, self);
-    }
-
-    // add
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-        return detail::fwd_to_sse([](__m128i s, __m128i o) { return add(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
-    template<class A> batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_add_ps(self, other);
-    }
-    template<class A> batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_add_pd(self, other);
-    }
+namespace xsimd
+{
 
-    // all
-    template<class A> bool all(batch_bool<float, A> const& self, requires_arch<avx>) {
-      return _mm256_testc_ps(self, batch_bool<float, A>(true)) != 0;
-    }
-    template<class A> bool all(batch_bool<double, A> const& self, requires_arch<avx>) {
-      return _mm256_testc_pd(self, batch_bool<double, A>(true)) != 0;
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    bool all(batch_bool<T, A> const& self, requires_arch<avx>) {
-                return _mm256_testc_si256(self, batch_bool<T, A>(true)) != 0;
-    }
+    namespace kernel
+    {
+        using namespace types;
 
-    // any
-    template<class A> bool any(batch_bool<float, A> const& self, requires_arch<avx>) {
-      return !_mm256_testz_ps(self, self);
-    }
-    template<class A> bool any(batch_bool<double, A> const& self, requires_arch<avx>) {
-      return !_mm256_testz_pd(self, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    bool any(batch_bool<T, A> const& self, requires_arch<avx>) {
-                return !_mm256_testz_si256(self, self);
-    }
+        namespace detail
+        {
+            inline void split_avx(__m256i val, __m128i& low, __m128i& high) noexcept
+            {
+                low = _mm256_castsi256_si128(val);
+                high = _mm256_extractf128_si256(val, 1);
+            }
+            inline __m256i merge_sse(__m128i low, __m128i high) noexcept
+            {
+                return _mm256_insertf128_si256(_mm256_castsi128_si256(low), high, 1);
+            }
+            template <class F>
+            inline __m256i fwd_to_sse(F f, __m256i self) noexcept
+            {
+                __m128i self_low, self_high;
+                split_avx(self, self_low, self_high);
+                __m128i res_low = f(self_low);
+                __m128i res_high = f(self_high);
+                return merge_sse(res_low, res_high);
+            }
+            template <class F>
+            inline __m256i fwd_to_sse(F f, __m256i self, __m256i other) noexcept
+            {
+                __m128i self_low, self_high, other_low, other_high;
+                split_avx(self, self_low, self_high);
+                split_avx(other, other_low, other_high);
+                __m128i res_low = f(self_low, other_low);
+                __m128i res_high = f(self_high, other_high);
+                return merge_sse(res_low, res_high);
+            }
+            template <class F>
+            inline __m256i fwd_to_sse(F f, __m256i self, int32_t other) noexcept
+            {
+                __m128i self_low, self_high;
+                split_avx(self, self_low, self_high);
+                __m128i res_low = f(self_low, other);
+                __m128i res_high = f(self_high, other);
+                return merge_sse(res_low, res_high);
+            }
+        }
 
-    // bitwise_and
-    template<class A> batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_and_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_and_pd(self, other);
-    }
+        // abs
+        template <class A>
+        inline batch<float, A> abs(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            __m256 sign_mask = _mm256_set1_ps(-0.f); // -0.f = 1 << 31
+            return _mm256_andnot_ps(sign_mask, self);
+        }
+        template <class A>
+        inline batch<double, A> abs(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            __m256d sign_mask = _mm256_set1_pd(-0.f); // -0.f = 1 << 31
+            return _mm256_andnot_pd(sign_mask, self);
+        }
 
-    template<class A> batch_bool<float, A> bitwise_and(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return _mm256_and_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> bitwise_and(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return _mm256_and_pd(self, other);
-    }
+        // add
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return add(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
+        template <class A>
+        inline batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_add_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_add_pd(self, other);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
+        // all
+        template <class A>
+        inline bool all(batch_bool<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_testc_ps(self, batch_bool<float, A>(true)) != 0;
+        }
+        template <class A>
+        inline bool all(batch_bool<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_testc_pd(self, batch_bool<double, A>(true)) != 0;
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline bool all(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_testc_si256(self, batch_bool<T, A>(true)) != 0;
+        }
 
-    // bitwise_andnot
-    template<class A> batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_andnot_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_andnot_pd(self, other);
-    }
+        // any
+        template <class A>
+        inline bool any(batch_bool<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return !_mm256_testz_ps(self, self);
+        }
+        template <class A>
+        inline bool any(batch_bool<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return !_mm256_testz_pd(self, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline bool any(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return !_mm256_testz_si256(self, self);
+        }
 
-    template<class A> batch_bool<float, A> bitwise_andnot(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return _mm256_andnot_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return _mm256_andnot_pd(self, other);
-    }
+        // bitwise_and
+        template <class A>
+        inline batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_and_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_and_pd(self, other);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_andnot(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_andnot(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
+        template <class A>
+        inline batch_bool<float, A> bitwise_and(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_and_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_and(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_and_pd(self, other);
+        }
 
-    // bitwise_lshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) {
-        return detail::fwd_to_sse([](__m128i s, int32_t o) { return bitwise_lshift(batch<T, sse4_2>(s), o, sse4_2{}); },self, other);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
 
-    // bitwise_not
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s) { return bitwise_not(batch<T, sse4_2>(s), sse4_2{}); }, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s) { return bitwise_not(batch_bool<T, sse4_2>(s), sse4_2{}); }, self);
-    }
+        // bitwise_andnot
+        template <class A>
+        inline batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_andnot_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_andnot_pd(self, other);
+        }
 
-    // bitwise_or
-    template<class A> batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_or_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_or_pd(self, other);
-    }
-    template<class A> batch_bool<float, A> bitwise_or(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return _mm256_or_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> bitwise_or(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return _mm256_or_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_or(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_or(batch_bool<T, sse4_2>(s), batch_bool<T, sse4_2>(o)); }, self, other);
-    }
+        template <class A>
+        inline batch_bool<float, A> bitwise_andnot(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_andnot_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_andnot_pd(self, other);
+        }
 
-    // bitwise_rshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, int32_t o) { return bitwise_rshift(batch<T, sse4_2>(s), o, sse4_2{}); }, self, other);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_andnot(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_andnot(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
 
-    // bitwise_xor
-    template<class A> batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_pd(self, other);
-    }
-    template<class A> batch_bool<float, A> bitwise_xor(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_xor(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2{}); },
-                                self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_xor(batch_bool<T, sse4_2>(s), batch_bool<T, sse4_2>(o), sse4_2{}); },
-                                self, other);
-    }
+        // bitwise_lshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, int32_t o) noexcept
+                                      { return bitwise_lshift(batch<T, sse4_2>(s), o, sse4_2 {}); },
+                                      self, other);
+        }
 
-    // bitwise_cast
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const &, requires_arch<avx>) {
-      return _mm256_castsi256_ps(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const &, requires_arch<avx>) {
-      return _mm256_castsi256_pd(self);
-    }
-    template<class A, class T, class Tp, class=typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
-    batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const &, requires_arch<avx>) {
-      return batch<Tp, A>(self.data);
-    }
-    template<class A>
-    batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const &, requires_arch<avx>) {
-      return _mm256_castps_pd(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const &, requires_arch<avx>) {
-      return _mm256_castps_si256(self);
-    }
-    template<class A>
-    batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const &, requires_arch<avx>) {
-      return _mm256_castpd_ps(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const &, requires_arch<avx>) {
-      return _mm256_castpd_si256(self);
-    }
+        // bitwise_not
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s) noexcept
+                                      { return bitwise_not(batch<T, sse4_2>(s), sse4_2 {}); },
+                                      self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s) noexcept
+                                      { return bitwise_not(batch_bool<T, sse4_2>(s), sse4_2 {}); },
+                                      self);
+        }
 
-    // bitwise_not
-    template<class A> batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(-1)));
-    }
-    template <class A>
-    batch<double, A> bitwise_not(batch<double, A> const &self, requires_arch<avx>) {
-      return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi32(-1)));
-    }
-    template<class A> batch_bool<float, A> bitwise_not(batch_bool<float, A> const& self, requires_arch<avx>) {
-      return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(-1)));
-    }
-    template <class A>
-    batch_bool<double, A> bitwise_not(batch_bool<double, A> const &self, requires_arch<avx>) {
-      return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi32(-1)));
-    }
+        // bitwise_or
+        template <class A>
+        inline batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_or_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_or_pd(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_or(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_or_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_or(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_or_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_or(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_or(batch_bool<T, sse4_2>(s), batch_bool<T, sse4_2>(o)); },
+                                      self, other);
+        }
 
-    // bool_cast
-    template<class A> batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self, requires_arch<avx>) {
-        return _mm256_castps_si256(self);
-    }
-    template<class A> batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self, requires_arch<avx>) {
-        return _mm256_castsi256_ps(self);
-    }
-    template<class A> batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self, requires_arch<avx>) {
-        return _mm256_castpd_si256(self);
-    }
-    template<class A> batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self, requires_arch<avx>) {
-        return _mm256_castsi256_pd(self);
-    }
+        // bitwise_rshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, int32_t o) noexcept
+                                      { return bitwise_rshift(batch<T, sse4_2>(s), o, sse4_2 {}); },
+                                      self, other);
+        }
 
-    // broadcast
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> broadcast(T val, requires_arch<avx>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_set1_epi8(val);
-        case 2: return _mm256_set1_epi16(val);
-        case 4: return _mm256_set1_epi32(val);
-        case 8: return _mm256_set1_epi64x(val);
-        default: assert(false && "unsupported"); return {};
-      }
-    }
-    template<class A> batch<float, A> broadcast(float val, requires_arch<avx>) {
-      return _mm256_set1_ps(val);
-    }
-    template<class A> batch<double, A> broadcast(double val, requires_arch<avx>) {
-      return _mm256_set1_pd(val);
-    }
+        // bitwise_xor
+        template <class A>
+        inline batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_xor(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_xor(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2 {}); },
+                                      self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return bitwise_xor(batch_bool<T, sse4_2>(s), batch_bool<T, sse4_2>(o), sse4_2 {}); },
+                                      self, other);
+        }
 
-    // ceil
-    template<class A> batch<float, A> ceil(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_ceil_ps(self);
-    }
-    template<class A> batch<double, A> ceil(batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_ceil_pd(self);
-    }
+        // bitwise_cast
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_ps(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_pd(self);
+        }
+        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
+        inline batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx>) noexcept
+        {
+            return batch<Tp, A>(self.data);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castps_pd(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castps_si256(self);
+        }
+        template <class A>
+        inline batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castpd_ps(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<avx>) noexcept
+        {
+            return _mm256_castpd_si256(self);
+        }
 
+        // bitwise_not
+        template <class A>
+        inline batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_not(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_not(batch_bool<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_not(batch_bool<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi32(-1)));
+        }
 
-    namespace detail {
-        // On clang, _mm256_extractf128_ps is built upon build_shufflevector
-        // which require index parameter to be a constant
-        template <int index, class B>
-        inline B get_half_complex_f(const B& real, const B& imag)
-        {
-            __m128 tmp0 = _mm256_extractf128_ps(real, index);
-            __m128 tmp1 = _mm256_extractf128_ps(imag, index);
-            __m128 tmp2 = _mm_unpackhi_ps(tmp0, tmp1);
-            tmp0 = _mm_unpacklo_ps(tmp0, tmp1);
-            __m256 res = real;
-            res = _mm256_insertf128_ps(res, tmp0, 0);
-            res = _mm256_insertf128_ps(res, tmp2, 1);
-            return res;
-        }
-        template <int index, class B>
-        inline B get_half_complex_d(const B& real, const B& imag)
-        {
-            __m128d tmp0 = _mm256_extractf128_pd(real, index);
-            __m128d tmp1 = _mm256_extractf128_pd(imag, index);
-            __m128d tmp2 = _mm_unpackhi_pd(tmp0, tmp1);
-            tmp0 = _mm_unpacklo_pd(tmp0, tmp1);
-            __m256d res = real;
-            res = _mm256_insertf128_pd(res, tmp0, 0);
-            res = _mm256_insertf128_pd(res, tmp2, 1);
-            return res;
-        }
-
-        // complex_low
-        template<class A> batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<avx>) {
-                return get_half_complex_f<0>(self.real(), self.imag());
+        // bool_cast
+        template <class A>
+        inline batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_castps_si256(self);
         }
-        template<class A> batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx>) {
-                return get_half_complex_d<0>(self.real(), self.imag());
+        template <class A>
+        inline batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_ps(self);
+        }
+        template <class A>
+        inline batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_castpd_si256(self);
+        }
+        template <class A>
+        inline batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_pd(self);
         }
 
-        // complex_high
-        template<class A> batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<avx>) {
-                return get_half_complex_f<1>(self.real(), self.imag());
+        // broadcast
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> broadcast(T val, requires_arch<avx>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_set1_epi8(val);
+            case 2:
+                return _mm256_set1_epi16(val);
+            case 4:
+                return _mm256_set1_epi32(val);
+            case 8:
+                return _mm256_set1_epi64x(val);
+            default:
+                assert(false && "unsupported");
+                return {};
+            }
         }
-        template<class A> batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx>) {
-                return get_half_complex_d<1>(self.real(), self.imag());
+        template <class A>
+        inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
+        {
+            return _mm256_set1_ps(val);
+        }
+        template <class A>
+        inline batch<double, A> broadcast(double val, requires_arch<avx>) noexcept
+        {
+            return _mm256_set1_pd(val);
         }
-    }
-    // convert
-    namespace detail {
-    template<class A> batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<avx>) {
-      return _mm256_cvtepi32_ps(self);
-    }
-    template<class A> batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<avx>) {
-      return _mm256_cvttps_epi32(self);
-    }
-    }
 
-    // div
-    template<class A> batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_div_ps(self, other);
-    }
-    template<class A> batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_div_pd(self, other);
-    }
+        // ceil
+        template <class A>
+        inline batch<float, A> ceil(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_ceil_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> ceil(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_ceil_pd(self);
+        }
 
-    // eq
-    template<class A> batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_EQ_OQ);
-    }
-    template<class A> batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_EQ_OQ);
-    }
-    template<class A> batch_bool<float, A> eq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return  _mm256_castsi256_ps(detail::fwd_to_sse([](__m128i s, __m128i o) { return eq(batch_bool<int32_t, sse4_2>(s), batch_bool<int32_t, sse4_2>(o), sse4_2{}); },
-                                  _mm256_castps_si256(self), _mm256_castps_si256(other)));
-    }
-    template<class A> batch_bool<double, A> eq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return  _mm256_castsi256_pd(detail::fwd_to_sse([](__m128i s, __m128i o) { return eq(batch_bool<int32_t, sse4_2>(s), batch_bool<int32_t, sse4_2>(o), sse4_2{}); }, _mm256_castpd_si256(self), _mm256_castpd_si256(other)));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return eq(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2{}); },self, other);
-    }
+        namespace detail
+        {
+            // On clang, _mm256_extractf128_ps is built upon build_shufflevector
+            // which require index parameter to be a constant
+            template <int index, class B>
+            inline B get_half_complex_f(const B& real, const B& imag) noexcept
+            {
+                __m128 tmp0 = _mm256_extractf128_ps(real, index);
+                __m128 tmp1 = _mm256_extractf128_ps(imag, index);
+                __m128 tmp2 = _mm_unpackhi_ps(tmp0, tmp1);
+                tmp0 = _mm_unpacklo_ps(tmp0, tmp1);
+                __m256 res = real;
+                res = _mm256_insertf128_ps(res, tmp0, 0);
+                res = _mm256_insertf128_ps(res, tmp2, 1);
+                return res;
+            }
+            template <int index, class B>
+            inline B get_half_complex_d(const B& real, const B& imag) noexcept
+            {
+                __m128d tmp0 = _mm256_extractf128_pd(real, index);
+                __m128d tmp1 = _mm256_extractf128_pd(imag, index);
+                __m128d tmp2 = _mm_unpackhi_pd(tmp0, tmp1);
+                tmp0 = _mm_unpacklo_pd(tmp0, tmp1);
+                __m256d res = real;
+                res = _mm256_insertf128_pd(res, tmp0, 0);
+                res = _mm256_insertf128_pd(res, tmp2, 1);
+                return res;
+            }
+
+            // complex_low
+            template <class A>
+            inline batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<avx>) noexcept
+            {
+                return get_half_complex_f<0>(self.real(), self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx>) noexcept
+            {
+                return get_half_complex_d<0>(self.real(), self.imag());
+            }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-      return eq(batch<T, A>(self.data), batch<T, A>(other.data));
-    }
+            // complex_high
+            template <class A>
+            inline batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<avx>) noexcept
+            {
+                return get_half_complex_f<1>(self.real(), self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx>) noexcept
+            {
+                return get_half_complex_d<1>(self.real(), self.imag());
+            }
+        }
 
-    // floor
-    template<class A> batch<float, A> floor(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_floor_ps(self);
-    }
-    template<class A> batch<double, A> floor(batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_floor_pd(self);
-    }
+        // convert
+        namespace detail
+        {
+            template <class A>
+            inline batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<avx>) noexcept
+            {
+                return _mm256_cvtepi32_ps(self);
+            }
+
+            template <class A>
+            inline batch<float, A> fast_cast(batch<uint32_t, A> const& v, batch<float, A> const&, requires_arch<avx>) noexcept
+            {
+                // see https://stackoverflow.com/questions/34066228/how-to-perform-uint32-float-conversion-with-sse
+                __m256i msk_lo = _mm256_set1_epi32(0xFFFF);
+                __m256 cnst65536f = _mm256_set1_ps(65536.0f);
+
+                __m256i v_lo = bitwise_and(batch<uint32_t, A>(v), batch<uint32_t, A>(msk_lo)); /* extract the 16 lowest significant bits of self                             */
+                __m256i v_hi = bitwise_rshift(batch<uint32_t, A>(v), 16, avx {}); /* 16 most significant bits of v                                                 */
+                __m256 v_lo_flt = _mm256_cvtepi32_ps(v_lo); /* No rounding                                                                   */
+                __m256 v_hi_flt = _mm256_cvtepi32_ps(v_hi); /* No rounding                                                                   */
+                v_hi_flt = _mm256_mul_ps(cnst65536f, v_hi_flt); /* No rounding                                                                   */
+                return _mm256_add_ps(v_hi_flt, v_lo_flt); /* Rounding may occur here, mul and add may fuse to fma for haswell and newer    */
+            }
+
+            template <class A>
+            inline batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<avx>) noexcept
+            {
+                return _mm256_cvttps_epi32(self);
+            }
 
-    // ge
-    template<class A> batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_GE_OQ);
-    }
-    template<class A> batch_bool<double, A> ge(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_GE_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return ge(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
+        }
 
-    // gt
-    template<class A> batch_bool<float, A> gt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_GT_OQ);
-    }
-    template<class A> batch_bool<double, A> gt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_GT_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return gt(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
+        // div
+        template <class A>
+        inline batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_div_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_div_pd(self, other);
+        }
 
+        // eq
+        template <class A>
+        inline batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_ps(self, other, _CMP_EQ_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_pd(self, other, _CMP_EQ_OQ);
+        }
+        template <class A>
+        inline batch_bool<float, A> eq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_ps(detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                                          { return eq(batch_bool<int32_t, sse4_2>(s), batch_bool<int32_t, sse4_2>(o), sse4_2 {}); },
+                                                          _mm256_castps_si256(self), _mm256_castps_si256(other)));
+        }
+        template <class A>
+        inline batch_bool<double, A> eq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_castsi256_pd(detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                                          { return eq(batch_bool<int32_t, sse4_2>(s), batch_bool<int32_t, sse4_2>(o), sse4_2 {}); },
+                                                          _mm256_castpd_si256(self), _mm256_castpd_si256(other)));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return eq(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2 {}); },
+                                      self, other);
+        }
 
-    // hadd
-    template<class A> float hadd(batch<float, A> const& rhs, requires_arch<avx>) {
-                // Warning about _mm256_hadd_ps:
-                // _mm256_hadd_ps(a,b) gives
-                // (a0+a1,a2+a3,b0+b1,b2+b3,a4+a5,a6+a7,b4+b5,b6+b7). Hence we can't
-                // rely on a naive use of this method
-                // rhs = (x0, x1, x2, x3, x4, x5, x6, x7)
-                // tmp = (x4, x5, x6, x7, x0, x1, x2, x3)
-                __m256 tmp = _mm256_permute2f128_ps(rhs, rhs, 1);
-                // tmp = (x4+x0, x5+x1, x6+x2, x7+x3, x0+x4, x1+x5, x2+x6, x3+x7)
-                tmp = _mm256_add_ps(rhs, tmp);
-                // tmp = (x4+x0+x5+x1, x6+x2+x7+x3, -, -, -, -, -, -)
-                tmp = _mm256_hadd_ps(tmp, tmp);
-                // tmp = (x4+x0+x5+x1+x6+x2+x7+x3, -, -, -, -, -, -, -)
-                tmp = _mm256_hadd_ps(tmp, tmp);
-                return _mm_cvtss_f32(_mm256_extractf128_ps(tmp, 0));
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return eq(batch<T, A>(self.data), batch<T, A>(other.data));
+        }
 
-    }
-    template <class A>
-    double hadd(batch<double, A> const &rhs, requires_arch<avx>) {
-                // rhs = (x0, x1, x2, x3)
-                // tmp = (x2, x3, x0, x1)
-                __m256d tmp = _mm256_permute2f128_pd(rhs, rhs, 1);
-                // tmp = (x2+x0, x3+x1, -, -)
-                tmp = _mm256_add_pd(rhs, tmp);
-                // tmp = (x2+x0+x3+x1, -, -, -)
-                tmp = _mm256_hadd_pd(tmp, tmp);
-                return _mm_cvtsd_f64(_mm256_extractf128_pd(tmp, 0));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd(batch<T, A> const& self, requires_arch<avx>) {
-      __m128i low, high;
-      detail::split_avx(self, low, high);
-      batch<T, sse4_2> blow(low), bhigh(high);
-      return hadd(blow) + hadd(bhigh);
-    }
+        // floor
+        template <class A>
+        inline batch<float, A> floor(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_floor_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> floor(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_floor_pd(self);
+        }
 
-    // haddp
-    template<class A> batch<float, A> haddp(batch<float, A> const* row, requires_arch<avx>) {
-                // row = (a,b,c,d,e,f,g,h)
-                // tmp0 = (a0+a1, a2+a3, b0+b1, b2+b3, a4+a5, a6+a7, b4+b5, b6+b7)
-                __m256 tmp0 = _mm256_hadd_ps(row[0], row[1]);
-                // tmp1 = (c0+c1, c2+c3, d1+d2, d2+d3, c4+c5, c6+c7, d4+d5, d6+d7)
-                __m256 tmp1 = _mm256_hadd_ps(row[2], row[3]);
-                // tmp1 = (a0+a1+a2+a3, b0+b1+b2+b3, c0+c1+c2+c3, d0+d1+d2+d3,
-                // a4+a5+a6+a7, b4+b5+b6+b7, c4+c5+c6+c7, d4+d5+d6+d7)
-                tmp1 = _mm256_hadd_ps(tmp0, tmp1);
-                // tmp0 = (e0+e1, e2+e3, f0+f1, f2+f3, e4+e5, e6+e7, f4+f5, f6+f7)
-                tmp0 = _mm256_hadd_ps(row[4], row[5]);
-                // tmp2 = (g0+g1, g2+g3, h0+h1, h2+h3, g4+g5, g6+g7, h4+h5, h6+h7)
-                __m256 tmp2 = _mm256_hadd_ps(row[6], row[7]);
-                // tmp2 = (e0+e1+e2+e3, f0+f1+f2+f3, g0+g1+g2+g3, h0+h1+h2+h3,
-                // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
-                tmp2 = _mm256_hadd_ps(tmp0, tmp2);
-                // tmp0 = (a0+a1+a2+a3, b0+b1+b2+b3, c0+c1+c2+c3, d0+d1+d2+d3,
-                // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
-                tmp0 = _mm256_blend_ps(tmp1, tmp2, 0b11110000);
-                // tmp1 = (a4+a5+a6+a7, b4+b5+b6+b7, c4+c5+c6+c7, d4+d5+d6+d7,
-                // e0+e1+e2+e3, f0+f1+f2+f3, g0+g1+g2+g3, h0+h1+h2+h3)
-                tmp1 = _mm256_permute2f128_ps(tmp1, tmp2, 0x21);
-                return _mm256_add_ps(tmp0, tmp1);
-    }
-    template <class A>
-    batch<double, A> haddp(batch<double, A> const *row, requires_arch<avx>) {
-                // row = (a,b,c,d)
-                // tmp0 = (a0+a1, b0+b1, a2+a3, b2+b3)
-                __m256d tmp0 = _mm256_hadd_pd(row[0], row[1]);
-                // tmp1 = (c0+c1, d0+d1, c2+c3, d2+d3)
-                __m256d tmp1 = _mm256_hadd_pd(row[2], row[3]);
-                // tmp2 = (a0+a1, b0+b1, c2+c3, d2+d3)
-                __m256d tmp2 = _mm256_blend_pd(tmp0, tmp1, 0b1100);
-                // tmp1 = (a2+a3, b2+b3, c2+c3, d2+d3)
-                tmp1 = _mm256_permute2f128_pd(tmp0, tmp1, 0x21);
-                return _mm256_add_pd(tmp1, tmp2);
-    }
+        // hadd
+        template <class A>
+        inline float hadd(batch<float, A> const& rhs, requires_arch<avx>) noexcept
+        {
+            // Warning about _mm256_hadd_ps:
+            // _mm256_hadd_ps(a,b) gives
+            // (a0+a1,a2+a3,b0+b1,b2+b3,a4+a5,a6+a7,b4+b5,b6+b7). Hence we can't
+            // rely on a naive use of this method
+            // rhs = (x0, x1, x2, x3, x4, x5, x6, x7)
+            // tmp = (x4, x5, x6, x7, x0, x1, x2, x3)
+            __m256 tmp = _mm256_permute2f128_ps(rhs, rhs, 1);
+            // tmp = (x4+x0, x5+x1, x6+x2, x7+x3, x0+x4, x1+x5, x2+x6, x3+x7)
+            tmp = _mm256_add_ps(rhs, tmp);
+            // tmp = (x4+x0+x5+x1, x6+x2+x7+x3, -, -, -, -, -, -)
+            tmp = _mm256_hadd_ps(tmp, tmp);
+            // tmp = (x4+x0+x5+x1+x6+x2+x7+x3, -, -, -, -, -, -, -)
+            tmp = _mm256_hadd_ps(tmp, tmp);
+            return _mm_cvtss_f32(_mm256_extractf128_ps(tmp, 0));
+        }
+        template <class A>
+        inline double hadd(batch<double, A> const& rhs, requires_arch<avx>) noexcept
+        {
+            // rhs = (x0, x1, x2, x3)
+            // tmp = (x2, x3, x0, x1)
+            __m256d tmp = _mm256_permute2f128_pd(rhs, rhs, 1);
+            // tmp = (x2+x0, x3+x1, -, -)
+            tmp = _mm256_add_pd(rhs, tmp);
+            // tmp = (x2+x0+x3+x1, -, -, -)
+            tmp = _mm256_hadd_pd(tmp, tmp);
+            return _mm_cvtsd_f64(_mm256_extractf128_pd(tmp, 0));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline T hadd(batch<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            __m128i low, high;
+            detail::split_avx(self, low, high);
+            batch<T, sse4_2> blow(low), bhigh(high);
+            return hadd(blow) + hadd(bhigh);
+        }
 
-    // isnan
-    template<class A> batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<avx>) {
-                return _mm256_cmp_ps(self, self, _CMP_UNORD_Q);
-    }
-    template<class A> batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<avx>) {
-                return _mm256_cmp_pd(self, self, _CMP_UNORD_Q);
-    }
+        // haddp
+        template <class A>
+        inline batch<float, A> haddp(batch<float, A> const* row, requires_arch<avx>) noexcept
+        {
+            // row = (a,b,c,d,e,f,g,h)
+            // tmp0 = (a0+a1, a2+a3, b0+b1, b2+b3, a4+a5, a6+a7, b4+b5, b6+b7)
+            __m256 tmp0 = _mm256_hadd_ps(row[0], row[1]);
+            // tmp1 = (c0+c1, c2+c3, d1+d2, d2+d3, c4+c5, c6+c7, d4+d5, d6+d7)
+            __m256 tmp1 = _mm256_hadd_ps(row[2], row[3]);
+            // tmp1 = (a0+a1+a2+a3, b0+b1+b2+b3, c0+c1+c2+c3, d0+d1+d2+d3,
+            // a4+a5+a6+a7, b4+b5+b6+b7, c4+c5+c6+c7, d4+d5+d6+d7)
+            tmp1 = _mm256_hadd_ps(tmp0, tmp1);
+            // tmp0 = (e0+e1, e2+e3, f0+f1, f2+f3, e4+e5, e6+e7, f4+f5, f6+f7)
+            tmp0 = _mm256_hadd_ps(row[4], row[5]);
+            // tmp2 = (g0+g1, g2+g3, h0+h1, h2+h3, g4+g5, g6+g7, h4+h5, h6+h7)
+            __m256 tmp2 = _mm256_hadd_ps(row[6], row[7]);
+            // tmp2 = (e0+e1+e2+e3, f0+f1+f2+f3, g0+g1+g2+g3, h0+h1+h2+h3,
+            // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
+            tmp2 = _mm256_hadd_ps(tmp0, tmp2);
+            // tmp0 = (a0+a1+a2+a3, b0+b1+b2+b3, c0+c1+c2+c3, d0+d1+d2+d3,
+            // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
+            tmp0 = _mm256_blend_ps(tmp1, tmp2, 0b11110000);
+            // tmp1 = (a4+a5+a6+a7, b4+b5+b6+b7, c4+c5+c6+c7, d4+d5+d6+d7,
+            // e0+e1+e2+e3, f0+f1+f2+f3, g0+g1+g2+g3, h0+h1+h2+h3)
+            tmp1 = _mm256_permute2f128_ps(tmp1, tmp2, 0x21);
+            return _mm256_add_ps(tmp0, tmp1);
+        }
+        template <class A>
+        inline batch<double, A> haddp(batch<double, A> const* row, requires_arch<avx>) noexcept
+        {
+            // row = (a,b,c,d)
+            // tmp0 = (a0+a1, b0+b1, a2+a3, b2+b3)
+            __m256d tmp0 = _mm256_hadd_pd(row[0], row[1]);
+            // tmp1 = (c0+c1, d0+d1, c2+c3, d2+d3)
+            __m256d tmp1 = _mm256_hadd_pd(row[2], row[3]);
+            // tmp2 = (a0+a1, b0+b1, c2+c3, d2+d3)
+            __m256d tmp2 = _mm256_blend_pd(tmp0, tmp1, 0b1100);
+            // tmp1 = (a2+a3, b2+b3, c2+c3, d2+d3)
+            tmp1 = _mm256_permute2f128_pd(tmp0, tmp1, 0x21);
+            return _mm256_add_pd(tmp1, tmp2);
+        }
 
-    // le
-    template<class A> batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_LE_OQ);
-    }
-    template<class A> batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_LE_OQ);
-    }
+        // isnan
+        template <class A>
+        inline batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_ps(self, self, _CMP_UNORD_Q);
+        }
+        template <class A>
+        inline batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_pd(self, self, _CMP_UNORD_Q);
+        }
 
-    // load_aligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx>) {
-      return _mm256_load_si256((__m256i const*)mem);
-    }
-    template<class A> batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<avx>) {
-      return _mm256_load_ps(mem);
-    }
-    template<class A> batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<avx>) {
-      return _mm256_load_pd(mem);
-    }
+        // le
+        template <class A>
+        inline batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_ps(self, other, _CMP_LE_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_pd(self, other, _CMP_LE_OQ);
+        }
 
-    namespace detail
-    {
-    // load_complex
-    template<class A> batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx>) {
-            using batch_type = batch<float, A>;
-            __m128 tmp0 = _mm256_extractf128_ps(hi, 0);
-            __m128 tmp1 = _mm256_extractf128_ps(hi, 1);
-            batch_type real, imag;
-            __m128 tmp_real = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(2, 0, 2, 0));
-            __m128 tmp_imag = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(3, 1, 3, 1));
-            real = _mm256_insertf128_ps(real, tmp_real, 0);
-            imag = _mm256_insertf128_ps(imag, tmp_imag, 0);
-
-            tmp0 = _mm256_extractf128_ps(lo, 0);
-            tmp1 = _mm256_extractf128_ps(lo, 1);
-            tmp_real = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(2, 0, 2, 0));
-            tmp_imag = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(3, 1, 3, 1));
-            real = _mm256_insertf128_ps(real, tmp_real, 1);
-            imag = _mm256_insertf128_ps(imag, tmp_imag, 1);
-            return {real, imag};
-    }
-    template<class A> batch<std::complex<double>, A> load_complex(batch<double,A> const& hi, batch<double,A> const& lo, requires_arch<avx>) {
-            using batch_type = batch<double, A>;
-            __m128d tmp0 = _mm256_extractf128_pd(hi, 0);
-            __m128d tmp1 = _mm256_extractf128_pd(hi, 1);
-            batch_type real, imag;
-            __m256d re_tmp0 = _mm256_insertf128_pd(real, _mm_unpacklo_pd(tmp0, tmp1), 0);
-            __m256d im_tmp0 = _mm256_insertf128_pd(imag, _mm_unpackhi_pd(tmp0, tmp1), 0);
-            tmp0 = _mm256_extractf128_pd(lo, 0);
-            tmp1 = _mm256_extractf128_pd(lo, 1);
-            __m256d re_tmp1 = _mm256_insertf128_pd(real, _mm_unpacklo_pd(tmp0, tmp1), 1);
-            __m256d im_tmp1 = _mm256_insertf128_pd(imag, _mm_unpackhi_pd(tmp0, tmp1), 1);
-            real = _mm256_blend_pd(re_tmp0, re_tmp1, 12);
-            imag = _mm256_blend_pd(im_tmp0, im_tmp1, 12);
-            return {real, imag};
-    }
-    }
+        // load_aligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx>) noexcept
+        {
+            return _mm256_load_si256((__m256i const*)mem);
+        }
+        template <class A>
+        inline batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<avx>) noexcept
+        {
+            return _mm256_load_ps(mem);
+        }
+        template <class A>
+        inline batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<avx>) noexcept
+        {
+            return _mm256_load_pd(mem);
+        }
 
-    // load_unaligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx>) {
-      return _mm256_loadu_si256((__m256i const*)mem);
-    }
-    template<class A> batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<avx>){
-      return _mm256_loadu_ps(mem);
-    }
-    template<class A> batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<avx>){
-      return _mm256_loadu_pd(mem);
-    }
+        namespace detail
+        {
+            // load_complex
+            template <class A>
+            inline batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx>) noexcept
+            {
+                using batch_type = batch<float, A>;
+                __m128 tmp0 = _mm256_extractf128_ps(hi, 0);
+                __m128 tmp1 = _mm256_extractf128_ps(hi, 1);
+                batch_type real, imag;
+                __m128 tmp_real = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(2, 0, 2, 0));
+                __m128 tmp_imag = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(3, 1, 3, 1));
+                real = _mm256_insertf128_ps(real, tmp_real, 0);
+                imag = _mm256_insertf128_ps(imag, tmp_imag, 0);
+
+                tmp0 = _mm256_extractf128_ps(lo, 0);
+                tmp1 = _mm256_extractf128_ps(lo, 1);
+                tmp_real = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(2, 0, 2, 0));
+                tmp_imag = _mm_shuffle_ps(tmp0, tmp1, _MM_SHUFFLE(3, 1, 3, 1));
+                real = _mm256_insertf128_ps(real, tmp_real, 1);
+                imag = _mm256_insertf128_ps(imag, tmp_imag, 1);
+                return { real, imag };
+            }
+            template <class A>
+            inline batch<std::complex<double>, A> load_complex(batch<double, A> const& hi, batch<double, A> const& lo, requires_arch<avx>) noexcept
+            {
+                using batch_type = batch<double, A>;
+                __m128d tmp0 = _mm256_extractf128_pd(hi, 0);
+                __m128d tmp1 = _mm256_extractf128_pd(hi, 1);
+                batch_type real, imag;
+                __m256d re_tmp0 = _mm256_insertf128_pd(real, _mm_unpacklo_pd(tmp0, tmp1), 0);
+                __m256d im_tmp0 = _mm256_insertf128_pd(imag, _mm_unpackhi_pd(tmp0, tmp1), 0);
+                tmp0 = _mm256_extractf128_pd(lo, 0);
+                tmp1 = _mm256_extractf128_pd(lo, 1);
+                __m256d re_tmp1 = _mm256_insertf128_pd(real, _mm_unpacklo_pd(tmp0, tmp1), 1);
+                __m256d im_tmp1 = _mm256_insertf128_pd(imag, _mm_unpackhi_pd(tmp0, tmp1), 1);
+                real = _mm256_blend_pd(re_tmp0, re_tmp1, 12);
+                imag = _mm256_blend_pd(im_tmp0, im_tmp1, 12);
+                return { real, imag };
+            }
+        }
 
-    // lt
-    template<class A> batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_LT_OQ);
-    }
-    template<class A> batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_LT_OQ);
-    }
+        // load_unaligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx>) noexcept
+        {
+            return _mm256_loadu_si256((__m256i const*)mem);
+        }
+        template <class A>
+        inline batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<avx>) noexcept
+        {
+            return _mm256_loadu_ps(mem);
+        }
+        template <class A>
+        inline batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<avx>) noexcept
+        {
+            return _mm256_loadu_pd(mem);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return detail::fwd_to_sse([](__m128i s, __m128i o) { return lt(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
+        // lt
+        template <class A>
+        inline batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_ps(self, other, _CMP_LT_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_pd(self, other, _CMP_LT_OQ);
+        }
 
-    // max
-    template<class A> batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_max_ps(self, other);
-    }
-    template<class A> batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_max_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return select(self > other, self, other);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return lt(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
 
-    // min
-    template<class A> batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_min_ps(self, other);
-    }
-    template<class A> batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_min_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      return select(self <= other, self, other);
-    }
+        // max
+        template <class A>
+        inline batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_max_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_max_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return select(self > other, self, other);
+        }
 
-    // mul
-    template<class A> batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_mul_ps(self, other);
-    }
-    template<class A> batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_mul_pd(self, other);
-    }
+        // min
+        template <class A>
+        inline batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_min_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_min_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return select(self <= other, self, other);
+        }
 
-    // nearbyint
-    template<class A> batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_round_ps(self, _MM_FROUND_TO_NEAREST_INT);
-    }
-    template<class A> batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_round_pd(self, _MM_FROUND_TO_NEAREST_INT);
-    }
+        // mul
+        template <class A>
+        inline batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_mul_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_mul_pd(self, other);
+        }
 
-    // neg
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> neg(batch<T, A> const& self, requires_arch<avx>) {
-      return 0 - self;
-    }
-    template<class A> batch<float, A> neg(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(0x80000000)));
-    }
-    template <class A>
-    batch<double, A> neg(batch<double, A> const &self, requires_arch<avx>) {
-      return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi64x(0x8000000000000000)));
-    }
+        // nearbyint
+        template <class A>
+        inline batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_round_ps(self, _MM_FROUND_TO_NEAREST_INT);
+        }
+        template <class A>
+        inline batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_round_pd(self, _MM_FROUND_TO_NEAREST_INT);
+        }
 
-    // neq
-    template<class A> batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_ps(self, other, _CMP_NEQ_OQ);
-    }
-    template<class A> batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_cmp_pd(self, other, _CMP_NEQ_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-        return ~(self == other);
-    }
+        // neg
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> neg(batch<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return 0 - self;
+        }
+        template <class A>
+        batch<float, A> neg(batch<float, A> const& self, requires_arch<avx>)
+        {
+            return _mm256_xor_ps(self, _mm256_castsi256_ps(_mm256_set1_epi32(0x80000000)));
+        }
+        template <class A>
+        inline batch<double, A> neg(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, _mm256_castsi256_pd(_mm256_set1_epi64x(0x8000000000000000)));
+        }
 
+        // neq
+        template <class A>
+        inline batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_ps(self, other, _CMP_NEQ_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_cmp_pd(self, other, _CMP_NEQ_OQ);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return ~(self == other);
+        }
 
-    template<class A> batch_bool<float, A> neq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> neq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) {
-      return _mm256_xor_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) {
-        return ~(self == other);
-    }
+        template <class A>
+        inline batch_bool<float, A> neq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> neq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_xor_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return ~(self == other);
+        }
 
-    // sadd
-    template<class A> batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return add(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A> batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return add(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      if(std::is_signed<T>::value) {
-        auto mask = (other >> (8 * sizeof(T) - 1));
-        auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
-        auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
-        return other + select(batch_bool<T, A>(mask.data), self_neg_branch, self_pos_branch);
-      }
-      else {
-        const auto diffmax = std::numeric_limits<T>::max() - self;
-        const auto mindiff = min(diffmax, other);
-        return self + mindiff;
-      }
-    }
+        // sadd
+        template <class A>
+        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                auto mask = (other >> (8 * sizeof(T) - 1));
+                auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
+                auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
+                return other + select(batch_bool<T, A>(mask.data), self_neg_branch, self_pos_branch);
+            }
+            else
+            {
+                const auto diffmax = std::numeric_limits<T>::max() - self;
+                const auto mindiff = min(diffmax, other);
+                return self + mindiff;
+            }
+        }
 
-    // select
-    template<class A> batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<avx>) {
-                return _mm256_blendv_ps(false_br, true_br, cond);
-    }
-    template<class A> batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<avx>) {
-                return _mm256_blendv_pd(false_br, true_br, cond);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) {
-      __m128i cond_low, cond_hi;
-      detail::split_avx(cond, cond_low, cond_hi);
+        // select
+        template <class A>
+        inline batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<avx>) noexcept
+        {
+            return _mm256_blendv_ps(false_br, true_br, cond);
+        }
+        template <class A>
+        inline batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<avx>) noexcept
+        {
+            return _mm256_blendv_pd(false_br, true_br, cond);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) noexcept
+        {
+            __m128i cond_low, cond_hi;
+            detail::split_avx(cond, cond_low, cond_hi);
 
-      __m128i true_low, true_hi;
-      detail::split_avx(true_br, true_low, true_hi);
+            __m128i true_low, true_hi;
+            detail::split_avx(true_br, true_low, true_hi);
 
-      __m128i false_low, false_hi;
-      detail::split_avx(false_br, false_low, false_hi);
+            __m128i false_low, false_hi;
+            detail::split_avx(false_br, false_low, false_hi);
 
-      __m128i res_low = select(batch_bool<T, sse4_2>(cond_low), batch<T, sse4_2>(true_low), batch<T, sse4_2>(false_low), sse4_2{});
-      __m128i res_hi = select(batch_bool<T, sse4_2>(cond_hi), batch<T, sse4_2>(true_hi), batch<T, sse4_2>(false_hi), sse4_2{});
-      return detail::merge_sse(res_low, res_hi);
-    }
-    template<class A, class T, bool... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) {
-      return select(batch_bool<T, A>{Values...}, true_br, false_br, avx2{});
-    }
+            __m128i res_low = select(batch_bool<T, sse4_2>(cond_low), batch<T, sse4_2>(true_low), batch<T, sse4_2>(false_low), sse4_2 {});
+            __m128i res_hi = select(batch_bool<T, sse4_2>(cond_hi), batch<T, sse4_2>(true_hi), batch<T, sse4_2>(false_hi), sse4_2 {});
+            return detail::merge_sse(res_low, res_hi);
+        }
+        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) noexcept
+        {
+            return select(batch_bool<T, A> { Values... }, true_br, false_br, avx2 {});
+        }
 
+        // set
+        template <class A, class... Values>
+        inline batch<float, A> set(batch<float, A> const&, requires_arch<avx>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch<float, A>::size, "consistent init");
+            return _mm256_setr_ps(values...);
+        }
 
-    // set
-    template<class A, class... Values>
-    batch<float, A> set(batch<float, A> const&, requires_arch<avx>, Values... values) {
-      static_assert(sizeof...(Values) == batch<float, A>::size, "consistent init");
-      return _mm256_setr_ps(values...);
-    }
+        template <class A, class... Values>
+        inline batch<double, A> set(batch<double, A> const&, requires_arch<avx>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch<double, A>::size, "consistent init");
+            return _mm256_setr_pd(values...);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3) noexcept
+        {
+            return _mm256_set_epi64x(v3, v2, v1, v0);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
+        {
+            return _mm256_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
+        {
+            return _mm256_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
+                               T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23, T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) noexcept
+        {
+            return _mm256_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
+        }
 
-    template<class A, class... Values>
-    batch<double, A> set(batch<double, A> const&, requires_arch<avx>, Values... values) {
-      static_assert(sizeof...(Values) == batch<double, A>::size, "consistent init");
-      return _mm256_setr_pd(values...);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3) {
-      return _mm256_set_epi64x(v3, v2, v1, v0);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) {
-      return _mm256_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) {
-      return _mm256_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
-      T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23, T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31  ) {
-      return _mm256_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
-    }
+        template <class A, class T, class... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<avx>, Values... values) noexcept
+        {
+            return set(batch<T, A>(), A {}, static_cast<T>(values ? -1LL : 0LL)...).data;
+        }
 
-    template<class A, class T, class... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<avx>, Values... values) {
-      return set(batch<T, A>(), A{}, static_cast<T>(values ? -1LL : 0LL )...).data;
-    }
+        template <class A, class... Values>
+        inline batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<avx>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch_bool<float, A>::size, "consistent init");
+            return _mm256_castsi256_ps(set(batch<int32_t, A>(), A {}, static_cast<int32_t>(values ? -1LL : 0LL)...).data);
+        }
 
-    template<class A, class... Values>
-    batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<avx>, Values... values) {
-      static_assert(sizeof...(Values) == batch_bool<float, A>::size, "consistent init");
-      return _mm256_castsi256_ps(set(batch<int32_t, A>(), A{}, static_cast<int32_t>(values ? -1LL : 0LL )...).data);
-    }
+        template <class A, class... Values>
+        inline batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<avx>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch_bool<double, A>::size, "consistent init");
+            return _mm256_castsi256_pd(set(batch<int64_t, A>(), A {}, static_cast<int64_t>(values ? -1LL : 0LL)...).data);
+        }
 
-    template<class A, class... Values>
-    batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<avx>, Values... values) {
-      static_assert(sizeof...(Values) == batch_bool<double, A>::size, "consistent init");
-      return _mm256_castsi256_pd(set(batch<int64_t, A>(), A{},  static_cast<int64_t>(values ? -1LL : 0LL )...).data);
-    }
+        // sqrt
+        template <class A>
+        inline batch<float, A> sqrt(batch<float, A> const& val, requires_arch<avx>) noexcept
+        {
+            return _mm256_sqrt_ps(val);
+        }
+        template <class A>
+        inline batch<double, A> sqrt(batch<double, A> const& val, requires_arch<avx>) noexcept
+        {
+            return _mm256_sqrt_pd(val);
+        }
 
-    // sqrt
-    template<class A> batch<float, A> sqrt(batch<float, A> const& val, requires_arch<avx>) {
-      return _mm256_sqrt_ps(val);
-    }
-    template<class A> batch<double, A> sqrt(batch<double, A> const& val, requires_arch<avx>) {
-      return _mm256_sqrt_pd(val);
-    }
+        // ssub
+        template <class A>
+        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_sub_ps(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_sub_pd(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                return sadd(self, -other);
+            }
+            else
+            {
+                const auto diff = min(self, other);
+                return self - diff;
+            }
+        }
 
-    // ssub
-    template<class A> batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A> batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      if(std::is_signed<T>::value) {
-         return sadd(self, -other);
-      }
-      else {
-        const auto diff = min(self, other);
-        return self - diff;
-      }
-    }
+        // store_aligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_store_si256((__m256i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_store_si256((__m256i*)mem, self);
+        }
+        template <class A>
+        inline void store_aligned(float* mem, batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_store_ps(mem, self);
+        }
+        template <class A>
+        inline void store_aligned(double* mem, batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_store_pd(mem, self);
+        }
 
-    // store_aligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch<T, A> const& self, requires_arch<avx>) {
-      return _mm256_store_si256((__m256i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch_bool<T, A> const& self, requires_arch<avx>) {
-      return _mm256_store_si256((__m256i *)mem, self);
-    }
-    template<class A> void store_aligned(float *mem, batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_store_ps(mem, self);
-    }
-    template<class A> void store_aligned(double *mem, batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_store_pd(mem, self);
-    }
+        // store_unaligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_storeu_si256((__m256i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_storeu_si256((__m256i*)mem, self);
+        }
+        template <class A>
+        inline void store_unaligned(float* mem, batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_storeu_ps(mem, self);
+        }
+        template <class A>
+        inline void store_unaligned(double* mem, batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_storeu_pd(mem, self);
+        }
 
-    // store_unaligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch<T, A> const& self, requires_arch<avx>) {
-      return _mm256_storeu_si256((__m256i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch_bool<T, A> const& self, requires_arch<avx>) {
-      return _mm256_storeu_si256((__m256i *)mem, self);
-    }
-    template<class A> void store_unaligned(float *mem, batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_storeu_ps(mem, self);
-    }
-    template<class A> void store_unaligned(double *mem, batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_storeu_pd(mem, self);
-    }
+        // sub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                      { return sub(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
+                                      self, other);
+        }
+        template <class A>
+        inline batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_sub_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_sub_pd(self, other);
+        }
 
-    // sub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-        return detail::fwd_to_sse([](__m128i s, __m128i o) { return sub(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); }, self, other);
-    }
-    template<class A> batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_sub_ps(self, other);
-    }
-    template<class A> batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_sub_pd(self, other);
-    }
+        // to_float
+        template <class A>
+        inline batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_cvtepi32_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx>) noexcept
+        {
+            // FIXME: call _mm_cvtepi64_pd
+            alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
+            self.store_aligned(&buffer[0]);
+            return {
+                (double)buffer[0],
+                (double)buffer[1],
+                (double)buffer[2],
+                (double)buffer[3],
+            };
+        }
 
-    // to_float
-    template<class A>
-    batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<avx>) {
-      return _mm256_cvtepi32_ps(self);
-    }
-    template<class A>
-    batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx>) {
-      // FIXME: call _mm_cvtepi64_pd
-      alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(double)buffer[0], (double)buffer[1], (double)buffer[2], (double)buffer[3],};
-    }
+        // to_int
+        template <class A>
+        inline batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_cvttps_epi32(self);
+        }
 
-    // to_int
-    template<class A>
-    batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_cvttps_epi32(self);
-    }
+        template <class A>
+        inline batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            // FIXME: call _mm_cvttpd_epi64
+            alignas(A::alignment()) double buffer[batch<double, A>::size];
+            self.store_aligned(&buffer[0]);
+            return { (int64_t)buffer[0], (int64_t)buffer[1], (int64_t)buffer[2], (int64_t)buffer[3] };
+        }
 
-    template<class A>
-    batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx>) {
-      // FIXME: call _mm_cvttpd_epi64
-      alignas(A::alignment()) double buffer[batch<double, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(int64_t)buffer[0], (int64_t)buffer[1], (int64_t)buffer[2], (int64_t)buffer[3]};
-    }
+        // trunc
+        template <class A>
+        inline batch<float, A> trunc(batch<float, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_round_ps(self, _MM_FROUND_TO_ZERO);
+        }
+        template <class A>
+        inline batch<double, A> trunc(batch<double, A> const& self, requires_arch<avx>) noexcept
+        {
+            return _mm256_round_pd(self, _MM_FROUND_TO_ZERO);
+        }
 
-    // trunc
-    template<class A> batch<float, A> trunc(batch<float, A> const& self, requires_arch<avx>) {
-      return _mm256_round_ps(self, _MM_FROUND_TO_ZERO);
-    }
-    template<class A> batch<double, A> trunc(batch<double, A> const& self, requires_arch<avx>) {
-      return _mm256_round_pd(self, _MM_FROUND_TO_ZERO);
-    }
+        // zip_hi
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_unpackhi_epi8(self, other);
+            case 2:
+                return _mm256_unpackhi_epi16(self, other);
+            case 4:
+                return _mm256_unpackhi_epi32(self, other);
+            case 8:
+                return _mm256_unpackhi_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_unpackhi_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_unpackhi_pd(self, other);
+        }
 
-    // zip_hi
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_unpackhi_epi8(self, other);
-        case 2: return _mm256_unpackhi_epi16(self, other);
-        case 4: return _mm256_unpackhi_epi32(self, other);
-        case 8: return _mm256_unpackhi_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_unpackhi_ps(self, other);
-    }
-    template<class A> batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_unpackhi_pd(self, other);
-    }
+        // zip_lo
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_unpacklo_epi8(self, other);
+            case 2:
+                return _mm256_unpacklo_epi16(self, other);
+            case 4:
+                return _mm256_unpacklo_epi32(self, other);
+            case 8:
+                return _mm256_unpacklo_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_unpacklo_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
+        {
+            return _mm256_unpacklo_pd(self, other);
+        }
 
-    // zip_lo
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_unpacklo_epi8(self, other);
-        case 2: return _mm256_unpacklo_epi16(self, other);
-        case 4: return _mm256_unpacklo_epi32(self, other);
-        case 8: return _mm256_unpacklo_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
     }
-    template<class A> batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) {
-      return _mm256_unpacklo_ps(self, other);
-    }
-    template<class A> batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) {
-      return _mm256_unpacklo_pd(self, other);
-    }
-
-  }
 
 }
 
diff --git a/third_party/xsimd/arch/xsimd_avx2.hpp b/third_party/xsimd/arch/xsimd_avx2.hpp
index 2dacb2eba..301191e0b 100644
--- a/third_party/xsimd/arch/xsimd_avx2.hpp
+++ b/third_party/xsimd/arch/xsimd_avx2.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX2_HPP
 #define XSIMD_AVX2_HPP
@@ -17,211 +17,313 @@
 
 #include "../types/xsimd_avx2_register.hpp"
 
-
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    // abs
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm256_abs_epi8(self);
-          case 2: return _mm256_abs_epi16(self);
-          case 4: return _mm256_abs_epi32(self);
-          default: return abs(self, avx{});
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+
+        // abs
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_abs_epi8(self);
+                case 2:
+                    return _mm256_abs_epi16(self);
+                case 4:
+                    return _mm256_abs_epi32(self);
+                default:
+                    return abs(self, avx {});
+                }
+            }
+            return self;
         }
-      }
-      return self;
-    }
 
-    // add
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_add_epi8(self, other);
-        case 2: return _mm256_add_epi16(self, other);
-        case 4: return _mm256_add_epi32(self, other);
-        case 8: return _mm256_add_epi64(self, other);
-        default: return add(self, other, avx{});
-      }
-    }
+        // add
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_add_epi8(self, other);
+            case 2:
+                return _mm256_add_epi16(self, other);
+            case 4:
+                return _mm256_add_epi32(self, other);
+            case 8:
+                return _mm256_add_epi64(self, other);
+            default:
+                return add(self, other, avx {});
+            }
+        }
 
-    // bitwise_and
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_and_si256(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_and_si256(self, other);
-    }
+        // bitwise_and
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_and_si256(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_and_si256(self, other);
+        }
 
-    // bitwise_andnot
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_andnot_si256(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_andnot_si256(self, other);
-    }
+        // bitwise_andnot
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_andnot_si256(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_andnot_si256(self, other);
+        }
 
-    // bitwise_not
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx2>) {
-      return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx2>) {
-      return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
-    }
+        // bitwise_not
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx2>) noexcept
+        {
+            return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx2>) noexcept
+        {
+            return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
+        }
 
-    // bitwise_lshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 2: return _mm256_slli_epi16(self, other);
-        case 4: return _mm256_slli_epi32(self, other);
-        case 8: return _mm256_slli_epi64(self, other);
-        default: return bitwise_lshift(self, other, avx{});
-      }
-    }
+        // bitwise_lshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 2:
+                return _mm256_slli_epi16(self, other);
+            case 4:
+                return _mm256_slli_epi32(self, other);
+            case 8:
+                return _mm256_slli_epi64(self, other);
+            default:
+                return bitwise_lshift(self, other, avx {});
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 4: return _mm256_sllv_epi32(self, other);
-        case 8: return _mm256_sllv_epi64(self, other);
-        default: return bitwise_lshift(self, other, avx{});
-      }
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 4:
+                return _mm256_sllv_epi32(self, other);
+            case 8:
+                return _mm256_sllv_epi64(self, other);
+            default:
+                return bitwise_lshift(self, other, avx {});
+            }
+        }
 
-    // bitwise_or
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_or_si256(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_or_si256(self, other);
-    }
+        // bitwise_or
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_or_si256(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_or_si256(self, other);
+        }
 
-    // bitwise_rshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: {
-            __m256i sign_mask = _mm256_set1_epi16((0xFF00 >> other) & 0x00FF);
-            __m256i cmp_is_negative = _mm256_cmpgt_epi8(_mm256_setzero_si256(), self);
-            __m256i res = _mm256_srai_epi16(self, other);
-            return _mm256_or_si256(
-                detail::fwd_to_sse([](__m128i s, __m128i o) { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2{}); },
-                                   sign_mask, cmp_is_negative),
-                _mm256_andnot_si256(sign_mask, res));
-          }
-          case 2: return _mm256_srai_epi16(self, other);
-          case 4: return _mm256_srai_epi32(self, other);
-          default: return bitwise_rshift(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 2: return _mm256_srli_epi16(self, other);
-          case 4: return _mm256_srli_epi32(self, other);
-          case 8: return _mm256_srli_epi64(self, other);
-          default: return bitwise_rshift(self, other, avx{});
-        }
-      }
-    }
+        // bitwise_rshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                {
+                    __m256i sign_mask = _mm256_set1_epi16((0xFF00 >> other) & 0x00FF);
+                    __m256i cmp_is_negative = _mm256_cmpgt_epi8(_mm256_setzero_si256(), self);
+                    __m256i res = _mm256_srai_epi16(self, other);
+                    return _mm256_or_si256(
+                        detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
+                                           { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2 {}); },
+                                           sign_mask, cmp_is_negative),
+                        _mm256_andnot_si256(sign_mask, res));
+                }
+                case 2:
+                    return _mm256_srai_epi16(self, other);
+                case 4:
+                    return _mm256_srai_epi32(self, other);
+                default:
+                    return bitwise_rshift(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 2:
+                    return _mm256_srli_epi16(self, other);
+                case 4:
+                    return _mm256_srli_epi32(self, other);
+                case 8:
+                    return _mm256_srli_epi64(self, other);
+                default:
+                    return bitwise_rshift(self, other, avx {});
+                }
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 4: return _mm256_srav_epi32(self, other);
-          default: return bitwise_rshift(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 4: return _mm256_srlv_epi32(self, other);
-          case 8: return _mm256_srlv_epi64(self, other);
-          default: return bitwise_rshift(self, other, avx{});
-        }
-      }
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm256_srav_epi32(self, other);
+                default:
+                    return bitwise_rshift(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm256_srlv_epi32(self, other);
+                case 8:
+                    return _mm256_srlv_epi64(self, other);
+                default:
+                    return bitwise_rshift(self, other, avx {});
+                }
+            }
+        }
 
-    // bitwise_xor
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_xor_si256(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) {
-      return _mm256_xor_si256(self, other);
-    }
+        // bitwise_xor
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_xor_si256(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            return _mm256_xor_si256(self, other);
+        }
 
-    // complex_low
-    template<class A> batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx2>) {
+        // complex_low
+        template <class A>
+        inline batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx2>) noexcept
+        {
             __m256d tmp0 = _mm256_permute4x64_pd(self.real(), _MM_SHUFFLE(3, 1, 1, 0));
             __m256d tmp1 = _mm256_permute4x64_pd(self.imag(), _MM_SHUFFLE(1, 2, 0, 0));
             return _mm256_blend_pd(tmp0, tmp1, 10);
-    }
+        }
 
-    // complex_high
-    template<class A> batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx2>) {
+        // complex_high
+        template <class A>
+        inline batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx2>) noexcept
+        {
             __m256d tmp0 = _mm256_permute4x64_pd(self.real(), _MM_SHUFFLE(3, 3, 1, 2));
             __m256d tmp1 = _mm256_permute4x64_pd(self.imag(), _MM_SHUFFLE(3, 2, 2, 0));
             return _mm256_blend_pd(tmp0, tmp1, 10);
-    }
+        }
+        // convert
+        namespace detail
+        {
+
+            template <class A>
+            inline batch<float, A> fast_cast(batch<uint32_t, A> const& v, batch<float, A> const&, requires_arch<avx2>) noexcept
+            {
+                // see https://stackoverflow.com/questions/34066228/how-to-perform-uint32-float-conversion-with-sse
+                __m256i msk_lo = _mm256_set1_epi32(0xFFFF);
+                __m256 cnst65536f = _mm256_set1_ps(65536.0f);
+
+                __m256i v_lo = _mm256_and_si256(v, msk_lo); /* extract the 16 lowest significant bits of self                             */
+                __m256i v_hi = _mm256_srli_epi32(v, 16); /* 16 most significant bits of v                                                 */
+                __m256 v_lo_flt = _mm256_cvtepi32_ps(v_lo); /* No rounding                                                                   */
+                __m256 v_hi_flt = _mm256_cvtepi32_ps(v_hi); /* No rounding                                                                   */
+                v_hi_flt = _mm256_mul_ps(cnst65536f, v_hi_flt); /* No rounding                                                                   */
+                return _mm256_add_ps(v_hi_flt, v_lo_flt); /* Rounding may occur here, mul and add may fuse to fma for haswell and newer    */
+            }
 
-    // eq
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_cmpeq_epi8(self, other);
-        case 2: return _mm256_cmpeq_epi16(self, other);
-        case 4: return _mm256_cmpeq_epi32(self, other);
-        case 8: return _mm256_cmpeq_epi64(self, other);
-        default: return eq(self, other, avx{});
-      }
-    }
+        }
 
-    // gt
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm256_cmpgt_epi8(self, other);
-          case 2: return _mm256_cmpgt_epi16(self, other);
-          case 4: return _mm256_cmpgt_epi32(self, other);
-          case 8: return _mm256_cmpgt_epi64(self, other);
-          default: return gt(self, other, avx{});
-        }
-      }
-      else {
-          return gt(self, other, avx{});
-      }
-    }
+        // eq
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_cmpeq_epi8(self, other);
+            case 2:
+                return _mm256_cmpeq_epi16(self, other);
+            case 4:
+                return _mm256_cmpeq_epi32(self, other);
+            case 8:
+                return _mm256_cmpeq_epi64(self, other);
+            default:
+                return eq(self, other, avx {});
+            }
+        }
 
-    // hadd
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd(batch<T, A> const& self, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 4:
-          {
+        // lt
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_cmpgt_epi8(other, self);
+                case 2:
+                    return _mm256_cmpgt_epi16(other, self);
+                case 4:
+                    return _mm256_cmpgt_epi32(other, self);
+                case 8:
+                    return _mm256_cmpgt_epi64(other, self);
+                default:
+                    return lt(self, other, avx {});
+                }
+            }
+            else
+            {
+                return lt(self, other, avx {});
+            }
+        }
+
+        // hadd
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline T hadd(batch<T, A> const& self, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 4:
+            {
                 __m256i tmp1 = _mm256_hadd_epi32(self, self);
                 __m256i tmp2 = _mm256_hadd_epi32(tmp1, tmp1);
                 __m128i tmp3 = _mm256_extracti128_si256(tmp2, 1);
                 __m128i tmp4 = _mm_add_epi32(_mm256_castsi256_si128(tmp2), tmp3);
                 return _mm_cvtsi128_si32(tmp4);
-          }
-        case 8:
-          {
+            }
+            case 8:
+            {
                 __m256i tmp1 = _mm256_shuffle_epi32(self, 0x0E);
                 __m256i tmp2 = _mm256_add_epi64(self, tmp1);
                 __m128i tmp3 = _mm256_extracti128_si256(tmp2, 1);
@@ -235,163 +337,237 @@ namespace xsimd {
                 std::memcpy(&i, &m, sizeof(i));
                 return i;
 #endif
-          }
-          default: return hadd(self, avx{});
-      }
-    }
-    // load_complex
-    template<class A> batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx2>) {
+            }
+            default:
+                return hadd(self, avx {});
+            }
+        }
+        // load_complex
+        template <class A>
+        inline batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx2>) noexcept
+        {
             using batch_type = batch<float, A>;
             batch_type real = _mm256_castpd_ps(
-                         _mm256_permute4x64_pd(
-                             _mm256_castps_pd(_mm256_shuffle_ps(hi, lo, _MM_SHUFFLE(2, 0, 2, 0))),
-                             _MM_SHUFFLE(3, 1, 2, 0)));
+                _mm256_permute4x64_pd(
+                    _mm256_castps_pd(_mm256_shuffle_ps(hi, lo, _MM_SHUFFLE(2, 0, 2, 0))),
+                    _MM_SHUFFLE(3, 1, 2, 0)));
             batch_type imag = _mm256_castpd_ps(
-                         _mm256_permute4x64_pd(
-                             _mm256_castps_pd(_mm256_shuffle_ps(hi, lo, _MM_SHUFFLE(3, 1, 3, 1))),
-                             _MM_SHUFFLE(3, 1, 2, 0)));
-            return {real, imag};
-    }
-    template<class A> batch<std::complex<double>, A> load_complex(batch<double,A> const& hi, batch<double,A> const& lo, requires_arch<avx2>) {
+                _mm256_permute4x64_pd(
+                    _mm256_castps_pd(_mm256_shuffle_ps(hi, lo, _MM_SHUFFLE(3, 1, 3, 1))),
+                    _MM_SHUFFLE(3, 1, 2, 0)));
+            return { real, imag };
+        }
+        template <class A>
+        inline batch<std::complex<double>, A> load_complex(batch<double, A> const& hi, batch<double, A> const& lo, requires_arch<avx2>) noexcept
+        {
             using batch_type = batch<double, A>;
             batch_type real = _mm256_permute4x64_pd(_mm256_unpacklo_pd(hi, lo), _MM_SHUFFLE(3, 1, 2, 0));
             batch_type imag = _mm256_permute4x64_pd(_mm256_unpackhi_pd(hi, lo), _MM_SHUFFLE(3, 1, 2, 0));
-            return {real, imag};
-    }
+            return { real, imag };
+        }
 
-    // max
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm256_max_epi8(self, other);
-          case 2: return _mm256_max_epi16(self, other);
-          case 4: return _mm256_max_epi32(self, other);
-          default: return max(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm256_max_epu8(self, other);
-          case 2: return _mm256_max_epu16(self, other);
-          case 4: return _mm256_max_epu32(self, other);
-          default: return max(self, other, avx{});
-        }
-      }
-    }
+        // max
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_max_epi8(self, other);
+                case 2:
+                    return _mm256_max_epi16(self, other);
+                case 4:
+                    return _mm256_max_epi32(self, other);
+                default:
+                    return max(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_max_epu8(self, other);
+                case 2:
+                    return _mm256_max_epu16(self, other);
+                case 4:
+                    return _mm256_max_epu32(self, other);
+                default:
+                    return max(self, other, avx {});
+                }
+            }
+        }
 
-    // min
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1:  return _mm256_min_epi8(self, other);
-          case 2:  return _mm256_min_epi16(self, other);
-          case 4:  return _mm256_min_epi32(self, other);
-          default: return min(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1:  return _mm256_min_epu8(self, other);
-          case 2:  return _mm256_min_epu16(self, other);
-          case 4:  return _mm256_min_epu32(self, other);
-          default: return min(self, other, avx{});
-        }
-      }
-    }
+        // min
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_min_epi8(self, other);
+                case 2:
+                    return _mm256_min_epi16(self, other);
+                case 4:
+                    return _mm256_min_epi32(self, other);
+                default:
+                    return min(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_min_epu8(self, other);
+                case 2:
+                    return _mm256_min_epu16(self, other);
+                case 4:
+                    return _mm256_min_epu32(self, other);
+                default:
+                    return min(self, other, avx {});
+                }
+            }
+        }
 
-    // mul
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 2: return _mm256_mullo_epi16(self, other);
-        case 4: return _mm256_mullo_epi32(self, other);
-        default: return mul(self, other, avx{});
-      }
-    }
+        // mul
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 2:
+                return _mm256_mullo_epi16(self, other);
+            case 4:
+                return _mm256_mullo_epi32(self, other);
+            default:
+                return mul(self, other, avx {});
+            }
+        }
 
-    // sadd
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm256_adds_epi8(self, other);
-          case 2: return _mm256_adds_epi16(self, other);
-          default: return sadd(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm256_adds_epu8(self, other);
-          case 2: return _mm256_adds_epu16(self, other);
-          default: return sadd(self, other, avx{});
-        }
-      }
-    }
+        // sadd
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_adds_epi8(self, other);
+                case 2:
+                    return _mm256_adds_epi16(self, other);
+                default:
+                    return sadd(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_adds_epu8(self, other);
+                case 2:
+                    return _mm256_adds_epu16(self, other);
+                default:
+                    return sadd(self, other, avx {});
+                }
+            }
+        }
 
-    // select
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_blendv_epi8(false_br, true_br, cond);
-        case 2: return _mm256_blendv_epi8(false_br, true_br, cond);
-        case 4: return _mm256_blendv_epi8(false_br, true_br, cond);
-        case 8: return _mm256_blendv_epi8(false_br, true_br, cond);
-        default: return select(cond, true_br, false_br, avx{});
-      }
-    }
-    template<class A, class T, bool... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) {
-      constexpr int mask = batch_bool_constant<batch<T, A>, Values...>::mask();
-      switch(sizeof(T)) {
-        // FIXME: for some reason mask here is not considered as an immediate,
-        // but it's okay for _mm256_blend_epi32
-        //case 2: return _mm256_blend_epi16(false_br, true_br, mask);
-        case 4: return _mm256_blend_epi32(false_br, true_br, mask);
-        case 8: {
-          constexpr int imask = detail::interleave(mask);
-          return _mm256_blend_epi32(false_br, true_br, imask);
-        }
-        default: return select(batch_bool<T, A>{Values...}, true_br, false_br, avx2{});
-      }
-    }
+        // select
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_blendv_epi8(false_br, true_br, cond);
+            case 2:
+                return _mm256_blendv_epi8(false_br, true_br, cond);
+            case 4:
+                return _mm256_blendv_epi8(false_br, true_br, cond);
+            case 8:
+                return _mm256_blendv_epi8(false_br, true_br, cond);
+            default:
+                return select(cond, true_br, false_br, avx {});
+            }
+        }
+        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) noexcept
+        {
+            constexpr int mask = batch_bool_constant<batch<T, A>, Values...>::mask();
+            switch (sizeof(T))
+            {
+            // FIXME: for some reason mask here is not considered as an immediate,
+            // but it's okay for _mm256_blend_epi32
+            // case 2: return _mm256_blend_epi16(false_br, true_br, mask);
+            case 4:
+                return _mm256_blend_epi32(false_br, true_br, mask);
+            case 8:
+            {
+                constexpr int imask = detail::interleave(mask);
+                return _mm256_blend_epi32(false_br, true_br, imask);
+            }
+            default:
+                return select(batch_bool<T, A> { Values... }, true_br, false_br, avx2 {});
+            }
+        }
 
-    // ssub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm256_subs_epi8(self, other);
-          case 2: return _mm256_subs_epi16(self, other);
-          default: return ssub(self, other, avx{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm256_subs_epu8(self, other);
-          case 2: return _mm256_subs_epu16(self, other);
-          default: return ssub(self, other, avx{});
-        }
-      }
-    }
+        // ssub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_subs_epi8(self, other);
+                case 2:
+                    return _mm256_subs_epi16(self, other);
+                default:
+                    return ssub(self, other, avx {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm256_subs_epu8(self, other);
+                case 2:
+                    return _mm256_subs_epu16(self, other);
+                default:
+                    return ssub(self, other, avx {});
+                }
+            }
+        }
 
-    // sub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm256_sub_epi8(self, other);
-        case 2: return _mm256_sub_epi16(self, other);
-        case 4: return _mm256_sub_epi32(self, other);
-        case 8: return _mm256_sub_epi64(self, other);
-        default: return sub(self, other, avx{});
-      }
+        // sub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm256_sub_epi8(self, other);
+            case 2:
+                return _mm256_sub_epi16(self, other);
+            case 4:
+                return _mm256_sub_epi32(self, other);
+            case 8:
+                return _mm256_sub_epi64(self, other);
+            default:
+                return sub(self, other, avx {});
+            }
+        }
     }
 
-
-
-  }
-
 }
 
 #endif
diff --git a/third_party/xsimd/arch/xsimd_avx512bw.hpp b/third_party/xsimd/arch/xsimd_avx512bw.hpp
index e33b42666..478b5de71 100644
--- a/third_party/xsimd/arch/xsimd_avx512bw.hpp
+++ b/third_party/xsimd/arch/xsimd_avx512bw.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512BW_HPP
 #define XSIMD_AVX512BW_HPP
@@ -16,261 +16,363 @@
 
 #include "../types/xsimd_avx512bw_register.hpp"
 
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    namespace detail {
-    template<class A, class T,  int Cmp>
-    batch_bool<T, A> compare_int_avx512bw(batch<T, A> const& self, batch<T, A> const& other) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return (register_type)_mm512_cmp_epi8_mask(self, other, Cmp);
-          case 2: return (register_type)_mm512_cmp_epi16_mask(self, other, Cmp);
-          case 4: return (register_type)_mm512_cmp_epi32_mask(self, other, Cmp);
-          case 8: return (register_type)_mm512_cmp_epi64_mask(self, other, Cmp);
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return (register_type)_mm512_cmp_epu8_mask(self, other, Cmp);
-          case 2: return (register_type)_mm512_cmp_epu16_mask(self, other, Cmp);
-          case 4: return (register_type)_mm512_cmp_epu32_mask(self, other, Cmp);
-          case 8: return (register_type)_mm512_cmp_epu64_mask(self, other, Cmp);
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+
+        namespace detail
+        {
+            template <class A, class T, int Cmp>
+            inline batch_bool<T, A> compare_int_avx512bw(batch<T, A> const& self, batch<T, A> const& other) noexcept
+            {
+                using register_type = typename batch_bool<T, A>::register_type;
+                if (std::is_signed<T>::value)
+                {
+                    switch (sizeof(T))
+                    {
+                    case 1:
+                        return (register_type)_mm512_cmp_epi8_mask(self, other, Cmp);
+                    case 2:
+                        return (register_type)_mm512_cmp_epi16_mask(self, other, Cmp);
+                    case 4:
+                        return (register_type)_mm512_cmp_epi32_mask(self, other, Cmp);
+                    case 8:
+                        return (register_type)_mm512_cmp_epi64_mask(self, other, Cmp);
+                    }
+                }
+                else
+                {
+                    switch (sizeof(T))
+                    {
+                    case 1:
+                        return (register_type)_mm512_cmp_epu8_mask(self, other, Cmp);
+                    case 2:
+                        return (register_type)_mm512_cmp_epu16_mask(self, other, Cmp);
+                    case 4:
+                        return (register_type)_mm512_cmp_epu32_mask(self, other, Cmp);
+                    case 8:
+                        return (register_type)_mm512_cmp_epu64_mask(self, other, Cmp);
+                    }
+                }
+            }
         }
-      }
-    }
-    }
-
-    // abs
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512bw>) {
-      if(std::is_unsigned<T>::value)
-        return self;
 
-      switch(sizeof(T)) {
-        case 1: return _mm512_abs_epi8(self);
-        case 2: return _mm512_abs_epi16(self);
-        default: return abs(self, avx512dq{});
-      }
-    }
+        // abs
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_unsigned<T>::value)
+                return self;
+
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_abs_epi8(self);
+            case 2:
+                return _mm512_abs_epi16(self);
+            default:
+                return abs(self, avx512dq {});
+            }
+        }
 
-    // add
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_add_epi8(self, other);
-        case 2: return _mm512_add_epi16(self, other);
-        default: return add(self, other, avx512dq{});
-      }
-    }
+        // add
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_add_epi8(self, other);
+            case 2:
+                return _mm512_add_epi16(self, other);
+            default:
+                return add(self, other, avx512dq {});
+            }
+        }
 
-    // bitwise_lshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) {
-      switch(sizeof(T)) {
+        // bitwise_lshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) noexcept
+        {
+            switch (sizeof(T))
+            {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-        case 2: return _mm512_sllv_epi16(self, _mm512_set1_epi16(other));
+            case 2:
+                return _mm512_sllv_epi16(self, _mm512_set1_epi16(other));
 #else
-        case 2: return _mm512_slli_epi16(self, other);
+            case 2:
+                return _mm512_slli_epi16(self, other);
 #endif
-        default: return bitwise_lshift(self, other, avx512dq{});
-      }
-    }
+            default:
+                return bitwise_lshift(self, other, avx512dq {});
+            }
+        }
 
-    // bitwise_rshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1:
-          {
-            __m512i sign_mask = _mm512_set1_epi16((0xFF00 >> other) & 0x00FF);
-            __m512i zeros = _mm512_setzero_si512();
-            __mmask64 cmp_is_negative_mask = _mm512_cmpgt_epi8_mask(zeros, self);
-            __m512i cmp_sign_mask = _mm512_mask_blend_epi8(cmp_is_negative_mask, zeros, sign_mask);
+        // bitwise_rshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                {
+                    __m512i sign_mask = _mm512_set1_epi16((0xFF00 >> other) & 0x00FF);
+                    __m512i zeros = _mm512_setzero_si512();
+                    __mmask64 cmp_is_negative_mask = _mm512_cmpgt_epi8_mask(zeros, self);
+                    __m512i cmp_sign_mask = _mm512_mask_blend_epi8(cmp_is_negative_mask, zeros, sign_mask);
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-            __m512i res = _mm512_srav_epi16(self, _mm512_set1_epi16(other));
+                    __m512i res = _mm512_srav_epi16(self, _mm512_set1_epi16(other));
 #else
-            __m512i res = _mm512_srai_epi16(self, other);
+                    __m512i res = _mm512_srai_epi16(self, other);
 #endif
-            return _mm512_or_si512(cmp_sign_mask, _mm512_andnot_si512(sign_mask, res));
-          }
+                    return _mm512_or_si512(cmp_sign_mask, _mm512_andnot_si512(sign_mask, res));
+                }
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-          case 2: return _mm512_srav_epi16(self, _mm512_set1_epi16(other));
+                case 2:
+                    return _mm512_srav_epi16(self, _mm512_set1_epi16(other));
 #else
-          case 2: return _mm512_srai_epi16(self, other);
+                case 2:
+                    return _mm512_srai_epi16(self, other);
 #endif
-          default: return bitwise_rshift(self, other, avx512dq{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
+                default:
+                    return bitwise_rshift(self, other, avx512dq {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-          case 2: return _mm512_srlv_epi16(self, _mm512_set1_epi16(other));
+                case 2:
+                    return _mm512_srlv_epi16(self, _mm512_set1_epi16(other));
 #else
-          case 2: return _mm512_srli_epi16(self, other);
+                case 2:
+                    return _mm512_srli_epi16(self, other);
 #endif
-          default: return bitwise_rshift(self, other, avx512dq{});
+                default:
+                    return bitwise_rshift(self, other, avx512dq {});
+                }
+            }
         }
-      }
-    }
 
-    // eq
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_EQ>(self, other);
-    }
-
-    // ge
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GE>(self, other);
-    }
-
-    // gt
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GT>(self, other);
-    }
-
-
-    // le
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LE>(self, other);
-    }
+        // eq
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_EQ>(self, other);
+        }
 
-    // lt
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LT>(self, other);
-    }
+        // ge
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GE>(self, other);
+        }
 
-    // max
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm512_max_epi8(self, other);
-          case 2: return _mm512_max_epi16(self, other);
-          default: return max(self, other, avx512dq{});
+        // gt
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GT>(self, other);
         }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm512_max_epu8(self, other);
-          case 2: return _mm512_max_epu16(self, other);
-          default: return max(self, other, avx512dq{});
+
+        // le
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LE>(self, other);
         }
-      }
-    }
 
-    // min
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm512_min_epi8(self, other);
-          case 2: return _mm512_min_epi16(self, other);
-          default: return min(self, other, avx512dq{});
+        // lt
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LT>(self, other);
         }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm512_min_epu8(self, other);
-          case 2: return _mm512_min_epu16(self, other);
-          default: return min(self, other, avx512dq{});
+
+        // max
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_max_epi8(self, other);
+                case 2:
+                    return _mm512_max_epi16(self, other);
+                default:
+                    return max(self, other, avx512dq {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_max_epu8(self, other);
+                case 2:
+                    return _mm512_max_epu16(self, other);
+                default:
+                    return max(self, other, avx512dq {});
+                }
+            }
         }
-      }
-    }
 
+        // min
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_min_epi8(self, other);
+                case 2:
+                    return _mm512_min_epi16(self, other);
+                default:
+                    return min(self, other, avx512dq {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_min_epu8(self, other);
+                case 2:
+                    return _mm512_min_epu16(self, other);
+                default:
+                    return min(self, other, avx512dq {});
+                }
+            }
+        }
 
-    // mul
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      switch(sizeof(T)) {
-        case 1: {
+        // mul
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+            {
                 __m512i upper = _mm512_and_si512(_mm512_mullo_epi16(self, other), _mm512_srli_epi16(_mm512_set1_epi16(-1), 8));
                 __m512i lower = _mm512_slli_epi16(_mm512_mullo_epi16(_mm512_srli_epi16(self, 8), _mm512_srli_epi16(other, 8)), 8);
                 return _mm512_or_si512(upper, lower);
+            }
+            case 2:
+                return _mm512_mullo_epi16(self, other);
+            default:
+                return mul(self, other, avx512dq {});
+            }
         }
-        case 2: return _mm512_mullo_epi16(self, other);
-        default: return mul(self, other, avx512dq{});
-      }
-    }
 
-
-    // neq
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      return detail::compare_int_avx512bw<A, T, _MM_CMPINT_NE>(self, other);
-    }
-
-    // sadd
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm512_adds_epi8(self, other);
-          case 2: return _mm512_adds_epi16(self, other);
-          default: return sadd(self, other, avx512dq{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm512_adds_epu8(self, other);
-          case 2: return _mm512_adds_epu16(self, other);
-          default: return sadd(self, other, avx512dq{});
+        // neq
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            return detail::compare_int_avx512bw<A, T, _MM_CMPINT_NE>(self, other);
         }
-      }
-    }
-
-    // select
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512bw>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_mask_blend_epi8(cond, false_br, true_br);
-        case 2: return _mm512_mask_blend_epi16(cond, false_br, true_br);
-        default: return select(cond, true_br, false_br, avx512dq{});
-      };
-    }
 
+        // sadd
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_adds_epi8(self, other);
+                case 2:
+                    return _mm512_adds_epi16(self, other);
+                default:
+                    return sadd(self, other, avx512dq {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_adds_epu8(self, other);
+                case 2:
+                    return _mm512_adds_epu16(self, other);
+                default:
+                    return sadd(self, other, avx512dq {});
+                }
+            }
+        }
 
-    // ssub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm512_subs_epi8(self, other);
-          case 2: return _mm512_subs_epi16(self, other);
-          default: return ssub(self, other, avx512dq{});
+        // select
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512bw>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_mask_blend_epi8(cond, false_br, true_br);
+            case 2:
+                return _mm512_mask_blend_epi16(cond, false_br, true_br);
+            default:
+                return select(cond, true_br, false_br, avx512dq {});
+            };
         }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm512_subs_epu8(self, other);
-          case 2: return _mm512_subs_epu16(self, other);
-          default: return ssub(self, other, avx512dq{});
+
+        // ssub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_subs_epi8(self, other);
+                case 2:
+                    return _mm512_subs_epi16(self, other);
+                default:
+                    return ssub(self, other, avx512dq {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm512_subs_epu8(self, other);
+                case 2:
+                    return _mm512_subs_epu16(self, other);
+                default:
+                    return ssub(self, other, avx512dq {});
+                }
+            }
         }
-      }
-    }
 
+        // sub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_sub_epi8(self, other);
+            case 2:
+                return _mm512_sub_epi16(self, other);
+            default:
+                return sub(self, other, avx512dq {});
+            }
+        }
 
-    // sub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_sub_epi8(self, other);
-        case 2: return _mm512_sub_epi16(self, other);
-          default: return sub(self, other, avx512dq{});
-      }
     }
 
-  }
-
 }
 
 #endif
diff --git a/third_party/xsimd/arch/xsimd_avx512cd.hpp b/third_party/xsimd/arch/xsimd_avx512cd.hpp
index b426adbb2..95f3f1df8 100644
--- a/third_party/xsimd/arch/xsimd_avx512cd.hpp
+++ b/third_party/xsimd/arch/xsimd_avx512cd.hpp
@@ -1,25 +1,27 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512CD_HPP
 #define XSIMD_AVX512CD_HPP
 
 #include "../types/xsimd_avx512cd_register.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
-  // Nothing there yet.
+    namespace kernel
+    {
+        // Nothing there yet.
 
-  }
+    }
 
 }
 
diff --git a/third_party/xsimd/arch/xsimd_avx512dq.hpp b/third_party/xsimd/arch/xsimd_avx512dq.hpp
index 00fe1f549..ecd4730d2 100644
--- a/third_party/xsimd/arch/xsimd_avx512dq.hpp
+++ b/third_party/xsimd/arch/xsimd_avx512dq.hpp
@@ -1,74 +1,96 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512_DQHPP
 #define XSIMD_AVX512_D_HPP
 
 #include "../types/xsimd_avx512dq_register.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
-    using namespace types;
+    namespace kernel
+    {
+        using namespace types;
 
-    // bitwise_and
-    template<class A> batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_and_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_and_pd(self, other);
-    }
+        // bitwise_and
+        template <class A>
+        inline batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_and_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_and_pd(self, other);
+        }
 
-    // bitwise_andnot
-    template<class A> batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_andnot_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_andnot_pd(self, other);
-    }
+        // bitwise_andnot
+        template <class A>
+        inline batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_andnot_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_andnot_pd(self, other);
+        }
 
-    // bitwise_or
-    template<class A> batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_or_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_or_pd(self, other);
-    }
+        // bitwise_or
+        template <class A>
+        inline batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_or_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_or_pd(self, other);
+        }
 
-    template<class A, class T> batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512dq>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data | other.data);
-    }
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data | other.data);
+        }
 
-    // bitwise_xor
-    template<class A> batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_xor_ps(self, other);
-    }
-    template<class A> batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) {
-      return _mm512_xor_pd(self, other);
-    }
+        // bitwise_xor
+        template <class A>
+        inline batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_xor_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_xor_pd(self, other);
+        }
 
-    // to_float
-    template<class A>
-    batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx512dq>) {
-      return _mm512_cvtepi64_pd(self);
-    }
+        // to_float
+        template <class A>
+        inline batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_cvtepi64_pd(self);
+        }
 
-    // to_int
-    template<class A>
-    batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx512dq>) {
-      return _mm512_cvttpd_epi64(self);
-    }
+        // to_int
+        template <class A>
+        inline batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx512dq>) noexcept
+        {
+            return _mm512_cvttpd_epi64(self);
+        }
 
-  }
+    }
 
 }
 
diff --git a/third_party/xsimd/arch/xsimd_avx512f.hpp b/third_party/xsimd/arch/xsimd_avx512f.hpp
index 13cc0da71..29d5f0eeb 100644
--- a/third_party/xsimd/arch/xsimd_avx512f.hpp
+++ b/third_party/xsimd/arch/xsimd_avx512f.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512F_HPP
 #define XSIMD_AVX512F_HPP
@@ -18,1212 +18,1602 @@
 
 #include "../types/xsimd_avx512f_register.hpp"
 
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    namespace detail {
-      inline void split_avx512(__m512 val, __m256& low, __m256& high) {
-        low =_mm512_castps512_ps256(val);
-        high =_mm512_extractf32x8_ps(val, 1);
-      }
-      inline void split_avx512(__m512d val, __m256d& low, __m256d& high) {
-        low =_mm512_castpd512_pd256(val);
-        high =_mm512_extractf64x4_pd(val, 1);
-      }
-      inline void split_avx512(__m512i val, __m256i& low, __m256i& high) {
-        low =_mm512_castsi512_si256(val);
-        high =_mm512_extracti64x4_epi64(val, 1);
-      }
-      inline __m512i merge_avx(__m256i low, __m256i high) {
-        return _mm512_inserti64x4(_mm512_castsi256_si512(low), high, 1);
-      }
-      inline __m512 merge_avx(__m256 low, __m256 high) {
-        return _mm512_insertf32x8(_mm512_castps256_ps512(low), high, 1);
-      }
-      inline __m512d merge_avx(__m256d low, __m256d high) {
-        return _mm512_insertf64x4(_mm512_castpd256_pd512(low), high, 1);
-      }
-      template<class F>
-      __m512i fwd_to_avx(F f, __m512i self) {
-        __m256i self_low, self_high;
-        split_avx512(self, self_low, self_high);
-        __m256i res_low = f(self_low);
-        __m256i res_high = f(self_high);
-        return merge_avx(res_low, res_high);
-      }
-      template<class F>
-      __m512i fwd_to_avx(F f, __m512i self, __m512i other) {
-        __m256i self_low, self_high, other_low, other_high;
-        split_avx512(self, self_low, self_high);
-        split_avx512(other, other_low, other_high);
-        __m256i res_low = f(self_low, other_low);
-        __m256i res_high = f(self_high, other_high);
-        return merge_avx(res_low, res_high);
-      }
-      template<class F>
-      __m512i fwd_to_avx(F f, __m512i self, int32_t other) {
-        __m256i self_low, self_high;
-        split_avx512(self, self_low, self_high);
-        __m256i res_low = f(self_low, other);
-        __m256i res_high = f(self_high, other);
-        return merge_avx(res_low, res_high);
-      }
-    }
-    namespace detail {
-
-    inline uint32_t morton(uint16_t x, uint16_t y) {
-
-      static const unsigned short MortonTable256[256] = 
-      {
-        0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015, 
-        0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055, 
-        0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115, 
-        0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155, 
-        0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415, 
-        0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455, 
-        0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515, 
-        0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555, 
-        0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015, 
-        0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055, 
-        0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115, 
-        0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155, 
-        0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415, 
-        0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455, 
-        0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515, 
-        0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555, 
-        0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015, 
-        0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055, 
-        0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115, 
-        0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155, 
-        0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415, 
-        0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455, 
-        0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515, 
-        0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555, 
-        0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015, 
-        0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055, 
-        0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115, 
-        0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155, 
-        0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415, 
-        0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455, 
-        0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515, 
-        0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555
-      };
-
-      uint32_t z = MortonTable256[y >> 8]   << 17 |
-          MortonTable256[x >> 8]   << 16 |
-          MortonTable256[y & 0xFF] <<  1 |
-          MortonTable256[x & 0xFF];
-      return z;
-    }
+namespace xsimd
+{
 
-    template<class A, class T,  int Cmp>
-    batch_bool<T, A> compare_int_avx512f(batch<T, A> const& self, batch<T, A> const& other) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: {
-            // shifting to take sign into account
-            uint64_t mask_low0 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x000000FF)) << 24,
-                                                         (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x000000FF)) << 24,
-                                                         Cmp);
-            uint64_t mask_low1 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x0000FF00)) << 16,
-                                                         (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x0000FF00)) << 16,
-                                                         Cmp);
-            uint64_t mask_high0 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x00FF0000)) << 8,
-                                                          (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x00FF0000)) << 8,
-                                                          Cmp);
-            uint64_t mask_high1 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0xFF000000)),
-                                                          (batch<int32_t, A>(other.data) & batch<int32_t, A>(0xFF000000)),
-                                                          Cmp);
-            uint64_t mask = 0;
-            for(unsigned i = 0; i < 16; ++i) {
-              mask |= (mask_low0 & (uint64_t(1) << i)) << (3 * i + 0);
-              mask |= (mask_low1 & (uint64_t(1) << i)) << (3 * i + 1);
-              mask |= (mask_high0 & (uint64_t(1) << i)) << (3 * i + 2);
-              mask |= (mask_high1 & (uint64_t(1) << i)) << (3 * i + 3);
+    namespace kernel
+    {
+        using namespace types;
+
+        namespace detail
+        {
+            inline void split_avx512(__m512 val, __m256& low, __m256& high) noexcept
+            {
+                low = _mm512_castps512_ps256(val);
+                high = _mm512_extractf32x8_ps(val, 1);
             }
-            return (register_type)mask;
-          }
-          case 2: {
-            // shifting to take sign into account
-            uint16_t mask_low = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x0000FFFF)) << 16,
-                                                          (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x0000FFFF)) << 16,
-                                                          Cmp);
-            uint16_t mask_high = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0xFFFF0000)),
-                                                          (batch<int32_t, A>(other.data) & batch<int32_t, A>(0xFFFF0000)),
-                                                          Cmp);
-            return static_cast<register_type>(morton(mask_low, mask_high));
-          }
-          case 4: return (register_type)_mm512_cmp_epi32_mask(self, other, Cmp);
-          case 8: return (register_type)_mm512_cmp_epi64_mask(self, other, Cmp);
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: {
-            uint64_t mask_low0 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x000000FF)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0x000000FF)), Cmp);
-            uint64_t mask_low1 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x0000FF00)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0x0000FF00)), Cmp);
-            uint64_t mask_high0 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x00FF0000)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0x00FF0000)), Cmp);
-            uint64_t mask_high1 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0xFF000000)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0xFF000000)), Cmp);
-            uint64_t mask = 0;
-            for(unsigned i = 0; i < 16; ++i) {
-              mask |= (mask_low0 & (uint64_t(1) << i)) << (3 * i + 0);
-              mask |= (mask_low1 & (uint64_t(1) << i)) << (3 * i + 1);
-              mask |= (mask_high0 & (uint64_t(1) << i)) << (3 * i + 2);
-              mask |= (mask_high1 & (uint64_t(1) << i)) << (3 * i + 3);
+            inline void split_avx512(__m512d val, __m256d& low, __m256d& high) noexcept
+            {
+                low = _mm512_castpd512_pd256(val);
+                high = _mm512_extractf64x4_pd(val, 1);
+            }
+            inline void split_avx512(__m512i val, __m256i& low, __m256i& high) noexcept
+            {
+                low = _mm512_castsi512_si256(val);
+                high = _mm512_extracti64x4_epi64(val, 1);
+            }
+            inline __m512i merge_avx(__m256i low, __m256i high) noexcept
+            {
+                return _mm512_inserti64x4(_mm512_castsi256_si512(low), high, 1);
+            }
+            inline __m512 merge_avx(__m256 low, __m256 high) noexcept
+            {
+                return _mm512_insertf32x8(_mm512_castps256_ps512(low), high, 1);
+            }
+            inline __m512d merge_avx(__m256d low, __m256d high) noexcept
+            {
+                return _mm512_insertf64x4(_mm512_castpd256_pd512(low), high, 1);
+            }
+            template <class F>
+            __m512i fwd_to_avx(F f, __m512i self)
+            {
+                __m256i self_low, self_high;
+                split_avx512(self, self_low, self_high);
+                __m256i res_low = f(self_low);
+                __m256i res_high = f(self_high);
+                return merge_avx(res_low, res_high);
+            }
+            template <class F>
+            __m512i fwd_to_avx(F f, __m512i self, __m512i other)
+            {
+                __m256i self_low, self_high, other_low, other_high;
+                split_avx512(self, self_low, self_high);
+                split_avx512(other, other_low, other_high);
+                __m256i res_low = f(self_low, other_low);
+                __m256i res_high = f(self_high, other_high);
+                return merge_avx(res_low, res_high);
+            }
+            template <class F>
+            __m512i fwd_to_avx(F f, __m512i self, int32_t other)
+            {
+                __m256i self_low, self_high;
+                split_avx512(self, self_low, self_high);
+                __m256i res_low = f(self_low, other);
+                __m256i res_high = f(self_high, other);
+                return merge_avx(res_low, res_high);
+            }
+        }
+        namespace detail
+        {
+
+            inline uint32_t morton(uint16_t x, uint16_t y) noexcept
+            {
+
+                static const unsigned short MortonTable256[256] = {
+                    0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015,
+                    0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055,
+                    0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115,
+                    0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155,
+                    0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415,
+                    0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455,
+                    0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515,
+                    0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555,
+                    0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015,
+                    0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055,
+                    0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115,
+                    0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155,
+                    0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415,
+                    0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455,
+                    0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515,
+                    0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555,
+                    0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015,
+                    0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055,
+                    0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115,
+                    0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155,
+                    0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415,
+                    0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455,
+                    0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515,
+                    0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555,
+                    0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015,
+                    0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055,
+                    0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115,
+                    0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155,
+                    0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415,
+                    0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455,
+                    0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515,
+                    0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555
+                };
+
+                uint32_t z = MortonTable256[y >> 8] << 17 | MortonTable256[x >> 8] << 16 | MortonTable256[y & 0xFF] << 1 | MortonTable256[x & 0xFF];
+                return z;
             }
-            return (register_type)mask;
-          }
-          case 2: {
-            uint16_t mask_low = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x0000FFFF)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0x0000FFFF)), Cmp);
-            uint16_t mask_high = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0xFFFF0000)), (batch<uint32_t, A>(other.data)  & batch<uint32_t, A>(0xFFFF0000)), Cmp);
-            return static_cast<register_type>(morton(mask_low, mask_high));
-          }
-          case 4: return (register_type)_mm512_cmp_epu32_mask(self, other, Cmp);
-          case 8: return (register_type)_mm512_cmp_epu64_mask(self, other, Cmp);
-        }
-      }
-    }
-    }
 
-    // abs
-    template<class A> batch<float, A> abs(batch<float, A> const& self, requires_arch<avx512f>) {
-      __m512 self_asf = (__m512)self;
-      __m512i self_asi = *reinterpret_cast<__m512i *>(&self_asf);
-      __m512i res_asi = _mm512_and_epi32(_mm512_set1_epi32(0x7FFFFFFF), self_asi);
-      return *reinterpret_cast<__m512*>(&res_asi);
-    }
-    template<class A> batch<double, A> abs(batch<double, A> const& self, requires_arch<avx512f>) {
-                __m512d self_asd = (__m512d)self;
-                __m512i self_asi = *reinterpret_cast<__m512i*>(&self_asd);
-                __m512i res_asi = _mm512_and_epi64(_mm512_set1_epi64(0x7FFFFFFFFFFFFFFF),
-                                                   self_asi);
-                return *reinterpret_cast<__m512d*>(&res_asi);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512f>) {
-      if(std::is_unsigned<T>::value)
-        return self;
-
-      switch(sizeof(T)) {
-        case 1: return detail::fwd_to_avx([](__m256i s) { return abs(batch<T, avx2>(s)); }, self);
-        case 2: return detail::fwd_to_avx([](__m256i s) { return abs(batch<T, avx2>(s)); }, self);
-        case 4: return _mm512_abs_epi32(self);
-        case 8: return _mm512_abs_epi64(self);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+            template <class A, class T, int Cmp>
+            inline batch_bool<T, A> compare_int_avx512f(batch<T, A> const& self, batch<T, A> const& other) noexcept
+            {
+                using register_type = typename batch_bool<T, A>::register_type;
+                if (std::is_signed<T>::value)
+                {
+                    switch (sizeof(T))
+                    {
+                    case 1:
+                    {
+                        // shifting to take sign into account
+                        uint64_t mask_low0 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x000000FF)) << 24,
+                                                                   (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x000000FF)) << 24,
+                                                                   Cmp);
+                        uint64_t mask_low1 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x0000FF00)) << 16,
+                                                                   (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x0000FF00)) << 16,
+                                                                   Cmp);
+                        uint64_t mask_high0 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x00FF0000)) << 8,
+                                                                    (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x00FF0000)) << 8,
+                                                                    Cmp);
+                        uint64_t mask_high1 = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0xFF000000)),
+                                                                    (batch<int32_t, A>(other.data) & batch<int32_t, A>(0xFF000000)),
+                                                                    Cmp);
+                        uint64_t mask = 0;
+                        for (unsigned i = 0; i < 16; ++i)
+                        {
+                            mask |= (mask_low0 & (uint64_t(1) << i)) << (3 * i + 0);
+                            mask |= (mask_low1 & (uint64_t(1) << i)) << (3 * i + 1);
+                            mask |= (mask_high0 & (uint64_t(1) << i)) << (3 * i + 2);
+                            mask |= (mask_high1 & (uint64_t(1) << i)) << (3 * i + 3);
+                        }
+                        return (register_type)mask;
+                    }
+                    case 2:
+                    {
+                        // shifting to take sign into account
+                        uint16_t mask_low = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0x0000FFFF)) << 16,
+                                                                  (batch<int32_t, A>(other.data) & batch<int32_t, A>(0x0000FFFF)) << 16,
+                                                                  Cmp);
+                        uint16_t mask_high = _mm512_cmp_epi32_mask((batch<int32_t, A>(self.data) & batch<int32_t, A>(0xFFFF0000)),
+                                                                   (batch<int32_t, A>(other.data) & batch<int32_t, A>(0xFFFF0000)),
+                                                                   Cmp);
+                        return static_cast<register_type>(morton(mask_low, mask_high));
+                    }
+                    case 4:
+                        return (register_type)_mm512_cmp_epi32_mask(self, other, Cmp);
+                    case 8:
+                        return (register_type)_mm512_cmp_epi64_mask(self, other, Cmp);
+                    }
+                }
+                else
+                {
+                    switch (sizeof(T))
+                    {
+                    case 1:
+                    {
+                        uint64_t mask_low0 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x000000FF)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0x000000FF)), Cmp);
+                        uint64_t mask_low1 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x0000FF00)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0x0000FF00)), Cmp);
+                        uint64_t mask_high0 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x00FF0000)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0x00FF0000)), Cmp);
+                        uint64_t mask_high1 = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0xFF000000)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0xFF000000)), Cmp);
+                        uint64_t mask = 0;
+                        for (unsigned i = 0; i < 16; ++i)
+                        {
+                            mask |= (mask_low0 & (uint64_t(1) << i)) << (3 * i + 0);
+                            mask |= (mask_low1 & (uint64_t(1) << i)) << (3 * i + 1);
+                            mask |= (mask_high0 & (uint64_t(1) << i)) << (3 * i + 2);
+                            mask |= (mask_high1 & (uint64_t(1) << i)) << (3 * i + 3);
+                        }
+                        return (register_type)mask;
+                    }
+                    case 2:
+                    {
+                        uint16_t mask_low = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0x0000FFFF)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0x0000FFFF)), Cmp);
+                        uint16_t mask_high = _mm512_cmp_epu32_mask((batch<uint32_t, A>(self.data) & batch<uint32_t, A>(0xFFFF0000)), (batch<uint32_t, A>(other.data) & batch<uint32_t, A>(0xFFFF0000)), Cmp);
+                        return static_cast<register_type>(morton(mask_low, mask_high));
+                    }
+                    case 4:
+                        return (register_type)_mm512_cmp_epu32_mask(self, other, Cmp);
+                    case 8:
+                        return (register_type)_mm512_cmp_epu64_mask(self, other, Cmp);
+                    }
+                }
+            }
+        }
 
-    // add
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: return detail::fwd_to_avx([](__m256i s, __m256i o) { return add(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        case 2: return detail::fwd_to_avx([](__m256i s, __m256i o) { return add(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        case 4: return _mm512_add_epi32(self, other);
-        case 8: return _mm512_add_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_add_ps(self, other);
-    }
-    template<class A> batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_add_pd(self, other);
-    }
+        // abs
+        template <class A>
+        inline batch<float, A> abs(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            __m512 self_asf = (__m512)self;
+            __m512i self_asi = *reinterpret_cast<__m512i*>(&self_asf);
+            __m512i res_asi = _mm512_and_epi32(_mm512_set1_epi32(0x7FFFFFFF), self_asi);
+            return *reinterpret_cast<__m512*>(&res_asi);
+        }
+        template <class A>
+        inline batch<double, A> abs(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            __m512d self_asd = (__m512d)self;
+            __m512i self_asi = *reinterpret_cast<__m512i*>(&self_asd);
+            __m512i res_asi = _mm512_and_epi64(_mm512_set1_epi64(0x7FFFFFFFFFFFFFFF),
+                                               self_asi);
+            return *reinterpret_cast<__m512d*>(&res_asi);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_unsigned<T>::value)
+                return self;
+
+            switch (sizeof(T))
+            {
+            case 1:
+                return detail::fwd_to_avx([](__m256i s) noexcept
+                                          { return abs(batch<T, avx2>(s)); },
+                                          self);
+            case 2:
+                return detail::fwd_to_avx([](__m256i s) noexcept
+                                          { return abs(batch<T, avx2>(s)); },
+                                          self);
+            case 4:
+                return _mm512_abs_epi32(self);
+            case 8:
+                return _mm512_abs_epi64(self);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    // all
-    template<class A, class T>
-    bool all(batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return self.data == register_type(-1);
-    }
+        // add
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                          { return add(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                          self, other);
+            case 2:
+                return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                          { return add(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                          self, other);
+            case 4:
+                return _mm512_add_epi32(self, other);
+            case 8:
+                return _mm512_add_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_add_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_add_pd(self, other);
+        }
 
-    // any
-    template<class A, class T>
-    bool any(batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return self.data != register_type(0);
-    }
+        // all
+        template <class A, class T>
+        inline bool all(batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return self.data == register_type(-1);
+        }
 
-    // bitwise_and
-    template<class A> batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_ps(_mm512_and_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
-    }
-    template<class A> batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
-    }
+        // any
+        template <class A, class T>
+        inline bool any(batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return self.data != register_type(0);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return _mm512_and_si512(self, other);
-    }
+        // bitwise_and
+        template <class A>
+        inline batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_ps(_mm512_and_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
+        }
 
-    template<class A, class T>
-    batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data & other.data);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_and_si512(self, other);
+        }
 
-    // bitwise_andnot
-    template<class A> batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_ps(_mm512_andnot_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
-    }
-    template<class A> batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_pd(_mm512_andnot_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
-    }
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data & other.data);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return _mm512_andnot_si512(self, other);
-    }
+        // bitwise_andnot
+        template <class A>
+        inline batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_ps(_mm512_andnot_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_pd(_mm512_andnot_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
+        }
 
-    template<class A, class T>
-    batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data & ~other.data);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_andnot_si512(self, other);
+        }
+
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data & ~other.data);
+        }
 
-    // bitwise_lshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: {
+        // bitwise_lshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+            {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-          __m512i tmp = _mm512_sllv_epi32(self, _mm512_set1_epi32(other));
+                __m512i tmp = _mm512_sllv_epi32(self, _mm512_set1_epi32(other));
 #else
-          __m512i tmp = _mm512_slli_epi32(self, other);
+                __m512i tmp = _mm512_slli_epi32(self, other);
 #endif
-          return _mm512_and_si512(_mm512_set1_epi8(0xFF << other), tmp);
-        }
-        case 2: return detail::fwd_to_avx([](__m256i s, int32_t o) { return bitwise_lshift(batch<T, avx2>(s), o, avx2{}); }, self, other);
+                return _mm512_and_si512(_mm512_set1_epi8(0xFF << other), tmp);
+            }
+            case 2:
+                return detail::fwd_to_avx([](__m256i s, int32_t o) noexcept
+                                          { return bitwise_lshift(batch<T, avx2>(s), o, avx2 {}); },
+                                          self, other);
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-        case 4: return _mm512_sllv_epi32(self, _mm512_set1_epi32(other));
-        case 8: return _mm512_sllv_epi64(self, _mm512_set1_epi64(other));
+            case 4:
+                return _mm512_sllv_epi32(self, _mm512_set1_epi32(other));
+            case 8:
+                return _mm512_sllv_epi64(self, _mm512_set1_epi64(other));
 #else
-        case 4: return _mm512_slli_epi32(self, other);
-        case 8: return _mm512_slli_epi64(self, other);
+            case 4:
+                return _mm512_slli_epi32(self, other);
+            case 8:
+                return _mm512_slli_epi64(self, other);
 #endif
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    // bitwise_not
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx512f>) {
-      return _mm512_xor_si512(self, _mm512_set1_epi32(-1));
-    }
-    template<class A, class T>
-    batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(~self.data);
-    }
+        // bitwise_not
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_xor_si512(self, _mm512_set1_epi32(-1));
+        }
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(~self.data);
+        }
 
-    template<class A> batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_xor_ps(self, _mm512_castsi512_ps(_mm512_set1_epi32(-1)));
-    }
-    template <class A>
-    batch<double, A> bitwise_not(batch<double, A> const &self, requires_arch<avx512f>) {
-      return _mm512_xor_pd(self, _mm512_castsi512_pd(_mm512_set1_epi32(-1)));
-    }
+        template <class A>
+        inline batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_xor_ps(self, _mm512_castsi512_ps(_mm512_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_not(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_xor_pd(self, _mm512_castsi512_pd(_mm512_set1_epi32(-1)));
+        }
 
-    // bitwise_or
-    template<class A> batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_ps(_mm512_or_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
-    }
-    template<class A> batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_pd(_mm512_or_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
-    }
+        // bitwise_or
+        template <class A>
+        inline batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_ps(_mm512_or_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_pd(_mm512_or_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
+        }
 
-    template<class A, class T> batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data | other.data);
-    }
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data | other.data);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return _mm512_or_si512(self, other);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_or_si512(self, other);
+        }
 
-    // bitwise_rshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
+        // bitwise_rshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-          case 4: return _mm512_srav_epi32(self, _mm512_set1_epi32(other));
-          case 8: return _mm512_srav_epi64(self, _mm512_set1_epi64(other));
+                case 4:
+                    return _mm512_srav_epi32(self, _mm512_set1_epi32(other));
+                case 8:
+                    return _mm512_srav_epi64(self, _mm512_set1_epi64(other));
 #else
-          case 4: return _mm512_srai_epi32(self, other);
-          case 8: return _mm512_srai_epi64(self, other);
+                case 4:
+                    return _mm512_srai_epi32(self, other);
+                case 8:
+                    return _mm512_srai_epi64(self, other);
 #endif
-          default: return detail::fwd_to_avx([](__m256i s, int32_t o) { return bitwise_rshift(batch<T, avx2>(s), o, avx2{}); }, self, other);
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1:
-          {
+                default:
+                    return detail::fwd_to_avx([](__m256i s, int32_t o) noexcept
+                                              { return bitwise_rshift(batch<T, avx2>(s), o, avx2 {}); },
+                                              self, other);
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-            __m512i tmp = _mm512_srlv_epi32(self, _mm512_set1_epi32(other));
+                    __m512i tmp = _mm512_srlv_epi32(self, _mm512_set1_epi32(other));
 #else
-            __m512i tmp = _mm512_srli_epi32(self, other);
+                    __m512i tmp = _mm512_srli_epi32(self, other);
 #endif
-            return _mm512_and_si512(_mm512_set1_epi8(0xFF >> other), tmp);
-          }
+                    return _mm512_and_si512(_mm512_set1_epi8(0xFF >> other), tmp);
+                }
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
-          case 4: return _mm512_srlv_epi32(self, _mm512_set1_epi32(other));
-          case 8: return _mm512_srlv_epi64(self, _mm512_set1_epi64(other));
+                case 4:
+                    return _mm512_srlv_epi32(self, _mm512_set1_epi32(other));
+                case 8:
+                    return _mm512_srlv_epi64(self, _mm512_set1_epi64(other));
 #else
-          case 4: return _mm512_srli_epi32(self, other);
-          case 8: return _mm512_srli_epi64(self, other);
+                case 4:
+                    return _mm512_srli_epi32(self, other);
+                case 8:
+                    return _mm512_srli_epi64(self, other);
 #endif
-          default: return detail::fwd_to_avx([](__m256i s, int32_t o) { return bitwise_rshift(batch<T, avx2>(s), o, avx2{}); }, self, other);
+                default:
+                    return detail::fwd_to_avx([](__m256i s, int32_t o) noexcept
+                                              { return bitwise_rshift(batch<T, avx2>(s), o, avx2 {}); },
+                                              self, other);
+                }
+            }
         }
-      }
-    }
-
-    // bitwise_xor
-    template<class A> batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_ps(_mm512_xor_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
-    }
-    template<class A> batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
-    }
 
-    template<class A, class T> batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data | other.data);
-    }
-
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return _mm512_xor_si512(self, other);
-    }
+        // bitwise_xor
+        template <class A>
+        inline batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_ps(_mm512_xor_si512(_mm512_castps_si512(self), _mm512_castps_si512(other)));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
+        }
 
-    // bitwise_cast
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const &, requires_arch<avx512f>) {
-      return _mm512_castsi512_ps(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const &, requires_arch<avx512f>) {
-      return _mm512_castsi512_pd(self);
-    }
-    template<class A, class T, class Tp, class=typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
-    batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const &, requires_arch<avx512f>) {
-      return batch<Tp, A>(self.data);
-    }
-    template<class A>
-    batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const &, requires_arch<avx512f>) {
-      return _mm512_castps_pd(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const &, requires_arch<avx512f>) {
-      return _mm512_castps_si512(self);
-    }
-    template<class A>
-    batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const &, requires_arch<avx512f>) {
-      return _mm512_castpd_ps(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const &, requires_arch<avx512f>) {
-      return _mm512_castpd_si512(self);
-    }
+        template <class A, class T>
+        inline batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data | other.data);
+        }
 
-    // bool_cast
-    template<class A> batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self, requires_arch<avx512f>) {
-        return self.data;
-    }
-    template<class A> batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self, requires_arch<avx512f>) {
-        return self.data;
-    }
-    template<class A> batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self, requires_arch<avx512f>) {
-        return self.data;
-    }
-    template<class A> batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self, requires_arch<avx512f>) {
-        return self.data;
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_xor_si512(self, other);
+        }
 
+        // bitwise_cast
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_ps(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castsi512_pd(self);
+        }
+        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
+        inline batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return batch<Tp, A>(self.data);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castps_pd(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castps_si512(self);
+        }
+        template <class A>
+        inline batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castpd_ps(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_castpd_si512(self);
+        }
 
-    // broadcast
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> broadcast(T val, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_set1_epi8(val);
-        case 2: return _mm512_set1_epi16(val);
-        case 4: return _mm512_set1_epi32(val);
-        case 8: return _mm512_set1_epi64(val);
-        default: assert(false && "unsupported"); return {};
-      }
-    }
-    template<class A> batch<float, A> broadcast(float val, requires_arch<avx512f>) {
-      return _mm512_set1_ps(val);
-    }
-    template<class A> batch<double, A> broadcast(double val, requires_arch<avx512f>) {
-      return _mm512_set1_pd(val);
-    }
+        // bool_cast
+        template <class A>
+        inline batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return self.data;
+        }
+        template <class A>
+        inline batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return self.data;
+        }
+        template <class A>
+        inline batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return self.data;
+        }
+        template <class A>
+        inline batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return self.data;
+        }
 
-    // ceil
-    template<class A> batch<float, A> ceil(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_ps(self, _MM_FROUND_TO_POS_INF);
-    }
-    template<class A> batch<double, A> ceil(batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_pd(self, _MM_FROUND_TO_POS_INF);
-    }
+        // broadcast
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> broadcast(T val, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_set1_epi8(val);
+            case 2:
+                return _mm512_set1_epi16(val);
+            case 4:
+                return _mm512_set1_epi32(val);
+            case 8:
+                return _mm512_set1_epi64(val);
+            default:
+                assert(false && "unsupported");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> broadcast(float val, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_set1_ps(val);
+        }
+        template <class A>
+        batch<double, A> inline broadcast(double val, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_set1_pd(val);
+        }
 
+        // ceil
+        template <class A>
+        inline batch<float, A> ceil(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_ps(self, _MM_FROUND_TO_POS_INF);
+        }
+        template <class A>
+        inline batch<double, A> ceil(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_pd(self, _MM_FROUND_TO_POS_INF);
+        }
 
-    namespace detail
-    {
-    // complex_low
-    template<class A> batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<avx512f>) {
-        __m512i idx = _mm512_setr_epi32(0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
-        return _mm512_permutex2var_ps(self.real(), idx, self.imag());
-    }
-    template<class A> batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx512f>) {
-        __m512i idx = _mm512_setr_epi64(0, 8, 1, 9, 2, 10, 3, 11);
-        return _mm512_permutex2var_pd(self.real(), idx, self.imag());
-    }
+        // convert
+        namespace detail
+        {
+            template <class A>
+            inline batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<avx512f>) noexcept
+            {
+                return _mm512_cvtepi32_ps(self);
+            }
 
-    // complex_high
-    template<class A> batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<avx512f>) {
-        __m512i idx = _mm512_setr_epi32(8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
-        return _mm512_permutex2var_ps(self.real(), idx, self.imag());
-    }
-    template<class A> batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx512f>) {
-        __m512i idx = _mm512_setr_epi64(4, 12, 5, 13, 6, 14, 7, 15);
-        return _mm512_permutex2var_pd(self.real(), idx, self.imag());
-    }
-    }
+            template <class A>
+            inline batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<avx512f>) noexcept
+            {
+                return _mm512_cvttps_epi32(self);
+            }
 
-    // convert
-    namespace detail {
-    template<class A> batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<avx512f>) {
-      return _mm512_cvtepi32_ps(self);
-    }
-    template<class A> batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<avx512f>) {
-      return _mm512_cvttps_epi32(self);
-    }
-    }
+            template <class A>
+            inline batch<float, A> fast_cast(batch<uint32_t, A> const& self, batch<float, A> const&, requires_arch<avx512f>) noexcept
+            {
+                return _mm512_cvtepu32_ps(self);
+            }
 
-    // div
-    template<class A> batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_div_ps(self, other);
-    }
-    template<class A> batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_div_pd(self, other);
-    }
+            template <class A>
+            batch<uint32_t, A> fast_cast(batch<float, A> const& self, batch<uint32_t, A> const&, requires_arch<avx512f>)
+            {
+                return _mm512_cvttps_epu32(self);
+            }
+        }
 
+        namespace detail
+        {
+            // complex_low
+            template <class A>
+            inline batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<avx512f>) noexcept
+            {
+                __m512i idx = _mm512_setr_epi32(0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+                return _mm512_permutex2var_ps(self.real(), idx, self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<avx512f>) noexcept
+            {
+                __m512i idx = _mm512_setr_epi64(0, 8, 1, 9, 2, 10, 3, 11);
+                return _mm512_permutex2var_pd(self.real(), idx, self.imag());
+            }
 
-    // eq
-    template<class A> batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_EQ_OQ);
-    }
-    template<class A> batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_EQ_OQ);
-    }
+            // complex_high
+            template <class A>
+            inline batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<avx512f>) noexcept
+            {
+                __m512i idx = _mm512_setr_epi32(8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+                return _mm512_permutex2var_ps(self.real(), idx, self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<avx512f>) noexcept
+            {
+                __m512i idx = _mm512_setr_epi64(4, 12, 5, 13, 6, 14, 7, 15);
+                return _mm512_permutex2var_pd(self.real(), idx, self.imag());
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return detail::compare_int_avx512f<A, T, _MM_CMPINT_EQ>(self, other);
-    }
-    template<class A, class T>
-    batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(~self.data ^ other.data);
-    }
+        // div
+        template <class A>
+        inline batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_div_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_div_pd(self, other);
+        }
 
-    // floor
-    template<class A> batch<float, A> floor(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_ps(self, _MM_FROUND_TO_NEG_INF);
-    }
-    template<class A> batch<double, A> floor(batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_pd(self, _MM_FROUND_TO_NEG_INF);
-    }
+        // eq
+        template <class A>
+        inline batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_EQ_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_EQ_OQ);
+        }
 
-    // from bool
-    template<class A, class T>
-    batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      return select(self, batch<T, A>(1), batch<T, A>(0));
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return detail::compare_int_avx512f<A, T, _MM_CMPINT_EQ>(self, other);
+        }
+        template <class A, class T>
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(~self.data ^ other.data);
+        }
 
-    // ge
-    template<class A> batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_GE_OQ);
-    }
-    template<class A> batch_bool<double, A> ge(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_GE_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return detail::compare_int_avx512f<A, T, _MM_CMPINT_GE>(self, other);
-    }
+        // floor
+        template <class A>
+        inline batch<float, A> floor(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_ps(self, _MM_FROUND_TO_NEG_INF);
+        }
+        template <class A>
+        inline batch<double, A> floor(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_pd(self, _MM_FROUND_TO_NEG_INF);
+        }
 
-    // gt
-    template<class A> batch_bool<float, A> gt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_GT_OQ);
-    }
-    template<class A> batch_bool<double, A> gt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_GT_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return detail::compare_int_avx512f<A, T, _MM_CMPINT_GT>(self, other);
-    }
+        // from bool
+        template <class A, class T>
+        inline batch<T, A> from_bool(batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return select(self, batch<T, A>(1), batch<T, A>(0));
+        }
 
+        // ge
+        template <class A>
+        inline batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_GE_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> ge(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_GE_OQ);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return detail::compare_int_avx512f<A, T, _MM_CMPINT_GE>(self, other);
+        }
 
-    // hadd
-    template<class A> float hadd(batch<float, A> const& rhs, requires_arch<avx512f>) {
-                __m256 tmp1 = _mm512_extractf32x8_ps(rhs, 1);
-                __m256 tmp2 = _mm512_extractf32x8_ps(rhs, 0);
-                __m256 res1 = _mm256_add_ps(tmp1, tmp2);
-                return hadd(batch<float, avx2>(res1), avx2{});
+        // gt
+        template <class A>
+        inline batch_bool<float, A> gt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_GT_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> gt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_GT_OQ);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return detail::compare_int_avx512f<A, T, _MM_CMPINT_GT>(self, other);
+        }
 
-    }
-    template <class A>
-    double hadd(batch<double, A> const &rhs, requires_arch<avx512f>) {
-                __m256d tmp1 = _mm512_extractf64x4_pd(rhs, 1);
-                __m256d tmp2 = _mm512_extractf64x4_pd(rhs, 0);
-                __m256d res1 = _mm256_add_pd(tmp1, tmp2);
-                return hadd(batch<double, avx2>(res1), avx2{});
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd(batch<T, A> const& self, requires_arch<avx512f>) {
-      __m256i low, high;
-      detail::split_avx512(self, low, high);
-      batch<T, avx2> blow(low), bhigh(high);
-      return hadd(blow, avx2{}) + hadd(bhigh, avx2{});
-    }
+        // hadd
+        template <class A>
+        inline float hadd(batch<float, A> const& rhs, requires_arch<avx512f>) noexcept
+        {
+            __m256 tmp1 = _mm512_extractf32x8_ps(rhs, 1);
+            __m256 tmp2 = _mm512_extractf32x8_ps(rhs, 0);
+            __m256 res1 = _mm256_add_ps(tmp1, tmp2);
+            return hadd(batch<float, avx2>(res1), avx2 {});
+        }
+        template <class A>
+        inline double hadd(batch<double, A> const& rhs, requires_arch<avx512f>) noexcept
+        {
+            __m256d tmp1 = _mm512_extractf64x4_pd(rhs, 1);
+            __m256d tmp2 = _mm512_extractf64x4_pd(rhs, 0);
+            __m256d res1 = _mm256_add_pd(tmp1, tmp2);
+            return hadd(batch<double, avx2>(res1), avx2 {});
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline T hadd(batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            __m256i low, high;
+            detail::split_avx512(self, low, high);
+            batch<T, avx2> blow(low), bhigh(high);
+            return hadd(blow, avx2 {}) + hadd(bhigh, avx2 {});
+        }
 
-    // haddp
-    template<class A> batch<float, A> haddp(batch<float, A> const* row, requires_arch<avx512f>) {
-                // The following folds over the vector once:
-                // tmp1 = [a0..8, b0..8]
-                // tmp2 = [a8..f, b8..f]
-#define XSIMD_AVX512_HADDP_STEP1(I, a, b)                                                  \
-        batch<float, avx512f> res ## I;                                                             \
-        {                                                                                      \
-            auto tmp1 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(1, 0, 1, 0));                   \
-            auto tmp2 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(3, 2, 3, 2));                   \
-            res ## I = _mm512_add_ps(tmp1, tmp2);                                              \
-        }                                                                                      \
-
-                XSIMD_AVX512_HADDP_STEP1(0, row[0], row[2]);
-                XSIMD_AVX512_HADDP_STEP1(1, row[4], row[6]);
-                XSIMD_AVX512_HADDP_STEP1(2, row[1], row[3]);
-                XSIMD_AVX512_HADDP_STEP1(3, row[5], row[7]);
-                XSIMD_AVX512_HADDP_STEP1(4, row[8], row[10]);
-                XSIMD_AVX512_HADDP_STEP1(5, row[12], row[14]);
-                XSIMD_AVX512_HADDP_STEP1(6, row[9], row[11]);
-                XSIMD_AVX512_HADDP_STEP1(7, row[13], row[15]);
+        // haddp
+        template <class A>
+        inline batch<float, A> haddp(batch<float, A> const* row, requires_arch<avx512f>) noexcept
+        {
+            // The following folds over the vector once:
+            // tmp1 = [a0..8, b0..8]
+            // tmp2 = [a8..f, b8..f]
+#define XSIMD_AVX512_HADDP_STEP1(I, a, b)                                \
+    batch<float, avx512f> res##I;                                        \
+    {                                                                    \
+        auto tmp1 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(1, 0, 1, 0)); \
+        auto tmp2 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(3, 2, 3, 2)); \
+        res##I = _mm512_add_ps(tmp1, tmp2);                              \
+    }
+
+            XSIMD_AVX512_HADDP_STEP1(0, row[0], row[2]);
+            XSIMD_AVX512_HADDP_STEP1(1, row[4], row[6]);
+            XSIMD_AVX512_HADDP_STEP1(2, row[1], row[3]);
+            XSIMD_AVX512_HADDP_STEP1(3, row[5], row[7]);
+            XSIMD_AVX512_HADDP_STEP1(4, row[8], row[10]);
+            XSIMD_AVX512_HADDP_STEP1(5, row[12], row[14]);
+            XSIMD_AVX512_HADDP_STEP1(6, row[9], row[11]);
+            XSIMD_AVX512_HADDP_STEP1(7, row[13], row[15]);
 
 #undef XSIMD_AVX512_HADDP_STEP1
 
-                // The following flds the code and shuffles so that hadd_ps produces the correct result
-                // tmp1 = [a0..4,  a8..12,  b0..4,  b8..12] (same for tmp3)
-                // tmp2 = [a5..8, a12..16, b5..8, b12..16]  (same for tmp4)
-                // tmp5 = [r1[0], r1[2], r2[0], r2[2], r1[4], r1[6] ...
-#define XSIMD_AVX512_HADDP_STEP2(I, a, b, c, d)                                             \
-        batch<float, avx2> halfx ## I;                                                             \
-        {                                                                                       \
-            auto tmp1 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(2, 0, 2, 0));        \
-            auto tmp2 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(3, 1, 3, 1));        \
-          \
-            auto resx1 = _mm512_add_ps(tmp1, tmp2);                                               \
-          \
-            auto tmp3 = _mm512_shuffle_f32x4(c, d, _MM_SHUFFLE(2, 0, 2, 0));        \
-            auto tmp4 = _mm512_shuffle_f32x4(c, d, _MM_SHUFFLE(3, 1, 3, 1));        \
-          \
-            auto resx2 = _mm512_add_ps(tmp3, tmp4);                                               \
-          \
-            auto tmp5 = _mm512_shuffle_ps(resx1, resx2, _MM_SHUFFLE(2, 0, 2, 0));   \
-            auto tmp6 = _mm512_shuffle_ps(resx1, resx2, _MM_SHUFFLE(3, 1, 3, 1));   \
-          \
-            auto resx3 = _mm512_add_ps(tmp5, tmp6);                                               \
-                                                                                                \
-            halfx ## I  = _mm256_hadd_ps(_mm512_extractf32x8_ps(resx3, 0),                      \
-                                         _mm512_extractf32x8_ps(resx3, 1));                     \
-        }                                                                                       \
-
-                XSIMD_AVX512_HADDP_STEP2(0, res0, res1, res2, res3);
-                XSIMD_AVX512_HADDP_STEP2(1, res4, res5, res6, res7);
+            // The following flds the code and shuffles so that hadd_ps produces the correct result
+            // tmp1 = [a0..4,  a8..12,  b0..4,  b8..12] (same for tmp3)
+            // tmp2 = [a5..8, a12..16, b5..8, b12..16]  (same for tmp4)
+            // tmp5 = [r1[0], r1[2], r2[0], r2[2], r1[4], r1[6] ...
+#define XSIMD_AVX512_HADDP_STEP2(I, a, b, c, d)                               \
+    batch<float, avx2> halfx##I;                                              \
+    {                                                                         \
+        auto tmp1 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(2, 0, 2, 0));      \
+        auto tmp2 = _mm512_shuffle_f32x4(a, b, _MM_SHUFFLE(3, 1, 3, 1));      \
+                                                                              \
+        auto resx1 = _mm512_add_ps(tmp1, tmp2);                               \
+                                                                              \
+        auto tmp3 = _mm512_shuffle_f32x4(c, d, _MM_SHUFFLE(2, 0, 2, 0));      \
+        auto tmp4 = _mm512_shuffle_f32x4(c, d, _MM_SHUFFLE(3, 1, 3, 1));      \
+                                                                              \
+        auto resx2 = _mm512_add_ps(tmp3, tmp4);                               \
+                                                                              \
+        auto tmp5 = _mm512_shuffle_ps(resx1, resx2, _MM_SHUFFLE(2, 0, 2, 0)); \
+        auto tmp6 = _mm512_shuffle_ps(resx1, resx2, _MM_SHUFFLE(3, 1, 3, 1)); \
+                                                                              \
+        auto resx3 = _mm512_add_ps(tmp5, tmp6);                               \
+                                                                              \
+        halfx##I = _mm256_hadd_ps(_mm512_extractf32x8_ps(resx3, 0),           \
+                                  _mm512_extractf32x8_ps(resx3, 1));          \
+    }
+
+            XSIMD_AVX512_HADDP_STEP2(0, res0, res1, res2, res3);
+            XSIMD_AVX512_HADDP_STEP2(1, res4, res5, res6, res7);
 
 #undef XSIMD_AVX512_HADDP_STEP2
 
-                auto concat = _mm512_castps256_ps512(halfx0);
-                concat = _mm512_insertf32x8(concat, halfx1, 1);
-                return concat;
-    }
-    template <class A>
-    batch<double, A> haddp(batch<double, A> const *row, requires_arch<avx512f>) {
+            auto concat = _mm512_castps256_ps512(halfx0);
+            concat = _mm512_insertf32x8(concat, halfx1, 1);
+            return concat;
+        }
+
+        template <class A>
+        inline batch<double, A> haddp(batch<double, A> const* row, requires_arch<avx512f>) noexcept
+        {
 #define step1(I, a, b)                                                   \
-        batch<double, avx512f> res ## I;                                           \
-        {                                                                    \
-            auto tmp1 = _mm512_shuffle_f64x2(a, b, _MM_SHUFFLE(1, 0, 1, 0)); \
-            auto tmp2 = _mm512_shuffle_f64x2(a, b, _MM_SHUFFLE(3, 2, 3, 2)); \
-            res ## I = _mm512_add_pd(tmp1, tmp2);                                        \
-        }                                                                    \
-
-                step1(1, row[0], row[2]);
-                step1(2, row[4], row[6]);
-                step1(3, row[1], row[3]);
-                step1(4, row[5], row[7]);
+    batch<double, avx512f> res##I;                                       \
+    {                                                                    \
+        auto tmp1 = _mm512_shuffle_f64x2(a, b, _MM_SHUFFLE(1, 0, 1, 0)); \
+        auto tmp2 = _mm512_shuffle_f64x2(a, b, _MM_SHUFFLE(3, 2, 3, 2)); \
+        res##I = _mm512_add_pd(tmp1, tmp2);                              \
+    }
+
+            step1(1, row[0], row[2]);
+            step1(2, row[4], row[6]);
+            step1(3, row[1], row[3]);
+            step1(4, row[5], row[7]);
 
 #undef step1
 
-                auto tmp5 = _mm512_shuffle_f64x2(res1, res2, _MM_SHUFFLE(2, 0, 2, 0));
-                auto tmp6 = _mm512_shuffle_f64x2(res1, res2, _MM_SHUFFLE(3, 1, 3, 1));
+            auto tmp5 = _mm512_shuffle_f64x2(res1, res2, _MM_SHUFFLE(2, 0, 2, 0));
+            auto tmp6 = _mm512_shuffle_f64x2(res1, res2, _MM_SHUFFLE(3, 1, 3, 1));
 
-                auto resx1 = _mm512_add_pd(tmp5, tmp6);
+            auto resx1 = _mm512_add_pd(tmp5, tmp6);
 
-                auto tmp7 = _mm512_shuffle_f64x2(res3, res4, _MM_SHUFFLE(2, 0, 2, 0));
-                auto tmp8 = _mm512_shuffle_f64x2(res3, res4, _MM_SHUFFLE(3, 1, 3, 1));
+            auto tmp7 = _mm512_shuffle_f64x2(res3, res4, _MM_SHUFFLE(2, 0, 2, 0));
+            auto tmp8 = _mm512_shuffle_f64x2(res3, res4, _MM_SHUFFLE(3, 1, 3, 1));
 
-                auto resx2 = _mm512_add_pd(tmp7, tmp8);
+            auto resx2 = _mm512_add_pd(tmp7, tmp8);
 
-                auto tmpx = _mm512_shuffle_pd(resx1, resx2, 0b00000000);
-                auto tmpy = _mm512_shuffle_pd(resx1, resx2, 0b11111111);
+            auto tmpx = _mm512_shuffle_pd(resx1, resx2, 0b00000000);
+            auto tmpy = _mm512_shuffle_pd(resx1, resx2, 0b11111111);
 
-                return _mm512_add_pd(tmpx, tmpy);
-    }
+            return _mm512_add_pd(tmpx, tmpy);
+        }
 
-    // isnan
-    template<class A> batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<avx512f>) {
-                return _mm512_cmp_ps_mask(self, self, _CMP_UNORD_Q);
-    }
-    template<class A> batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<avx512f>) {
-                return _mm512_cmp_pd_mask(self, self, _CMP_UNORD_Q);
-    }
+        // isnan
+        template <class A>
+        inline batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, self, _CMP_UNORD_Q);
+        }
+        template <class A>
+        inline batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, self, _CMP_UNORD_Q);
+        }
 
-    // le
-    template<class A> batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_LE_OQ);
-    }
-    template<class A> batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_LE_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return detail::compare_int_avx512f<A, T, _MM_CMPINT_LE>(self, other);
-    }
+        // le
+        template <class A>
+        inline batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_LE_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_LE_OQ);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return detail::compare_int_avx512f<A, T, _MM_CMPINT_LE>(self, other);
+        }
 
+        // load_aligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_load_si512((__m512i const*)mem);
+        }
+        template <class A>
+        inline batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_load_ps(mem);
+        }
+        template <class A>
+        inline batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_load_pd(mem);
+        }
 
-    // load_aligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx512f>) {
-      return _mm512_load_si512((__m512i const*)mem);
-    }
-    template<class A> batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<avx512f>) {
-      return _mm512_load_ps(mem);
-    }
-    template<class A> batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<avx512f>) {
-      return _mm512_load_pd(mem);
-    }
+        // load_complex
+        namespace detail
+        {
+            template <class A>
+            inline batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx512f>) noexcept
+            {
+                __m512i real_idx = _mm512_setr_epi32(0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+                __m512i imag_idx = _mm512_setr_epi32(1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+                auto real = _mm512_permutex2var_ps(hi, real_idx, lo);
+                auto imag = _mm512_permutex2var_ps(hi, imag_idx, lo);
+                return { real, imag };
+            }
+            template <class A>
+            inline batch<std::complex<double>, A> load_complex(batch<double, A> const& hi, batch<double, A> const& lo, requires_arch<avx512f>) noexcept
+            {
+                __m512i real_idx = _mm512_setr_epi64(0, 2, 4, 6, 8, 10, 12, 14);
+                __m512i imag_idx = _mm512_setr_epi64(1, 3, 5, 7, 9, 11, 13, 15);
+                auto real = _mm512_permutex2var_pd(hi, real_idx, lo);
+                auto imag = _mm512_permutex2var_pd(hi, imag_idx, lo);
+                return { real, imag };
+            }
+        }
 
-    // load_complex
-    namespace detail
-    {
-    template<class A> batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<avx512f>) {
-        __m512i real_idx = _mm512_setr_epi32(0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
-        __m512i imag_idx = _mm512_setr_epi32(1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
-        auto real = _mm512_permutex2var_ps(hi, real_idx, lo);
-        auto imag = _mm512_permutex2var_ps(hi, imag_idx, lo);
-        return {real, imag};
-    }
-    template<class A> batch<std::complex<double>, A> load_complex(batch<double,A> const& hi, batch<double,A> const& lo, requires_arch<avx512f>) {
-        __m512i real_idx = _mm512_setr_epi64(0, 2, 4, 6, 8, 10, 12, 14);
-        __m512i imag_idx = _mm512_setr_epi64(1, 3, 5, 7, 9, 11, 13, 15);
-        auto real = _mm512_permutex2var_pd(hi, real_idx, lo);
-        auto imag = _mm512_permutex2var_pd(hi, imag_idx, lo);
-        return {real, imag};
-    }
-    }
+        // load_unaligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_loadu_si512((__m512i const*)mem);
+        }
+        template <class A>
+        inline batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_loadu_ps(mem);
+        }
+        template <class A>
+        inline batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_loadu_pd(mem);
+        }
 
-    // load_unaligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx512f>) {
-      return _mm512_loadu_si512((__m512i const*)mem);
-    }
-    template<class A> batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<avx512f>){
-      return _mm512_loadu_ps(mem);
-    }
-    template<class A> batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<avx512f>){
-      return _mm512_loadu_pd(mem);
-    }
+        // lt
+        template <class A>
+        inline batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_LT_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_LT_OQ);
+        }
 
-    // lt
-    template<class A> batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_LT_OQ);
-    }
-    template<class A> batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_LT_OQ);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return detail::compare_int_avx512f<A, T, _MM_CMPINT_LT>(self, other);
+        }
 
+        // max
+        template <class A>
+        inline batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_max_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_max_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm512_max_epi32(self, other);
+                case 8:
+                    return _mm512_max_epi64(self, other);
+                default:
+                    return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                              { return max(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                              self, other);
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm512_max_epu32(self, other);
+                case 8:
+                    return _mm512_max_epu64(self, other);
+                default:
+                    return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                              { return max(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                              self, other);
+                }
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      return detail::compare_int_avx512f<A, T, _MM_CMPINT_LT>(self, other);
-    }
+        // min
+        template <class A>
+        inline batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_min_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_min_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm512_min_epi32(self, other);
+                case 8:
+                    return _mm512_min_epi64(self, other);
+                default:
+                    return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                              { return min(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                              self, other);
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 4:
+                    return _mm512_min_epu32(self, other);
+                case 8:
+                    return _mm512_min_epu64(self, other);
+                default:
+                    return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                              { return min(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                              self, other);
+                }
+            }
+        }
 
-    // max
-    template<class A> batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_max_ps(self, other);
-    }
-    template<class A> batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_max_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 4: return _mm512_max_epi32(self, other);
-          case 8: return _mm512_max_epi64(self, other);
-          default : return detail::fwd_to_avx([](__m256i s, __m256i o) { return max(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 4: return _mm512_max_epu32(self, other);
-          case 8: return _mm512_max_epu64(self, other);
-          default : return detail::fwd_to_avx([](__m256i s, __m256i o) { return max(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        }
-      }
-    }
+        // mul
+        template <class A>
+        inline batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_mul_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_mul_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 4:
+                return _mm512_mullo_epi32(self, other);
+            case 8:
+                return _mm512_mullo_epi64(self, other);
+            default:
+                return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                          { return mul(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                          self, other);
+            }
+        }
 
-    // min
-    template<class A> batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_min_ps(self, other);
-    }
-    template<class A> batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_min_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 4: return _mm512_min_epi32(self, other);
-          case 8: return _mm512_min_epi64(self, other);
-          default : return detail::fwd_to_avx([](__m256i s, __m256i o) { return min(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 4: return _mm512_min_epu32(self, other);
-          case 8: return _mm512_min_epu64(self, other);
-          default : return detail::fwd_to_avx([](__m256i s, __m256i o) { return min(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        }
-      }
-    }
+        // nearbyint
+        template <class A>
+        inline batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_round_ps(self, _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_CUR_DIRECTION);
+        }
+        template <class A>
+        inline batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_round_pd(self, _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_CUR_DIRECTION);
+        }
 
-    // mul
-    template<class A> batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_mul_ps(self, other);
-    }
-    template<class A> batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_mul_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-        switch(sizeof(T)) {
-          case 4: return _mm512_mullo_epi32(self, other);
-          case 8: return _mm512_mullo_epi64(self, other);
-          default : return detail::fwd_to_avx([](__m256i s, __m256i o) { return mul(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
+        // neg
+        template <class A, class T>
+        inline batch<T, A> neg(batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return 0 - self;
         }
-    }
 
-    // nearbyint
-    template<class A> batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_round_ps(self, _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_CUR_DIRECTION);
-    }
-    template<class A> batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_round_pd(self, _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_CUR_DIRECTION);
-    }
+        // neq
+        template <class A>
+        inline batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_ps_mask(self, other, _CMP_NEQ_OQ);
+        }
+        template <class A>
+        inline batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cmp_pd_mask(self, other, _CMP_NEQ_OQ);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return ~(self == other);
+        }
 
-    // neg
-    template<class A, class T>
-    batch<T, A> neg(batch<T, A> const& self, requires_arch<avx512f>) {
-      return 0 - self;
-    }
+        template <class A, class T>
+        inline batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            return register_type(self.data ^ other.data);
+        }
 
-    // neq
-    template<class A> batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_ps_mask(self, other, _CMP_NEQ_OQ);
-    }
-    template<class A> batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_cmp_pd_mask(self, other, _CMP_NEQ_OQ);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-        return ~(self == other);
-    }
+        // sadd
+        template <class A>
+        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                auto mask = other < 0;
+                auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
+                auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
+                return other + select(mask, self_neg_branch, self_pos_branch);
+            }
+            else
+            {
+                const auto diffmax = std::numeric_limits<T>::max() - self;
+                const auto mindiff = min(diffmax, other);
+                return self + mindiff;
+            }
+        }
 
-    template<class A, class T>
-    batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      return register_type(self.data ^ other.data);
-    }
+        // select
+        template <class A>
+        inline batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_mask_blend_ps(cond, false_br, true_br);
+        }
+        template <class A>
+        inline batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_mask_blend_pd(cond, false_br, true_br);
+        }
 
-    // sadd
-    template<class A> batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return add(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A> batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return add(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      if(std::is_signed<T>::value) {
-        auto mask = other < 0;
-        auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
-        auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
-        return other + select(mask, self_neg_branch, self_pos_branch);
-      }
-      else {
-        const auto diffmax = std::numeric_limits<T>::max() - self;
-        const auto mindiff = min(diffmax, other);
-        return self + mindiff;
-      }
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+            {
+                alignas(avx2::alignment()) uint8_t buffer[64];
+                // FIXME: ultra inefficient
+                for (int i = 0; i < 64; ++i)
+                    buffer[i] = cond.data & ((uint64_t)1 << i) ? 0xFF : 0;
+                __m256i cond_low = batch<uint8_t, avx2>::load_aligned(&buffer[0]);
+                __m256i cond_hi = batch<uint8_t, avx2>::load_aligned(&buffer[32]);
+
+                __m256i true_low, true_hi;
+                detail::split_avx512(true_br, true_low, true_hi);
+
+                __m256i false_low, false_hi;
+                detail::split_avx512(false_br, false_low, false_hi);
+
+                __m256i res_low = select(batch_bool<T, avx2>(cond_low), batch<T, avx2>(true_low), batch<T, avx2>(false_low), avx2 {});
+                __m256i res_hi = select(batch_bool<T, avx2>(cond_hi), batch<T, avx2>(true_hi), batch<T, avx2>(false_hi), avx2 {});
+                return detail::merge_avx(res_low, res_hi);
+            }
+            case 2:
+            {
+                __m256i cond_low = _mm512_maskz_cvtepi32_epi16((uint64_t)cond.data & 0xFFFF, _mm512_set1_epi32(~0));
+                __m256i cond_hi = _mm512_maskz_cvtepi32_epi16((uint64_t)cond.data >> 16, _mm512_set1_epi32(~0));
 
-    // select
-    template<class A> batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<avx512f>) {
-                return _mm512_mask_blend_ps(cond, false_br, true_br);
-    }
-    template<class A> batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<avx512f>) {
-                return _mm512_mask_blend_pd(cond, false_br, true_br);
-    }
+                __m256i true_low, true_hi;
+                detail::split_avx512(true_br, true_low, true_hi);
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: {
-          alignas(avx2::alignment()) uint8_t buffer[64];
-          // FIXME: ultra inefficient
-          for(int i =0; i < 64; ++i)
-            buffer[i] = cond.data & ((uint64_t)1 << i) ? 0xFF : 0;
-          __m256i cond_low = batch<uint8_t, avx2>::load_aligned(&buffer[0]);
-          __m256i cond_hi = batch<uint8_t, avx2>::load_aligned(&buffer[32]);
-
-          __m256i true_low, true_hi;
-          detail::split_avx512(true_br, true_low, true_hi);
-
-          __m256i false_low, false_hi;
-          detail::split_avx512(false_br, false_low, false_hi);
-
-          __m256i res_low = select(batch_bool<T, avx2>(cond_low), batch<T, avx2>(true_low), batch<T, avx2>(false_low), avx2{});
-          __m256i res_hi = select(batch_bool<T, avx2>(cond_hi), batch<T, avx2>(true_hi), batch<T, avx2>(false_hi), avx2{});
-          return detail::merge_avx(res_low, res_hi);
-        }
-        case 2: {
-          __m256i cond_low = _mm512_maskz_cvtepi32_epi16((uint64_t)cond.data & 0xFFFF, _mm512_set1_epi32(~0));
-          __m256i cond_hi = _mm512_maskz_cvtepi32_epi16((uint64_t)cond.data >> 16, _mm512_set1_epi32(~0));
-
-          __m256i true_low, true_hi;
-          detail::split_avx512(true_br, true_low, true_hi);
-
-          __m256i false_low, false_hi;
-          detail::split_avx512(false_br, false_low, false_hi);
-
-          __m256i res_low = select(batch_bool<T, avx2>(cond_low), batch<T, avx2>(true_low), batch<T, avx2>(false_low), avx2{});
-          __m256i res_hi = select(batch_bool<T, avx2>(cond_hi), batch<T, avx2>(true_hi), batch<T, avx2>(false_hi), avx2{});
-          return detail::merge_avx(res_low, res_hi);
-        }
-        case 4: return _mm512_mask_blend_epi32(cond, false_br, true_br);
-        case 8: return _mm512_mask_blend_epi64(cond, false_br, true_br);
-        default: assert(false && "unsupported arch/type combination"); return {};
-      };
-    }
-    template<class A, class T, bool... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) {
-      return select(batch_bool<T, A>{Values...}, true_br, false_br, avx512f{});
-    }
+                __m256i false_low, false_hi;
+                detail::split_avx512(false_br, false_low, false_hi);
 
+                __m256i res_low = select(batch_bool<T, avx2>(cond_low), batch<T, avx2>(true_low), batch<T, avx2>(false_low), avx2 {});
+                __m256i res_hi = select(batch_bool<T, avx2>(cond_hi), batch<T, avx2>(true_hi), batch<T, avx2>(false_hi), avx2 {});
+                return detail::merge_avx(res_low, res_hi);
+            }
+            case 4:
+                return _mm512_mask_blend_epi32(cond, false_br, true_br);
+            case 8:
+                return _mm512_mask_blend_epi64(cond, false_br, true_br);
+            default:
+                assert(false && "unsupported arch/type combination");
+                return {};
+            };
+        }
 
-    namespace detail
-    {
-        template <class T>
-        using enable_signed_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,
-                                                                int>::type;
+        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) noexcept
+        {
+            return select(batch_bool<T, A> { Values... }, true_br, false_br, avx512f {});
+        }
 
-        template <class T>
-        using enable_unsigned_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value,
-                                                                  int>::type;
-    }
+        namespace detail
+        {
+            template <class T>
+            using enable_signed_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,
+                                                                    int>::type;
 
-    // set
-    template<class A>
-    batch<float, A> set(batch<float, A> const&, requires_arch<avx512f>, float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10, float v11, float v12, float v13, float v14, float v15) {
-      return _mm512_setr_ps(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
-    }
+            template <class T>
+            using enable_unsigned_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value,
+                                                                      int>::type;
+        }
 
-    template<class A>
-    batch<double, A> set(batch<double, A> const&, requires_arch<avx512f>, double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7) {
-      return _mm512_setr_pd(v0, v1, v2, v3, v4, v5, v6, v7);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) {
-      return _mm512_set_epi64(v7, v6, v5, v4, v3, v2, v1, v0);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
-                                                           T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) {
-      return _mm512_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
-    }
-    template<class A, class T, detail::enable_signed_integer_t<T> = 0>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
-                                                           T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
-                                                           T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
-                                                           T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) {
+        // set
+        template <class A>
+        inline batch<float, A> set(batch<float, A> const&, requires_arch<avx512f>, float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10, float v11, float v12, float v13, float v14, float v15) noexcept
+        {
+            return _mm512_setr_ps(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
+        }
+
+        template <class A>
+        inline batch<double, A> set(batch<double, A> const&, requires_arch<avx512f>, double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7) noexcept
+        {
+            return _mm512_setr_pd(v0, v1, v2, v3, v4, v5, v6, v7);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
+        {
+            return _mm512_set_epi64(v7, v6, v5, v4, v3, v2, v1, v0);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
+                               T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
+        {
+            return _mm512_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
+        }
+        template <class A, class T, detail::enable_signed_integer_t<T> = 0>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
+                               T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
+                               T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
+                               T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) noexcept
+        {
 #if defined(__clang__) || __GNUC__
-      return __extension__ (__m512i)(__v32hi)
-      {
-        v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-        v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
-      };
+            return __extension__(__m512i)(__v32hi) {
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+            };
 #else
-      return _mm512_set_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-                              v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
+            return _mm512_set_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                                    v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
 #endif
-    }
-    template<class A, class T, detail::enable_unsigned_integer_t<T> = 0>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
-                                                           T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
-                                                           T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
-                                                           T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) {
+        }
+
+        template <class A, class T, detail::enable_unsigned_integer_t<T> = 0>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
+                               T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
+                               T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
+                               T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) noexcept
+        {
 #if defined(__clang__) || __GNUC__
-      return __extension__ (__m512i)(__v32hu)
-      {
-        v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-        v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
-      };
+            return __extension__(__m512i)(__v32hu) {
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+            };
 #else
-      return _mm512_set_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-                              v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
+            return _mm512_set_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                                    v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
 #endif
-    }
-    template<class A, class T, detail::enable_signed_integer_t<T> = 0>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
-                                                           T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
-                                                           T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
-                                                           T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31,
-                                                           T v32, T v33, T v34, T v35, T v36, T v37, T v38, T v39,
-                                                           T v40, T v41, T v42, T v43, T v44, T v45, T v46, T v47,
-                                                           T v48, T v49, T v50, T v51, T v52, T v53, T v54, T v55,
-                                                           T v56, T v57, T v58, T v59, T v60, T v61, T v62, T v63
-      ) {
+        }
+
+        template <class A, class T, detail::enable_signed_integer_t<T> = 0>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
+                               T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
+                               T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
+                               T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31,
+                               T v32, T v33, T v34, T v35, T v36, T v37, T v38, T v39,
+                               T v40, T v41, T v42, T v43, T v44, T v45, T v46, T v47,
+                               T v48, T v49, T v50, T v51, T v52, T v53, T v54, T v55,
+                               T v56, T v57, T v58, T v59, T v60, T v61, T v62, T v63) noexcept
+        {
 
 #if defined(__clang__) || __GNUC__
-      return __extension__ (__m512i)(__v64qi)
-      {
-          v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-          v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-          v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-          v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63
-      };
+            return __extension__(__m512i)(__v64qi) {
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+                v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+                v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63
+            };
 #else
-      return _mm512_set_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-          v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-          v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-          v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63);
+            return _mm512_set_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                                   v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+                                   v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+                                   v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63);
 #endif
-    }
-    template<class A, class T, detail::enable_unsigned_integer_t<T> = 0>
-    batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
-                                                           T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
-                                                           T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
-                                                           T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31,
-                                                           T v32, T v33, T v34, T v35, T v36, T v37, T v38, T v39,
-                                                           T v40, T v41, T v42, T v43, T v44, T v45, T v46, T v47,
-                                                           T v48, T v49, T v50, T v51, T v52, T v53, T v54, T v55,
-                                                           T v56, T v57, T v58, T v59, T v60, T v61, T v62, T v63
-      ) {
+        }
+        template <class A, class T, detail::enable_unsigned_integer_t<T> = 0>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
+                               T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
+                               T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23,
+                               T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31,
+                               T v32, T v33, T v34, T v35, T v36, T v37, T v38, T v39,
+                               T v40, T v41, T v42, T v43, T v44, T v45, T v46, T v47,
+                               T v48, T v49, T v50, T v51, T v52, T v53, T v54, T v55,
+                               T v56, T v57, T v58, T v59, T v60, T v61, T v62, T v63) noexcept
+        {
 
 #if defined(__clang__) || __GNUC__
-      return __extension__ (__m512i)(__v64qu)
-      {
-          v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-          v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-          v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-          v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63
-      };
+            return __extension__(__m512i)(__v64qu) {
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+                v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+                v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63
+            };
 #else
-      return _mm512_set_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-          v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-          v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-          v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63);
+            return _mm512_set_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+                                   v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+                                   v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+                                   v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63);
 #endif
-    }
-    template<class A, class T, class... Values>
-    batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<avx512f>, Values... values) {
-      static_assert(sizeof...(Values) == batch_bool<T, A>::size, "consistent init");
-      using register_type = typename batch_bool<T, A>::register_type;
-      register_type r = 0;
-      unsigned shift = 0;
-      (void)std::initializer_list<register_type>{(r|=register_type(values?1:0) << (shift++))...};
-      return r;
-    }
+        }
 
-    // sqrt
-    template<class A> batch<float, A> sqrt(batch<float, A> const& val, requires_arch<avx512f>) {
-      return _mm512_sqrt_ps(val);
-    }
-    template<class A> batch<double, A> sqrt(batch<double, A> const& val, requires_arch<avx512f>) {
-      return _mm512_sqrt_pd(val);
-    }
+        template <class A, class T, class... Values>
+        inline batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<avx512f>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch_bool<T, A>::size, "consistent init");
+            using register_type = typename batch_bool<T, A>::register_type;
+            register_type r = 0;
+            unsigned shift = 0;
+            (void)std::initializer_list<register_type> { (r |= register_type(values ? 1 : 0) << (shift++))... };
+            return r;
+        }
 
-    // ssub
-    template<class A> batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A> batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      if(std::is_signed<T>::value) {
-         return sadd(self, -other);
-      }
-      else {
-        const auto diff = min(self, other);
-        return self - diff;
-      }
-    }
+        // sqrt
+        template <class A>
+        inline batch<float, A> sqrt(batch<float, A> const& val, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sqrt_ps(val);
+        }
+        template <class A>
+        inline batch<double, A> sqrt(batch<double, A> const& val, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sqrt_pd(val);
+        }
 
-    // store
-    template<class T, class A>
-    void store(batch_bool<T, A> const& self, bool* mem, requires_arch<avx512f>) {
-      using register_type = typename batch_bool<T, A>::register_type;
-      constexpr auto size = batch_bool<T, A>::size;
-      for(std::size_t i = 0; i < size; ++i)
-        mem[i] = self.data & (register_type(1) << i);
-    }
+        // ssub
+        template <class A>
+        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sub_ps(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sub_pd(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                return sadd(self, -other);
+            }
+            else
+            {
+                const auto diff = min(self, other);
+                return self - diff;
+            }
+        }
 
-    // store_aligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch<T, A> const& self, requires_arch<avx512f>) {
-      return _mm512_store_si512((__m512i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      return _mm512_store_si512((__m512i *)mem, self);
-    }
-    template<class A> void store_aligned(float *mem, batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_store_ps(mem, self);
-    }
-    template<class A> void store_aligned(double *mem, batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_store_pd(mem, self);
-    }
+        // store
+        template <class T, class A>
+        inline void store(batch_bool<T, A> const& self, bool* mem, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            constexpr auto size = batch_bool<T, A>::size;
+            for (std::size_t i = 0; i < size; ++i)
+                mem[i] = self.data & (register_type(1) << i);
+        }
 
-    // store_unaligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch<T, A> const& self, requires_arch<avx512f>) {
-      return _mm512_storeu_si512((__m512i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch_bool<T, A> const& self, requires_arch<avx512f>) {
-      return _mm512_storeu_si512((__m512i *)mem, self);
-    }
-    template<class A> void store_unaligned(float *mem, batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_storeu_ps(mem, self);
-    }
-    template<class A> void store_unaligned(double *mem, batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_storeu_pd(mem, self);
-    }
+        // store_aligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_store_si512((__m512i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_store_si512((__m512i*)mem, self);
+        }
+        template <class A>
+        inline void store_aligned(float* mem, batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_store_ps(mem, self);
+        }
+        template <class A>
+        inline void store_aligned(double* mem, batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_store_pd(mem, self);
+        }
 
-    // sub
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: return detail::fwd_to_avx([](__m256i s, __m256i o) { return sub(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        case 2: return detail::fwd_to_avx([](__m256i s, __m256i o) { return sub(batch<T, avx2>(s), batch<T, avx2>(o)); }, self, other);
-        case 4: return _mm512_sub_epi32(self, other);
-        case 8: return _mm512_sub_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_sub_ps(self, other);
-    }
-    template<class A> batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_sub_pd(self, other);
-    }
+        // store_unaligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_storeu_si512((__m512i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_storeu_si512((__m512i*)mem, self);
+        }
+        template <class A>
+        inline void store_unaligned(float* mem, batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_storeu_ps(mem, self);
+        }
+        template <class A>
+        inline void store_unaligned(double* mem, batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_storeu_pd(mem, self);
+        }
 
-    // to_float
-    template<class A>
-    batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<avx512f>) {
-      return _mm512_cvtepi32_ps(self);
-    }
-    template<class A>
-    batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx512f>) {
-      // FIXME: call _mm_cvtepi64_pd
-      alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(double)buffer[0], (double)buffer[1], (double)buffer[2], (double)buffer[3],
-              (double)buffer[4], (double)buffer[5], (double)buffer[6], (double)buffer[7]};
-    }
+        // sub
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                          { return sub(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                          self, other);
+            case 2:
+                return detail::fwd_to_avx([](__m256i s, __m256i o) noexcept
+                                          { return sub(batch<T, avx2>(s), batch<T, avx2>(o)); },
+                                          self, other);
+            case 4:
+                return _mm512_sub_epi32(self, other);
+            case 8:
+                return _mm512_sub_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sub_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_sub_pd(self, other);
+        }
 
-    // to_int
-    template<class A>
-    batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_cvttps_epi32(self);
-    }
+        // to_float
+        template <class A>
+        inline batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cvtepi32_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            // FIXME: call _mm_cvtepi64_pd
+            alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
+            self.store_aligned(&buffer[0]);
+            return { (double)buffer[0], (double)buffer[1], (double)buffer[2], (double)buffer[3],
+                     (double)buffer[4], (double)buffer[5], (double)buffer[6], (double)buffer[7] };
+        }
 
-    template<class A>
-    batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx512f>) {
-      // FIXME: call _mm_cvttpd_epi64
-      alignas(A::alignment()) double buffer[batch<double, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(int64_t)buffer[0], (int64_t)buffer[1], (int64_t)buffer[2], (int64_t)buffer[3],
-              (int64_t)buffer[4], (int64_t)buffer[5], (int64_t)buffer[6], (int64_t)buffer[7]};
-    }
+        // to_int
+        template <class A>
+        inline batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_cvttps_epi32(self);
+        }
 
-    // trunc
-    template<class A> batch<float, A> trunc(batch<float, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_round_ps(self, _MM_FROUND_TO_ZERO, _MM_FROUND_CUR_DIRECTION);
-    }
-    template<class A> batch<double, A> trunc(batch<double, A> const& self, requires_arch<avx512f>) {
-      return _mm512_roundscale_round_pd(self, _MM_FROUND_TO_ZERO, _MM_FROUND_CUR_DIRECTION);
-    }
+        template <class A>
+        inline batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            // FIXME: call _mm_cvttpd_epi64
+            alignas(A::alignment()) double buffer[batch<double, A>::size];
+            self.store_aligned(&buffer[0]);
+            return { (int64_t)buffer[0], (int64_t)buffer[1], (int64_t)buffer[2], (int64_t)buffer[3],
+                     (int64_t)buffer[4], (int64_t)buffer[5], (int64_t)buffer[6], (int64_t)buffer[7] };
+        }
 
-    // zip_hi
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_unpackhi_epi8(self, other);
-        case 2: return _mm512_unpackhi_epi16(self, other);
-        case 4: return _mm512_unpackhi_epi32(self, other);
-        case 8: return _mm512_unpackhi_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_unpackhi_ps(self, other);
-    }
-    template<class A> batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_unpackhi_pd(self, other);
-    }
+        // trunc
+        template <class A>
+        inline batch<float, A> trunc(batch<float, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_round_ps(self, _MM_FROUND_TO_ZERO, _MM_FROUND_CUR_DIRECTION);
+        }
+        template <class A>
+        inline batch<double, A> trunc(batch<double, A> const& self, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_roundscale_round_pd(self, _MM_FROUND_TO_ZERO, _MM_FROUND_CUR_DIRECTION);
+        }
 
-    // zip_lo
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) {
-      switch(sizeof(T)) {
-        case 1: return _mm512_unpacklo_epi8(self, other);
-        case 2: return _mm512_unpacklo_epi16(self, other);
-        case 4: return _mm512_unpacklo_epi32(self, other);
-        case 8: return _mm512_unpacklo_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) {
-      return _mm512_unpacklo_ps(self, other);
-    }
-    template<class A> batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) {
-      return _mm512_unpacklo_pd(self, other);
-    }
+        // zip_hi
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_unpackhi_epi8(self, other);
+            case 2:
+                return _mm512_unpackhi_epi16(self, other);
+            case 4:
+                return _mm512_unpackhi_epi32(self, other);
+            case 8:
+                return _mm512_unpackhi_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_unpackhi_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_unpackhi_pd(self, other);
+        }
 
-  }
+        // zip_lo
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm512_unpacklo_epi8(self, other);
+            case 2:
+                return _mm512_unpacklo_epi16(self, other);
+            case 4:
+                return _mm512_unpacklo_epi32(self, other);
+            case 8:
+                return _mm512_unpacklo_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_unpacklo_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
+        {
+            return _mm512_unpacklo_pd(self, other);
+        }
+
+    }
 
 }
 
diff --git a/third_party/xsimd/arch/xsimd_constants.hpp b/third_party/xsimd/arch/xsimd_constants.hpp
index a9ff97feb..1ae77e8c7 100644
--- a/third_party/xsimd/arch/xsimd_constants.hpp
+++ b/third_party/xsimd/arch/xsimd_constants.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NUMERICAL_CONSTANT_HPP
 #define XSIMD_NUMERICAL_CONSTANT_HPP
@@ -19,350 +19,366 @@
 namespace xsimd
 {
 
-namespace constants {
+    namespace constants
+    {
 
 #define XSIMD_DEFINE_CONSTANT(NAME, SINGLE, DOUBLE) \
     template <class T>                              \
-    inline T NAME() noexcept                     \
+    inline T NAME() noexcept                        \
     {                                               \
         return T(NAME<typename T::value_type>());   \
     }                                               \
     template <>                                     \
-    inline float NAME<float>() noexcept          \
+    inline float NAME<float>() noexcept             \
     {                                               \
         return SINGLE;                              \
     }                                               \
     template <>                                     \
-    inline double NAME<double>() noexcept        \
+    inline double NAME<double>() noexcept           \
     {                                               \
         return DOUBLE;                              \
     }
 
 #define XSIMD_DEFINE_CONSTANT_HEX(NAME, SINGLE, DOUBLE) \
     template <class T>                                  \
-    inline T NAME() noexcept                         \
+    inline T NAME() noexcept                            \
     {                                                   \
         return T(NAME<typename T::value_type>());       \
     }                                                   \
     template <>                                         \
-    inline float NAME<float>() noexcept              \
+    inline float NAME<float>() noexcept                 \
     {                                                   \
-      return bit_cast<float>((uint32_t)SINGLE); \
+        return bit_cast<float>((uint32_t)SINGLE);       \
     }                                                   \
     template <>                                         \
-    inline double NAME<double>() noexcept            \
+    inline double NAME<double>() noexcept               \
     {                                                   \
-      return bit_cast<double>((uint64_t)DOUBLE); \
+        return bit_cast<double>((uint64_t)DOUBLE);      \
     }
 
-    XSIMD_DEFINE_CONSTANT(infinity, (std::numeric_limits<float>::infinity()), (std::numeric_limits<double>::infinity()))
-    XSIMD_DEFINE_CONSTANT(invlog_2, 1.442695040888963407359924681001892137426645954152986f, 1.442695040888963407359924681001892137426645954152986)
-    XSIMD_DEFINE_CONSTANT_HEX(invlog_2hi, 0x3fb8b000, 0x3ff7154765200000)
-    XSIMD_DEFINE_CONSTANT_HEX(invlog_2lo, 0xb9389ad4, 0x3de705fc2eefa200)
-    XSIMD_DEFINE_CONSTANT(invlog10_2, 3.32192809488736234787031942949f, 3.32192809488736234787031942949)
-    XSIMD_DEFINE_CONSTANT_HEX(invpi, 0x3ea2f983, 0x3fd45f306dc9c883)
-    XSIMD_DEFINE_CONSTANT(log_2, 0.6931471805599453094172321214581765680755001343602553f, 0.6931471805599453094172321214581765680755001343602553)
-    XSIMD_DEFINE_CONSTANT_HEX(log_2hi, 0x3f318000, 0x3fe62e42fee00000)
-    XSIMD_DEFINE_CONSTANT_HEX(log_2lo, 0xb95e8083, 0x3dea39ef35793c76)
-    XSIMD_DEFINE_CONSTANT_HEX(log10_2hi, 0x3e9a0000, 0x3fd3440000000000)
-    XSIMD_DEFINE_CONSTANT_HEX(log10_2lo, 0x39826a14, 0x3ed3509f79fef312)
-    XSIMD_DEFINE_CONSTANT_HEX(logeps, 0xc17f1402, 0xc04205966f2b4f12)
-    XSIMD_DEFINE_CONSTANT_HEX(logpi, 0x3f928682, 0x3ff250d048e7a1bd)
-    XSIMD_DEFINE_CONSTANT_HEX(logsqrt2pi, 0x3f6b3f8e, 0x3fed67f1c864beb5)
-    XSIMD_DEFINE_CONSTANT(maxflint, 16777216.0f, 9007199254740992.0)
-    XSIMD_DEFINE_CONSTANT(maxlog, 88.3762626647949f, 709.78271289338400)
-    XSIMD_DEFINE_CONSTANT(maxlog2, 127.0f, 1023.)
-    XSIMD_DEFINE_CONSTANT(maxlog10, 38.23080825805664f, 308.2547155599167)
-    XSIMD_DEFINE_CONSTANT_HEX(mediumpi, 0x43490fdb, 0x412921fb54442d18)
-    XSIMD_DEFINE_CONSTANT(minlog, -88.3762626647949f, -708.3964185322641)
-    XSIMD_DEFINE_CONSTANT(minlog2, -127.0f, -1023.)
-    XSIMD_DEFINE_CONSTANT(minlog10, -37.89999771118164f, -308.2547155599167)
-    XSIMD_DEFINE_CONSTANT(minusinfinity, (-infinity<float>()), (-infinity<double>()))
-    XSIMD_DEFINE_CONSTANT(minuszero, -0.0f, -0.0)
-    XSIMD_DEFINE_CONSTANT_HEX(nan, 0xffffffff, 0xffffffffffffffff)
-    XSIMD_DEFINE_CONSTANT_HEX(oneosqrteps, 0x453504f3, 0x4190000000000000)
-    XSIMD_DEFINE_CONSTANT_HEX(oneotwoeps, 0x4a800000, 0x4320000000000000)
-    XSIMD_DEFINE_CONSTANT_HEX(pi, 0x40490fdb, 0x400921fb54442d18)
-    XSIMD_DEFINE_CONSTANT_HEX(pio_2lo, 0xb33bbd2e, 0x3c91a62633145c07)
-    XSIMD_DEFINE_CONSTANT_HEX(pio_4lo, 0xb2bbbd2e, 0x3c81a62633145c07)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2, 0x3fc90fdb, 0x3ff921fb54442d18)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_1, 0x3fc90f80, 0x3ff921fb54400000)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_1t, 0x37354443, 0x3dd0b4611a626331)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_2, 0x37354400, 0x3dd0b4611a600000)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_2t, 0x2e85a308, 0x3ba3198a2e037073)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_3, 0x2e85a300, 0x3ba3198a2e000000)
-    XSIMD_DEFINE_CONSTANT_HEX(pio2_3t, 0x248d3132, 0x397b839a252049c1)
-    XSIMD_DEFINE_CONSTANT_HEX(pio4, 0x3f490fdb, 0x3fe921fb54442d18)
-    XSIMD_DEFINE_CONSTANT_HEX(signmask, 0x80000000, 0x8000000000000000)
-    XSIMD_DEFINE_CONSTANT(smallestposval, std::numeric_limits<float>::min(), std::numeric_limits<double>::min())
-    XSIMD_DEFINE_CONSTANT_HEX(sqrt_2pi, 0x40206c99, 0x40040d931ff62704)
-    XSIMD_DEFINE_CONSTANT_HEX(sqrteps, 0x39b504f3, 0x3e50000000000000)
-    XSIMD_DEFINE_CONSTANT_HEX(tanpio8, 0x3ed413cd, 0x3fda827999fcef31)
-    XSIMD_DEFINE_CONSTANT_HEX(tan3pio8, 0x401a827a, 0x4003504f333f9de6)
-    XSIMD_DEFINE_CONSTANT_HEX(twentypi, 0x427b53d1, 0x404f6a7a2955385e)
-    XSIMD_DEFINE_CONSTANT_HEX(twoopi, 0x3f22f983, 0x3fe45f306dc9c883)
-    XSIMD_DEFINE_CONSTANT(twotonmb, 8388608.0f, 4503599627370496.0)
-    XSIMD_DEFINE_CONSTANT_HEX(twotonmbo3, 0x3ba14518, 0x3ed428a2f98d7286)
+        XSIMD_DEFINE_CONSTANT(infinity, (std::numeric_limits<float>::infinity()), (std::numeric_limits<double>::infinity()))
+        XSIMD_DEFINE_CONSTANT(invlog_2, 1.442695040888963407359924681001892137426645954152986f, 1.442695040888963407359924681001892137426645954152986)
+        XSIMD_DEFINE_CONSTANT_HEX(invlog_2hi, 0x3fb8b000, 0x3ff7154765200000)
+        XSIMD_DEFINE_CONSTANT_HEX(invlog_2lo, 0xb9389ad4, 0x3de705fc2eefa200)
+        XSIMD_DEFINE_CONSTANT(invlog10_2, 3.32192809488736234787031942949f, 3.32192809488736234787031942949)
+        XSIMD_DEFINE_CONSTANT_HEX(invpi, 0x3ea2f983, 0x3fd45f306dc9c883)
+        XSIMD_DEFINE_CONSTANT(log_2, 0.6931471805599453094172321214581765680755001343602553f, 0.6931471805599453094172321214581765680755001343602553)
+        XSIMD_DEFINE_CONSTANT_HEX(log_2hi, 0x3f318000, 0x3fe62e42fee00000)
+        XSIMD_DEFINE_CONSTANT_HEX(log_2lo, 0xb95e8083, 0x3dea39ef35793c76)
+        XSIMD_DEFINE_CONSTANT_HEX(log10_2hi, 0x3e9a0000, 0x3fd3440000000000)
+        XSIMD_DEFINE_CONSTANT_HEX(log10_2lo, 0x39826a14, 0x3ed3509f79fef312)
+        XSIMD_DEFINE_CONSTANT_HEX(logeps, 0xc17f1402, 0xc04205966f2b4f12)
+        XSIMD_DEFINE_CONSTANT_HEX(logpi, 0x3f928682, 0x3ff250d048e7a1bd)
+        XSIMD_DEFINE_CONSTANT_HEX(logsqrt2pi, 0x3f6b3f8e, 0x3fed67f1c864beb5)
+        XSIMD_DEFINE_CONSTANT(maxflint, 16777216.0f, 9007199254740992.0)
+        XSIMD_DEFINE_CONSTANT(maxlog, 88.3762626647949f, 709.78271289338400)
+        XSIMD_DEFINE_CONSTANT(maxlog2, 127.0f, 1023.)
+        XSIMD_DEFINE_CONSTANT(maxlog10, 38.23080825805664f, 308.2547155599167)
+        XSIMD_DEFINE_CONSTANT_HEX(mediumpi, 0x43490fdb, 0x412921fb54442d18)
+        XSIMD_DEFINE_CONSTANT(minlog, -88.3762626647949f, -708.3964185322641)
+        XSIMD_DEFINE_CONSTANT(minlog2, -127.0f, -1023.)
+        XSIMD_DEFINE_CONSTANT(minlog10, -37.89999771118164f, -308.2547155599167)
+        XSIMD_DEFINE_CONSTANT(minusinfinity, (-infinity<float>()), (-infinity<double>()))
+        XSIMD_DEFINE_CONSTANT(minuszero, -0.0f, -0.0)
+        XSIMD_DEFINE_CONSTANT_HEX(nan, 0xffffffff, 0xffffffffffffffff)
+        XSIMD_DEFINE_CONSTANT_HEX(oneosqrteps, 0x453504f3, 0x4190000000000000)
+        XSIMD_DEFINE_CONSTANT_HEX(oneotwoeps, 0x4a800000, 0x4320000000000000)
+        XSIMD_DEFINE_CONSTANT_HEX(pi, 0x40490fdb, 0x400921fb54442d18)
+        XSIMD_DEFINE_CONSTANT_HEX(pio_2lo, 0xb33bbd2e, 0x3c91a62633145c07)
+        XSIMD_DEFINE_CONSTANT_HEX(pio_4lo, 0xb2bbbd2e, 0x3c81a62633145c07)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2, 0x3fc90fdb, 0x3ff921fb54442d18)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_1, 0x3fc90f80, 0x3ff921fb54400000)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_1t, 0x37354443, 0x3dd0b4611a626331)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_2, 0x37354400, 0x3dd0b4611a600000)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_2t, 0x2e85a308, 0x3ba3198a2e037073)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_3, 0x2e85a300, 0x3ba3198a2e000000)
+        XSIMD_DEFINE_CONSTANT_HEX(pio2_3t, 0x248d3132, 0x397b839a252049c1)
+        XSIMD_DEFINE_CONSTANT_HEX(pio4, 0x3f490fdb, 0x3fe921fb54442d18)
+        XSIMD_DEFINE_CONSTANT_HEX(signmask, 0x80000000, 0x8000000000000000)
+        XSIMD_DEFINE_CONSTANT(smallestposval, std::numeric_limits<float>::min(), std::numeric_limits<double>::min())
+        XSIMD_DEFINE_CONSTANT_HEX(sqrt_2pi, 0x40206c99, 0x40040d931ff62704)
+        XSIMD_DEFINE_CONSTANT_HEX(sqrteps, 0x39b504f3, 0x3e50000000000000)
+        XSIMD_DEFINE_CONSTANT_HEX(tanpio8, 0x3ed413cd, 0x3fda827999fcef31)
+        XSIMD_DEFINE_CONSTANT_HEX(tan3pio8, 0x401a827a, 0x4003504f333f9de6)
+        XSIMD_DEFINE_CONSTANT_HEX(twentypi, 0x427b53d1, 0x404f6a7a2955385e)
+        XSIMD_DEFINE_CONSTANT_HEX(twoopi, 0x3f22f983, 0x3fe45f306dc9c883)
+        XSIMD_DEFINE_CONSTANT(twotonmb, 8388608.0f, 4503599627370496.0)
+        XSIMD_DEFINE_CONSTANT_HEX(twotonmbo3, 0x3ba14518, 0x3ed428a2f98d7286)
 
 #undef XSIMD_DEFINE_CONSTANT
 #undef XSIMD_DEFINE_CONSTANT_HEX
 
-    template <class T>
-    constexpr T allbits() noexcept;
+        template <class T>
+        constexpr T allbits() noexcept;
 
-    template <class T>
-    constexpr as_integer_t<T> mask1frexp() noexcept;
+        template <class T>
+        constexpr as_integer_t<T> mask1frexp() noexcept;
 
-    template <class T>
-    constexpr as_integer_t<T> mask2frexp() noexcept;
+        template <class T>
+        constexpr as_integer_t<T> mask2frexp() noexcept;
 
-    template <class T>
-    constexpr as_integer_t<T> maxexponent() noexcept;
+        template <class T>
+        constexpr as_integer_t<T> maxexponent() noexcept;
 
-    template <class T>
-    constexpr as_integer_t<T> maxexponentm1() noexcept;
+        template <class T>
+        constexpr as_integer_t<T> maxexponentm1() noexcept;
 
-    template <class T>
-    constexpr int32_t nmb() noexcept;
+        template <class T>
+        constexpr int32_t nmb() noexcept;
 
-    template <class T>
-    constexpr T zero() noexcept;
+        template <class T>
+        constexpr T zero() noexcept;
 
-    template <class T>
-    constexpr T minvalue() noexcept;
+        template <class T>
+        constexpr T minvalue() noexcept;
 
-    template <class T>
-    constexpr T maxvalue() noexcept;
+        template <class T>
+        constexpr T maxvalue() noexcept;
 
-    /**************************
-     * allbits implementation *
-     **************************/
+        /**************************
+         * allbits implementation *
+         **************************/
 
-    namespace detail
-    {
-        template <class T, bool = std::is_integral<T>::value>
-        struct allbits_impl
+        namespace detail
         {
-            static constexpr T get_value() noexcept
+            template <class T, bool = std::is_integral<T>::value>
+            struct allbits_impl
+            {
+                static constexpr T get_value() noexcept
+                {
+                    return T(~0);
+                }
+            };
+
+            template <class T>
+            struct allbits_impl<T, false>
             {
-                return T(~0);
-            }
-        };
+                static constexpr T get_value() noexcept
+                {
+                    return nan<T>();
+                }
+            };
+        }
 
         template <class T>
-        struct allbits_impl<T, false>
+        inline constexpr T allbits() noexcept
         {
-            static constexpr T get_value() noexcept
-            {
-                return nan<T>();
-            }
-        };
-    }
-
-    template <class T>
-    constexpr T allbits() noexcept
-    {
-        return T(detail::allbits_impl<typename T::value_type>::get_value());
-    }
-
-    /*****************************
-     * mask1frexp implementation *
-     *****************************/
-
-    template <class T>
-    constexpr as_integer_t<T> mask1frexp() noexcept
-    {
-        return as_integer_t<T>(mask1frexp<typename T::value_type>());
-    }
+            return T(detail::allbits_impl<typename T::value_type>::get_value());
+        }
 
-    template <>
-    constexpr int32_t mask1frexp<float>() noexcept
-    {
-        return 0x7f800000;
-    }
+        /*****************************
+         * mask1frexp implementation *
+         *****************************/
 
-    template <>
-    constexpr int64_t mask1frexp<double>() noexcept
-    {
-        return 0x7ff0000000000000;
-    }
-
-    /*****************************
-     * mask2frexp implementation *
-     *****************************/
-
-    template <class T>
-    constexpr as_integer_t<T> mask2frexp() noexcept
-    {
-        return as_integer_t<T>(mask2frexp<typename T::value_type>());
-    }
+        template <class T>
+        inline constexpr as_integer_t<T> mask1frexp() noexcept
+        {
+            return as_integer_t<T>(mask1frexp<typename T::value_type>());
+        }
 
-    template <>
-    constexpr int32_t mask2frexp<float>() noexcept
-    {
-        return 0x3f000000;
-    }
+        template <>
+        inline constexpr int32_t mask1frexp<float>() noexcept
+        {
+            return 0x7f800000;
+        }
 
-    template <>
-    constexpr int64_t mask2frexp<double>() noexcept
-    {
-        return 0x3fe0000000000000;
-    }
+        template <>
+        inline constexpr int64_t mask1frexp<double>() noexcept
+        {
+            return 0x7ff0000000000000;
+        }
 
-    /******************************
-     * maxexponent implementation *
-     ******************************/
+        /*****************************
+         * mask2frexp implementation *
+         *****************************/
 
-    template <class T>
-    constexpr as_integer_t<T> maxexponent() noexcept
-    {
-        return as_integer_t<T>(maxexponent<typename T::value_type>());
-    }
+        template <class T>
+        inline constexpr as_integer_t<T> mask2frexp() noexcept
+        {
+            return as_integer_t<T>(mask2frexp<typename T::value_type>());
+        }
 
-    template <>
-    constexpr int32_t maxexponent<float>() noexcept
-    {
-        return 127;
-    }
+        template <>
+        inline constexpr int32_t mask2frexp<float>() noexcept
+        {
+            return 0x3f000000;
+        }
 
-    template <>
-    constexpr int64_t maxexponent<double>() noexcept
-    {
-        return 1023;
-    }
+        template <>
+        inline constexpr int64_t mask2frexp<double>() noexcept
+        {
+            return 0x3fe0000000000000;
+        }
 
-    /******************************
-     * maxexponent implementation *
-     ******************************/
+        /******************************
+         * maxexponent implementation *
+         ******************************/
 
-    template <class T>
-    constexpr as_integer_t<T> maxexponentm1() noexcept
-    {
-        return as_integer_t<T>(maxexponentm1<typename T::value_type>());
-    }
+        template <class T>
+        inline constexpr as_integer_t<T> maxexponent() noexcept
+        {
+            return as_integer_t<T>(maxexponent<typename T::value_type>());
+        }
 
-    template <>
-    constexpr int32_t maxexponentm1<float>() noexcept
-    {
-        return 126;
-    }
+        template <>
+        inline constexpr int32_t maxexponent<float>() noexcept
+        {
+            return 127;
+        }
 
-    template <>
-    constexpr int64_t maxexponentm1<double>() noexcept
-    {
-        return 1022;
-    }
+        template <>
+        inline constexpr int64_t maxexponent<double>() noexcept
+        {
+            return 1023;
+        }
 
-    /**********************
-     * nmb implementation *
-     **********************/
+        /******************************
+         * maxexponent implementation *
+         ******************************/
 
-    template <class T>
-    constexpr int32_t nmb() noexcept
-    {
-        return nmb<typename T::value_type>();
-    }
+        template <class T>
+        inline constexpr as_integer_t<T> maxexponentm1() noexcept
+        {
+            return as_integer_t<T>(maxexponentm1<typename T::value_type>());
+        }
 
-    template <>
-    constexpr int32_t nmb<float>() noexcept
-    {
-        return 23;
-    }
+        template <>
+        inline constexpr int32_t maxexponentm1<float>() noexcept
+        {
+            return 126;
+        }
 
-    template <>
-    constexpr int32_t nmb<double>() noexcept
-    {
-        return 52;
-    }
+        template <>
+        inline constexpr int64_t maxexponentm1<double>() noexcept
+        {
+            return 1022;
+        }
 
-    /***********************
-     * zero implementation *
-     ***********************/
+        /**********************
+         * nmb implementation *
+         **********************/
 
-    template <class T>
-    constexpr T zero() noexcept
-    {
-        return T(typename T::value_type(0));
-    }
+        template <class T>
+        inline constexpr int32_t nmb() noexcept
+        {
+            return nmb<typename T::value_type>();
+        }
 
-    /***************************
-     * minvalue implementation *
-     ***************************/
+        template <>
+        inline constexpr int32_t nmb<float>() noexcept
+        {
+            return 23;
+        }
 
-    namespace detail
-    {
-        template <class T>
-        struct minvalue_impl
+        template <>
+        inline constexpr int32_t nmb<double>() noexcept
         {
-            static constexpr T get_value() noexcept
-            {
-                return std::numeric_limits<typename T::value_type>::min();
-            }
-        };
+            return 52;
+        }
+
+        /***********************
+         * zero implementation *
+         ***********************/
 
         template <class T>
-        struct minvalue_common
+        inline constexpr T zero() noexcept
         {
-            static constexpr T get_value() noexcept
-            {
-                return std::numeric_limits<T>::min();
-            }
-        };
+            return T(typename T::value_type(0));
+        }
 
-        template <>
-        struct minvalue_impl<int8_t> : minvalue_common<int8_t> {};
-        template <>
-        struct minvalue_impl<uint8_t> : minvalue_common<uint8_t> {};
-        template <>
-        struct minvalue_impl<int16_t> : minvalue_common<int16_t> {};
-        template <>
-        struct minvalue_impl<uint16_t> : minvalue_common<uint16_t> {};
-        template <>
-        struct minvalue_impl<int32_t> : minvalue_common<int32_t> {};
-        template <>
-        struct minvalue_impl<uint32_t> : minvalue_common<uint32_t> {};
-        template <>
-        struct minvalue_impl<int64_t> : minvalue_common<int64_t> {};
-        template <>
-        struct minvalue_impl<uint64_t> : minvalue_common<uint64_t> {};
+        /***************************
+         * minvalue implementation *
+         ***************************/
 
-        template <>
-        struct minvalue_impl<float>
+        namespace detail
         {
-            static float get_value() noexcept
+            template <class T>
+            struct minvalue_impl
+            {
+                static constexpr T get_value() noexcept
+                {
+                    return std::numeric_limits<typename T::value_type>::min();
+                }
+            };
+
+            template <class T>
+            struct minvalue_common
+            {
+                static constexpr T get_value() noexcept
+                {
+                    return std::numeric_limits<T>::min();
+                }
+            };
+
+            template <>
+            struct minvalue_impl<int8_t> : minvalue_common<int8_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<uint8_t> : minvalue_common<uint8_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<int16_t> : minvalue_common<int16_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<uint16_t> : minvalue_common<uint16_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<int32_t> : minvalue_common<int32_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<uint32_t> : minvalue_common<uint32_t>
+            {
+            };
+            template <>
+            struct minvalue_impl<int64_t> : minvalue_common<int64_t>
             {
-              return bit_cast<float>((uint32_t)0xff7fffff);
-            }
-        };
+            };
+            template <>
+            struct minvalue_impl<uint64_t> : minvalue_common<uint64_t>
+            {
+            };
 
-        template <>
-        struct minvalue_impl<double>
-        {
-            static double get_value() noexcept
+            template <>
+            struct minvalue_impl<float>
             {
-                return bit_cast<double>((uint64_t)0xffefffffffffffff);
-            }
-        };
-    }
+                static float get_value() noexcept
+                {
+                    return bit_cast<float>((uint32_t)0xff7fffff);
+                }
+            };
+
+            template <>
+            struct minvalue_impl<double>
+            {
+                static double get_value() noexcept
+                {
+                    return bit_cast<double>((uint64_t)0xffefffffffffffff);
+                }
+            };
+        }
 
-    template <class T>
-    constexpr T minvalue() noexcept
-    {
-        return T(detail::minvalue_impl<typename T::value_type>::get_value());
-    }
+        template <class T>
+        inline constexpr T minvalue() noexcept
+        {
+            return T(detail::minvalue_impl<typename T::value_type>::get_value());
+        }
 
-    /***************************
-     * maxvalue implementation *
-     ***************************/
+        /***************************
+         * maxvalue implementation *
+         ***************************/
 
-    template <class T>
-    constexpr T maxvalue() noexcept
-    {
-        return T(std::numeric_limits<typename T::value_type>::max());
+        template <class T>
+        inline constexpr T maxvalue() noexcept
+        {
+            return T(std::numeric_limits<typename T::value_type>::max());
+        }
     }
-}
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_fma3.hpp b/third_party/xsimd/arch/xsimd_fma3.hpp
index e4646e90d..fa86c22a5 100644
--- a/third_party/xsimd/arch/xsimd_fma3.hpp
+++ b/third_party/xsimd/arch/xsimd_fma3.hpp
@@ -1,63 +1,79 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FMA3_HPP
 #define XSIMD_FMA3_HPP
 
-#include "../types/xsimd_sse_register.hpp"
+#include "../types/xsimd_fma3_register.hpp"
+
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+        // fnma
+        template <class A>
+        inline batch<float, A> fnma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fnmadd_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fnmadd_pd(x, y, z);
+        }
+
+        // fnms
+        template <class A>
+        inline batch<float, A> fnms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fnmsub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fnmsub_pd(x, y, z);
+        }
+
+        // fma
+        template <class A>
+        inline batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fmadd_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fmadd_pd(x, y, z);
+        }
+
+        // fms
+        template <class A>
+        inline batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fmsub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) noexcept
+        {
+            return _mm_fmsub_pd(x, y, z);
+        }
 
-
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-    // fnma
-    template<class A> batch<float, A> fnma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) {
-      return _mm_fnmadd_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) {
-      return _mm_fnmadd_pd(x, y, z);
-    }
-
-    // fnms
-    template<class A> batch<float, A> fnms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) {
-      return _mm_fnmsub_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) {
-      return _mm_fnmsub_pd(x, y, z);
-    }
-
-    // fma
-    template<class A> batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) {
-      return _mm_fmadd_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) {
-      return _mm_fmadd_pd(x, y, z);
-    }
-
-    // fms
-    template<class A> batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma3>) {
-      return _mm_fmsub_ps(x, y, z);
     }
 
-    template<class A> batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma3>) {
-      return _mm_fmsub_pd(x, y, z);
-    }
-
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_fma4.hpp b/third_party/xsimd/arch/xsimd_fma4.hpp
index 814bcd145..21df72416 100644
--- a/third_party/xsimd/arch/xsimd_fma4.hpp
+++ b/third_party/xsimd/arch/xsimd_fma4.hpp
@@ -1,63 +1,79 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FMA3_HPP
 #define XSIMD_FMA3_HPP
 
 #include "../types/xsimd_sse_register.hpp"
 
-
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    // fnma
-    template<class A> batch<float, A> fnma(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) {
-      return _mm_nmacc_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnma(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) {
-      return _mm_nmacc_pd(x, y, z);
-    }
-
-    // fnms
-    template<class A> batch<float, A> fnms(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) {
-      return _mm_nmsub_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnms(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) {
-      return _mm_nmsub_pd(x, y, z);
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+
+        // fnma
+        template <class A>
+        inline batch<float, A> fnma(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_nmacc_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnma(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_nmacc_pd(x, y, z);
+        }
+
+        // fnms
+        template <class A>
+        inline batch<float, A> fnms(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_nmsub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnms(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_nmsub_pd(x, y, z);
+        }
+
+        // fma
+        template <class A>
+        inline batch<float, A> fma(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_macc_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fma(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_macc_pd(x, y, z);
+        }
+
+        // fms
+        template <class A>
+        inline batch<float, A> fms(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_msub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fms(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) noexcept
+        {
+            return _mm_msub_pd(x, y, z);
+        }
     }
 
-    // fma
-    template<class A> batch<float, A> fma(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) {
-      return _mm_macc_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fma(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) {
-      return _mm_macc_pd(x, y, z);
-    }
-
-    // fms
-    template<class A> batch<float, A> fms(simd_register<float, A> const& x, simd_register<float, A> const& y, simd_register<float, A> const& z, requires_arch<fma4>) {
-      return _mm_msub_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fms(simd_register<double, A> const& x, simd_register<double, A> const& y, simd_register<double, A> const& z, requires_arch<fma4>) {
-      return _mm_msub_pd(x, y, z);
-    }
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_fma5.hpp b/third_party/xsimd/arch/xsimd_fma5.hpp
index 786949d25..51e767240 100644
--- a/third_party/xsimd/arch/xsimd_fma5.hpp
+++ b/third_party/xsimd/arch/xsimd_fma5.hpp
@@ -1,64 +1,80 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FMA5_HPP
 #define XSIMD_FMA5_HPP
 
 #include "../types/xsimd_fma5_register.hpp"
 
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+
+        // fnma
+        template <class A>
+        inline batch<float, A> fnma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fnmadd_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fnmadd_pd(x, y, z);
+        }
+
+        // fnms
+        template <class A>
+        inline batch<float, A> fnms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fnmsub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fnms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fnmsub_pd(x, y, z);
+        }
+
+        // fma
+        template <class A>
+        inline batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fmadd_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fmadd_pd(x, y, z);
+        }
+
+        // fms
+        template <class A>
+        inline batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fmsub_ps(x, y, z);
+        }
+
+        template <class A>
+        inline batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) noexcept
+        {
+            return _mm256_fmsub_pd(x, y, z);
+        }
 
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-
-    // fnma
-    template<class A> batch<float, A> fnma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) {
-      return _mm256_fnmadd_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) {
-      return _mm256_fnmadd_pd(x, y, z);
-    }
-
-    // fnms
-    template<class A> batch<float, A> fnms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) {
-      return _mm256_fnmsub_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fnms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) {
-      return _mm256_fnmsub_pd(x, y, z);
-    }
-
-    // fma
-    template<class A> batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) {
-      return _mm256_fmadd_ps(x, y, z);
-    }
-
-    template<class A> batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) {
-      return _mm256_fmadd_pd(x, y, z);
-    }
-
-    // fms
-    template<class A> batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<fma5>) {
-      return _mm256_fmsub_ps(x, y, z);
     }
 
-    template<class A> batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<fma5>) {
-      return _mm256_fmsub_pd(x, y, z);
-    }
-
-
-  }
-
 }
 
 #endif
diff --git a/third_party/xsimd/arch/xsimd_generic.hpp b/third_party/xsimd/arch/xsimd_generic.hpp
index 338413d36..6403cfb0f 100644
--- a/third_party/xsimd/arch/xsimd_generic.hpp
+++ b/third_party/xsimd/arch/xsimd_generic.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_HPP
 #define XSIMD_GENERIC_HPP
@@ -21,4 +21,3 @@
 #include "./generic/xsimd_generic_trigo.hpp"
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_generic_fwd.hpp b/third_party/xsimd/arch/xsimd_generic_fwd.hpp
index 8326066e1..d66ae7d6b 100644
--- a/third_party/xsimd/arch/xsimd_generic_fwd.hpp
+++ b/third_party/xsimd/arch/xsimd_generic_fwd.hpp
@@ -1,35 +1,37 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_FWD_HPP
 #define XSIMD_GENERIC_FWD_HPP
 
 #include <type_traits>
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
-    // forward declaration
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>);
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>);
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>);
-    template<class A, class T> batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>);
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>);
+    namespace kernel
+    {
+        // forward declaration
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<generic>) noexcept;
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        template <class A, class T>
+        inline batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<generic>) noexcept;
 
-  }
+    }
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_isa.hpp b/third_party/xsimd/arch/xsimd_isa.hpp
index c3f868740..e9c847cf7 100644
--- a/third_party/xsimd/arch/xsimd_isa.hpp
+++ b/third_party/xsimd/arch/xsimd_isa.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ISA_HPP
 #define XSIMD_ISA_HPP
@@ -72,4 +72,3 @@
 #include "./xsimd_generic.hpp"
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_neon.hpp b/third_party/xsimd/arch/xsimd_neon.hpp
index e3b02018a..42e256506 100644
--- a/third_party/xsimd/arch/xsimd_neon.hpp
+++ b/third_party/xsimd/arch/xsimd_neon.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NEON_HPP
 #define XSIMD_NEON_HPP
@@ -23,63 +23,72 @@
 // Wrap intrinsics so we can pass them as function pointers
 // - OP: intrinsics name prefix, e.g., vorrq
 // - RT: type traits to deduce intrinsics return types
-#define WRAP_BINARY_INT_EXCLUDING_64(OP, RT)                                                    \
-    namespace wrap {                                                                            \
-        inline RT<uint8x16_t> OP##_u8 (uint8x16_t a, uint8x16_t b) { return ::OP##_u8 (a, b); } \
-        inline RT<int8x16_t>  OP##_s8 (int8x16_t  a, int8x16_t  b) { return ::OP##_s8 (a, b); } \
-        inline RT<uint16x8_t> OP##_u16(uint16x8_t a, uint16x8_t b) { return ::OP##_u16(a, b); } \
-        inline RT<int16x8_t>  OP##_s16(int16x8_t  a, int16x8_t  b) { return ::OP##_s16(a, b); } \
-        inline RT<uint32x4_t> OP##_u32(uint32x4_t a, uint32x4_t b) { return ::OP##_u32(a, b); } \
-        inline RT<int32x4_t>  OP##_s32(int32x4_t  a, int32x4_t  b) { return ::OP##_s32(a, b); } \
+#define WRAP_BINARY_INT_EXCLUDING_64(OP, RT)                                                             \
+    namespace wrap                                                                                       \
+    {                                                                                                    \
+        inline RT<uint8x16_t> OP##_u8(uint8x16_t a, uint8x16_t b) noexcept { return ::OP##_u8(a, b); }   \
+        inline RT<int8x16_t> OP##_s8(int8x16_t a, int8x16_t b) noexcept { return ::OP##_s8(a, b); }      \
+        inline RT<uint16x8_t> OP##_u16(uint16x8_t a, uint16x8_t b) noexcept { return ::OP##_u16(a, b); } \
+        inline RT<int16x8_t> OP##_s16(int16x8_t a, int16x8_t b) noexcept { return ::OP##_s16(a, b); }    \
+        inline RT<uint32x4_t> OP##_u32(uint32x4_t a, uint32x4_t b) noexcept { return ::OP##_u32(a, b); } \
+        inline RT<int32x4_t> OP##_s32(int32x4_t a, int32x4_t b) noexcept { return ::OP##_s32(a, b); }    \
     }
 
-#define WRAP_BINARY_INT(OP, RT)                                                                 \
-    WRAP_BINARY_INT_EXCLUDING_64(OP, RT)                                                        \
-    namespace wrap {                                                                            \
-        inline RT<uint64x2_t> OP##_u64(uint64x2_t a, uint64x2_t b) { return ::OP##_u64(a, b); } \
-        inline RT<int64x2_t>  OP##_s64(int64x2_t  a, int64x2_t  b) { return ::OP##_s64(a, b); } \
+#define WRAP_BINARY_INT(OP, RT)                                                                          \
+    WRAP_BINARY_INT_EXCLUDING_64(OP, RT)                                                                 \
+    namespace wrap                                                                                       \
+    {                                                                                                    \
+        inline RT<uint64x2_t> OP##_u64(uint64x2_t a, uint64x2_t b) noexcept { return ::OP##_u64(a, b); } \
+        inline RT<int64x2_t> OP##_s64(int64x2_t a, int64x2_t b) noexcept { return ::OP##_s64(a, b); }    \
     }
 
-#define WRAP_BINARY_FLOAT(OP, RT)                                                                  \
-    namespace wrap {                                                                               \
-        inline RT<float32x4_t> OP##_f32(float32x4_t a, float32x4_t b) { return ::OP##_f32(a, b); } \
+#define WRAP_BINARY_FLOAT(OP, RT)                                                                           \
+    namespace wrap                                                                                          \
+    {                                                                                                       \
+        inline RT<float32x4_t> OP##_f32(float32x4_t a, float32x4_t b) noexcept { return ::OP##_f32(a, b); } \
     }
 
-#define WRAP_UNARY_INT_EXCLUDING_64(OP)                                    \
-    namespace wrap {                                                       \
-        inline uint8x16_t OP##_u8 (uint8x16_t a) { return ::OP##_u8 (a); } \
-        inline int8x16_t  OP##_s8 (int8x16_t  a) { return ::OP##_s8 (a); } \
-        inline uint16x8_t OP##_u16(uint16x8_t a) { return ::OP##_u16(a); } \
-        inline int16x8_t  OP##_s16(int16x8_t  a) { return ::OP##_s16(a); } \
-        inline uint32x4_t OP##_u32(uint32x4_t a) { return ::OP##_u32(a); } \
-        inline int32x4_t  OP##_s32(int32x4_t  a) { return ::OP##_s32(a); } \
+#define WRAP_UNARY_INT_EXCLUDING_64(OP)                                             \
+    namespace wrap                                                                  \
+    {                                                                               \
+        inline uint8x16_t OP##_u8(uint8x16_t a) noexcept { return ::OP##_u8(a); }   \
+        inline int8x16_t OP##_s8(int8x16_t a) noexcept { return ::OP##_s8(a); }     \
+        inline uint16x8_t OP##_u16(uint16x8_t a) noexcept { return ::OP##_u16(a); } \
+        inline int16x8_t OP##_s16(int16x8_t a) noexcept { return ::OP##_s16(a); }   \
+        inline uint32x4_t OP##_u32(uint32x4_t a) noexcept { return ::OP##_u32(a); } \
+        inline int32x4_t OP##_s32(int32x4_t a) noexcept { return ::OP##_s32(a); }   \
     }
 
-#define WRAP_UNARY_INT(OP)                                                 \
-    WRAP_UNARY_INT_EXCLUDING_64(OP)                                        \
-    namespace wrap {                                                       \
-        inline uint64x2_t OP##_u64(uint64x2_t a) { return ::OP##_u64(a); } \
-        inline int64x2_t  OP##_s64(int64x2_t  a) { return ::OP##_s64(a); } \
+#define WRAP_UNARY_INT(OP)                                                          \
+    WRAP_UNARY_INT_EXCLUDING_64(OP)                                                 \
+    namespace wrap                                                                  \
+    {                                                                               \
+        inline uint64x2_t OP##_u64(uint64x2_t a) noexcept { return ::OP##_u64(a); } \
+        inline int64x2_t OP##_s64(int64x2_t a) noexcept { return ::OP##_s64(a); }   \
     }
 
-#define WRAP_UNARY_FLOAT(OP)                                                 \
-    namespace wrap {                                                         \
-        inline float32x4_t OP##_f32(float32x4_t a) { return ::OP##_f32(a); } \
+#define WRAP_UNARY_FLOAT(OP)                                                          \
+    namespace wrap                                                                    \
+    {                                                                                 \
+        inline float32x4_t OP##_f32(float32x4_t a) noexcept { return ::OP##_f32(a); } \
     }
 
 // Dummy identity caster to ease coding
-inline uint8x16_t  vreinterpretq_u8_u8  (uint8x16_t  arg) { return arg; }
-inline int8x16_t   vreinterpretq_s8_s8  (int8x16_t   arg) { return arg; }
-inline uint16x8_t  vreinterpretq_u16_u16(uint16x8_t  arg) { return arg; }
-inline int16x8_t   vreinterpretq_s16_s16(int16x8_t   arg) { return arg; }
-inline uint32x4_t  vreinterpretq_u32_u32(uint32x4_t  arg) { return arg; }
-inline int32x4_t   vreinterpretq_s32_s32(int32x4_t   arg) { return arg; }
-inline uint64x2_t  vreinterpretq_u64_u64(uint64x2_t  arg) { return arg; }
-inline int64x2_t   vreinterpretq_s64_s64(int64x2_t   arg) { return arg; }
-inline float32x4_t vreinterpretq_f32_f32(float32x4_t arg) { return arg; }
+inline uint8x16_t vreinterpretq_u8_u8(uint8x16_t arg) noexcept { return arg; }
+inline int8x16_t vreinterpretq_s8_s8(int8x16_t arg) noexcept { return arg; }
+inline uint16x8_t vreinterpretq_u16_u16(uint16x8_t arg) noexcept { return arg; }
+inline int16x8_t vreinterpretq_s16_s16(int16x8_t arg) noexcept { return arg; }
+inline uint32x4_t vreinterpretq_u32_u32(uint32x4_t arg) noexcept { return arg; }
+inline int32x4_t vreinterpretq_s32_s32(int32x4_t arg) noexcept { return arg; }
+inline uint64x2_t vreinterpretq_u64_u64(uint64x2_t arg) noexcept { return arg; }
+inline int64x2_t vreinterpretq_s64_s64(int64x2_t arg) noexcept { return arg; }
+inline float32x4_t vreinterpretq_f32_f32(float32x4_t arg) noexcept { return arg; }
 
 namespace xsimd
 {
+    template <class batch_type, bool... Values>
+    struct batch_bool_constant;
+
     namespace kernel
     {
         using namespace types;
@@ -95,7 +104,7 @@ namespace xsimd
                     const container_type m_func;
 
                     template <class U>
-                    return_type<U> apply(U rhs) const
+                    return_type<U> apply(U rhs) const noexcept
                     {
                         using func_type = return_type<U> (*)(U);
                         auto func = xsimd::detail::get<func_type>(m_func);
@@ -105,11 +114,11 @@ namespace xsimd
 
                 struct binary
                 {
-                    using container_type = std::tuple<return_type<T> (*)(T, T) ...>;
+                    using container_type = std::tuple<return_type<T> (*)(T, T)...>;
                     const container_type m_func;
 
                     template <class U>
-                    return_type<U> apply(U lhs, U rhs) const
+                    return_type<U> apply(U lhs, U rhs) const noexcept
                     {
                         using func_type = return_type<U> (*)(U, U);
                         auto func = xsimd::detail::get<func_type>(m_func);
@@ -124,23 +133,22 @@ namespace xsimd
 
             template <class T>
             using identity_return_type = T;
-            
+
             template <class... T>
             struct neon_dispatcher_impl : neon_dispatcher_base<identity_return_type, T...>
             {
             };
 
-
             using neon_dispatcher = neon_dispatcher_impl<uint8x16_t, int8x16_t,
-                                                       uint16x8_t, int16x8_t,
-                                                       uint32x4_t, int32x4_t,
-                                                       uint64x2_t, int64x2_t,
-                                                       float32x4_t>;
+                                                         uint16x8_t, int16x8_t,
+                                                         uint32x4_t, int32x4_t,
+                                                         uint64x2_t, int64x2_t,
+                                                         float32x4_t>;
 
             using excluding_int64_dispatcher = neon_dispatcher_impl<uint8x16_t, int8x16_t,
-                                                                   uint16x8_t, int16x8_t,
-                                                                   uint32x4_t, int32x4_t,
-                                                                   float32x4_t>;
+                                                                    uint16x8_t, int16x8_t,
+                                                                    uint32x4_t, int32x4_t,
+                                                                    float32x4_t>;
 
             /**************************
              * comparison dispatchers *
@@ -196,7 +204,7 @@ namespace xsimd
             {
                 using type = uint64x2_t;
             };
-            
+
             template <>
             struct comp_return_type_impl<float32x4_t>
             {
@@ -212,9 +220,9 @@ namespace xsimd
             };
 
             using excluding_int64_comp_dispatcher = neon_comp_dispatcher_impl<uint8x16_t, int8x16_t,
-                                                                             uint16x8_t, int16x8_t,
-                                                                             uint32x4_t, int32x4_t,
-                                                                             float32x4_t>;
+                                                                              uint16x8_t, int16x8_t,
+                                                                              uint32x4_t, int32x4_t,
+                                                                              float32x4_t>;
 
             /**************************************
              * enabling / disabling metafunctions *
@@ -228,25 +236,20 @@ namespace xsimd
                                                                int>::type;
 
             template <class T, size_t S>
-            using enable_sized_signed_t = typename std::enable_if<std::is_integral<T>::value &&
-                                                                  std::is_signed<T>::value &&
-                                                                  sizeof(T) == S, int>::type;
+            using enable_sized_signed_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) == S, int>::type;
 
             template <class T, size_t S>
-            using enable_sized_unsigned_t = typename std::enable_if<std::is_integral<T>::value &&
-                                                                    !std::is_signed<T>::value &&
-                                                                    sizeof(T) == S, int>::type;
+            using enable_sized_unsigned_t = typename std::enable_if<std::is_integral<T>::value && !std::is_signed<T>::value && sizeof(T) == S, int>::type;
 
             template <class T, size_t S>
-            using enable_sized_integral_t = typename std::enable_if<std::is_integral<T>::value &&
-                                                                   sizeof(T) == S, int>::type;
+            using enable_sized_integral_t = typename std::enable_if<std::is_integral<T>::value && sizeof(T) == S, int>::type;
 
             template <class T, size_t S>
             using enable_sized_t = typename std::enable_if<sizeof(T) == S, int>::type;
 
             template <class T>
             using exclude_int64_neon_t
-                 = typename std::enable_if<(std::is_integral<T>::value && sizeof(T) != 8) || std::is_same<T, float>::value, int>::type;
+                = typename std::enable_if<(std::is_integral<T>::value && sizeof(T) != 8) || std::is_same<T, float>::value, int>::type;
         }
 
         /*************
@@ -254,55 +257,55 @@ namespace xsimd
          *************/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_u8(uint8_t(val));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_s8(int8_t(val));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_u16(uint16_t(val));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_s16(int16_t(val));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_u32(uint32_t(val));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_s32(int32_t(val));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_u64(uint64_t(val));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> broadcast(T val, requires_arch<neon>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon>) noexcept
         {
             return vdupq_n_s64(int64_t(val));
         }
 
         template <class A>
-        batch<float, A> broadcast(float val, requires_arch<neon>)
+        inline batch<float, A> broadcast(float val, requires_arch<neon>) noexcept
         {
             return vdupq_n_f32(val);
         }
@@ -312,31 +315,31 @@ namespace xsimd
          *******/
 
         template <class A, class T, class... Args, detail::enable_integral_t<T> = 0>
-        batch<T, A> set(batch<T, A> const&, requires_arch<neon>, Args... args)
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<neon>, Args... args) noexcept
         {
-            return xsimd::types::detail::neon_vector_type<T>{args...};
+            return xsimd::types::detail::neon_vector_type<T> { args... };
         }
 
         template <class A, class T, class... Args, detail::enable_integral_t<T> = 0>
-        batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<neon>, Args... args)
+        inline batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<neon>, Args... args) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             using unsigned_type = as_unsigned_integer_t<T>;
-            return register_type{static_cast<unsigned_type>(args ? -1LL : 0LL)...};
+            return register_type { static_cast<unsigned_type>(args ? -1LL : 0LL)... };
         }
 
         template <class A>
-        batch<float, A> set(batch<float, A> const&, requires_arch<neon>, float f0, float f1, float f2, float f3)
+        inline batch<float, A> set(batch<float, A> const&, requires_arch<neon>, float f0, float f1, float f2, float f3) noexcept
         {
-            return float32x4_t{f0, f1, f2, f3};
+            return float32x4_t { f0, f1, f2, f3 };
         }
 
         template <class A, class... Args>
-        batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<neon>, Args... args)
+        inline batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<neon>, Args... args) noexcept
         {
             using register_type = typename batch_bool<float, A>::register_type;
             using unsigned_type = as_unsigned_integer_t<float>;
-            return register_type{static_cast<unsigned_type>(args ? -1LL : 0LL)...};
+            return register_type { static_cast<unsigned_type>(args ? -1LL : 0LL)... };
         }
 
         /*************
@@ -344,55 +347,55 @@ namespace xsimd
          *************/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_u8(arg, vdupq_n_u8(1));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_s8(reinterpret_cast<int8x16_t>(arg.data), vdupq_n_s8(1));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_u16(arg, vdupq_n_u16(1));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_s16(reinterpret_cast<int16x8_t>(arg.data), vdupq_n_s16(1));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_u32(arg, vdupq_n_u32(1));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_s32(reinterpret_cast<int32x4_t>(arg.data), vdupq_n_s32(1));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_u64(arg, vdupq_n_u64(1));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return vandq_s64(reinterpret_cast<int64x2_t>(arg.data), vdupq_n_s64(1));
         }
 
         template <class A>
-        batch<float, A> from_bool(batch_bool<float, A> const& arg, requires_arch<neon>)
+        inline batch<float, A> from_bool(batch_bool<float, A> const& arg, requires_arch<neon>) noexcept
         {
             return vreinterpretq_f32_u32(vandq_u32(arg, vreinterpretq_u32_f32(vdupq_n_f32(1.f))));
         }
@@ -402,58 +405,58 @@ namespace xsimd
          ********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_u8(src);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_s8(src);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_u16(src);
         }
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_s16(src);
         }
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_u32(src);
         }
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_s32(src);
         }
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_u64(src);
         }
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
             return vld1q_s64(src);
         }
 
         template <class A>
-        batch<float, A> load_aligned(float const* src, convert<float>, requires_arch<neon>)
+        inline batch<float, A> load_aligned(float const* src, convert<float>, requires_arch<neon>) noexcept
         {
             return vld1q_f32(src);
         }
 
         template <class A, class T>
-        batch<T, A> load_unaligned(T const* src, convert<T>, requires_arch<neon>)
+        inline batch<T, A> load_unaligned(T const* src, convert<T>, requires_arch<neon>) noexcept
         {
-            return load_aligned<A>(src, convert<T>(), A{});
+            return load_aligned<A>(src, convert<T>(), A {});
         }
 
         /*********
@@ -461,63 +464,63 @@ namespace xsimd
          *********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_u8(dst, src);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_s8(dst, src);
         }
-        
+
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_u16(dst, src);
         }
-        
+
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_s16(dst, src);
         }
-        
+
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_u32(dst, src);
         }
-        
+
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_s32(dst, src);
         }
-        
+
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_u64(dst, src);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_aligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_s64(dst, src);
         }
 
         template <class A>
-        void store_aligned(float* dst, batch<float, A> const& src, requires_arch<neon>)
+        inline void store_aligned(float* dst, batch<float, A> const& src, requires_arch<neon>) noexcept
         {
             vst1q_f32(dst, src);
         }
 
         template <class A, class T>
-        void store_unaligned(T* dst, batch<T, A> const& src, requires_arch<neon>)
+        inline void store_unaligned(T* dst, batch<T, A> const& src, requires_arch<neon>) noexcept
         {
-            store_aligned<A>(dst, src, A{});
+            store_aligned<A>(dst, src, A {});
         }
 
         /****************
@@ -525,20 +528,20 @@ namespace xsimd
          ****************/
 
         template <class A>
-        batch<std::complex<float>, A> load_complex_aligned(std::complex<float> const* mem, convert<std::complex<float>>, requires_arch<neon>)
+        inline batch<std::complex<float>, A> load_complex_aligned(std::complex<float> const* mem, convert<std::complex<float>>, requires_arch<neon>) noexcept
         {
             using real_batch = batch<float, A>;
             const float* buf = reinterpret_cast<const float*>(mem);
             float32x4x2_t tmp = vld2q_f32(buf);
             real_batch real = tmp.val[0],
                        imag = tmp.val[1];
-            return batch<std::complex<float>, A>{real, imag};
+            return batch<std::complex<float>, A> { real, imag };
         }
 
         template <class A>
-        batch<std::complex<float>, A> load_complex_unaligned(std::complex<float> const* mem, convert<std::complex<float>> cvt, requires_arch<neon>)
+        inline batch<std::complex<float>, A> load_complex_unaligned(std::complex<float> const* mem, convert<std::complex<float>> cvt, requires_arch<neon>) noexcept
         {
-            return load_complex_aligned<A>(mem, cvt, A{});
+            return load_complex_aligned<A>(mem, cvt, A {});
         }
 
         /*****************
@@ -546,7 +549,7 @@ namespace xsimd
          *****************/
 
         template <class A>
-        void store_complex_aligned(std::complex<float>* dst, batch<std::complex<float> ,A> const& src, requires_arch<neon>)
+        inline void store_complex_aligned(std::complex<float>* dst, batch<std::complex<float>, A> const& src, requires_arch<neon>) noexcept
         {
             float32x4x2_t tmp;
             tmp.val[0] = src.real();
@@ -556,9 +559,9 @@ namespace xsimd
         }
 
         template <class A>
-        void store_complex_unaligned(std::complex<float>* dst, batch<std::complex<float> ,A> const& src, requires_arch<neon>)
+        inline void store_complex_unaligned(std::complex<float>* dst, batch<std::complex<float>, A> const& src, requires_arch<neon>) noexcept
         {
-            store_complex_aligned(dst, src, A{});
+            store_complex_aligned(dst, src, A {});
         }
 
         /*******
@@ -566,55 +569,55 @@ namespace xsimd
          *******/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vreinterpretq_u8_s8(vnegq_s8(vreinterpretq_s8_u8(rhs)));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vnegq_s8(rhs);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vreinterpretq_u16_s16(vnegq_s16(vreinterpretq_s16_u16(rhs)));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vnegq_s16(rhs);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vreinterpretq_u32_s32(vnegq_s32(vreinterpretq_s32_u32(rhs)));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vnegq_s32(rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch<T, A>({-rhs.get(0), -rhs.get(1)});
+            return batch<T, A>({ -rhs.get(0), -rhs.get(1) });
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch<T, A>({-rhs.get(0), -rhs.get(1)});
+            return batch<T, A>({ -rhs.get(0), -rhs.get(1) });
         }
-        
+
         template <class A>
-        batch<float, A> neg(batch<float, A> const& rhs, requires_arch<neon>)
+        inline batch<float, A> neg(batch<float, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vnegq_f32(rhs);
         }
@@ -627,11 +630,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vaddq, detail::identity_return_type)
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::neon_dispatcher::binary dispatcher =
-            {
+            const detail::neon_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vaddq_u8, wrap::vaddq_s8, wrap::vaddq_u16, wrap::vaddq_s16,
                                 wrap::vaddq_u32, wrap::vaddq_s32, wrap::vaddq_u64, wrap::vaddq_s64,
                                 wrap::vaddq_f32)
@@ -646,11 +648,10 @@ namespace xsimd
         WRAP_BINARY_INT(vqaddq, detail::identity_return_type)
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> sadd(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> sadd(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::neon_dispatcher::binary dispatcher =
-            {
+            const detail::neon_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vqaddq_u8, wrap::vqaddq_s8, wrap::vqaddq_u16, wrap::vqaddq_s16,
                                 wrap::vqaddq_u32, wrap::vqaddq_s32, wrap::vqaddq_u64, wrap::vqaddq_s64,
                                 wrap::vaddq_f32)
@@ -666,11 +667,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vsubq, detail::identity_return_type)
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::neon_dispatcher::binary dispatcher =
-            {
+            const detail::neon_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vsubq_u8, wrap::vsubq_s8, wrap::vsubq_u16, wrap::vsubq_s16,
                                 wrap::vsubq_u32, wrap::vsubq_s32, wrap::vsubq_u64, wrap::vsubq_s64,
                                 wrap::vsubq_f32)
@@ -685,11 +685,10 @@ namespace xsimd
         WRAP_BINARY_INT(vqsubq, detail::identity_return_type)
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> ssub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> ssub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::neon_dispatcher::binary dispatcher =
-            {
+            const detail::neon_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vqsubq_u8, wrap::vqsubq_s8, wrap::vqsubq_u16, wrap::vqsubq_s16,
                                 wrap::vqsubq_u32, wrap::vqsubq_s32, wrap::vqsubq_u64, wrap::vqsubq_s64,
                                 wrap::vsubq_f32)
@@ -697,7 +696,6 @@ namespace xsimd
             return dispatcher.apply(register_type(lhs), register_type(rhs));
         }
 
-
         /*******
          * mul *
          *******/
@@ -706,11 +704,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vmulq, detail::identity_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vmulq_u8, wrap::vmulq_s8, wrap::vmulq_u16, wrap::vmulq_s16,
                                 wrap::vmulq_u32, wrap::vmulq_s32, wrap::vmulq_f32)
             };
@@ -722,21 +719,21 @@ namespace xsimd
          *******/
 
 #if defined(XSIMD_FAST_INTEGER_DIVISION)
-        template <class A, class T,  detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
+        inline batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcvtq_s32_f32(vcvtq_f32_s32(lhs) / vcvtq_f32_s32(rhs));
         }
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
+        inline batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcvtq_u32_f32(vcvtq_f32_u32(lhs) / vcvtq_f32_u32(rhs));
         }
 #endif
 
         template <class A>
-        batch<float, A> div(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>)
+        inline batch<float, A> div(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>) noexcept
         {
             // from stackoverflow & https://projectne10.github.io/Ne10/doc/NE10__divc_8neon_8c_source.html
             // get an initial estimate of 1/b.
@@ -760,11 +757,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vceqq, detail::comp_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_comp_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_comp_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vceqq_u8, wrap::vceqq_s8, wrap::vceqq_u16, wrap::vceqq_s16,
                                 wrap::vceqq_u32, wrap::vceqq_s32, wrap::vceqq_f32)
             };
@@ -772,27 +768,26 @@ namespace xsimd
         }
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             using dispatcher_type = detail::neon_comp_dispatcher_impl<uint8x16_t, uint16x8_t, uint32x4_t>::binary;
-            const dispatcher_type dispatcher =
-            {
+            const dispatcher_type dispatcher = {
                 std::make_tuple(wrap::vceqq_u8, wrap::vceqq_u16, wrap::vceqq_u32)
             };
             return dispatcher.apply(register_type(lhs), register_type(rhs));
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) == rhs.get(0), lhs.get(1) == rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) == rhs.get(0), lhs.get(1) == rhs.get(1) });
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) == rhs.get(0), lhs.get(1) == rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) == rhs.get(0), lhs.get(1) == rhs.get(1) });
         }
 
         /******
@@ -803,11 +798,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vcltq, detail::comp_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_comp_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_comp_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vcltq_u8, wrap::vcltq_s8, wrap::vcltq_u16, wrap::vcltq_s16,
                                 wrap::vcltq_u32, wrap::vcltq_s32, wrap::vcltq_f32)
             };
@@ -815,9 +809,9 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) < rhs.get(0), lhs.get(1) < rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) < rhs.get(0), lhs.get(1) < rhs.get(1) });
         }
 
         /******
@@ -828,11 +822,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vcleq, detail::comp_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_comp_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_comp_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vcleq_u8, wrap::vcleq_s8, wrap::vcleq_u16, wrap::vcleq_s16,
                                 wrap::vcleq_u32, wrap::vcleq_s32, wrap::vcleq_f32)
             };
@@ -840,9 +833,9 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) <= rhs.get(0), lhs.get(1) <= rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) <= rhs.get(0), lhs.get(1) <= rhs.get(1) });
         }
 
         /******
@@ -853,11 +846,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vcgtq, detail::comp_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_comp_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_comp_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vcgtq_u8, wrap::vcgtq_s8, wrap::vcgtq_u16, wrap::vcgtq_s16,
                                 wrap::vcgtq_u32, wrap::vcgtq_s32, wrap::vcgtq_f32)
             };
@@ -865,9 +857,9 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) > rhs.get(0), lhs.get(1) > rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) > rhs.get(0), lhs.get(1) > rhs.get(1) });
         }
 
         /******
@@ -878,11 +870,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vcgeq, detail::comp_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_comp_dispatcher::binary dispatcher =
-            {
+            const detail::excluding_int64_comp_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vcgeq_u8, wrap::vcgeq_s8, wrap::vcgeq_u16, wrap::vcgeq_s16,
                                 wrap::vcgeq_u32, wrap::vcgeq_s32, wrap::vcgeq_f32)
             };
@@ -890,9 +881,9 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return batch_bool<T, A>({lhs.get(0) >= rhs.get(0), lhs.get(1) >= rhs.get(1)});
+            return batch_bool<T, A>({ lhs.get(0) >= rhs.get(0), lhs.get(1) >= rhs.get(1) });
         }
 
         /***************
@@ -903,7 +894,7 @@ namespace xsimd
 
         namespace detail
         {
-            inline float32x4_t bitwise_and_f32(float32x4_t lhs, float32x4_t rhs)
+            inline float32x4_t bitwise_and_f32(float32x4_t lhs, float32x4_t rhs) noexcept
             {
                 return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(lhs),
                                                        vreinterpretq_u32_f32(rhs)));
@@ -912,8 +903,7 @@ namespace xsimd
             template <class V>
             V bitwise_and_neon(V const& lhs, V const& rhs)
             {
-                const neon_dispatcher::binary dispatcher =
-                {
+                const neon_dispatcher::binary dispatcher = {
                     std::make_tuple(wrap::vandq_u8, wrap::vandq_s8, wrap::vandq_u16, wrap::vandq_s16,
                                     wrap::vandq_u32, wrap::vandq_s32, wrap::vandq_u64, wrap::vandq_s64,
                                     bitwise_and_f32)
@@ -923,14 +913,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
             return detail::bitwise_and_neon(register_type(lhs), register_type(rhs));
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             return detail::bitwise_and_neon(register_type(lhs), register_type(rhs));
@@ -944,17 +934,16 @@ namespace xsimd
 
         namespace detail
         {
-            inline float32x4_t bitwise_or_f32(float32x4_t lhs, float32x4_t rhs)
+            inline float32x4_t bitwise_or_f32(float32x4_t lhs, float32x4_t rhs) noexcept
             {
                 return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(lhs),
                                                        vreinterpretq_u32_f32(rhs)));
             }
 
             template <class V>
-            V bitwise_or_neon(V const& lhs, V const& rhs)
+            inline V bitwise_or_neon(V const& lhs, V const& rhs) noexcept
             {
-                const neon_dispatcher::binary dispatcher =
-                {
+                const neon_dispatcher::binary dispatcher = {
                     std::make_tuple(wrap::vorrq_u8, wrap::vorrq_s8, wrap::vorrq_u16, wrap::vorrq_s16,
                                     wrap::vorrq_u32, wrap::vorrq_s32, wrap::vorrq_u64, wrap::vorrq_s64,
                                     bitwise_or_f32)
@@ -964,14 +953,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
             return detail::bitwise_or_neon(register_type(lhs), register_type(rhs));
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             return detail::bitwise_or_neon(register_type(lhs), register_type(rhs));
@@ -985,17 +974,16 @@ namespace xsimd
 
         namespace detail
         {
-            inline float32x4_t bitwise_xor_f32(float32x4_t lhs, float32x4_t rhs)
+            inline float32x4_t bitwise_xor_f32(float32x4_t lhs, float32x4_t rhs) noexcept
             {
                 return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(lhs),
                                                        vreinterpretq_u32_f32(rhs)));
             }
 
             template <class V>
-            V bitwise_xor_neon(V const& lhs, V const& rhs)
+            inline V bitwise_xor_neon(V const& lhs, V const& rhs) noexcept
             {
-                const neon_dispatcher::binary dispatcher =
-                {
+                const neon_dispatcher::binary dispatcher = {
                     std::make_tuple(wrap::veorq_u8, wrap::veorq_s8, wrap::veorq_u16, wrap::veorq_s16,
                                     wrap::veorq_u32, wrap::veorq_s32, wrap::veorq_u64, wrap::veorq_s64,
                                     bitwise_xor_f32)
@@ -1005,14 +993,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
             return detail::bitwise_xor_neon(register_type(lhs), register_type(rhs));
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             return detail::bitwise_xor_neon(register_type(lhs), register_type(rhs));
@@ -1023,9 +1011,9 @@ namespace xsimd
          *******/
 
         template <class A, class T>
-        batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
-            return bitwise_xor(lhs, rhs, A{});
+            return bitwise_xor(lhs, rhs, A {});
         }
 
         /***************
@@ -1036,26 +1024,25 @@ namespace xsimd
 
         namespace detail
         {
-            inline int64x2_t bitwise_not_s64(int64x2_t arg)
+            inline int64x2_t bitwise_not_s64(int64x2_t arg) noexcept
             {
                 return vreinterpretq_s64_s32(vmvnq_s32(vreinterpretq_s32_s64(arg)));
             }
 
-            inline uint64x2_t bitwise_not_u64(uint64x2_t arg)
+            inline uint64x2_t bitwise_not_u64(uint64x2_t arg) noexcept
             {
                 return vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(arg)));
             }
 
-            inline float32x4_t bitwise_not_f32(float32x4_t arg)
+            inline float32x4_t bitwise_not_f32(float32x4_t arg) noexcept
             {
                 return vreinterpretq_f32_u32(vmvnq_u32(vreinterpretq_u32_f32(arg)));
             }
 
             template <class V>
-            V bitwise_not_neon(V const& arg)
+            inline V bitwise_not_neon(V const& arg) noexcept
             {
-                const neon_dispatcher::unary dispatcher =
-                {
+                const neon_dispatcher::unary dispatcher = {
                     std::make_tuple(wrap::vmvnq_u8, wrap::vmvnq_s8, wrap::vmvnq_u16, wrap::vmvnq_s16,
                                     wrap::vmvnq_u32, wrap::vmvnq_s32,
                                     bitwise_not_u64, bitwise_not_s64,
@@ -1066,14 +1053,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
             return detail::bitwise_not_neon(register_type(arg));
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             return detail::bitwise_not_neon(register_type(arg));
@@ -1087,16 +1074,15 @@ namespace xsimd
 
         namespace detail
         {
-            inline float32x4_t bitwise_andnot_f32(float32x4_t lhs, float32x4_t rhs)
+            inline float32x4_t bitwise_andnot_f32(float32x4_t lhs, float32x4_t rhs) noexcept
             {
                 return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(lhs), vreinterpretq_u32_f32(rhs)));
             }
 
             template <class V>
-            V bitwise_andnot_neon(V const& lhs, V const& rhs)
+            inline V bitwise_andnot_neon(V const& lhs, V const& rhs) noexcept
             {
-                const detail::neon_dispatcher::binary dispatcher =
-                {
+                const detail::neon_dispatcher::binary dispatcher = {
                     std::make_tuple(wrap::vbicq_u8, wrap::vbicq_s8, wrap::vbicq_u16, wrap::vbicq_s16,
                                     wrap::vbicq_u32, wrap::vbicq_s32, wrap::vbicq_u64, wrap::vbicq_s64,
                                     bitwise_andnot_f32)
@@ -1106,14 +1092,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
             return detail::bitwise_andnot_neon(register_type(lhs), register_type(rhs));
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>)
+        inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<T, A>::register_type;
             return detail::bitwise_andnot_neon(register_type(lhs), register_type(rhs));
@@ -1127,11 +1113,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vminq, detail::identity_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_dispatcher::binary dispatcher = 
-            {
+            const detail::excluding_int64_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vminq_u8, wrap::vminq_s8, wrap::vminq_u16, wrap::vminq_s16,
                                 wrap::vminq_u32, wrap::vminq_s32, wrap::vminq_f32)
             };
@@ -1139,7 +1124,7 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return { std::min(lhs.get(0), rhs.get(0)), std::min(lhs.get(1), rhs.get(1)) };
         }
@@ -1152,11 +1137,10 @@ namespace xsimd
         WRAP_BINARY_FLOAT(vmaxq, detail::identity_return_type)
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_dispatcher::binary dispatcher = 
-            {
+            const detail::excluding_int64_dispatcher::binary dispatcher = {
                 std::make_tuple(wrap::vmaxq_u8, wrap::vmaxq_s8, wrap::vmaxq_u16, wrap::vmaxq_s16,
                                 wrap::vmaxq_u32, wrap::vmaxq_s32, wrap::vmaxq_f32)
             };
@@ -1164,7 +1148,7 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return { std::max(lhs.get(0), rhs.get(0)), std::max(lhs.get(1), rhs.get(1)) };
         }
@@ -1173,37 +1157,37 @@ namespace xsimd
          * abs *
          *******/
 
-        namespace wrap {
-            inline int8x16_t vabsq_s8 (int8x16_t a) { return ::vabsq_s8 (a); }
-            inline int16x8_t vabsq_s16(int16x8_t a) { return ::vabsq_s16(a); }
-            inline int32x4_t vabsq_s32(int32x4_t a) { return ::vabsq_s32(a); }
+        namespace wrap
+        {
+            inline int8x16_t vabsq_s8(int8x16_t a) noexcept { return ::vabsq_s8(a); }
+            inline int16x8_t vabsq_s16(int16x8_t a) noexcept { return ::vabsq_s16(a); }
+            inline int32x4_t vabsq_s32(int32x4_t a) noexcept { return ::vabsq_s32(a); }
         }
         WRAP_UNARY_FLOAT(vabsq)
 
         namespace detail
         {
-            inline uint8x16_t abs_u8(uint8x16_t arg)
+            inline uint8x16_t abs_u8(uint8x16_t arg) noexcept
             {
                 return arg;
             }
 
-            inline uint16x8_t abs_u16(uint16x8_t arg)
+            inline uint16x8_t abs_u16(uint16x8_t arg) noexcept
             {
                 return arg;
             }
 
-            inline uint32x4_t abs_u32(uint32x4_t arg)
+            inline uint32x4_t abs_u32(uint32x4_t arg) noexcept
             {
                 return arg;
             }
         }
 
         template <class A, class T, detail::exclude_int64_neon_t<T> = 0>
-        batch<T, A> abs(batch<T, A> const& arg, requires_arch<neon>)
+        inline batch<T, A> abs(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
-            const detail::excluding_int64_dispatcher::unary dispatcher = 
-            {
+            const detail::excluding_int64_dispatcher::unary dispatcher = {
                 std::make_tuple(detail::abs_u8, wrap::vabsq_s8, detail::abs_u16, wrap::vabsq_s16,
                                 detail::abs_u32, wrap::vabsq_s32, wrap::vabsq_f32)
             };
@@ -1215,7 +1199,7 @@ namespace xsimd
          ********/
 
         template <class A>
-        batch<float, A> sqrt(batch<float, A> const& arg, requires_arch<neon>)
+        inline batch<float, A> sqrt(batch<float, A> const& arg, requires_arch<neon>) noexcept
         {
             batch<float, A> sqrt_reciprocal = vrsqrteq_f32(arg);
             // one iter
@@ -1231,13 +1215,13 @@ namespace xsimd
 
 #ifdef __ARM_FEATURE_FMA
         template <class A>
-        batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<neon>)
+        inline batch<float, A> fma(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<neon>) noexcept
         {
             return vfmaq_f32(z, x, y);
         }
 
         template <class A>
-        batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<neon>)
+        inline batch<float, A> fms(batch<float, A> const& x, batch<float, A> const& y, batch<float, A> const& z, requires_arch<neon>) noexcept
         {
             return vfmaq_f32(-z, x, y);
         }
@@ -1250,7 +1234,7 @@ namespace xsimd
         namespace detail
         {
             template <class T, class A, class V>
-            T sum_batch(V const& arg)
+            inline T sum_batch(V const& arg) noexcept
             {
                 T res = T(0);
                 for (std::size_t i = 0; i < batch<T, A>::size; ++i)
@@ -1262,35 +1246,45 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint8x8_t tmp = vpadd_u8(vget_low_u8(arg), vget_high_u8(arg));
-            return detail::sum_batch<T, A>(tmp);
+            tmp = vpadd_u8(tmp, tmp);
+            tmp = vpadd_u8(tmp, tmp);
+            tmp = vpadd_u8(tmp, tmp);
+            return vget_lane_u8(tmp, 0);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             int8x8_t tmp = vpadd_s8(vget_low_s8(arg), vget_high_s8(arg));
-            return detail::sum_batch<T, A>(tmp);
+            tmp = vpadd_s8(tmp, tmp);
+            tmp = vpadd_s8(tmp, tmp);
+            tmp = vpadd_s8(tmp, tmp);
+            return vget_lane_s8(tmp, 0);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint16x4_t tmp = vpadd_u16(vget_low_u16(arg), vget_high_u16(arg));
-            return detail::sum_batch<T, A>(tmp);
+            tmp = vpadd_u16(tmp, tmp);
+            tmp = vpadd_u16(tmp, tmp);
+            return vget_lane_u16(tmp, 0);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             int16x4_t tmp = vpadd_s16(vget_low_s16(arg), vget_high_s16(arg));
-            return detail::sum_batch<T, A>(tmp);
+            tmp = vpadd_s16(tmp, tmp);
+            tmp = vpadd_s16(tmp, tmp);
+            return vget_lane_s16(tmp, 0);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint32x2_t tmp = vpadd_u32(vget_low_u32(arg), vget_high_u32(arg));
             tmp = vpadd_u32(tmp, tmp);
@@ -1298,7 +1292,7 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             int32x2_t tmp = vpadd_s32(vget_low_s32(arg), vget_high_s32(arg));
             tmp = vpadd_s32(tmp, tmp);
@@ -1306,13 +1300,13 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_integral_t<T, 8> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon>) noexcept
         {
             return arg.get(0) + arg.get(1);
         }
 
         template <class A>
-        float hadd(batch<float, A> const& arg, requires_arch<neon>)
+        inline float hadd(batch<float, A> const& arg, requires_arch<neon>) noexcept
         {
             float32x2_t tmp = vpadd_f32(vget_low_f32(arg), vget_high_f32(arg));
             tmp = vpadd_f32(tmp, tmp);
@@ -1324,7 +1318,7 @@ namespace xsimd
          *********/
 
         template <class A>
-        batch<float, A> haddp(const batch<float, A>* row, requires_arch<neon>)
+        inline batch<float, A> haddp(const batch<float, A>* row, requires_arch<neon>) noexcept
         {
             // row = (a,b,c,d)
             float32x2_t tmp1, tmp2, tmp3;
@@ -1348,16 +1342,17 @@ namespace xsimd
          * select *
          **********/
 
-        namespace wrap {
-            inline uint8x16_t  vbslq_u8 (uint8x16_t a, uint8x16_t  b, uint8x16_t  c) { return ::vbslq_u8 (a, b, c); }
-            inline int8x16_t   vbslq_s8 (uint8x16_t a, int8x16_t   b, int8x16_t   c) { return ::vbslq_s8 (a, b, c); }
-            inline uint16x8_t  vbslq_u16(uint16x8_t a, uint16x8_t  b, uint16x8_t  c) { return ::vbslq_u16(a, b, c); }
-            inline int16x8_t   vbslq_s16(uint16x8_t a, int16x8_t   b, int16x8_t   c) { return ::vbslq_s16(a, b, c); }
-            inline uint32x4_t  vbslq_u32(uint32x4_t a, uint32x4_t  b, uint32x4_t  c) { return ::vbslq_u32(a, b, c); }
-            inline int32x4_t   vbslq_s32(uint32x4_t a, int32x4_t   b, int32x4_t   c) { return ::vbslq_s32(a, b, c); }
-            inline uint64x2_t  vbslq_u64(uint64x2_t a, uint64x2_t  b, uint64x2_t  c) { return ::vbslq_u64(a, b, c); }
-            inline int64x2_t   vbslq_s64(uint64x2_t a, int64x2_t   b, int64x2_t   c) { return ::vbslq_s64(a, b, c); }
-            inline float32x4_t vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) { return ::vbslq_f32(a, b, c); }
+        namespace wrap
+        {
+            inline uint8x16_t vbslq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) noexcept { return ::vbslq_u8(a, b, c); }
+            inline int8x16_t vbslq_s8(uint8x16_t a, int8x16_t b, int8x16_t c) noexcept { return ::vbslq_s8(a, b, c); }
+            inline uint16x8_t vbslq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) noexcept { return ::vbslq_u16(a, b, c); }
+            inline int16x8_t vbslq_s16(uint16x8_t a, int16x8_t b, int16x8_t c) noexcept { return ::vbslq_s16(a, b, c); }
+            inline uint32x4_t vbslq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) noexcept { return ::vbslq_u32(a, b, c); }
+            inline int32x4_t vbslq_s32(uint32x4_t a, int32x4_t b, int32x4_t c) noexcept { return ::vbslq_s32(a, b, c); }
+            inline uint64x2_t vbslq_u64(uint64x2_t a, uint64x2_t b, uint64x2_t c) noexcept { return ::vbslq_u64(a, b, c); }
+            inline int64x2_t vbslq_s64(uint64x2_t a, int64x2_t b, int64x2_t c) noexcept { return ::vbslq_s64(a, b, c); }
+            inline float32x4_t vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) noexcept { return ::vbslq_f32(a, b, c); }
         }
 
         namespace detail
@@ -1369,7 +1364,7 @@ namespace xsimd
                 const container_type m_func;
 
                 template <class U>
-                U apply(comp_return_type<U> cond, U lhs, U rhs) const
+                U apply(comp_return_type<U> cond, U lhs, U rhs) const noexcept
                 {
                     using func_type = U (*)(comp_return_type<U>, U, U);
                     auto func = xsimd::detail::get<func_type>(m_func);
@@ -1378,19 +1373,18 @@ namespace xsimd
             };
 
             using neon_select_dispatcher = neon_select_dispatcher_impl<uint8x16_t, int8x16_t,
-                                                                     uint16x8_t, int16x8_t,
-                                                                     uint32x4_t, int32x4_t,
-                                                                     uint64x2_t, int64x2_t,
-                                                                     float32x4_t>;
+                                                                       uint16x8_t, int16x8_t,
+                                                                       uint32x4_t, int32x4_t,
+                                                                       uint64x2_t, int64x2_t,
+                                                                       float32x4_t>;
         }
 
         template <class A, class T, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<neon>)
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<neon>) noexcept
         {
             using bool_register_type = typename batch_bool<T, A>::register_type;
             using register_type = typename batch<T, A>::register_type;
-            const detail::neon_select_dispatcher dispatcher =
-            {
+            const detail::neon_select_dispatcher dispatcher = {
                 std::make_tuple(wrap::vbslq_u8, wrap::vbslq_s8, wrap::vbslq_u16, wrap::vbslq_s16,
                                 wrap::vbslq_u32, wrap::vbslq_s32, wrap::vbslq_u64, wrap::vbslq_s64,
                                 wrap::vbslq_f32)
@@ -1399,9 +1393,9 @@ namespace xsimd
         }
 
         template <class A, class T, bool... b, detail::enable_neon_type_t<T> = 0>
-        batch<T, A> select(batch_bool_constant<batch<T, A>, b...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<neon>)
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, b...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<neon>) noexcept
         {
-            return select(batch_bool<T, A>{b...}, true_br, false_br, neon{});
+            return select(batch_bool<T, A> { b... }, true_br, false_br, neon {});
         }
 
         /**********
@@ -1409,61 +1403,61 @@ namespace xsimd
          **********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint8x8x2_t tmp = vzip_u8(vget_low_u8(lhs), vget_low_u8(rhs));
             return vcombine_u8(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int8x8x2_t tmp = vzip_s8(vget_low_s8(lhs), vget_low_s8(rhs));
             return vcombine_s8(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint16x4x2_t tmp = vzip_u16(vget_low_u16(lhs), vget_low_u16(rhs));
             return vcombine_u16(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int16x4x2_t tmp = vzip_s16(vget_low_s16(lhs), vget_low_s16(rhs));
             return vcombine_s16(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint32x2x2_t tmp = vzip_u32(vget_low_u32(lhs), vget_low_u32(rhs));
             return vcombine_u32(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int32x2x2_t tmp = vzip_s32(vget_low_s32(lhs), vget_low_s32(rhs));
             return vcombine_s32(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcombine_u64(vget_low_u64(lhs), vget_low_u64(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcombine_s64(vget_low_s64(lhs), vget_low_s64(rhs));
         }
 
         template <class A>
-        batch<float, A> zip_lo(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>)
+        inline batch<float, A> zip_lo(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>) noexcept
         {
             float32x2x2_t tmp = vzip_f32(vget_low_f32(lhs), vget_low_f32(rhs));
             return vcombine_f32(tmp.val[0], tmp.val[1]);
@@ -1474,61 +1468,61 @@ namespace xsimd
          **********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint8x8x2_t tmp = vzip_u8(vget_high_u8(lhs), vget_high_u8(rhs));
             return vcombine_u8(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int8x8x2_t tmp = vzip_s8(vget_high_s8(lhs), vget_high_s8(rhs));
             return vcombine_s8(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint16x4x2_t tmp = vzip_u16(vget_high_u16(lhs), vget_high_u16(rhs));
             return vcombine_u16(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int16x4x2_t tmp = vzip_s16(vget_high_s16(lhs), vget_high_s16(rhs));
             return vcombine_s16(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             uint32x2x2_t tmp = vzip_u32(vget_high_u32(lhs), vget_high_u32(rhs));
             return vcombine_u32(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             int32x2x2_t tmp = vzip_s32(vget_high_s32(lhs), vget_high_s32(rhs));
             return vcombine_s32(tmp.val[0], tmp.val[1]);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcombine_u64(vget_high_u64(lhs), vget_high_u64(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vcombine_s64(vget_high_s64(lhs), vget_high_s64(rhs));
         }
 
         template <class A>
-        batch<float, A> zip_hi(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>)
+        inline batch<float, A> zip_hi(batch<float, A> const& lhs, batch<float, A> const& rhs, requires_arch<neon>) noexcept
         {
             float32x2x2_t tmp = vzip_f32(vget_high_f32(lhs), vget_high_f32(rhs));
             return vcombine_f32(tmp.val[0], tmp.val[1]);
@@ -1541,14 +1535,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, ::xsimd::detail::index_sequence<>)
+            inline batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
             {
                 assert(false && "extract_pair out of bounds");
-                return  batch<T, A>{};
+                return batch<T, A> {};
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 1> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1561,7 +1555,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 1> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1574,7 +1568,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 2> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1587,7 +1581,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 2> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1600,7 +1594,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 4> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1613,7 +1607,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 4> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1626,7 +1620,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 8> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1639,7 +1633,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 8> = 0>
-            batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1652,7 +1646,7 @@ namespace xsimd
             }
 
             template <class A, size_t I, size_t... Is>
-            batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1665,7 +1659,7 @@ namespace xsimd
             }
 
             template <class A, class T, size_t... Is>
-            batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<0, Is...>)
+            inline batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<0, Is...>) noexcept
             {
                 if (n == 0)
                 {
@@ -1679,10 +1673,10 @@ namespace xsimd
         }
 
         template <class A, class T>
-        batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, requires_arch<neon>)
+        inline batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, requires_arch<neon>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
-            assert(0<= n && n< size && "index in bounds");
+            assert(0 <= n && n < size && "index in bounds");
             return detail::extract_pair_impl(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
         }
 
@@ -1693,14 +1687,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            batch<T, A> bitwise_lshift(batch<T, A> const& /*lhs*/, int /*n*/, ::xsimd::detail::int_sequence<>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& /*lhs*/, int /*n*/, ::xsimd::detail::int_sequence<>) noexcept
             {
                 assert(false && "bitwise_lshift out of bounds");
-                return batch<T, A>{};
+                return batch<T, A> {};
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 1> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1713,7 +1707,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 1> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1726,7 +1720,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 2> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1739,7 +1733,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 2> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1752,7 +1746,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 4> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1765,7 +1759,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 4> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1778,7 +1772,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 8> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1791,7 +1785,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 8> = 0>
-            batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1804,7 +1798,7 @@ namespace xsimd
             }
 
             template <class A, class T, int... Is>
-            batch<T, A> bitwise_lshift_impl(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<0, Is...>)
+            inline batch<T, A> bitwise_lshift_impl(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<0, Is...>) noexcept
             {
                 if (n == 0)
                 {
@@ -1816,59 +1810,59 @@ namespace xsimd
                 }
             }
         }
-        
+
         template <class A, class T>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, int n, requires_arch<neon>) noexcept
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
-            assert(0<= n && n< size && "index in bounds");
+            assert(0 <= n && n < size && "index in bounds");
             return detail::bitwise_lshift_impl(lhs, n, ::xsimd::detail::make_int_sequence<size>());
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u8(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s8(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u16(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s16(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u32(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s32(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u64(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s64(lhs, rhs);
         }
@@ -1880,14 +1874,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            batch<T, A> bitwise_rshift(batch<T, A> const& /*lhs*/, int /*n*/, ::xsimd::detail::int_sequence<>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& /*lhs*/, int /*n*/, ::xsimd::detail::int_sequence<>) noexcept
             {
                 assert(false && "bitwise_rshift out of bounds");
-                return batch<T, A>{};
+                return batch<T, A> {};
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 1> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1900,7 +1894,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 1> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1913,7 +1907,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 2> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1926,7 +1920,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 2> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1939,7 +1933,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 4> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1952,7 +1946,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 4> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1965,7 +1959,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_unsigned_t<T, 8> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1978,7 +1972,7 @@ namespace xsimd
             }
 
             template <class A, class T, int I, int... Is, detail::enable_sized_signed_t<T, 8> = 0>
-            batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>)
+            inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1991,7 +1985,7 @@ namespace xsimd
             }
 
             template <class A, class T, int... Is>
-            batch<T, A> bitwise_rshift_impl(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<0, Is...>)
+            inline batch<T, A> bitwise_rshift_impl(batch<T, A> const& lhs, int n, ::xsimd::detail::int_sequence<0, Is...>) noexcept
             {
                 if (n == 0)
                 {
@@ -2003,47 +1997,47 @@ namespace xsimd
                 }
             }
         }
-        
+
         template <class A, class T>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon>) noexcept
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
-            assert(0<= n && n< size && "index in bounds");
+            assert(0 <= n && n < size && "index in bounds");
             return detail::bitwise_rshift_impl(lhs, n, ::xsimd::detail::make_int_sequence<size>());
         }
-        
+
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u8(lhs, vnegq_s8(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s8(lhs, vnegq_s8(rhs));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u16(lhs, vnegq_s16(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s16(lhs, vnegq_s16(rhs));
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_u32(lhs, vnegq_s32(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             return vshlq_s32(lhs, vnegq_s32(rhs));
         }
@@ -2055,7 +2049,7 @@ namespace xsimd
          *******/
 
         template <class A, class T, detail::enable_sized_t<T, 1> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint8x8_t tmp = vand_u8(vget_low_u8(arg), vget_high_u8(arg));
             tmp = vpmin_u8(tmp, tmp);
@@ -2065,7 +2059,7 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_t<T, 2> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint16x4_t tmp = vand_u16(vget_low_u16(arg), vget_high_u16(arg));
             tmp = vpmin_u16(tmp, tmp);
@@ -2074,14 +2068,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_t<T, 4> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint32x2_t tmp = vand_u32(vget_low_u32(arg), vget_high_u32(arg));
             return vget_lane_u32(vpmin_u32(tmp, tmp), 0) != 0;
         }
 
         template <class A, class T, detail::enable_sized_t<T, 8> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint64x1_t tmp = vand_u64(vget_low_u64(arg), vget_high_u64(arg));
             return vget_lane_u64(tmp, 0) != 0;
@@ -2092,7 +2086,7 @@ namespace xsimd
          *******/
 
         template <class A, class T, detail::enable_sized_t<T, 1> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint8x8_t tmp = vorr_u8(vget_low_u8(arg), vget_high_u8(arg));
             tmp = vpmax_u8(tmp, tmp);
@@ -2102,7 +2096,7 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_t<T, 2> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint16x4_t tmp = vorr_u16(vget_low_u16(arg), vget_high_u16(arg));
             tmp = vpmax_u16(tmp, tmp);
@@ -2111,14 +2105,14 @@ namespace xsimd
         }
 
         template <class A, class T, detail::enable_sized_t<T, 4> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint32x2_t tmp = vorr_u32(vget_low_u32(arg), vget_high_u32(arg));
             return vget_lane_u32(vpmax_u32(tmp, tmp), 0);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 8> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon>) noexcept
         {
             uint64x1_t tmp = vorr_u64(vget_low_u64(arg), vget_high_u64(arg));
             return bool(vget_lane_u64(tmp, 0));
@@ -2128,18 +2122,19 @@ namespace xsimd
          * bitwise_cast *
          ****************/
 
-        #define WRAP_CAST(SUFFIX, TYPE)                                                                               \
-            namespace wrap {                                                                                          \
-                inline TYPE vreinterpretq_##SUFFIX##_u8(uint8x16_t   a) { return ::vreinterpretq_##SUFFIX##_u8 (a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_s8(int8x16_t    a) { return ::vreinterpretq_##SUFFIX##_s8 (a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_u16(uint16x8_t  a) { return ::vreinterpretq_##SUFFIX##_u16(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_s16(int16x8_t   a) { return ::vreinterpretq_##SUFFIX##_s16(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_u32(uint32x4_t  a) { return ::vreinterpretq_##SUFFIX##_u32(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_s32(int32x4_t   a) { return ::vreinterpretq_##SUFFIX##_s32(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_u64(uint64x2_t  a) { return ::vreinterpretq_##SUFFIX##_u64(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_s64(int64x2_t   a) { return ::vreinterpretq_##SUFFIX##_s64(a); } \
-                inline TYPE vreinterpretq_##SUFFIX##_f32(float32x4_t a) { return ::vreinterpretq_##SUFFIX##_f32(a); } \
-            }
+#define WRAP_CAST(SUFFIX, TYPE)                                                                                        \
+    namespace wrap                                                                                                     \
+    {                                                                                                                  \
+        inline TYPE vreinterpretq_##SUFFIX##_u8(uint8x16_t a) noexcept { return ::vreinterpretq_##SUFFIX##_u8(a); }    \
+        inline TYPE vreinterpretq_##SUFFIX##_s8(int8x16_t a) noexcept { return ::vreinterpretq_##SUFFIX##_s8(a); }     \
+        inline TYPE vreinterpretq_##SUFFIX##_u16(uint16x8_t a) noexcept { return ::vreinterpretq_##SUFFIX##_u16(a); }  \
+        inline TYPE vreinterpretq_##SUFFIX##_s16(int16x8_t a) noexcept { return ::vreinterpretq_##SUFFIX##_s16(a); }   \
+        inline TYPE vreinterpretq_##SUFFIX##_u32(uint32x4_t a) noexcept { return ::vreinterpretq_##SUFFIX##_u32(a); }  \
+        inline TYPE vreinterpretq_##SUFFIX##_s32(int32x4_t a) noexcept { return ::vreinterpretq_##SUFFIX##_s32(a); }   \
+        inline TYPE vreinterpretq_##SUFFIX##_u64(uint64x2_t a) noexcept { return ::vreinterpretq_##SUFFIX##_u64(a); }  \
+        inline TYPE vreinterpretq_##SUFFIX##_s64(int64x2_t a) noexcept { return ::vreinterpretq_##SUFFIX##_s64(a); }   \
+        inline TYPE vreinterpretq_##SUFFIX##_f32(float32x4_t a) noexcept { return ::vreinterpretq_##SUFFIX##_f32(a); } \
+    }
 
         WRAP_CAST(u8, uint8x16_t)
         WRAP_CAST(s8, int8x16_t)
@@ -2151,7 +2146,7 @@ namespace xsimd
         WRAP_CAST(s64, int64x2_t)
         WRAP_CAST(f32, float32x4_t)
 
-        #undef WRAP_CAST
+#undef WRAP_CAST
 
         namespace detail
         {
@@ -2162,7 +2157,7 @@ namespace xsimd
                 container_type m_func;
 
                 template <class U>
-                R apply(U rhs) const
+                R apply(U rhs) const noexcept
                 {
                     using func_type = R (*)(U);
                     auto func = xsimd::detail::get<func_type>(m_func);
@@ -2171,14 +2166,16 @@ namespace xsimd
             };
 
             template <class R, class... T>
-            const bitwise_caster_impl<R, T...> make_bitwise_caster_impl(R (*...arg)(T))
+            inline const bitwise_caster_impl<R, T...> make_bitwise_caster_impl(R (*... arg)(T)) noexcept
             {
-                return {std::make_tuple(arg...)};
+                return { std::make_tuple(arg...) };
             }
 
             template <class... T>
-            struct type_list {};
-            
+            struct type_list
+            {
+            };
+
             template <class RTL, class TTL>
             struct bitwise_caster;
 
@@ -2189,7 +2186,7 @@ namespace xsimd
                 container_type m_caster;
 
                 template <class V, class U>
-                V apply(U rhs) const
+                V apply(U rhs) const noexcept
                 {
                     using caster_type = bitwise_caster_impl<V, T...>;
                     auto caster = xsimd::detail::get<caster_type>(m_caster);
@@ -2199,46 +2196,46 @@ namespace xsimd
 
             template <class... T>
             using bitwise_caster_t = bitwise_caster<type_list<T...>, type_list<T...>>;
-                    
+
             using neon_bitwise_caster = bitwise_caster_t<uint8x16_t, int8x16_t,
-                                                        uint16x8_t, int16x8_t,
-                                                        uint32x4_t, int32x4_t,
-                                                        uint64x2_t, int64x2_t,
-                                                        float32x4_t>;
+                                                         uint16x8_t, int16x8_t,
+                                                         uint32x4_t, int32x4_t,
+                                                         uint64x2_t, int64x2_t,
+                                                         float32x4_t>;
         }
 
         template <class A, class T, class R>
-        batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<neon>)
+        inline batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<neon>) noexcept
         {
             const detail::neon_bitwise_caster caster = {
                 std::make_tuple(
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_u8_u8,  wrap::vreinterpretq_u8_s8,  wrap::vreinterpretq_u8_u16, wrap::vreinterpretq_u8_s16,
-                                                 wrap::vreinterpretq_u8_u32, wrap::vreinterpretq_u8_s32, wrap::vreinterpretq_u8_u64, wrap::vreinterpretq_u8_s64,
-                                                 wrap::vreinterpretq_u8_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_s8_u8,  wrap::vreinterpretq_s8_s8,  wrap::vreinterpretq_s8_u16, wrap::vreinterpretq_s8_s16,
-                                                 wrap::vreinterpretq_s8_u32, wrap::vreinterpretq_s8_s32, wrap::vreinterpretq_s8_u64, wrap::vreinterpretq_s8_s64,
-                                                 wrap::vreinterpretq_s8_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_u16_u8,  wrap::vreinterpretq_u16_s8,  wrap::vreinterpretq_u16_u16, wrap::vreinterpretq_u16_s16,
-                                                 wrap::vreinterpretq_u16_u32, wrap::vreinterpretq_u16_s32, wrap::vreinterpretq_u16_u64, wrap::vreinterpretq_u16_s64,
-                                                 wrap::vreinterpretq_u16_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_s16_u8,  wrap::vreinterpretq_s16_s8,  wrap::vreinterpretq_s16_u16, wrap::vreinterpretq_s16_s16,
-                                                 wrap::vreinterpretq_s16_u32, wrap::vreinterpretq_s16_s32, wrap::vreinterpretq_s16_u64, wrap::vreinterpretq_s16_s64,
-                                                 wrap::vreinterpretq_s16_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_u32_u8,  wrap::vreinterpretq_u32_s8,  wrap::vreinterpretq_u32_u16, wrap::vreinterpretq_u32_s16,
-                                                 wrap::vreinterpretq_u32_u32, wrap::vreinterpretq_u32_s32, wrap::vreinterpretq_u32_u64, wrap::vreinterpretq_u32_s64,
-                                                 wrap::vreinterpretq_u32_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_s32_u8,  wrap::vreinterpretq_s32_s8,  wrap::vreinterpretq_s32_u16, wrap::vreinterpretq_s32_s16,
-                                                 wrap::vreinterpretq_s32_u32, wrap::vreinterpretq_s32_s32, wrap::vreinterpretq_s32_u64, wrap::vreinterpretq_s32_s64,
-                                                 wrap::vreinterpretq_s32_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_u64_u8,  wrap::vreinterpretq_u64_s8,  wrap::vreinterpretq_u64_u16, wrap::vreinterpretq_u64_s16,
-                                                 wrap::vreinterpretq_u64_u32, wrap::vreinterpretq_u64_s32, wrap::vreinterpretq_u64_u64, wrap::vreinterpretq_u64_s64,
-                                                 wrap::vreinterpretq_u64_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_s64_u8,  wrap::vreinterpretq_s64_s8,  wrap::vreinterpretq_s64_u16, wrap::vreinterpretq_s64_s16,
-                                                 wrap::vreinterpretq_s64_u32, wrap::vreinterpretq_s64_s32, wrap::vreinterpretq_s64_u64, wrap::vreinterpretq_s64_s64,
-                                                 wrap::vreinterpretq_s64_f32),
-                detail::make_bitwise_caster_impl(wrap::vreinterpretq_f32_u8,  wrap::vreinterpretq_f32_s8,  wrap::vreinterpretq_f32_u16, wrap::vreinterpretq_f32_s16,
-                                                 wrap::vreinterpretq_f32_u32, wrap::vreinterpretq_f32_s32, wrap::vreinterpretq_f32_u64, wrap::vreinterpretq_f32_s64,
-                                                 wrap::vreinterpretq_f32_f32))
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_u8_u8, wrap::vreinterpretq_u8_s8, wrap::vreinterpretq_u8_u16, wrap::vreinterpretq_u8_s16,
+                                                     wrap::vreinterpretq_u8_u32, wrap::vreinterpretq_u8_s32, wrap::vreinterpretq_u8_u64, wrap::vreinterpretq_u8_s64,
+                                                     wrap::vreinterpretq_u8_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_s8_u8, wrap::vreinterpretq_s8_s8, wrap::vreinterpretq_s8_u16, wrap::vreinterpretq_s8_s16,
+                                                     wrap::vreinterpretq_s8_u32, wrap::vreinterpretq_s8_s32, wrap::vreinterpretq_s8_u64, wrap::vreinterpretq_s8_s64,
+                                                     wrap::vreinterpretq_s8_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_u16_u8, wrap::vreinterpretq_u16_s8, wrap::vreinterpretq_u16_u16, wrap::vreinterpretq_u16_s16,
+                                                     wrap::vreinterpretq_u16_u32, wrap::vreinterpretq_u16_s32, wrap::vreinterpretq_u16_u64, wrap::vreinterpretq_u16_s64,
+                                                     wrap::vreinterpretq_u16_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_s16_u8, wrap::vreinterpretq_s16_s8, wrap::vreinterpretq_s16_u16, wrap::vreinterpretq_s16_s16,
+                                                     wrap::vreinterpretq_s16_u32, wrap::vreinterpretq_s16_s32, wrap::vreinterpretq_s16_u64, wrap::vreinterpretq_s16_s64,
+                                                     wrap::vreinterpretq_s16_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_u32_u8, wrap::vreinterpretq_u32_s8, wrap::vreinterpretq_u32_u16, wrap::vreinterpretq_u32_s16,
+                                                     wrap::vreinterpretq_u32_u32, wrap::vreinterpretq_u32_s32, wrap::vreinterpretq_u32_u64, wrap::vreinterpretq_u32_s64,
+                                                     wrap::vreinterpretq_u32_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_s32_u8, wrap::vreinterpretq_s32_s8, wrap::vreinterpretq_s32_u16, wrap::vreinterpretq_s32_s16,
+                                                     wrap::vreinterpretq_s32_u32, wrap::vreinterpretq_s32_s32, wrap::vreinterpretq_s32_u64, wrap::vreinterpretq_s32_s64,
+                                                     wrap::vreinterpretq_s32_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_u64_u8, wrap::vreinterpretq_u64_s8, wrap::vreinterpretq_u64_u16, wrap::vreinterpretq_u64_s16,
+                                                     wrap::vreinterpretq_u64_u32, wrap::vreinterpretq_u64_s32, wrap::vreinterpretq_u64_u64, wrap::vreinterpretq_u64_s64,
+                                                     wrap::vreinterpretq_u64_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_s64_u8, wrap::vreinterpretq_s64_s8, wrap::vreinterpretq_s64_u16, wrap::vreinterpretq_s64_s16,
+                                                     wrap::vreinterpretq_s64_u32, wrap::vreinterpretq_s64_s32, wrap::vreinterpretq_s64_u64, wrap::vreinterpretq_s64_s64,
+                                                     wrap::vreinterpretq_s64_f32),
+                    detail::make_bitwise_caster_impl(wrap::vreinterpretq_f32_u8, wrap::vreinterpretq_f32_s8, wrap::vreinterpretq_f32_u16, wrap::vreinterpretq_f32_s16,
+                                                     wrap::vreinterpretq_f32_u32, wrap::vreinterpretq_f32_s32, wrap::vreinterpretq_f32_u64, wrap::vreinterpretq_f32_s64,
+                                                     wrap::vreinterpretq_f32_f32))
             };
             using src_register_type = typename batch<T, A>::register_type;
             using dst_register_type = typename batch<R, A>::register_type;
@@ -2250,14 +2247,14 @@ namespace xsimd
          *************/
 
         template <class A>
-        batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& arg, requires_arch<neon>)
+        inline batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& arg, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<int32_t, A>::register_type;
             return register_type(arg);
         }
 
         template <class A>
-        batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& arg, requires_arch<neon>)
+        inline batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& arg, requires_arch<neon>) noexcept
         {
             using register_type = typename batch_bool<float, A>::register_type;
             return register_type(arg);
@@ -2268,7 +2265,7 @@ namespace xsimd
          **********/
 
         template <class A>
-        batch<int32_t, A> to_int(const batch<float, A>& x, requires_arch<neon>)
+        inline batch<int32_t, A> to_int(const batch<float, A>& x, requires_arch<neon>) noexcept
         {
             return vcvtq_s32_f32(x);
         }
@@ -2278,30 +2275,17 @@ namespace xsimd
          ************/
 
         template <class A>
-        batch<float, A> to_float(const batch<int32_t, A>& x, requires_arch<neon>)
+        inline batch<float, A> to_float(const batch<int32_t, A>& x, requires_arch<neon>) noexcept
         {
             return vcvtq_f32_s32(x);
         }
 
-        /*************
-         * fast_cast *
-         *************/
-
-        namespace detail
-        {
-            template <class Tin, class Tout, class A>
-            batch<Tout, A> fast_cast(batch<Tin, A> const& in, batch<Tout, A> const& out, requires_arch<neon>)
-            {
-                return bitwise_cast(in, out, A{});
-            }
-        }
-
         /*********
          * isnan *
          *********/
 
         template <class A>
-        batch_bool<float, A> isnan(batch<float, A> const& arg, requires_arch<neon>)
+        inline batch_bool<float, A> isnan(batch<float, A> const& arg, requires_arch<neon>) noexcept
         {
             return !(arg == arg);
         }
diff --git a/third_party/xsimd/arch/xsimd_neon64.hpp b/third_party/xsimd/arch/xsimd_neon64.hpp
index f63254adf..50f172688 100644
--- a/third_party/xsimd/arch/xsimd_neon64.hpp
+++ b/third_party/xsimd/arch/xsimd_neon64.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NEON64_HPP
 #define XSIMD_NEON64_HPP
@@ -21,6 +21,9 @@
 
 namespace xsimd
 {
+    template <class batch_type, bool... Values>
+    struct batch_bool_constant;
+
     namespace kernel
     {
         using namespace types;
@@ -29,27 +32,27 @@ namespace xsimd
          *******/
 
         template <class A, class T, detail::enable_sized_t<T, 1> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vminvq_u8(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 2> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vminvq_u16(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 4> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vminvq_u32(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 8> = 0>
-        bool all(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool all(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
-            return all(batch_bool<uint32_t, A>(vreinterpretq_u32_u64(arg)), neon64{});
+            return all(batch_bool<uint32_t, A>(vreinterpretq_u32_u64(arg)), neon64 {});
         }
 
         /*******
@@ -57,27 +60,27 @@ namespace xsimd
          *******/
 
         template <class A, class T, detail::enable_sized_t<T, 1> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vmaxvq_u8(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 2> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vmaxvq_u16(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 4> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vmaxvq_u32(arg);
         }
 
         template <class A, class T, detail::enable_sized_t<T, 8> = 0>
-        bool any(batch_bool<T, A> const& arg, requires_arch<neon64>)
+        inline bool any(batch_bool<T, A> const& arg, requires_arch<neon64>) noexcept
         {
-            return any(batch_bool<uint32_t, A>(vreinterpretq_u32_u64(arg)), neon64{});
+            return any(batch_bool<uint32_t, A>(vreinterpretq_u32_u64(arg)), neon64 {});
         }
 
         /*************
@@ -86,13 +89,13 @@ namespace xsimd
 
         // Required to avoid ambiguous call
         template <class A, class T>
-        batch<T, A> broadcast(T val, requires_arch<neon64>)
+        inline batch<T, A> broadcast(T val, requires_arch<neon64>) noexcept
         {
-            return broadcast<neon64>(val, neon{});
+            return broadcast<neon64>(val, neon {});
         }
 
         template <class A>
-        batch<double, A> broadcast(double val, requires_arch<neon64>)
+        inline batch<double, A> broadcast(double val, requires_arch<neon64>) noexcept
         {
             return vdupq_n_f64(val);
         }
@@ -102,18 +105,18 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> set(batch<double, A> const&, requires_arch<neon64>, double d0, double d1)
+        inline batch<double, A> set(batch<double, A> const&, requires_arch<neon64>, double d0, double d1) noexcept
         {
-            return float64x2_t{d0, d1};
+            return float64x2_t { d0, d1 };
         }
 
         template <class A>
-        batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<neon64>, bool b0, bool b1)
+        inline batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<neon64>, bool b0, bool b1) noexcept
         {
             using register_type = typename batch_bool<double, A>::register_type;
             using unsigned_type = as_unsigned_integer_t<double>;
-            return register_type{static_cast<unsigned_type>(b0 ? -1LL : 0LL),
-                                 static_cast<unsigned_type>(b1 ? -1LL : 0LL)};
+            return register_type { static_cast<unsigned_type>(b0 ? -1LL : 0LL),
+                                   static_cast<unsigned_type>(b1 ? -1LL : 0LL) };
         }
 
         /*************
@@ -121,7 +124,7 @@ namespace xsimd
          *************/
 
         template <class A>
-        batch<double, A> from_bool(batch_bool<double, A> const& arg, requires_arch<neon64>)
+        inline batch<double, A> from_bool(batch_bool<double, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u64(vandq_u64(arg, vreinterpretq_u64_f64(vdupq_n_f64(1.))));
         }
@@ -131,15 +134,15 @@ namespace xsimd
          ********/
 
         template <class A>
-        batch<double, A> load_aligned(double const* src, convert<double>, requires_arch<neon64>)
+        inline batch<double, A> load_aligned(double const* src, convert<double>, requires_arch<neon64>) noexcept
         {
             return vld1q_f64(src);
         }
 
         template <class A>
-        batch<double, A> load_unaligned(double const* src, convert<double>, requires_arch<neon64>)
+        inline batch<double, A> load_unaligned(double const* src, convert<double>, requires_arch<neon64>) noexcept
         {
-            return load_aligned<A>(src, convert<double>(), A{});
+            return load_aligned<A>(src, convert<double>(), A {});
         }
 
         /*********
@@ -147,15 +150,15 @@ namespace xsimd
          *********/
 
         template <class A>
-        void store_aligned(double* dst, batch<double, A> const& src, requires_arch<neon64>)
+        inline void store_aligned(double* dst, batch<double, A> const& src, requires_arch<neon64>) noexcept
         {
             vst1q_f64(dst, src);
         }
 
         template <class A>
-        void store_unaligned(double* dst, batch<double, A> const& src, requires_arch<neon64>)
+        inline void store_unaligned(double* dst, batch<double, A> const& src, requires_arch<neon64>) noexcept
         {
-            return store_aligned<A>(dst, src, A{});
+            return store_aligned<A>(dst, src, A {});
         }
 
         /****************
@@ -163,20 +166,20 @@ namespace xsimd
          ****************/
 
         template <class A>
-        batch<std::complex<double>, A> load_complex_aligned(std::complex<double> const* mem, convert<std::complex<double>>, requires_arch<neon64>)
+        inline batch<std::complex<double>, A> load_complex_aligned(std::complex<double> const* mem, convert<std::complex<double>>, requires_arch<neon64>) noexcept
         {
             using real_batch = batch<double, A>;
             const double* buf = reinterpret_cast<const double*>(mem);
             float64x2x2_t tmp = vld2q_f64(buf);
             real_batch real = tmp.val[0],
                        imag = tmp.val[1];
-            return batch<std::complex<double>, A>{real, imag};
+            return batch<std::complex<double>, A> { real, imag };
         }
 
         template <class A>
-        batch<std::complex<double>, A> load_complex_unaligned(std::complex<double> const* mem, convert<std::complex<double>> cvt, requires_arch<neon64>)
+        inline batch<std::complex<double>, A> load_complex_unaligned(std::complex<double> const* mem, convert<std::complex<double>> cvt, requires_arch<neon64>) noexcept
         {
-            return load_complex_aligned<A>(mem, cvt, A{});
+            return load_complex_aligned<A>(mem, cvt, A {});
         }
 
         /*****************
@@ -184,7 +187,7 @@ namespace xsimd
          *****************/
 
         template <class A>
-        void store_complex_aligned(std::complex<double>* dst, batch<std::complex<double> ,A> const& src, requires_arch<neon64>)
+        inline void store_complex_aligned(std::complex<double>* dst, batch<std::complex<double>, A> const& src, requires_arch<neon64>) noexcept
         {
             float64x2x2_t tmp;
             tmp.val[0] = src.real();
@@ -194,29 +197,29 @@ namespace xsimd
         }
 
         template <class A>
-        void store_complex_unaligned(std::complex<double>* dst, batch<std::complex<double>, A> const& src, requires_arch<neon64>)
+        inline void store_complex_unaligned(std::complex<double>* dst, batch<std::complex<double>, A> const& src, requires_arch<neon64>) noexcept
         {
-            store_complex_aligned(dst, src, A{});
+            store_complex_aligned(dst, src, A {});
         }
 
         /*******
          * neg *
          *******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_u64_s64(vnegq_s64(vreinterpretq_s64_u64(rhs)));
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch<T, A> neg(batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vnegq_s64(rhs);
         }
 
         template <class A>
-        batch<double, A> neg(batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> neg(batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vnegq_f64(rhs);
         }
@@ -226,7 +229,7 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> add(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> add(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vaddq_f64(lhs, rhs);
         }
@@ -236,9 +239,9 @@ namespace xsimd
          ********/
 
         template <class A>
-        batch<double, A> sadd(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> sadd(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
-            return add(lhs, rhs, neon64{});
+            return add(lhs, rhs, neon64 {});
         }
 
         /*******
@@ -246,7 +249,7 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> sub(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> sub(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vsubq_f64(lhs, rhs);
         }
@@ -256,9 +259,9 @@ namespace xsimd
          ********/
 
         template <class A>
-        batch<double, A> ssub(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> ssub(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
-            return sub(lhs, rhs, neon64{});
+            return sub(lhs, rhs, neon64 {});
         }
 
         /*******
@@ -266,7 +269,7 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> mul(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> mul(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vmulq_f64(lhs, rhs);
         }
@@ -276,20 +279,20 @@ namespace xsimd
          *******/
 
 #if defined(XSIMD_FAST_INTEGER_DIVISION)
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcvtq_u64_f64(vcvtq_f64_u64(lhs) / vcvtq_f64_u64(rhs));
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcvtq_s64_f64(vcvtq_f64_s64(lhs) / vcvtq_f64_s64(rhs));
         }
 #endif
         template <class A>
-        batch<double, A> div(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> div(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vdivq_f64(lhs, rhs);
         }
@@ -298,38 +301,38 @@ namespace xsimd
          * eq *
          ******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_s64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> eq(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> eq(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_f64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_u64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> eq(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> eq(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vceqq_u64(lhs, rhs);
         }
@@ -338,20 +341,20 @@ namespace xsimd
          * lt *
          ******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcltq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcltq_s64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> lt(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> lt(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcltq_f64(lhs, rhs);
         }
@@ -359,21 +362,21 @@ namespace xsimd
         /******
          * le *
          ******/
-        
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcleq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcleq_s64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> le(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> le(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcleq_f64(lhs, rhs);
         }
@@ -382,20 +385,20 @@ namespace xsimd
          * gt *
          ******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgtq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgtq_s64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> gt(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> gt(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgtq_f64(lhs, rhs);
         }
@@ -404,20 +407,20 @@ namespace xsimd
          * ge *
          ******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgeq_u64(lhs, rhs);
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgeq_s64(lhs, rhs);
         }
 
         template <class A>
-        batch_bool<double, A> ge(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> ge(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vcgeq_f64(lhs, rhs);
         }
@@ -427,14 +430,14 @@ namespace xsimd
          ***************/
 
         template <class A>
-        batch<double, A> bitwise_and(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> bitwise_and(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(lhs),
                                                    vreinterpretq_u64_f64(rhs)));
         }
 
         template <class A>
-        batch_bool<double, A> bitwise_and(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> bitwise_and(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vandq_u64(lhs, rhs);
         }
@@ -444,14 +447,14 @@ namespace xsimd
          **************/
 
         template <class A>
-        batch<double, A> bitwise_or(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> bitwise_or(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(lhs),
                                                    vreinterpretq_u64_f64(rhs)));
         }
 
         template <class A>
-        batch_bool<double, A> bitwise_or(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> bitwise_or(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vorrq_u64(lhs, rhs);
         }
@@ -461,14 +464,14 @@ namespace xsimd
          ***************/
 
         template <class A>
-        batch<double, A> bitwise_xor(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> bitwise_xor(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(lhs),
                                                    vreinterpretq_u64_f64(rhs)));
         }
 
         template <class A>
-        batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return veorq_u64(lhs, rhs);
         }
@@ -478,9 +481,9 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch_bool<double, A> neq(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> neq(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
-            return bitwise_xor(lhs, rhs, A{});
+            return bitwise_xor(lhs, rhs, A {});
         }
 
         /***************
@@ -488,13 +491,13 @@ namespace xsimd
          ***************/
 
         template <class A>
-        batch<double, A> bitwise_not(batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> bitwise_not(batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u32(vmvnq_u32(vreinterpretq_u32_f64(rhs)));
         }
 
         template <class A>
-        batch_bool<double, A> bitwise_not(batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> bitwise_not(batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return detail::bitwise_not_u64(rhs);
         }
@@ -504,14 +507,14 @@ namespace xsimd
          ******************/
 
         template <class A>
-        batch<double, A> bitwise_andnot(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> bitwise_andnot(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(lhs),
                                                    vreinterpretq_u64_f64(rhs)));
         }
-        
+
         template <class A>
-        batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>)
+        inline batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& lhs, batch_bool<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vbicq_u64(lhs, rhs);
         }
@@ -521,7 +524,7 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> min(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> min(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vminq_f64(lhs, rhs);
         }
@@ -531,7 +534,7 @@ namespace xsimd
          *******/
 
         template <class A>
-        batch<double, A> max(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> max(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vmaxq_f64(lhs, rhs);
         }
@@ -540,20 +543,20 @@ namespace xsimd
          * abs *
          *******/
 
-        template <class A, class T,  detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> abs(batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
+        inline batch<T, A> abs(batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return rhs;
         }
 
-        template <class A, class T,  detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> abs(batch<T, A> const& rhs, requires_arch<neon64>)
+        template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
+        inline batch<T, A> abs(batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vabsq_s64(rhs);
         }
 
         template <class A>
-        batch<double, A> abs(batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> abs(batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vabsq_f64(rhs);
         }
@@ -563,7 +566,7 @@ namespace xsimd
          ********/
 
         template <class A>
-        batch<double, A> sqrt(batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> sqrt(batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vsqrtq_f64(rhs);
         }
@@ -571,16 +574,16 @@ namespace xsimd
         /********************
          * Fused operations *
          ********************/
-        
+
 #ifdef __ARM_FEATURE_FMA
         template <class A>
-        batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<neon64>)
+        inline batch<double, A> fma(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<neon64>) noexcept
         {
             return vfmaq_f64(z, x, y);
         }
 
         template <class A>
-        batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<neon64>)
+        inline batch<double, A> fms(batch<double, A> const& x, batch<double, A> const& y, batch<double, A> const& z, requires_arch<neon64>) noexcept
         {
             return vfmaq_f64(-z, x, y);
         }
@@ -591,55 +594,55 @@ namespace xsimd
          ********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 1> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_u8(arg);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 1> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_s8(arg);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 2> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_u16(arg);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 2> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_s16(arg);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 4> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_u32(arg);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 4> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_s32(arg);
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_u64(arg);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>)
+        inline typename batch<T, A>::value_type hadd(batch<T, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_s64(arg);
         }
 
         template <class A>
-        double hadd(batch<double, A> const& arg, requires_arch<neon64>)
+        inline double hadd(batch<double, A> const& arg, requires_arch<neon64>) noexcept
         {
             return vaddvq_f64(arg);
         }
@@ -649,7 +652,7 @@ namespace xsimd
          *********/
 
         template <class A>
-        batch<double, A> haddp(const batch<double, A>* row, requires_arch<neon64>)
+        inline batch<double, A> haddp(const batch<double, A>* row, requires_arch<neon64>) noexcept
         {
             return vpaddq_f64(row[0], row[1]);
         }
@@ -659,37 +662,37 @@ namespace xsimd
          **********/
 
         template <class A>
-        batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& a, batch<double, A> const& b, requires_arch<neon64>)
+        inline batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& a, batch<double, A> const& b, requires_arch<neon64>) noexcept
         {
             return vbslq_f64(cond, a, b);
         }
 
         template <class A, bool... b>
-        batch<double, A> select(batch_bool_constant<batch<double, A>, b...> const&,
-                                batch<double, A> const& true_br,
-                                batch<double, A> const& false_br,
-                                requires_arch<neon64>)
+        inline batch<double, A> select(batch_bool_constant<batch<double, A>, b...> const&,
+                                       batch<double, A> const& true_br,
+                                       batch<double, A> const& false_br,
+                                       requires_arch<neon64>) noexcept
         {
-            return select(batch_bool<double, A>{b...}, true_br, false_br, neon64{});
+            return select(batch_bool<double, A> { b... }, true_br, false_br, neon64 {});
         }
         /**********
          * zip_lo *
          **********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip1q_u64(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip1q_s64(lhs, rhs);
         }
 
         template <class A>
-        batch<double, A> zip_lo(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> zip_lo(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip1q_f64(lhs, rhs);
         }
@@ -699,19 +702,19 @@ namespace xsimd
          **********/
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip2q_u64(lhs, rhs);
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip2q_s64(lhs, rhs);
         }
 
         template <class A>
-        batch<double, A> zip_hi(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>)
+        inline batch<double, A> zip_hi(batch<double, A> const& lhs, batch<double, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vzip2q_f64(lhs, rhs);
         }
@@ -723,8 +726,8 @@ namespace xsimd
         namespace detail
         {
             template <class A, size_t I, size_t... Is>
-            batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n,
-                                          ::xsimd::detail::index_sequence<I, Is...>)
+            inline batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n,
+                                                 ::xsimd::detail::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -738,37 +741,37 @@ namespace xsimd
         }
 
         template <class A>
-        batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n, requires_arch<neon64>)
+        inline batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n, requires_arch<neon64>) noexcept
         {
             constexpr std::size_t size = batch<double, A>::size;
-            assert(0<= n && n< size && "index in bounds");
+            assert(0 <= n && n < size && "index in bounds");
             return detail::extract_pair(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
         }
 
         /******************
          * bitwise_rshift *
          ******************/
-        
+
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon64>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon64>) noexcept
         {
-            return bitwise_rshift<A>(lhs, n, neon{}); 
+            return bitwise_rshift<A>(lhs, n, neon {});
         }
 
         template <class A, class T, detail::enable_sized_unsigned_t<T, 8> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<as_signed_integer_t<T>, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vshlq_u64(lhs, vnegq_s64(rhs));
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon64>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, int n, requires_arch<neon64>) noexcept
         {
-            return bitwise_rshift<A>(lhs, n, neon{}); 
+            return bitwise_rshift<A>(lhs, n, neon {});
         }
 
         template <class A, class T, detail::enable_sized_signed_t<T, 8> = 0>
-        batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>)
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon64>) noexcept
         {
             return vshlq_s64(lhs, vnegq_s64(rhs));
         }
@@ -777,11 +780,12 @@ namespace xsimd
          * bitwise_cast *
          ****************/
 
-        #define WRAP_CAST(SUFFIX, TYPE)                                                                               \
-            namespace wrap {                                                                                          \
-                inline float64x2_t vreinterpretq_f64_##SUFFIX(TYPE a) { return ::vreinterpretq_f64_##SUFFIX(a); }     \
-                inline TYPE vreinterpretq_##SUFFIX##_f64(float64x2_t a) { return ::vreinterpretq_##SUFFIX##_f64(a); } \
-            }
+#define WRAP_CAST(SUFFIX, TYPE)                                                                                        \
+    namespace wrap                                                                                                     \
+    {                                                                                                                  \
+        inline float64x2_t vreinterpretq_f64_##SUFFIX(TYPE a) noexcept { return ::vreinterpretq_f64_##SUFFIX(a); }     \
+        inline TYPE vreinterpretq_##SUFFIX##_f64(float64x2_t a) noexcept { return ::vreinterpretq_##SUFFIX##_f64(a); } \
+    }
 
         WRAP_CAST(u8, uint8x16_t)
         WRAP_CAST(s8, int8x16_t)
@@ -793,10 +797,10 @@ namespace xsimd
         WRAP_CAST(s64, int64x2_t)
         WRAP_CAST(f32, float32x4_t)
 
-        #undef WRAP_CAST
+#undef WRAP_CAST
 
         template <class A, class T>
-        batch<double, A> bitwise_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<neon64>)
+        inline batch<double, A> bitwise_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<neon64>) noexcept
         {
             using caster_type = detail::bitwise_caster_impl<float64x2_t,
                                                             uint8x16_t, int8x16_t,
@@ -805,7 +809,7 @@ namespace xsimd
                                                             uint64x2_t, int64x2_t,
                                                             float32x4_t>;
             const caster_type caster = {
-                std::make_tuple(wrap::vreinterpretq_f64_u8,  wrap::vreinterpretq_f64_s8,  wrap::vreinterpretq_f64_u16, wrap::vreinterpretq_f64_s16,
+                std::make_tuple(wrap::vreinterpretq_f64_u8, wrap::vreinterpretq_f64_s8, wrap::vreinterpretq_f64_u16, wrap::vreinterpretq_f64_s16,
                                 wrap::vreinterpretq_f64_u32, wrap::vreinterpretq_f64_s32, wrap::vreinterpretq_f64_u64, wrap::vreinterpretq_f64_s64,
                                 wrap::vreinterpretq_f64_f32)
             };
@@ -832,7 +836,7 @@ namespace xsimd
         }
 
         template <class A, class R>
-        batch<R, A> bitwise_cast(batch<double, A> const& arg, batch<R, A> const&, requires_arch<neon64>)
+        inline batch<R, A> bitwise_cast(batch<double, A> const& arg, batch<R, A> const&, requires_arch<neon64>) noexcept
         {
             using caster_type = detail::bitwise_caster_neon64<float64x2_t,
                                                               uint8x16_t, int8x16_t,
@@ -841,7 +845,7 @@ namespace xsimd
                                                               uint64x2_t, int64x2_t,
                                                               float32x4_t>;
             const caster_type caster = {
-                std::make_tuple(wrap::vreinterpretq_u8_f64,  wrap::vreinterpretq_s8_f64,  wrap::vreinterpretq_u16_f64, wrap::vreinterpretq_s16_f64,
+                std::make_tuple(wrap::vreinterpretq_u8_f64, wrap::vreinterpretq_s8_f64, wrap::vreinterpretq_u16_f64, wrap::vreinterpretq_s16_f64,
                                 wrap::vreinterpretq_u32_f64, wrap::vreinterpretq_s32_f64, wrap::vreinterpretq_u64_f64, wrap::vreinterpretq_s64_f64,
                                 wrap::vreinterpretq_f32_f64)
             };
@@ -851,7 +855,7 @@ namespace xsimd
         }
 
         template <class A>
-        batch<double, A> bitwise_cast(batch<double, A> const& arg, batch<double, A> const&, requires_arch<neon64>)
+        inline batch<double, A> bitwise_cast(batch<double, A> const& arg, batch<double, A> const&, requires_arch<neon64>) noexcept
         {
             return arg;
         }
@@ -861,14 +865,14 @@ namespace xsimd
          *************/
 
         template <class A>
-        batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& arg, requires_arch<neon64>)
+        inline batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& arg, requires_arch<neon64>) noexcept
         {
             using register_type = typename batch_bool<int64_t, A>::register_type;
             return register_type(arg);
         }
 
         template <class A>
-        batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& arg, requires_arch<neon64>)
+        inline batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& arg, requires_arch<neon64>) noexcept
         {
             using register_type = typename batch_bool<double, A>::register_type;
             return register_type(arg);
@@ -879,7 +883,7 @@ namespace xsimd
          **********/
 
         template <class A>
-        batch<int64_t, A> to_int(const batch<double, A>& x, requires_arch<neon64>)
+        inline batch<int64_t, A> to_int(const batch<double, A>& x, requires_arch<neon64>) noexcept
         {
             return vcvtq_s64_f64(x);
         }
@@ -889,7 +893,7 @@ namespace xsimd
          ************/
 
         template <class A>
-        batch<double, A> to_float(batch<int64_t, A> const& x, requires_arch<neon64>)
+        inline batch<double, A> to_float(batch<int64_t, A> const& x, requires_arch<neon64>) noexcept
         {
             return vcvtq_f64_s64(x);
         }
@@ -899,7 +903,7 @@ namespace xsimd
          *********/
 
         template <class A>
-        batch_bool<double, A> isnan(batch<double, A> const& arg, requires_arch<neon64>)
+        inline batch_bool<double, A> isnan(batch<double, A> const& arg, requires_arch<neon64>) noexcept
         {
             return !(arg == arg);
         }
@@ -907,4 +911,3 @@ namespace xsimd
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_scalar.hpp b/third_party/xsimd/arch/xsimd_scalar.hpp
index 42adfc994..c9e7e65e7 100644
--- a/third_party/xsimd/arch/xsimd_scalar.hpp
+++ b/third_party/xsimd/arch/xsimd_scalar.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SCALAR_HPP
 #define XSIMD_SCALAR_HPP
@@ -17,8 +17,16 @@
 #include <limits>
 #include <type_traits>
 
+#ifdef XSIMD_ENABLE_XTL_COMPLEX
+#include "xtl/xcomplex.hpp"
+#endif
+
 namespace xsimd
 {
+    template <class T, class A>
+    class batch;
+    template <class T, class A>
+    class batch_bool;
 
     using std::abs;
 
@@ -26,8 +34,8 @@ namespace xsimd
     using std::acosh;
     using std::asin;
     using std::asinh;
-    using std::atan2;
     using std::atan;
+    using std::atan2;
     using std::atanh;
     using std::cbrt;
     using std::ceil;
@@ -36,30 +44,28 @@ namespace xsimd
     using std::cosh;
     using std::erf;
     using std::erfc;
-    using std::exp2;
     using std::exp;
+    using std::exp2;
     using std::expm1;
     using std::fabs;
     using std::fdim;
+    using std::floor;
     using std::fmax;
     using std::fmin;
-    using std::floor;
     using std::fmod;
     using std::hypot;
-    using std::lgamma;
     using std::ldexp;
+    using std::lgamma;
+    using std::log;
     using std::log10;
     using std::log1p;
     using std::log2;
-    using std::log;
     using std::modf;
     using std::nearbyint;
     using std::nextafter;
     using std::proj;
     using std::remainder;
     using std::rint;
-    using std::rint;
-    using std::round;
     using std::round;
     using std::sin;
     using std::sinh;
@@ -76,43 +82,43 @@ namespace xsimd
 #else
     // Windows defines catch all templates
     template <class T>
-    typename std::enable_if<std::is_floating_point<T>::value, bool>::type
-    isfinite(T var)
+    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    isfinite(T var) noexcept
     {
         return std::isfinite(var);
     }
 
     template <class T>
-    typename std::enable_if<std::is_integral<T>::value, bool>::type
-    isfinite(T var)
+    inline typename std::enable_if<std::is_integral<T>::value, bool>::type
+    isfinite(T var) noexcept
     {
         return isfinite(double(var));
     }
 
     template <class T>
-    typename std::enable_if<std::is_floating_point<T>::value, bool>::type
-    isinf(T var)
+    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    isinf(T var) noexcept
     {
         return std::isinf(var);
     }
 
     template <class T>
-    typename std::enable_if<std::is_integral<T>::value, bool>::type
-    isinf(T var)
+    inline typename std::enable_if<std::is_integral<T>::value, bool>::type
+    isinf(T var) noexcept
     {
         return isinf(double(var));
     }
 
     template <class T>
-    typename std::enable_if<std::is_floating_point<T>::value, bool>::type
-    isnan(T var)
+    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    isnan(T var) noexcept
     {
         return std::isnan(var);
     }
 
     template <class T>
-    typename std::enable_if<std::is_integral<T>::value, bool>::type
-    isnan(T var)
+    inline typename std::enable_if<std::is_integral<T>::value, bool>::type
+    isnan(T var) noexcept
     {
         return isnan(double(var));
     }
@@ -120,13 +126,13 @@ namespace xsimd
 
 #ifdef XSIMD_ENABLE_NUMPY_COMPLEX
     template <class T>
-    bool isnan(std::complex<T> var)
+    inline bool isnan(std::complex<T> var) noexcept
     {
         return std::isnan(std::real(var)) || std::isnan(std::imag(var));
     }
 
     template <class T>
-    bool isinf(std::complex<T> var)
+    inline bool isinf(std::complex<T> var) noexcept
     {
         return std::isinf(std::real(var)) || std::isinf(std::imag(var));
     }
@@ -134,77 +140,75 @@ namespace xsimd
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     using xtl::abs;
-    using xtl::norm;
-    using xtl::proj;
+    using xtl::acos;
+    using xtl::acosh;
+    using xtl::asin;
+    using xtl::asinh;
+    using xtl::atan;
+    using xtl::atanh;
+    using xtl::cos;
+    using xtl::cosh;
     using xtl::exp;
     using xtl::log;
     using xtl::log10;
+    using xtl::norm;
     using xtl::pow;
-    using xtl::sqrt;
+    using xtl::proj;
     using xtl::sin;
-    using xtl::cos;
-    using xtl::tan;
-    using xtl::asin;
-    using xtl::acos;
-    using xtl::atan;
     using xtl::sinh;
-    using xtl::cosh;
+    using xtl::sqrt;
+    using xtl::tan;
     using xtl::tanh;
-    using xtl::asinh;
-    using xtl::acosh;
-    using xtl::atanh;
 #endif
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    inline bool is_flint(const T& x)
+    inline bool is_flint(const T& x) noexcept
     {
         return std::isnan(x - x) ? std::numeric_limits<T>::quiet_NaN() : x - std::trunc(x);
     }
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    inline bool is_odd(const T& x)
+    inline bool is_odd(const T& x) noexcept
     {
         return is_even(x - 1.);
     }
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    inline bool is_even(const T& x)
+    inline bool is_even(const T& x) noexcept
     {
         return is_flint(x * T(0.5));
     }
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    inline T exp10(const T& x)
+    inline T exp10(const T& x) noexcept
     {
         // FIXME: faster alternatives exist
         return std::pow(T(10), x);
     }
 
-
     namespace detail
     {
         template <class C>
-        inline C expm1_complex_scalar_impl(const C& val)
+        inline C expm1_complex_scalar_impl(const C& val) noexcept
         {
             using T = typename C::value_type;
             T isin = std::sin(val.imag());
             T rem1 = std::expm1(val.real());
             T re = rem1 + T(1.);
             T si = std::sin(val.imag() * T(0.5));
-            return std::complex<T>(rem1 - T(2.) * re *si * si, re * isin);
+            return std::complex<T>(rem1 - T(2.) * re * si * si, re * isin);
         }
     }
 
-
     template <class T>
-    inline std::complex<T> expm1(const std::complex<T>& val)
+    inline std::complex<T> expm1(const std::complex<T>& val) noexcept
     {
         return detail::expm1_complex_scalar_impl(val);
     }
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T, bool i3ec>
-    inline xtl::xcomplex<T, T, i3ec> expm1(const xtl::xcomplex<T, T, i3ec>& val)
+    inline xtl::xcomplex<T, T, i3ec> expm1(const xtl::xcomplex<T, T, i3ec>& val) noexcept
     {
         return detail::expm1_complex_scalar_impl(val);
     }
@@ -213,7 +217,7 @@ namespace xsimd
     namespace detail
     {
         template <class C>
-        inline C log1p_complex_scalar_impl(const C& val)
+        inline C log1p_complex_scalar_impl(const C& val) noexcept
         {
             using T = typename C::value_type;
             C u = C(1.) + val;
@@ -222,19 +226,19 @@ namespace xsimd
     }
 
     template <class T>
-    inline std::complex<T> log1p(const std::complex<T>& val)
+    inline std::complex<T> log1p(const std::complex<T>& val) noexcept
     {
         return detail::log1p_complex_scalar_impl(val);
     }
 
     template <class T>
-    std::complex<T> log2(const std::complex<T>& val)
+    inline std::complex<T> log2(const std::complex<T>& val) noexcept
     {
         return log(val) / std::log(T(2));
     }
 
-    template<typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    T sadd(const T& lhs, const T& rhs)
+    template <typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    inline T sadd(const T& lhs, const T& rhs) noexcept
     {
         if (std::numeric_limits<T>::is_signed)
         {
@@ -246,7 +250,8 @@ namespace xsimd
             {
                 return std::numeric_limits<T>::lowest();
             }
-            else {
+            else
+            {
                 return lhs + rhs;
             }
         }
@@ -260,12 +265,11 @@ namespace xsimd
             {
                 return lhs + rhs;
             }
-
         }
     }
 
-    template<typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    T ssub(const T& lhs, const T& rhs)
+    template <typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    inline T ssub(const T& lhs, const T& rhs) noexcept
     {
         if (std::numeric_limits<T>::is_signed)
         {
@@ -281,57 +285,61 @@ namespace xsimd
             {
                 return lhs - rhs;
             }
-
         }
     }
 
-    namespace detail {
-      template <class T> struct value_type_or_type_helper {
-        using type = T;
-      };
-      template<class T, class A> struct value_type_or_type_helper<batch<T, A>> {
-        using type = T;
-      };
-
-      template<class T>
-      using value_type_or_type = typename value_type_or_type_helper<T>::type;
-
-      template <class T0, class T1>
-      inline typename std::enable_if<std::is_integral<T1>::value, T0>::type
-      ipow(const T0& x, const T1& n)
-      {
-        static_assert(std::is_integral<T1>::value, "second argument must be an integer");
-        T0 a = x;
-        T1 b = n;
-        bool const recip = b < 0;
-        T0 r(static_cast<value_type_or_type<T0>>(1));
-        while (1)
+    namespace detail
+    {
+        template <class T>
+        struct value_type_or_type_helper
         {
-            if (b & 1)
-            {
-                r *= a;
-            }
-            b /= 2;
-            if (b == 0)
+            using type = T;
+        };
+        template <class T, class A>
+        struct value_type_or_type_helper<batch<T, A>>
+        {
+            using type = T;
+        };
+
+        template <class T>
+        using value_type_or_type = typename value_type_or_type_helper<T>::type;
+
+        template <class T0, class T1>
+        inline typename std::enable_if<std::is_integral<T1>::value, T0>::type
+        ipow(const T0& x, const T1& n) noexcept
+        {
+            static_assert(std::is_integral<T1>::value, "second argument must be an integer");
+            T0 a = x;
+            T1 b = n;
+            bool const recip = b < 0;
+            T0 r(static_cast<value_type_or_type<T0>>(1));
+            while (1)
             {
-                break;
+                if (b & 1)
+                {
+                    r *= a;
+                }
+                b /= 2;
+                if (b == 0)
+                {
+                    break;
+                }
+                a *= a;
             }
-            a *= a;
+            return recip ? 1 / r : r;
         }
-        return recip ? 1 / r : r;
-      }
     }
 
     template <class T0, class T1>
     inline typename std::enable_if<std::is_integral<T1>::value, T0>::type
-    pow(const T0& x, const T1& n)
+    pow(const T0& x, const T1& n) noexcept
     {
-      return detail::ipow(x, n);
+        return detail::ipow(x, n);
     }
 
     template <class T0, class T1>
     inline auto
-    pow(const T0& t0, const T1& t1)
+    pow(const T0& t0, const T1& t1) noexcept
         -> typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value, decltype(std::pow(t0, t1))>::type
     {
         return std::pow(t0, t1);
@@ -339,53 +347,54 @@ namespace xsimd
 
     template <class T0, class T1>
     inline typename std::enable_if<std::is_integral<T1>::value, std::complex<T0>>::type
-    pow(const std::complex<T0>& t0, const T1& t1)
+    pow(const std::complex<T0>& t0, const T1& t1) noexcept
     {
         return detail::ipow(t0, t1);
     }
 
     template <class T0, class T1>
     inline typename std::enable_if<!std::is_integral<T1>::value, std::complex<T0>>::type
-    pow(const std::complex<T0>& t0, const T1& t1)
+    pow(const std::complex<T0>& t0, const T1& t1) noexcept
     {
-      return std::pow(t0, t1);
+        return std::pow(t0, t1);
     }
 
     template <class T0, class T1>
     inline auto
-    pow(const T0& t0, const std::complex<T1>& t1)
+    pow(const T0& t0, const std::complex<T1>& t1) noexcept
         -> typename std::enable_if<std::is_scalar<T0>::value, decltype(std::pow(t0, t1))>::type
     {
-      return std::pow(t0, t1);
+        return std::pow(t0, t1);
     }
 
     template <class T>
-    inline auto bitofsign(T const& x) -> decltype(std::signbit(x))
+    inline auto bitofsign(T const& x) noexcept -> decltype(std::signbit(x))
     {
         return std::signbit(x);
     }
 
     template <class T>
-    inline auto signbit(T const& v) -> decltype(bitofsign(v))
+    inline auto signbit(T const& v) noexcept -> decltype(bitofsign(v))
     {
         return bitofsign(v);
     }
 
-   inline double sign(bool const &v)
+    inline double sign(bool const& v) noexcept
     {
         return v;
     }
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    inline T sign(const T& v)
+    inline T sign(const T& v) noexcept
     {
-        return v < T(0) ? T(-1.) : v == T(0) ? T(0.) : T(1.);
+        return v < T(0) ? T(-1.) : v == T(0) ? T(0.)
+                                             : T(1.);
     }
 
     namespace detail
     {
         template <class C>
-        inline C sign_complex_scalar_impl(const C& v)
+        inline C sign_complex_scalar_impl(const C& v) noexcept
         {
             using value_type = typename C::value_type;
             if (v.real())
@@ -400,14 +409,14 @@ namespace xsimd
     }
 
     template <class T>
-    inline std::complex<T> sign(const std::complex<T>& v)
+    inline std::complex<T> sign(const std::complex<T>& v) noexcept
     {
         return detail::sign_complex_scalar_impl(v);
     }
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T, bool i3ec>
-    inline xtl::xcomplex<T, T, i3ec> sign(const xtl::xcomplex<T, T, i3ec>& v)
+    inline xtl::xcomplex<T, T, i3ec> sign(const xtl::xcomplex<T, T, i3ec>& v) noexcept
     {
         return detail::sign_complex_scalar_impl(v);
     }
@@ -415,25 +424,24 @@ namespace xsimd
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T, bool i3ec>
-    inline xtl::xcomplex<T, T, i3ec> log2(const xtl::xcomplex<T, T, i3ec>& val)
+    inline xtl::xcomplex<T, T, i3ec> log2(const xtl::xcomplex<T, T, i3ec>& val) noexcept
     {
         return log(val) / log(T(2));
     }
 #endif
 
-
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T, bool i3ec>
-    inline xtl::xcomplex<T, T, i3ec> log1p(const xtl::xcomplex<T, T, i3ec>& val)
+    inline xtl::xcomplex<T, T, i3ec> log1p(const xtl::xcomplex<T, T, i3ec>& val) noexcept
     {
         return detail::log1p_complex_scalar_impl(val);
     }
 #endif
 
     template <class T0, class T1>
-    inline auto min(T0 const &self, T1 const &other) ->
-        typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                typename std::decay<decltype(self > other ? other : self)>::type>::type
+    inline auto min(T0 const& self, T1 const& other) noexcept
+        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
+                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self > other ? other : self;
     }
@@ -441,15 +449,15 @@ namespace xsimd
     // numpy defines minimum operator on complex using lexical comparison
     template <class T0, class T1>
     inline std::complex<typename std::common_type<T0, T1>::type>
-    min(std::complex<T0> const &self, std::complex<T1> const &other)
+    min(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);
     }
 
-   template <class T0, class T1>
-    inline auto max(T0 const &self, T1 const &other) ->
-        typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                typename std::decay<decltype(self > other ? other : self)>::type>::type
+    template <class T0, class T1>
+    inline auto max(T0 const& self, T1 const& other) noexcept
+        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
+                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self < other ? other : self;
     }
@@ -457,13 +465,13 @@ namespace xsimd
     // numpy defines maximum operator on complex using lexical comparison
     template <class T0, class T1>
     inline std::complex<typename std::common_type<T0, T1>::type>
-    max(std::complex<T0> const &self, std::complex<T1> const &other)
+    max(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() > other.real()) ? (self) : (self.real() == other.real() ? (self.imag() > other.imag() ? self : other) : other);
     }
 
     template <class T>
-    inline typename std::enable_if<std::is_scalar<T>::value, T>::type fma(const T& a, const T& b, const T& c)
+    inline typename std::enable_if<std::is_scalar<T>::value, T>::type fma(const T& a, const T& b, const T& c) noexcept
     {
         return std::fma(a, b, c);
     }
@@ -471,22 +479,22 @@ namespace xsimd
     namespace detail
     {
         template <class C>
-        inline C fma_complex_scalar_impl(const C& a, const C& b, const C& c)
+        inline C fma_complex_scalar_impl(const C& a, const C& b, const C& c) noexcept
         {
-            return {fms(a.real(), b.real(), fms(a.imag(), b.imag(), c.real())),
-                    fma(a.real(), b.imag(), fma(a.imag(), b.real(), c.imag()))};
+            return { fms(a.real(), b.real(), fms(a.imag(), b.imag(), c.real())),
+                     fma(a.real(), b.imag(), fma(a.imag(), b.real(), c.imag())) };
         }
     }
 
     template <class T>
-    inline std::complex<T> fma(const std::complex<T>& a, const std::complex<T>& b, const std::complex<T>& c)
+    inline std::complex<T> fma(const std::complex<T>& a, const std::complex<T>& b, const std::complex<T>& c) noexcept
     {
         return detail::fma_complex_scalar_impl(a, b, c);
     }
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T, bool i3ec>
-    inline xtl::xcomplex<T, T, i3ec> fma(const xtl::xcomplex<T, T, i3ec>& a, const xtl::xcomplex<T, T, i3ec>& b, const xtl::xcomplex<T, T, i3ec>& c)
+    inline xtl::xcomplex<T, T, i3ec> fma(const xtl::xcomplex<T, T, i3ec>& a, const xtl::xcomplex<T, T, i3ec>& b, const xtl::xcomplex<T, T, i3ec>& c) noexcept
     {
         return detail::fma_complex_scalar_impl(a, b, c);
     }
@@ -494,14 +502,15 @@ namespace xsimd
 
     namespace detail
     {
-#define XSIMD_HASSINCOS_TRAIT(func) \
-        template<class S> \
-        struct has##func \
-        { \
-          template<class T> static auto get(T* ptr) -> decltype(func(std::declval<T>(), std::declval<T*>(), std::declval<T*>()), std::true_type{});\
-          static std::false_type get(...); \
-          static constexpr bool value = decltype(get((S*)nullptr))::value; \
-        }
+#define XSIMD_HASSINCOS_TRAIT(func)                                                                                              \
+    template <class S>                                                                                                           \
+    struct has##func                                                                                                             \
+    {                                                                                                                            \
+        template <class T>                                                                                                       \
+        static auto get(T* ptr) -> decltype(func(std::declval<T>(), std::declval<T*>(), std::declval<T*>()), std::true_type {}); \
+        static std::false_type get(...);                                                                                         \
+        static constexpr bool value = decltype(get((S*)nullptr))::value;                                                         \
+    }
 
 #define XSIMD_HASSINCOS(func, T) has##func<T>::value
 
@@ -512,48 +521,48 @@ namespace xsimd
 
         struct generic_sincosf
         {
-            template<class T>
+            template <class T>
             typename std::enable_if<XSIMD_HASSINCOS(sincosf, T), void>::type
-            operator()(float val, T &s, T &c)
+            operator()(float val, T& s, T& c)
             {
                 sincosf(val, &s, &c);
             }
 
-            template<class T>
+            template <class T>
             typename std::enable_if<!XSIMD_HASSINCOS(sincosf, T) && XSIMD_HASSINCOS(__sincosf, T), void>::type
-            operator()(float val, T &s, T &c)
+            operator()(float val, T& s, T& c)
             {
                 __sincosf(val, &s, &c);
             }
 
-            template<class T>
+            template <class T>
             typename std::enable_if<!XSIMD_HASSINCOS(sincosf, T) && !XSIMD_HASSINCOS(__sincosf, T), void>::type
-            operator()(float val, T &s, T &c)
+            operator()(float val, T& s, T& c)
             {
                 s = std::sin(val);
                 c = std::cos(val);
             }
         };
 
-       struct generic_sincos
+        struct generic_sincos
         {
-            template<class T>
+            template <class T>
             typename std::enable_if<XSIMD_HASSINCOS(sincos, T), void>::type
-            operator()(double val, T &s, T &c)
+            operator()(double val, T& s, T& c)
             {
                 sincos(val, &s, &c);
             }
 
-            template<class T>
+            template <class T>
             typename std::enable_if<!XSIMD_HASSINCOS(sincos, T) && XSIMD_HASSINCOS(__sincos, T), void>::type
-            operator()(double val, T &s, T &c)
+            operator()(double val, T& s, T& c)
             {
                 __sincos(val, &s, &c);
             }
 
-            template<class T>
+            template <class T>
             typename std::enable_if<!XSIMD_HASSINCOS(sincos, T) && !XSIMD_HASSINCOS(__sincos, T), void>::type
-            operator()(double val, T &s, T &c)
+            operator()(double val, T& s, T& c)
             {
                 s = std::sin(val);
                 c = std::cos(val);
@@ -564,18 +573,18 @@ namespace xsimd
 #undef XSIMD_HASSINCOS
     }
 
-    inline void sincos(float val, float&s, float& c)
+    inline void sincos(float val, float& s, float& c) noexcept
     {
-        detail::generic_sincosf{}(val, s, c);
+        detail::generic_sincosf {}(val, s, c);
     }
 
-    inline void sincos(double val, double&s, double& c)
+    inline void sincos(double val, double& s, double& c) noexcept
     {
-        detail::generic_sincos{}(val, s, c);
+        detail::generic_sincos {}(val, s, c);
     }
 
     template <class T>
-    inline void sincos(const std::complex<T>& val, std::complex<T>& s, std::complex<T>& c)
+    inline void sincos(const std::complex<T>& val, std::complex<T>& s, std::complex<T>& c) noexcept
     {
         s = std::sin(val);
         c = std::cos(val);
@@ -583,7 +592,7 @@ namespace xsimd
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
     template <class T>
-    inline void sincos(const xtl::xcomplex<T>& val, xtl::xcomplex<T>& s, xtl::xcomplex<T>& c)
+    inline void sincos(const xtl::xcomplex<T>& val, xtl::xcomplex<T>& s, xtl::xcomplex<T>& c) noexcept
     {
         s = sin(val);
         c = cos(val);
@@ -591,19 +600,18 @@ namespace xsimd
 #endif
 
     template <class T>
-    inline T frexp(T const& val, int& exp)
+    inline T frexp(T const& val, int& exp) noexcept
     {
         return std::frexp(val, &exp);
     }
 
     template <class T>
-    inline decltype(abs(std::declval<T>())) norm(const T& val)
+    inline decltype(abs(std::declval<T>())) norm(const T& val) noexcept
     {
         auto tmp = abs(val);
         return tmp * tmp;
     }
 
-
 }
 
 #endif
diff --git a/third_party/xsimd/arch/xsimd_sse2.hpp b/third_party/xsimd/arch/xsimd_sse2.hpp
index 755956d67..d5306f1aa 100644
--- a/third_party/xsimd/arch/xsimd_sse2.hpp
+++ b/third_party/xsimd/arch/xsimd_sse2.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE2_HPP
 #define XSIMD_SSE2_HPP
@@ -18,428 +18,632 @@
 
 #include "../types/xsimd_sse2_register.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
+    template <class batch_type, bool... Values>
+    struct batch_bool_constant;
 
-  namespace kernel {
-    using namespace types;
+    namespace kernel
+    {
+        using namespace types;
 
-    // abs
-    template<class A> batch<double, A> abs(batch<double, A> const& self, requires_arch<sse2>) {
-      __m128d sign_mask = _mm_set1_pd(-0.f);  // -0.f = 1 << 31
-      return _mm_andnot_pd(sign_mask, self);
-    }
-    template<class A> batch<float, A> abs(batch<float, A> const& self, requires_arch<sse2>) {
-      __m128 sign_mask = _mm_set1_ps(-0.f);  // -0.f = 1 << 31
-      return _mm_andnot_ps(sign_mask, self);
-    }
+        // abs
+        template <class A>
+        inline batch<double, A> abs(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            __m128d sign_mask = _mm_set1_pd(-0.f); // -0.f = 1 << 31
+            return _mm_andnot_pd(sign_mask, self);
+        }
+        template <class A>
+        inline batch<float, A> abs(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            __m128 sign_mask = _mm_set1_ps(-0.f); // -0.f = 1 << 31
+            return _mm_andnot_ps(sign_mask, self);
+        }
 
-    // add
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_add_epi8(self, other);
-        case 2: return _mm_add_epi16(self, other);
-        case 4: return _mm_add_epi32(self, other);
-        case 8: return _mm_add_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+        // add
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_add_epi8(self, other);
+            case 2:
+                return _mm_add_epi16(self, other);
+            case 4:
+                return _mm_add_epi32(self, other);
+            case 8:
+                return _mm_add_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    template<class A> batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_add_ps(self, other);
-    }
+        template <class A>
+        inline batch<float, A> add(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_add_ps(self, other);
+        }
 
-    template<class A> batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_add_pd(self, other);
-    }
+        template <class A>
+        inline batch<double, A> add(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_add_pd(self, other);
+        }
 
-    // all
-    template<class A> bool all(batch_bool<float, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_ps(self) == 0x0F;
-    }
-    template<class A> bool all(batch_bool<double, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_pd(self) == 0x03;
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    bool all(batch_bool<T, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_epi8(self) == 0xFFFF;
-    }
+        // all
+        template <class A>
+        inline bool all(batch_bool<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_ps(self) == 0x0F;
+        }
+        template <class A>
+        inline bool all(batch_bool<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_pd(self) == 0x03;
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline bool all(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_epi8(self) == 0xFFFF;
+        }
 
-    // any
-    template<class A> bool any(batch_bool<float, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_ps(self) != 0;
-    }
-    template<class A> bool any(batch_bool<double, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_pd(self) != 0;
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    bool any(batch_bool<T, A> const& self, requires_arch<sse2>) {
-      return _mm_movemask_epi8(self) != 0;
-    }
+        // any
+        template <class A>
+        inline bool any(batch_bool<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_ps(self) != 0;
+        }
+        template <class A>
+        inline bool any(batch_bool<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_pd(self) != 0;
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline bool any(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_movemask_epi8(self) != 0;
+        }
 
-    // bitwise_and
-    template<class A> batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_and_ps(self, other);
-    }
-    template<class A> batch_bool<float, A> bitwise_and(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return _mm_and_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return _mm_and_si128(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-      return _mm_and_si128(self, other);
-    }
+        // bitwise_and
+        template <class A>
+        inline batch<float, A> bitwise_and(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_and(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_si128(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_si128(self, other);
+        }
 
-    template<class A> batch<double, A> bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_and_pd(self, other);
-    }
+        template <class A>
+        batch<double, A> inline bitwise_and(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_pd(self, other);
+        }
 
-    template<class A> batch_bool<double, A> bitwise_and(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return _mm_and_pd(self, other);
-    }
+        template <class A>
+        inline batch_bool<double, A> bitwise_and(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_and_pd(self, other);
+        }
 
-    // bitwise_andnot
-    template<class A> batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_ps(self, other);
-    }
+        // bitwise_andnot
+        template <class A>
+        inline batch<float, A> bitwise_andnot(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_ps(self, other);
+        }
 
-    template<class A> batch_bool<float, A> bitwise_andnot(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_si128(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_si128(self, other);
-    }
+        template <class A>
+        inline batch_bool<float, A> bitwise_andnot(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_si128(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_si128(self, other);
+        }
 
-    template<class A> batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_pd(self, other);
-    }
-    
-    template<class A> batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return _mm_andnot_pd(self, other);
-    }
+        template <class A>
+        inline batch<double, A> bitwise_andnot(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_pd(self, other);
+        }
 
-    // bitwise_lshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_and_si128(_mm_set1_epi8(0xFF << other), _mm_slli_epi32(self, other));
-        case 2: return _mm_slli_epi16(self, other);
-        case 4: return _mm_slli_epi32(self, other);
-        case 8: return _mm_slli_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+        template <class A>
+        inline batch_bool<double, A> bitwise_andnot(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_andnot_pd(self, other);
+        }
 
-    // bitwise_not
-    template<class A> batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(-1)));
-    }
-    template<class A> batch_bool<float, A> bitwise_not(batch_bool<float, A> const& self, requires_arch<sse2>) {
-      return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(-1)));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<sse2>) {
-      return _mm_xor_si128(self, _mm_set1_epi32(-1));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<sse2>) {
-      return _mm_xor_si128(self, _mm_set1_epi32(-1));
-    }
-    template <class A>
-    batch<double, A> bitwise_not(batch<double, A> const &self, requires_arch<sse2>) {
-      return _mm_xor_pd(self, _mm_castsi128_pd(_mm_set1_epi32(-1)));
-    }
-    template <class A>
-    batch_bool<double, A> bitwise_not(batch_bool<double, A> const &self, requires_arch<sse2>) {
-      return _mm_xor_pd(self, _mm_castsi128_pd(_mm_set1_epi32(-1)));
-    }
+        // bitwise_lshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_and_si128(_mm_set1_epi8(0xFF << other), _mm_slli_epi32(self, other));
+            case 2:
+                return _mm_slli_epi16(self, other);
+            case 4:
+                return _mm_slli_epi32(self, other);
+            case 8:
+                return _mm_slli_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    // bitwise_or
-    template<class A> batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_or_ps(self, other);
-    }
-    template<class A> batch_bool<float, A> bitwise_or(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return _mm_or_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return _mm_or_si128(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-      return _mm_or_si128(self, other);
-    }
+        // bitwise_not
+        template <class A>
+        inline batch<float, A> bitwise_not(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_not(batch_bool<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(-1)));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_si128(self, _mm_set1_epi32(-1));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_si128(self, _mm_set1_epi32(-1));
+        }
+        template <class A>
+        inline batch<double, A> bitwise_not(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_pd(self, _mm_castsi128_pd(_mm_set1_epi32(-1)));
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_not(batch_bool<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_pd(self, _mm_castsi128_pd(_mm_set1_epi32(-1)));
+        }
 
-    template<class A> batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_or_pd(self, other);
-    }
+        // bitwise_or
+        template <class A>
+        inline batch<float, A> bitwise_or(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_or(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_si128(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_si128(self, other);
+        }
 
-    template<class A> batch_bool<double, A> bitwise_or(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return _mm_or_pd(self, other);
-    }
+        template <class A>
+        inline batch<double, A> bitwise_or(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_pd(self, other);
+        }
 
-    // bitwise_rshift
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: {
-            __m128i sign_mask = _mm_set1_epi16((0xFF00 >> other) & 0x00FF);
-            __m128i cmp_is_negative = _mm_cmpgt_epi8(_mm_setzero_si128(), self);
-            __m128i res = _mm_srai_epi16(self, other);
-            return _mm_or_si128(_mm_and_si128(sign_mask, cmp_is_negative), _mm_andnot_si128(sign_mask, res));
-          }
-          case 2: return _mm_srai_epi16(self, other);
-          case 4: return _mm_srai_epi32(self, other);
-          case 8: {
-            // from https://github.com/samyvilar/vect/blob/master/vect_128.h
-            return _mm_or_si128(
-                _mm_srli_epi64(self, other),
-                _mm_slli_epi64(
-                    _mm_srai_epi32(_mm_shuffle_epi32(self, _MM_SHUFFLE(3, 3, 1, 1)), 32),
-                    64 - other));
-          }
-          default: assert(false && "unsupported arch/op combination"); return {};
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_and_si128(_mm_set1_epi8(0xFF >> other), _mm_srli_epi32(self, other));
-          case 2: return _mm_srli_epi16(self, other);
-          case 4: return _mm_srli_epi32(self, other);
-          case 8: return _mm_srli_epi64(self, other);
-          default: assert(false && "unsupported arch/op combination"); return {};
-        }
-      }
-    }
+        template <class A>
+        inline batch_bool<double, A> bitwise_or(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_pd(self, other);
+        }
 
-    // bitwise_xor
-    template<class A> batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_ps(self, other);
-    }
-    template<class A> batch_bool<float, A> bitwise_xor(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_si128(self, other);
-    }
-    template<class A> batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_pd(self, other);
-    }
-    template<class A> batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_pd(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-      return _mm_xor_si128(self, other);
-    }
+        // bitwise_rshift
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                {
+                    __m128i sign_mask = _mm_set1_epi16((0xFF00 >> other) & 0x00FF);
+                    __m128i cmp_is_negative = _mm_cmpgt_epi8(_mm_setzero_si128(), self);
+                    __m128i res = _mm_srai_epi16(self, other);
+                    return _mm_or_si128(_mm_and_si128(sign_mask, cmp_is_negative), _mm_andnot_si128(sign_mask, res));
+                }
+                case 2:
+                    return _mm_srai_epi16(self, other);
+                case 4:
+                    return _mm_srai_epi32(self, other);
+                case 8:
+                {
+                    // from https://github.com/samyvilar/vect/blob/master/vect_128.h
+                    return _mm_or_si128(
+                        _mm_srli_epi64(self, other),
+                        _mm_slli_epi64(
+                            _mm_srai_epi32(_mm_shuffle_epi32(self, _MM_SHUFFLE(3, 3, 1, 1)), 32),
+                            64 - other));
+                }
+                default:
+                    assert(false && "unsupported arch/op combination");
+                    return {};
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_and_si128(_mm_set1_epi8(0xFF >> other), _mm_srli_epi32(self, other));
+                case 2:
+                    return _mm_srli_epi16(self, other);
+                case 4:
+                    return _mm_srli_epi32(self, other);
+                case 8:
+                    return _mm_srli_epi64(self, other);
+                default:
+                    assert(false && "unsupported arch/op combination");
+                    return {};
+                }
+            }
+        }
 
-    // bitwise_cast
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const &, requires_arch<sse2>) {
-      return _mm_castsi128_ps(self);
-    }
-    template<class A, class T, class Tp, class=typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
-    batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const &, requires_arch<sse2>) {
-      return batch<Tp, A>(self.data);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const &, requires_arch<sse2>) {
-      return _mm_castps_si128(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const &, requires_arch<sse2>) {
-      return _mm_castsi128_pd(self);
-    }
-    template<class A>
-    batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const &, requires_arch<sse2>) {
-      return _mm_castps_pd(self);
-    }
-    template<class A>
-    batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const &, requires_arch<sse2>) {
-      return _mm_castpd_ps(self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const &, requires_arch<sse2>) {
-      return _mm_castpd_si128(self);
-    }
+        // bitwise_xor
+        template <class A>
+        inline batch<float, A> bitwise_xor(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> bitwise_xor(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_si128(self, other);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_xor(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_pd(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> bitwise_xor(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_pd(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_si128(self, other);
+        }
 
-    // bool_cast
-    template<class A> batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& self, requires_arch<sse2>) {
-        return _mm_castps_si128(self);
-    }
-    template<class A> batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& self, requires_arch<sse2>) {
-        return _mm_castsi128_ps(self);
-    }
-    template<class A> batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& self, requires_arch<sse2>) {
-        return _mm_castpd_si128(self);
-    }
-    template<class A> batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& self, requires_arch<sse2>) {
-        return _mm_castsi128_pd(self);
-    }
+        // bitwise_cast
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_ps(self);
+        }
+        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value, void>::type>
+        inline batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<sse2>) noexcept
+        {
+            return batch<Tp, A>(self.data);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castps_si128(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_pd(self);
+        }
+        template <class A>
+        inline batch<double, A> bitwise_cast(batch<float, A> const& self, batch<double, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castps_pd(self);
+        }
+        template <class A>
+        inline batch<float, A> bitwise_cast(batch<double, A> const& self, batch<float, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castpd_ps(self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<sse2>) noexcept
+        {
+            return _mm_castpd_si128(self);
+        }
 
-    // broadcast
-    template<class A> batch<float, A> broadcast(float val, requires_arch<sse2>) {
-      return _mm_set1_ps(val);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> broadcast(T val, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_set1_epi8(val);
-        case 2: return _mm_set1_epi16(val);
-        case 4: return _mm_set1_epi32(val);
-        case 8: return _mm_set1_epi64x(val);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<double, A> broadcast(double val, requires_arch<sse2>) {
-      return _mm_set1_pd(val);
-    }
+        // bool_cast
+        template <class A>
+        batch_bool<int32_t, A> inline bool_cast(batch_bool<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_castps_si128(self);
+        }
+        template <class A>
+        batch_bool<float, A> inline bool_cast(batch_bool<int32_t, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_ps(self);
+        }
+        template <class A>
+        batch_bool<int64_t, A> inline bool_cast(batch_bool<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_castpd_si128(self);
+        }
+        template <class A>
+        batch_bool<double, A> inline bool_cast(batch_bool<int64_t, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_pd(self);
+        }
 
-    // store_complex
-    namespace detail
-    {
-      // Override these methods in SSE-based archs, no need to override store_aligned / store_unaligned
-      // complex_low
-      template<class A> batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<sse2>) {
-        return _mm_unpacklo_ps(self.real(), self.imag());
-      }
-      // complex_high
-      template<class A> batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<sse2>) {
-        return _mm_unpackhi_ps(self.real(), self.imag());
-      }
-      template<class A> batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<sse2>) {
-        return _mm_unpacklo_pd(self.real(), self.imag());
-      }
-      template<class A> batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<sse2>) {
-        return _mm_unpackhi_pd(self.real(), self.imag());
-      }
-    }
+        // broadcast
+        template <class A>
+        batch<float, A> inline broadcast(float val, requires_arch<sse2>) noexcept
+        {
+            return _mm_set1_ps(val);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> broadcast(T val, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_set1_epi8(val);
+            case 2:
+                return _mm_set1_epi16(val);
+            case 4:
+                return _mm_set1_epi32(val);
+            case 8:
+                return _mm_set1_epi64x(val);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<double, A> broadcast(double val, requires_arch<sse2>) noexcept
+        {
+            return _mm_set1_pd(val);
+        }
 
-    // div
-    template<class A> batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_div_ps(self, other);
-    }
-    template<class A> batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_div_pd(self, other);
-    }
+        // store_complex
+        namespace detail
+        {
+            // Override these methods in SSE-based archs, no need to override store_aligned / store_unaligned
+            // complex_low
+            template <class A>
+            inline batch<float, A> complex_low(batch<std::complex<float>, A> const& self, requires_arch<sse2>) noexcept
+            {
+                return _mm_unpacklo_ps(self.real(), self.imag());
+            }
+            // complex_high
+            template <class A>
+            inline batch<float, A> complex_high(batch<std::complex<float>, A> const& self, requires_arch<sse2>) noexcept
+            {
+                return _mm_unpackhi_ps(self.real(), self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_low(batch<std::complex<double>, A> const& self, requires_arch<sse2>) noexcept
+            {
+                return _mm_unpacklo_pd(self.real(), self.imag());
+            }
+            template <class A>
+            inline batch<double, A> complex_high(batch<std::complex<double>, A> const& self, requires_arch<sse2>) noexcept
+            {
+                return _mm_unpackhi_pd(self.real(), self.imag());
+            }
+        }
 
-    // convert
-    namespace detail {
-    template<class A> batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<sse2>) {
-      return _mm_cvtepi32_ps(self);
-    }
-    template<class A> batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<sse2>) {
-      return _mm_cvttps_epi32(self);
-    }
-    }
+        // div
+        template <class A>
+        inline batch<float, A> div(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_div_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> div(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_div_pd(self, other);
+        }
 
-    // eq
-    template<class A> batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpeq_ps(self, other);
-    }
-    template<class A> batch_bool<float, A> eq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return  _mm_castsi128_ps(_mm_cmpeq_epi32(_mm_castps_si128(self), _mm_castps_si128(other)));
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_cmpeq_epi8(self, other);
-        case 2: return _mm_cmpeq_epi16(self, other);
-        case 4: return _mm_cmpeq_epi32(self, other);
-        case 8: {
-            __m128i tmp1 = _mm_cmpeq_epi32(self, other);
-            __m128i tmp2 = _mm_shuffle_epi32(tmp1, 0xB1);
-            __m128i tmp3 = _mm_and_si128(tmp1, tmp2);
-            __m128i tmp4 = _mm_srai_epi32(tmp3, 31);
-            return _mm_shuffle_epi32(tmp4, 0xF5);
-        }
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-      return eq(batch<T, A>(self.data), batch<T, A>(other.data));
-    }
-    template<class A> batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpeq_pd(self, other);
-    }
-    template<class A> batch_bool<double, A> eq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return  _mm_castsi128_pd(_mm_cmpeq_epi32(_mm_castpd_si128(self), _mm_castpd_si128(other)));
-    }
+        // convert
+        namespace detail
+        {
+            template <class A>
+            inline batch<float, A> fast_cast(batch<int32_t, A> const& self, batch<float, A> const&, requires_arch<sse2>) noexcept
+            {
+                return _mm_cvtepi32_ps(self);
+            }
+
+            template <class A>
+            inline batch<float, A> fast_cast(batch<uint32_t, A> const& v, batch<float, A> const&, requires_arch<sse2>) noexcept
+            {
+                // see https://stackoverflow.com/questions/34066228/how-to-perform-uint32-float-conversion-with-sse
+                __m128i msk_lo = _mm_set1_epi32(0xFFFF);
+                __m128 cnst65536f = _mm_set1_ps(65536.0f);
+
+                __m128i v_lo = _mm_and_si128(v, msk_lo); /* extract the 16 lowest significant bits of self                             */
+                __m128i v_hi = _mm_srli_epi32(v, 16); /* 16 most significant bits of v                                                 */
+                __m128 v_lo_flt = _mm_cvtepi32_ps(v_lo); /* No rounding                                                                   */
+                __m128 v_hi_flt = _mm_cvtepi32_ps(v_hi); /* No rounding                                                                   */
+                v_hi_flt = _mm_mul_ps(cnst65536f, v_hi_flt); /* No rounding                                                                   */
+                return _mm_add_ps(v_hi_flt, v_lo_flt); /* Rounding may occur here, mul and add may fuse to fma for haswell and newer    */
+            }
+
+            template <class A>
+            inline batch<int32_t, A> fast_cast(batch<float, A> const& self, batch<int32_t, A> const&, requires_arch<sse2>) noexcept
+            {
+                return _mm_cvttps_epi32(self);
+            }
 
-    // ge
-    template<class A> batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpge_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> ge(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpge_pd(self, other);
-    }
-    // gt
+        }
 
-    template<class A> batch_bool<float, A> gt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpgt_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_cmpgt_epi8(self, other);
-          case 2: return _mm_cmpgt_epi16(self, other);
-          case 4: return _mm_cmpgt_epi32(self, other);
-          default: return gt(self, other, generic{});
-        }
-      }
-      else {
-        return gt(self, other, generic{});
-      }
-    }
+        // eq
+        template <class A>
+        inline batch_bool<float, A> eq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpeq_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<float, A> eq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_ps(_mm_cmpeq_epi32(_mm_castps_si128(self), _mm_castps_si128(other)));
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_cmpeq_epi8(self, other);
+            case 2:
+                return _mm_cmpeq_epi16(self, other);
+            case 4:
+                return _mm_cmpeq_epi32(self, other);
+            case 8:
+            {
+                __m128i tmp1 = _mm_cmpeq_epi32(self, other);
+                __m128i tmp2 = _mm_shuffle_epi32(tmp1, 0xB1);
+                __m128i tmp3 = _mm_and_si128(tmp1, tmp2);
+                __m128i tmp4 = _mm_srai_epi32(tmp3, 31);
+                return _mm_shuffle_epi32(tmp4, 0xF5);
+            }
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return eq(batch<T, A>(self.data), batch<T, A>(other.data));
+        }
+        template <class A>
+        inline batch_bool<double, A> eq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpeq_pd(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> eq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_castsi128_pd(_mm_cmpeq_epi32(_mm_castpd_si128(self), _mm_castpd_si128(other)));
+        }
 
-    template<class A> batch_bool<double, A> gt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpgt_pd(self, other);
-    }
-    
-    // hadd
-    template<class A> float hadd(batch<float, A> const& self, requires_arch<sse2>) {
-      __m128 tmp0 = _mm_add_ps(self, _mm_movehl_ps(self, self));
-      __m128 tmp1 = _mm_add_ss(tmp0, _mm_shuffle_ps(tmp0, tmp0, 1));
-      return _mm_cvtss_f32(tmp1);
-    }
-    // TODO: move this in xsimd_generic
-    namespace detail
-    {
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd_default(batch<T, A> const& self, requires_arch<sse2>) {
-        alignas(A::alignment()) T buffer[batch<T, A>::size];
-        self.store_aligned(buffer);
-        T res = 0;
-        for (T val : buffer)
+        // ge
+        template <class A>
+        inline batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
         {
-            res += val;
+            return _mm_cmpge_ps(self, other);
         }
-        return res;
-    }
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd(batch<T, A> const& self, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 4: {
+        template <class A>
+        inline batch_bool<double, A> ge(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpge_pd(self, other);
+        }
+
+        // gt
+        template <class A>
+        inline batch_bool<float, A> gt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpgt_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_cmpgt_epi8(self, other);
+                case 2:
+                    return _mm_cmpgt_epi16(self, other);
+                case 4:
+                    return _mm_cmpgt_epi32(self, other);
+                default:
+                    return gt(self, other, generic {});
+                }
+            }
+            else
+            {
+                return gt(self, other, generic {});
+            }
+        }
+
+        template <class A>
+        inline batch_bool<double, A> gt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpgt_pd(self, other);
+        }
+
+        // hadd
+        template <class A>
+        inline float hadd(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            __m128 tmp0 = _mm_add_ps(self, _mm_movehl_ps(self, self));
+            __m128 tmp1 = _mm_add_ss(tmp0, _mm_shuffle_ps(tmp0, tmp0, 1));
+            return _mm_cvtss_f32(tmp1);
+        }
+        // TODO: move this in xsimd_generic
+        namespace detail
+        {
+            template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+            inline T hadd_default(batch<T, A> const& self, requires_arch<sse2>) 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;
+            }
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline T hadd(batch<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 4:
+            {
                 __m128i tmp1 = _mm_shuffle_epi32(self, 0x0E);
                 __m128i tmp2 = _mm_add_epi32(self, tmp1);
                 __m128i tmp3 = _mm_shuffle_epi32(tmp2, 0x01);
                 __m128i tmp4 = _mm_add_epi32(tmp2, tmp3);
                 return _mm_cvtsi128_si32(tmp4);
-                }
-        case 8: {
+            }
+            case 8:
+            {
                 __m128i tmp1 = _mm_shuffle_epi32(self, 0x0E);
                 __m128i tmp2 = _mm_add_epi64(self, tmp1);
 #if defined(__x86_64__)
@@ -451,479 +655,656 @@ namespace xsimd {
                 std::memcpy(&i, &m, sizeof(i));
                 return i;
 #endif
+            }
+            default:
+                return detail::hadd_default(self, A {});
+            }
+        }
+        template <class A>
+        inline double hadd(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_cvtsd_f64(_mm_add_sd(self, _mm_unpackhi_pd(self, self)));
         }
-        default: return detail::hadd_default(self, A{});
-      }
-    }
-    template <class A>
-    double hadd(batch<double, A> const &self, requires_arch<sse2>) {
-      return _mm_cvtsd_f64(_mm_add_sd(self, _mm_unpackhi_pd(self, self)));
-    }
-
-    // haddp
-    template<class A> batch<float, A> haddp(batch<float, A> const* row, requires_arch<sse2>) {
-      __m128 tmp0 = _mm_unpacklo_ps(row[0], row[1]);
-      __m128 tmp1 = _mm_unpackhi_ps(row[0], row[1]);
-      __m128 tmp2 = _mm_unpackhi_ps(row[2], row[3]);
-      tmp0 = _mm_add_ps(tmp0, tmp1);
-      tmp1 = _mm_unpacklo_ps(row[2], row[3]);
-      tmp1 = _mm_add_ps(tmp1, tmp2);
-      tmp2 = _mm_movehl_ps(tmp1, tmp0);
-      tmp0 = _mm_movelh_ps(tmp0, tmp1);
-      return _mm_add_ps(tmp0, tmp2);
-    }
-    template <class A>
-    batch<double, A> haddp(batch<double, A> const *row, requires_arch<sse2>) {
-      return _mm_add_pd(_mm_unpacklo_pd(row[0], row[1]),
-          _mm_unpackhi_pd(row[0], row[1]));
-    }
-
-    // isnan
-    template<class A> batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_cmpunord_ps(self, self);
-    }
-    template<class A> batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<sse2>) {
-      return _mm_cmpunord_pd(self, self);
-    }
-
-    // load_aligned
-    template<class A> batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<sse2>) {
-      return _mm_load_ps(mem);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<sse2>) {
-      return _mm_load_si128((__m128i const*)mem);
-    }
-    template<class A> batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<sse2>) {
-      return _mm_load_pd(mem);
-    }
 
-    // load_unaligned
-    template<class A> batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<sse2>){
-      return _mm_loadu_ps(mem);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse2>) {
-      return _mm_loadu_si128((__m128i const*)mem);
-    }
-    template<class A> batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<sse2>){
-      return _mm_loadu_pd(mem);
-    }
+        // haddp
+        template <class A>
+        inline batch<float, A> haddp(batch<float, A> const* row, requires_arch<sse2>) noexcept
+        {
+            __m128 tmp0 = _mm_unpacklo_ps(row[0], row[1]);
+            __m128 tmp1 = _mm_unpackhi_ps(row[0], row[1]);
+            __m128 tmp2 = _mm_unpackhi_ps(row[2], row[3]);
+            tmp0 = _mm_add_ps(tmp0, tmp1);
+            tmp1 = _mm_unpacklo_ps(row[2], row[3]);
+            tmp1 = _mm_add_ps(tmp1, tmp2);
+            tmp2 = _mm_movehl_ps(tmp1, tmp0);
+            tmp0 = _mm_movelh_ps(tmp0, tmp1);
+            return _mm_add_ps(tmp0, tmp2);
+        }
+        template <class A>
+        inline batch<double, A> haddp(batch<double, A> const* row, requires_arch<sse2>) noexcept
+        {
+            return _mm_add_pd(_mm_unpacklo_pd(row[0], row[1]),
+                              _mm_unpackhi_pd(row[0], row[1]));
+        }
 
-    // load_complex
-    namespace detail
-    {
-      // Redefine these methods in the SSE-based archs if required
-      template<class A> batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<sse2>) {
-        return {_mm_shuffle_ps(hi, lo, _MM_SHUFFLE(2, 0, 2, 0)), _mm_shuffle_ps(hi, lo, _MM_SHUFFLE(3, 1, 3, 1))};
-      }
-        template<class A> batch<std::complex<double>, A> load_complex(batch<double, A> const& hi, batch<double, A> const& lo, requires_arch<sse2>) {
-            return {_mm_shuffle_pd(hi, lo, _MM_SHUFFLE2(0, 0)), _mm_shuffle_pd(hi, lo, _MM_SHUFFLE2(1, 1))};
+        // isnan
+        template <class A>
+        inline batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpunord_ps(self, self);
+        }
+        template <class A>
+        inline batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpunord_pd(self, self);
         }
-    }
 
-    // le
-    template<class A> batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmple_ps(self, other);
-    }
-    template<class A> batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmple_pd(self, other);
-    }
+        // load_aligned
+        template <class A>
+        inline batch<float, A> load_aligned(float const* mem, convert<float>, requires_arch<sse2>) noexcept
+        {
+            return _mm_load_ps(mem);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<sse2>) noexcept
+        {
+            return _mm_load_si128((__m128i const*)mem);
+        }
+        template <class A>
+        inline batch<double, A> load_aligned(double const* mem, convert<double>, requires_arch<sse2>) noexcept
+        {
+            return _mm_load_pd(mem);
+        }
 
-    // lt
-    template<class A> batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmplt_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_cmplt_epi8(self, other);
-          case 2: return _mm_cmplt_epi16(self, other);
-          case 4: return _mm_cmplt_epi32(self, other);
-          case 8: {
-              __m128i tmp1 = _mm_sub_epi64(self, other);
-              __m128i tmp2 = _mm_xor_si128(self, other);
-              __m128i tmp3 = _mm_andnot_si128(other, self);
-              __m128i tmp4 = _mm_andnot_si128(tmp2, tmp1);
-              __m128i tmp5 = _mm_or_si128(tmp3, tmp4);
-              __m128i tmp6 = _mm_srai_epi32(tmp5, 31);
-              return _mm_shuffle_epi32(tmp6, 0xF5);
-          }
-          default: assert(false && "unsupported arch/op combination"); return {};
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_cmplt_epi8(_mm_xor_si128(self, _mm_set1_epi8(std::numeric_limits<int8_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi8(std::numeric_limits<int8_t>::lowest())));
-          case 2: return _mm_cmplt_epi16(_mm_xor_si128(self, _mm_set1_epi16(std::numeric_limits<int16_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi16(std::numeric_limits<int16_t>::lowest())));
-          case 4: return _mm_cmplt_epi32(_mm_xor_si128(self, _mm_set1_epi32(std::numeric_limits<int32_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi32(std::numeric_limits<int32_t>::lowest())));
-          case 8: {
-                auto xself = _mm_xor_si128(self, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
-                auto xother = _mm_xor_si128(other, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
-                __m128i tmp1 = _mm_sub_epi64(xself, xother);
-                __m128i tmp2 = _mm_xor_si128(xself, xother);
-                __m128i tmp3 = _mm_andnot_si128(xother, xself);
-                __m128i tmp4 = _mm_andnot_si128(tmp2, tmp1);
-                __m128i tmp5 = _mm_or_si128(tmp3, tmp4);
-                __m128i tmp6 = _mm_srai_epi32(tmp5, 31);
-                return _mm_shuffle_epi32(tmp6, 0xF5);
-                  }
-          default: assert(false && "unsupported arch/op combination"); return {};
-        }
-      }
-    }
-    template<class A> batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmplt_pd(self, other);
-    }
+        // load_unaligned
+        template <class A>
+        inline batch<float, A> load_unaligned(float const* mem, convert<float>, requires_arch<sse2>) noexcept
+        {
+            return _mm_loadu_ps(mem);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse2>) noexcept
+        {
+            return _mm_loadu_si128((__m128i const*)mem);
+        }
+        template <class A>
+        inline batch<double, A> load_unaligned(double const* mem, convert<double>, requires_arch<sse2>) noexcept
+        {
+            return _mm_loadu_pd(mem);
+        }
 
-    // max
-    template<class A> batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_max_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return select(self > other, self, other);
-    }
-    template<class A> batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_max_pd(self, other);
-    }
+        // load_complex
+        namespace detail
+        {
+            // Redefine these methods in the SSE-based archs if required
+            template <class A>
+            inline batch<std::complex<float>, A> load_complex(batch<float, A> const& hi, batch<float, A> const& lo, requires_arch<sse2>) noexcept
+            {
+                return { _mm_shuffle_ps(hi, lo, _MM_SHUFFLE(2, 0, 2, 0)), _mm_shuffle_ps(hi, lo, _MM_SHUFFLE(3, 1, 3, 1)) };
+            }
+            template <class A>
+            inline batch<std::complex<double>, A> load_complex(batch<double, A> const& hi, batch<double, A> const& lo, requires_arch<sse2>) noexcept
+            {
+                return { _mm_shuffle_pd(hi, lo, _MM_SHUFFLE2(0, 0)), _mm_shuffle_pd(hi, lo, _MM_SHUFFLE2(1, 1)) };
+            }
+        }
 
-    // min
-    template<class A> batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_min_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      return select(self <= other, self, other);
-    }
-    template<class A> batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_min_pd(self, other);
-    }
+        // le
+        template <class A>
+        inline batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmple_ps(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> le(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmple_pd(self, other);
+        }
 
-    // mul
-    template<class A> batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_mul_ps(self, other);
-    }
-    template<class A> batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_mul_pd(self, other);
-    }
+        // lt
+        template <class A>
+        inline batch_bool<float, A> lt(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmplt_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_cmplt_epi8(self, other);
+                case 2:
+                    return _mm_cmplt_epi16(self, other);
+                case 4:
+                    return _mm_cmplt_epi32(self, other);
+                case 8:
+                {
+                    __m128i tmp1 = _mm_sub_epi64(self, other);
+                    __m128i tmp2 = _mm_xor_si128(self, other);
+                    __m128i tmp3 = _mm_andnot_si128(other, self);
+                    __m128i tmp4 = _mm_andnot_si128(tmp2, tmp1);
+                    __m128i tmp5 = _mm_or_si128(tmp3, tmp4);
+                    __m128i tmp6 = _mm_srai_epi32(tmp5, 31);
+                    return _mm_shuffle_epi32(tmp6, 0xF5);
+                }
+                default:
+                    assert(false && "unsupported arch/op combination");
+                    return {};
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_cmplt_epi8(_mm_xor_si128(self, _mm_set1_epi8(std::numeric_limits<int8_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi8(std::numeric_limits<int8_t>::lowest())));
+                case 2:
+                    return _mm_cmplt_epi16(_mm_xor_si128(self, _mm_set1_epi16(std::numeric_limits<int16_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi16(std::numeric_limits<int16_t>::lowest())));
+                case 4:
+                    return _mm_cmplt_epi32(_mm_xor_si128(self, _mm_set1_epi32(std::numeric_limits<int32_t>::lowest())), _mm_xor_si128(other, _mm_set1_epi32(std::numeric_limits<int32_t>::lowest())));
+                case 8:
+                {
+                    auto xself = _mm_xor_si128(self, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
+                    auto xother = _mm_xor_si128(other, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
+                    __m128i tmp1 = _mm_sub_epi64(xself, xother);
+                    __m128i tmp2 = _mm_xor_si128(xself, xother);
+                    __m128i tmp3 = _mm_andnot_si128(xother, xself);
+                    __m128i tmp4 = _mm_andnot_si128(tmp2, tmp1);
+                    __m128i tmp5 = _mm_or_si128(tmp3, tmp4);
+                    __m128i tmp6 = _mm_srai_epi32(tmp5, 31);
+                    return _mm_shuffle_epi32(tmp6, 0xF5);
+                }
+                default:
+                    assert(false && "unsupported arch/op combination");
+                    return {};
+                }
+            }
+        }
 
-    // neg
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> neg(batch<T, A> const& self, requires_arch<sse2>) {
-      return 0 - self;
-    }
-    template<class A> batch<float, A> neg(batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(0x80000000)));
-    }
+        template <class A>
+        inline batch_bool<double, A> lt(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmplt_pd(self, other);
+        }
 
+        // max
+        template <class A>
+        inline batch<float, A> max(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_max_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return select(self > other, self, other);
+        }
+        template <class A>
+        inline batch<double, A> max(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_max_pd(self, other);
+        }
 
-    template <class A>
-    batch<double, A> neg(batch<double, A> const &self, requires_arch<sse2>) {
-      return _mm_xor_pd(
-          self, _mm_castsi128_pd(_mm_setr_epi32(0, 0x80000000, 0, 0x80000000)));
-    }
+        // min
+        template <class A>
+        inline batch<float, A> min(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_min_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return select(self <= other, self, other);
+        }
+        template <class A>
+        inline batch<double, A> min(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_min_pd(self, other);
+        }
 
-    // neq
-    template<class A> batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpneq_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-        return ~(self == other);
-    }
-    template<class A> batch_bool<float, A> neq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpneq_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) {
-        return ~(self == other);
-    }
+        // mul
+        template <class A>
+        inline batch<float, A> mul(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_mul_ps(self, other);
+        }
+        template <class A>
+        inline batch<double, A> mul(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_mul_pd(self, other);
+        }
 
+        // neg
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> neg(batch<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return 0 - self;
+        }
+        template <class A>
+        inline batch<float, A> neg(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(0x80000000)));
+        }
 
-    template<class A> batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpneq_pd(self, other);
-    }
-    template<class A> batch_bool<double, A> neq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) {
-      return _mm_cmpneq_pd(self, other);
-    }
+        template <class A>
+        inline batch<double, A> neg(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_xor_pd(
+                self, _mm_castsi128_pd(_mm_setr_epi32(0, 0x80000000, 0, 0x80000000)));
+        }
 
-    // select
-    template<class A> batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse2>) {
-      return _mm_or_ps(_mm_and_ps(cond, true_br), _mm_andnot_ps(cond, false_br));
-    }
+        // neq
+        template <class A>
+        inline batch_bool<float, A> neq(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpneq_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return ~(self == other);
+        }
+        template <class A>
+        inline batch_bool<float, A> neq(batch_bool<float, A> const& self, batch_bool<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpneq_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return ~(self == other);
+        }
 
+        template <class A>
+        inline batch_bool<double, A> neq(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpneq_pd(self, other);
+        }
+        template <class A>
+        inline batch_bool<double, A> neq(batch_bool<double, A> const& self, batch_bool<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_cmpneq_pd(self, other);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) {
-      return _mm_or_si128(_mm_and_si128(cond, true_br), _mm_andnot_si128(cond, false_br));
-    }
-    template<class A, class T, bool... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) {
-      return select(batch_bool<T, A>{Values...}, true_br, false_br, sse2{});
-    }
-    template<class A> batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse2>) {
-      return _mm_or_pd(_mm_and_pd(cond, true_br), _mm_andnot_pd(cond, false_br));
-    }
+        // select
+        template <class A>
+        inline batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_ps(_mm_and_ps(cond, true_br), _mm_andnot_ps(cond, false_br));
+        }
 
-    // sqrt
-    template<class A> batch<float, A> sqrt(batch<float, A> const& val, requires_arch<sse2>) {
-      return _mm_sqrt_ps(val);
-    }
-    template<class A> batch<double, A> sqrt(batch<double, A> const& val, requires_arch<sse2>) {
-      return _mm_sqrt_pd(val);
-    }
-    // sadd
-    template<class A> batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_add_ps(self, other); // no saturated arithmetic on floating point numbers
-    }
-    // TODO: move this in xsimd_generic
-    namespace detail
-    {
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd_default(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        auto mask = (other >> (8 * sizeof(T) - 1));
-        auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
-        auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
-        return other + select(batch_bool<T, A>(mask.data), self_neg_branch, self_pos_branch);
-      }
-      else {
-        const auto diffmax = std::numeric_limits<T>::max() - self;
-        const auto mindiff = min(diffmax, other);
-        return self + mindiff;
-      }
-    }
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_si128(_mm_and_si128(cond, true_br), _mm_andnot_si128(cond, false_br));
+        }
+        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) noexcept
+        {
+            return select(batch_bool<T, A> { Values... }, true_br, false_br, sse2 {});
+        }
+        template <class A>
+        inline batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse2>) noexcept
+        {
+            return _mm_or_pd(_mm_and_pd(cond, true_br), _mm_andnot_pd(cond, false_br));
+        }
 
+        // sqrt
+        template <class A>
+        inline batch<float, A> sqrt(batch<float, A> const& val, requires_arch<sse2>) noexcept
+        {
+            return _mm_sqrt_ps(val);
+        }
+        template <class A>
+        inline batch<double, A> sqrt(batch<double, A> const& val, requires_arch<sse2>) noexcept
+        {
+            return _mm_sqrt_pd(val);
+        }
+        // sadd
+        template <class A>
+        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_add_ps(self, other); // no saturated arithmetic on floating point numbers
+        }
+        // TODO: move this in xsimd_generic
+        namespace detail
+        {
+            template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+            inline batch<T, A> sadd_default(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+            {
+                if (std::is_signed<T>::value)
+                {
+                    auto mask = (other >> (8 * sizeof(T) - 1));
+                    auto self_pos_branch = min(std::numeric_limits<T>::max() - other, self);
+                    auto self_neg_branch = max(std::numeric_limits<T>::min() - other, self);
+                    return other + select(batch_bool<T, A>(mask.data), self_neg_branch, self_pos_branch);
+                }
+                else
+                {
+                    const auto diffmax = std::numeric_limits<T>::max() - self;
+                    const auto mindiff = min(diffmax, other);
+                    return self + mindiff;
+                }
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_adds_epi8(self, other);
-          case 2: return _mm_adds_epi16(self, other);
-          default: return detail::sadd_default(self, other, A{});
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_adds_epi8(self, other);
+                case 2:
+                    return _mm_adds_epi16(self, other);
+                default:
+                    return detail::sadd_default(self, other, A {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_adds_epu8(self, other);
+                case 2:
+                    return _mm_adds_epu16(self, other);
+                default:
+                    return detail::sadd_default(self, other, A {});
+                }
+            }
         }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_adds_epu8(self, other);
-          case 2: return _mm_adds_epu16(self, other);
-          default: return detail::sadd_default(self, other, A{});
+        template <class A>
+        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_add_pd(self, other); // no saturated arithmetic on floating point numbers
         }
-      }
-    }
-    template<class A> batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_add_pd(self, other); // no saturated arithmetic on floating point numbers
-    }
 
-    // set
-    template<class A, class... Values>
-    batch<float, A> set(batch<float, A> const&, requires_arch<sse2>, Values... values) {
-      static_assert(sizeof...(Values) == batch<float, A>::size, "consistent init");
-      return _mm_setr_ps(values...);
-    }
+        // set
+        template <class A, class... Values>
+        inline batch<float, A> set(batch<float, A> const&, requires_arch<sse2>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch<float, A>::size, "consistent init");
+            return _mm_setr_ps(values...);
+        }
 
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1) noexcept
+        {
+            return _mm_set_epi64x(v1, v0);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3) noexcept
+        {
+            return _mm_setr_epi32(v0, v1, v2, v3);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
+        {
+            return _mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
+        {
+            return _mm_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1) {
-      return _mm_set_epi64x(v1, v0);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3) {
-      return _mm_setr_epi32(v0, v1, v2, v3);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) {
-      return _mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) {
-      return _mm_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
-    }
+        template <class A, class... Values>
+        inline batch<double, A> set(batch<double, A> const&, requires_arch<sse2>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch<double, A>::size, "consistent init");
+            return _mm_setr_pd(values...);
+        }
 
-    template<class A, class... Values>
-    batch<double, A> set(batch<double, A> const&, requires_arch<sse2>, Values... values) {
-      static_assert(sizeof...(Values) == batch<double, A>::size, "consistent init");
-      return _mm_setr_pd(values...);
-    }
+        template <class A, class T, class... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<sse2>, Values... values) noexcept
+        {
+            return set(batch<T, A>(), A {}, static_cast<T>(values ? -1LL : 0LL)...).data;
+        }
 
-    template<class A, class T, class... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<sse2>, Values... values) {
-      return set(batch<T, A>(), A{}, static_cast<T>(values ? -1LL : 0LL )...).data;
-    }
+        template <class A, class... Values>
+        inline batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<sse2>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch_bool<float, A>::size, "consistent init");
+            return _mm_castsi128_ps(set(batch<int32_t, A>(), A {}, static_cast<int32_t>(values ? -1LL : 0LL)...).data);
+        }
 
-    template<class A, class... Values>
-    batch_bool<float, A> set(batch_bool<float, A> const&, requires_arch<sse2>, Values... values) {
-      static_assert(sizeof...(Values) == batch_bool<float, A>::size, "consistent init");
-      return _mm_castsi128_ps(set(batch<int32_t, A>(), A{}, static_cast<int32_t>(values ? -1LL : 0LL )...).data);
-    }
+        template <class A, class... Values>
+        inline batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<sse2>, Values... values) noexcept
+        {
+            static_assert(sizeof...(Values) == batch_bool<double, A>::size, "consistent init");
+            return _mm_castsi128_pd(set(batch<int64_t, A>(), A {}, static_cast<int64_t>(values ? -1LL : 0LL)...).data);
+        }
 
-    template<class A, class... Values>
-    batch_bool<double, A> set(batch_bool<double, A> const&, requires_arch<sse2>, Values... values) {
-      static_assert(sizeof...(Values) == batch_bool<double, A>::size, "consistent init");
-      return _mm_castsi128_pd(set(batch<int64_t, A>(), A{},  static_cast<int64_t>(values ? -1LL : 0LL )...).data);
-    }
+        // ssub
+        template <class A>
+        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_sub_ps(self, other); // no saturated arithmetic on floating point numbers
+        }
+        // TODO: move this in xsimd_generic
+        namespace detail
+        {
+            template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+            inline batch<T, A> ssub_default(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+            {
+                if (std::is_signed<T>::value)
+                {
+                    return sadd(self, -other);
+                }
+                else
+                {
+                    const auto diff = min(self, other);
+                    return self - diff;
+                }
+            }
+        }
 
-    // ssub
-    template<class A> batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-    }
-    // TODO: move this in xsimd_generic
-    namespace detail
-    {
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub_default(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-         return sadd(self, -other);
-      }
-      else {
-        const auto diff = min(self, other);
-        return self - diff;
-      }
-    }
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_subs_epi8(self, other);
+                case 2:
+                    return _mm_subs_epi16(self, other);
+                default:
+                    return detail::ssub_default(self, other, A {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_subs_epu8(self, other);
+                case 2:
+                    return _mm_subs_epu16(self, other);
+                default:
+                    return detail::ssub_default(self, other, A {});
+                }
+            }
+        }
 
+        template <class A>
+        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_sub_pd(self, other); // no saturated arithmetic on floating point numbers
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_subs_epi8(self, other);
-          case 2: return _mm_subs_epi16(self, other);
-          default: return detail::ssub_default(self, other, A{});
+        // store_aligned
+        template <class A>
+        inline void store_aligned(float* mem, batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_store_ps(mem, self);
         }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_subs_epu8(self, other);
-          case 2: return _mm_subs_epu16(self, other);
-          default: return detail::ssub_default(self, other, A{});
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_store_si128((__m128i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_store_si128((__m128i*)mem, self);
+        }
+        template <class A>
+        inline void store_aligned(double* mem, batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_store_pd(mem, self);
         }
-      }
-    }
-    template<class A> batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-    }
-
-    // store_aligned
-    template<class A> void store_aligned(float *mem, batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_store_ps(mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch<T, A> const& self, requires_arch<sse2>) {
-      return _mm_store_si128((__m128i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_aligned(T *mem, batch_bool<T, A> const& self, requires_arch<sse2>) {
-      return _mm_store_si128((__m128i *)mem, self);
-    }
-    template<class A> void store_aligned(double *mem, batch<double, A> const& self, requires_arch<sse2>) {
-      return _mm_store_pd(mem, self);
-    }
 
-    // store_unaligned
-    template<class A> void store_unaligned(float *mem, batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_storeu_ps(mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch<T, A> const& self, requires_arch<sse2>) {
-      return _mm_storeu_si128((__m128i *)mem, self);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    void store_unaligned(T *mem, batch_bool<T, A> const& self, requires_arch<sse2>) {
-      return _mm_storeu_si128((__m128i *)mem, self);
-    }
-    template<class A> void store_unaligned(double *mem, batch<double, A> const& self, requires_arch<sse2>) {
-      return _mm_storeu_pd(mem, self);
-    }
+        // store_unaligned
+        template <class A>
+        inline void store_unaligned(float* mem, batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_storeu_ps(mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_storeu_si128((__m128i*)mem, self);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_storeu_si128((__m128i*)mem, self);
+        }
+        template <class A>
+        inline void store_unaligned(double* mem, batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_storeu_pd(mem, self);
+        }
 
-    // sub
-    template<class A> batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_sub_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_sub_epi8(self, other);
-        case 2: return _mm_sub_epi16(self, other);
-        case 4: return _mm_sub_epi32(self, other);
-        case 8: return _mm_sub_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_sub_pd(self, other);
-    }
+        // sub
+        template <class A>
+        inline batch<float, A> sub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_sub_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_sub_epi8(self, other);
+            case 2:
+                return _mm_sub_epi16(self, other);
+            case 4:
+                return _mm_sub_epi32(self, other);
+            case 8:
+                return _mm_sub_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<double, A> sub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_sub_pd(self, other);
+        }
 
-    // to_float
-    template<class A>
-    batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<sse2>) {
-      return _mm_cvtepi32_ps(self);
-    }
-    template<class A>
-    batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<sse2>) {
-      // FIXME: call _mm_cvtepi64_pd
-      alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(double)buffer[0], (double)buffer[1]};
-    }
+        // to_float
+        template <class A>
+        inline batch<float, A> to_float(batch<int32_t, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_cvtepi32_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> to_float(batch<int64_t, A> const& self, requires_arch<sse2>) noexcept
+        {
+            // FIXME: call _mm_cvtepi64_pd
+            alignas(A::alignment()) int64_t buffer[batch<int64_t, A>::size];
+            self.store_aligned(&buffer[0]);
+            return { (double)buffer[0], (double)buffer[1] };
+        }
 
-    // to_int
-    template<class A>
-    batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<sse2>) {
-      return _mm_cvttps_epi32(self);
-    }
+        // to_int
+        template <class A>
+        inline batch<int32_t, A> to_int(batch<float, A> const& self, requires_arch<sse2>) noexcept
+        {
+            return _mm_cvttps_epi32(self);
+        }
 
-    template<class A>
-    batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<sse2>) {
-      // FIXME: call _mm_cvttpd_epi64
-      alignas(A::alignment()) double buffer[batch<double, A>::size];
-      self.store_aligned(&buffer[0]);
-      return {(int64_t)buffer[0], (int64_t)buffer[1]};
-    }
+        template <class A>
+        inline batch<int64_t, A> to_int(batch<double, A> const& self, requires_arch<sse2>) noexcept
+        {
+            // FIXME: call _mm_cvttpd_epi64
+            alignas(A::alignment()) double buffer[batch<double, A>::size];
+            self.store_aligned(&buffer[0]);
+            return { (int64_t)buffer[0], (int64_t)buffer[1] };
+        }
 
-    // zip_hi
-    template<class A> batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_unpackhi_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_unpackhi_epi8(self, other);
-        case 2: return _mm_unpackhi_epi16(self, other);
-        case 4: return _mm_unpackhi_epi32(self, other);
-        case 8: return _mm_unpackhi_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_unpackhi_pd(self, other);
-    }
+        // zip_hi
+        template <class A>
+        inline batch<float, A> zip_hi(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_unpackhi_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_unpackhi_epi8(self, other);
+            case 2:
+                return _mm_unpackhi_epi16(self, other);
+            case 4:
+                return _mm_unpackhi_epi32(self, other);
+            case 8:
+                return _mm_unpackhi_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<double, A> zip_hi(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_unpackhi_pd(self, other);
+        }
 
-    // zip_lo
-    template<class A> batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) {
-      return _mm_unpacklo_ps(self, other);
-    }
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_unpacklo_epi8(self, other);
-        case 2: return _mm_unpacklo_epi16(self, other);
-        case 4: return _mm_unpacklo_epi32(self, other);
-        case 8: return _mm_unpacklo_epi64(self, other);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
-    template<class A> batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) {
-      return _mm_unpacklo_pd(self, other);
+        // zip_lo
+        template <class A>
+        inline batch<float, A> zip_lo(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_unpacklo_ps(self, other);
+        }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_unpacklo_epi8(self, other);
+            case 2:
+                return _mm_unpacklo_epi16(self, other);
+            case 4:
+                return _mm_unpacklo_epi32(self, other);
+            case 8:
+                return _mm_unpacklo_epi64(self, other);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
+        template <class A>
+        inline batch<double, A> zip_lo(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
+        {
+            return _mm_unpacklo_pd(self, other);
+        }
     }
-  }
 
 }
 
 #endif
-
-
diff --git a/third_party/xsimd/arch/xsimd_sse3.hpp b/third_party/xsimd/arch/xsimd_sse3.hpp
index 5c521e9c0..bf7a8df74 100644
--- a/third_party/xsimd/arch/xsimd_sse3.hpp
+++ b/third_party/xsimd/arch/xsimd_sse3.hpp
@@ -1,56 +1,64 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE3_HPP
 #define XSIMD_SSE3_HPP
 
-#include <type_traits>
 #include "../types/xsimd_sse3_register.hpp"
+#include <type_traits>
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
-    using namespace types;
+    namespace kernel
+    {
+        using namespace types;
 
-    // load_unaligned
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse3>) {
-      return _mm_lddqu_si128((__m128i const*)mem);
-    }
+        // load_unaligned
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse3>) noexcept
+        {
+            return _mm_lddqu_si128((__m128i const*)mem);
+        }
 
-    // hadd
-    template<class A> float hadd(batch<float, A> const& self, requires_arch<sse3>) {
-      __m128 tmp0 = _mm_hadd_ps(self, self);
-      __m128 tmp1 = _mm_hadd_ps(tmp0, tmp0);
-      return _mm_cvtss_f32(tmp1);
-    }
-    template <class A>
-    double hadd(batch<double, A> const &self, requires_arch<sse3>) {
-      __m128d tmp0 = _mm_hadd_pd(self, self);
-      return _mm_cvtsd_f64(tmp0);
-    }
+        // hadd
+        template <class A>
+        inline float hadd(batch<float, A> const& self, requires_arch<sse3>) noexcept
+        {
+            __m128 tmp0 = _mm_hadd_ps(self, self);
+            __m128 tmp1 = _mm_hadd_ps(tmp0, tmp0);
+            return _mm_cvtss_f32(tmp1);
+        }
+        template <class A>
+        inline double hadd(batch<double, A> const& self, requires_arch<sse3>) noexcept
+        {
+            __m128d tmp0 = _mm_hadd_pd(self, self);
+            return _mm_cvtsd_f64(tmp0);
+        }
 
-    // haddp
-    template<class A> batch<float, A> haddp(batch<float, A> const* row, requires_arch<sse3>) {
-      return _mm_hadd_ps(_mm_hadd_ps(row[0], row[1]),
-                              _mm_hadd_ps(row[2], row[3]));
-    }
-    template <class A>
-    batch<double, A> haddp(batch<double, A> const *row, requires_arch<sse3>) {
-      return _mm_hadd_pd(row[0], row[1]);
-    }
+        // haddp
+        template <class A>
+        inline batch<float, A> haddp(batch<float, A> const* row, requires_arch<sse3>) noexcept
+        {
+            return _mm_hadd_ps(_mm_hadd_ps(row[0], row[1]),
+                               _mm_hadd_ps(row[2], row[3]));
+        }
+        template <class A>
+        inline batch<double, A> haddp(batch<double, A> const* row, requires_arch<sse3>) noexcept
+        {
+            return _mm_hadd_pd(row[0], row[1]);
+        }
 
-  }
+    }
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_sse4_1.hpp b/third_party/xsimd/arch/xsimd_sse4_1.hpp
index dbd35ff3f..6d5fe6ae2 100644
--- a/third_party/xsimd/arch/xsimd_sse4_1.hpp
+++ b/third_party/xsimd/arch/xsimd_sse4_1.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE4_1_HPP
 #define XSIMD_SSE4_1_HPP
@@ -16,171 +16,239 @@
 
 #include "../types/xsimd_sse4_1_register.hpp"
 
-namespace xsimd {
-
-  namespace kernel {
-    using namespace types;
-    // any
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    bool any(batch<T, A> const& self, requires_arch<sse4_1>) {
-      return !_mm_testz_si128(self, self);
-    }
-    // ceil
-    template<class A> batch<float, A> ceil(batch<float, A> const& self, requires_arch<sse4_1>) {
-      return _mm_ceil_ps(self);
-    }
-    template<class A> batch<double, A> ceil(batch<double, A> const& self, requires_arch<sse4_1>) {
-      return _mm_ceil_pd(self);
-    }
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+        // any
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline bool any(batch<T, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return !_mm_testz_si128(self, self);
+        }
+        // ceil
+        template <class A>
+        inline batch<float, A> ceil(batch<float, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_ceil_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> ceil(batch<double, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_ceil_pd(self);
+        }
 
-    // eq
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) {
-      switch(sizeof(T)) {
-        case 8: return _mm_cmpeq_epi64(self, other);
-        default: return eq(self, other, ssse3{});
-      }
-    }
+        // eq
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 8:
+                return _mm_cmpeq_epi64(self, other);
+            default:
+                return eq(self, other, ssse3 {});
+            }
+        }
 
-    // floor
-    template<class A> batch<float, A> floor(batch<float, A> const& self, requires_arch<sse4_1>) {
-      return _mm_floor_ps(self);
-    }
-    template<class A> batch<double, A> floor(batch<double, A> const& self, requires_arch<sse4_1>) {
-      return _mm_floor_pd(self);
-    }
+        // floor
+        template <class A>
+        inline batch<float, A> floor(batch<float, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_floor_ps(self);
+        }
+        template <class A>
+        inline batch<double, A> floor(batch<double, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_floor_pd(self);
+        }
 
-    // max
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_max_epi8(self, other);
-          case 2: return _mm_max_epi16(self, other);
-          case 4: return _mm_max_epi32(self, other);
-          default: return max(self, other, ssse3{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_max_epu8(self, other);
-          case 2: return _mm_max_epu16(self, other);
-          case 4: return _mm_max_epu32(self, other);
-          default: return max(self, other, ssse3{});
-        }
-      }
-    }
+        // max
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_max_epi8(self, other);
+                case 2:
+                    return _mm_max_epi16(self, other);
+                case 4:
+                    return _mm_max_epi32(self, other);
+                default:
+                    return max(self, other, ssse3 {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_max_epu8(self, other);
+                case 2:
+                    return _mm_max_epu16(self, other);
+                case 4:
+                    return _mm_max_epu32(self, other);
+                default:
+                    return max(self, other, ssse3 {});
+                }
+            }
+        }
 
-    // min
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) {
-      if(std::is_signed<T>::value) {
-        switch(sizeof(T)) {
-          case 1: return _mm_min_epi8(self, other);
-          case 2: return _mm_min_epi16(self, other);
-          case 4: return _mm_min_epi32(self, other);
-          default: return min(self, other, ssse3{});
-        }
-      }
-      else {
-        switch(sizeof(T)) {
-          case 1: return _mm_min_epu8(self, other);
-          case 2: return _mm_min_epu16(self, other);
-          case 4: return _mm_min_epu32(self, other);
-          default: return min(self, other, ssse3{});
-        }
-      }
-    }
+        // min
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_min_epi8(self, other);
+                case 2:
+                    return _mm_min_epi16(self, other);
+                case 4:
+                    return _mm_min_epi32(self, other);
+                default:
+                    return min(self, other, ssse3 {});
+                }
+            }
+            else
+            {
+                switch (sizeof(T))
+                {
+                case 1:
+                    return _mm_min_epu8(self, other);
+                case 2:
+                    return _mm_min_epu16(self, other);
+                case 4:
+                    return _mm_min_epu32(self, other);
+                default:
+                    return min(self, other, ssse3 {});
+                }
+            }
+        }
 
-    // mul
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_or_si128(
-                            _mm_and_si128(_mm_mullo_epi16(self, other), _mm_srli_epi16(_mm_cmpeq_epi8(self, self), 8)),
-                                    _mm_slli_epi16(_mm_mullo_epi16(_mm_srli_epi16(self, 8), _mm_srli_epi16(other, 8)), 8)
-                                        );
-        case 2: return _mm_mullo_epi16(self, other);
-        case 4: return _mm_mullo_epi32(self, other);
-        case 8:
-        return _mm_add_epi64(
-            _mm_mul_epu32(self, other),
-            _mm_slli_epi64(
-                _mm_add_epi64(
-                    _mm_mul_epu32(other, _mm_shuffle_epi32(self, _MM_SHUFFLE(2, 3, 0, 1))),
-                    _mm_mul_epu32(self, _mm_shuffle_epi32(other, _MM_SHUFFLE(2, 3, 0, 1)))),
-                32));
-              default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+        // mul
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_or_si128(
+                    _mm_and_si128(_mm_mullo_epi16(self, other), _mm_srli_epi16(_mm_cmpeq_epi8(self, self), 8)),
+                    _mm_slli_epi16(_mm_mullo_epi16(_mm_srli_epi16(self, 8), _mm_srli_epi16(other, 8)), 8));
+            case 2:
+                return _mm_mullo_epi16(self, other);
+            case 4:
+                return _mm_mullo_epi32(self, other);
+            case 8:
+                return _mm_add_epi64(
+                    _mm_mul_epu32(self, other),
+                    _mm_slli_epi64(
+                        _mm_add_epi64(
+                            _mm_mul_epu32(other, _mm_shuffle_epi32(self, _MM_SHUFFLE(2, 3, 0, 1))),
+                            _mm_mul_epu32(self, _mm_shuffle_epi32(other, _MM_SHUFFLE(2, 3, 0, 1)))),
+                        32));
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    // nearbyint
-    template<class A> batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<sse4_1>) {
-      return _mm_round_ps(self, _MM_FROUND_TO_NEAREST_INT);
-    }
-    template<class A> batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<sse4_1>) {
-      return _mm_round_pd(self, _MM_FROUND_TO_NEAREST_INT);
-    }
+        // nearbyint
+        template <class A>
+        inline batch<float, A> nearbyint(batch<float, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_round_ps(self, _MM_FROUND_TO_NEAREST_INT);
+        }
+        template <class A>
+        inline batch<double, A> nearbyint(batch<double, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_round_pd(self, _MM_FROUND_TO_NEAREST_INT);
+        }
 
-    // select
-    namespace detail {
-      template<class T>
-      constexpr T interleave(T const &cond) {
-        return (((cond * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 49) & 0x5555) |
-               (((cond * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 48) & 0xAAAA);
-      }
-    }
+        // select
+        namespace detail
+        {
+            template <class T>
+            inline constexpr T interleave(T const& cond) noexcept
+            {
+                return (((cond * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 49) & 0x5555) | (((cond * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 48) & 0xAAAA);
+            }
+        }
 
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) {
-      return _mm_blendv_epi8(false_br, true_br, cond);
-    }
-    template<class A> batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse4_1>) {
-      return _mm_blendv_ps(false_br, true_br, cond);
-    }
-    template<class A> batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse4_1>) {
-      return _mm_blendv_pd(false_br, true_br, cond);
-    }
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_blendv_epi8(false_br, true_br, cond);
+        }
+        template <class A>
+        inline batch<float, A> select(batch_bool<float, A> const& cond, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_blendv_ps(false_br, true_br, cond);
+        }
+        template <class A>
+        inline batch<double, A> select(batch_bool<double, A> const& cond, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_blendv_pd(false_br, true_br, cond);
+        }
 
-    template<class A, class T, bool... Values, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) {
-      constexpr int mask = batch_bool_constant<batch<T, A>, Values...>::mask();
-      switch(sizeof(T)) {
-        case 2: return _mm_blend_epi16(false_br, true_br, mask);
-        case 4: {
-          constexpr int imask = detail::interleave(mask);
-          return _mm_blend_epi16(false_br, true_br, imask);
-        }
-        case 8: {
-          constexpr int imask = detail::interleave(mask);
-          constexpr int imask2 = detail::interleave(imask);
-          return _mm_blend_epi16(false_br, true_br, imask2);
-        }
-        default: return select(batch_bool_constant<batch<T, A>, Values...>(), true_br, false_br, ssse3{});
-      }
-    }
-    template<class A, bool... Values> batch<float, A> select(batch_bool_constant<batch<float, A>, Values...> const& , batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse4_1>) {
-      constexpr int mask = batch_bool_constant<batch<float, A>, Values...>::mask();
-      return _mm_blend_ps(false_br, true_br, mask);
-    }
-    template<class A, bool... Values> batch<double, A> select(batch_bool_constant<batch<double, A>, Values...> const& , batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse4_1>) {
-      constexpr int mask = batch_bool_constant<batch<double, A>, Values...>::mask();
-      return _mm_blend_pd(false_br, true_br, mask);
-    }
+        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            constexpr int mask = batch_bool_constant<batch<T, A>, Values...>::mask();
+            switch (sizeof(T))
+            {
+            case 2:
+                return _mm_blend_epi16(false_br, true_br, mask);
+            case 4:
+            {
+                constexpr int imask = detail::interleave(mask);
+                return _mm_blend_epi16(false_br, true_br, imask);
+            }
+            case 8:
+            {
+                constexpr int imask = detail::interleave(mask);
+                constexpr int imask2 = detail::interleave(imask);
+                return _mm_blend_epi16(false_br, true_br, imask2);
+            }
+            default:
+                return select(batch_bool_constant<batch<T, A>, Values...>(), true_br, false_br, ssse3 {});
+            }
+        }
+        template <class A, bool... Values>
+        inline batch<float, A> select(batch_bool_constant<batch<float, A>, Values...> const&, batch<float, A> const& true_br, batch<float, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            constexpr int mask = batch_bool_constant<batch<float, A>, Values...>::mask();
+            return _mm_blend_ps(false_br, true_br, mask);
+        }
+        template <class A, bool... Values>
+        inline batch<double, A> select(batch_bool_constant<batch<double, A>, Values...> const&, batch<double, A> const& true_br, batch<double, A> const& false_br, requires_arch<sse4_1>) noexcept
+        {
+            constexpr int mask = batch_bool_constant<batch<double, A>, Values...>::mask();
+            return _mm_blend_pd(false_br, true_br, mask);
+        }
 
+        // trunc
+        template <class A>
+        inline batch<float, A> trunc(batch<float, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_round_ps(self, _MM_FROUND_TO_ZERO);
+        }
+        template <class A>
+        inline batch<double, A> trunc(batch<double, A> const& self, requires_arch<sse4_1>) noexcept
+        {
+            return _mm_round_pd(self, _MM_FROUND_TO_ZERO);
+        }
 
-    // trunc
-    template<class A> batch<float, A> trunc(batch<float, A> const& self, requires_arch<sse4_1>) {
-      return _mm_round_ps(self, _MM_FROUND_TO_ZERO);
-    }
-    template<class A> batch<double, A> trunc(batch<double, A> const& self, requires_arch<sse4_1>) {
-      return _mm_round_pd(self, _MM_FROUND_TO_ZERO);
     }
 
-
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_sse4_2.hpp b/third_party/xsimd/arch/xsimd_sse4_2.hpp
index 2746302fa..8f9b7a76e 100644
--- a/third_party/xsimd/arch/xsimd_sse4_2.hpp
+++ b/third_party/xsimd/arch/xsimd_sse4_2.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE4_2_HPP
 #define XSIMD_SSE4_2_HPP
@@ -16,26 +16,29 @@
 
 #include "../types/xsimd_sse4_2_register.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
+
+    namespace kernel
+    {
+        using namespace types;
+
+        // lt
+        template <class A>
+        inline batch_bool<int64_t, A> lt(batch<int64_t, A> const& self, batch<int64_t, A> const& other, requires_arch<sse4_2>) noexcept
+        {
+            return _mm_cmpgt_epi64(other, self);
+        }
+        template <class A>
+        inline batch_bool<uint64_t, A> lt(batch<uint64_t, A> const& self, batch<uint64_t, A> const& other, requires_arch<sse4_2>) noexcept
+        {
+            auto xself = _mm_xor_si128(self, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
+            auto xother = _mm_xor_si128(other, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
+            return _mm_cmpgt_epi64(xother, xself);
+        }
 
-  namespace kernel {
-    using namespace types;
-
-    // lt
-    template<class A>
-    batch_bool<int64_t, A> lt(batch<int64_t, A> const& self, batch<int64_t, A> const& other, requires_arch<sse4_2>) {
-      return _mm_cmpgt_epi64(other, self);
-    }
-    template<class A>
-    batch_bool<uint64_t, A> lt(batch<uint64_t, A> const& self, batch<uint64_t, A> const& other, requires_arch<sse4_2>) {
-      auto xself = _mm_xor_si128(self, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
-      auto xother = _mm_xor_si128(other, _mm_set1_epi64x(std::numeric_limits<int64_t>::lowest()));
-      return _mm_cmpgt_epi64(xother, xself);
     }
 
-  }
-
 }
 
 #endif
-
diff --git a/third_party/xsimd/arch/xsimd_ssse3.hpp b/third_party/xsimd/arch/xsimd_ssse3.hpp
index 4bc2bcfa9..e830cbc73 100644
--- a/third_party/xsimd/arch/xsimd_ssse3.hpp
+++ b/third_party/xsimd/arch/xsimd_ssse3.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSSE3_HPP
 #define XSIMD_SSSE3_HPP
@@ -16,70 +16,90 @@
 #include <type_traits>
 
 #include "../types/xsimd_ssse3_register.hpp"
+#include "../types/xsimd_utils.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace kernel {
-    using namespace types;
+    namespace kernel
+    {
+        using namespace types;
 
-    // abs
-    template<class A, class T, typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, void>::type>
-    batch<T, A> abs(batch<T, A> const& self, requires_arch<ssse3>) {
-      switch(sizeof(T)) {
-        case 1: return _mm_abs_epi8(self);
-        case 2: return _mm_abs_epi16(self);
-        case 4: return _mm_abs_epi32(self);
-        case 8: return _mm_abs_epi64(self);
-        default: assert(false && "unsupported arch/op combination"); return {};
-      }
-    }
+        // abs
+        template <class A, class T, typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, void>::type>
+        inline batch<T, A> abs(batch<T, A> const& self, requires_arch<ssse3>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 1:
+                return _mm_abs_epi8(self);
+            case 2:
+                return _mm_abs_epi16(self);
+            case 4:
+                return _mm_abs_epi32(self);
+            case 8:
+                return _mm_abs_epi64(self);
+            default:
+                assert(false && "unsupported arch/op combination");
+                return {};
+            }
+        }
 
-    // extract_pair
-    namespace detail {
+        // extract_pair
+        namespace detail
+        {
 
-      template<class T, class A>
-      batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, ::xsimd::detail::index_sequence<>) {
-        return other;
-      }
+            template <class T, class A>
+            inline batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
+            {
+                return other;
+            }
 
-      template<class T, class A, std::size_t I, std::size_t... Is>
-      batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, ::xsimd::detail::index_sequence<I, Is...>) {
-        if(i == I) {
-          return _mm_alignr_epi8(self, other, sizeof(T) * I);
+            template <class T, class A, std::size_t I, std::size_t... Is>
+            inline batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            {
+                if (i == I)
+                {
+                    return _mm_alignr_epi8(self, other, sizeof(T) * I);
+                }
+                else
+                    return extract_pair(self, other, i, ::xsimd::detail::index_sequence<Is...>());
+            }
         }
-        else
-          return extract_pair(self, other, i, ::xsimd::detail::index_sequence<Is...>());
-      }
-    }
 
-    template<class A, class T, class _ = typename std::enable_if<std::is_integral<T>::value, void>::type>
-    batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<ssse3>) {
-      constexpr std::size_t size = batch<T, A>::size;
-      assert(0<= i && i< size && "index in bounds");
-      return detail::extract_pair(self, other, i, ::xsimd::detail::make_index_sequence<size>());
-    }
+        template <class A, class T, class _ = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<ssse3>) noexcept
+        {
+            constexpr std::size_t size = batch<T, A>::size;
+            assert(0 <= i && i < size && "index in bounds");
+            return detail::extract_pair(self, other, i, ::xsimd::detail::make_index_sequence<size>());
+        }
 
-    // hadd
-    template<class A, class T, class=typename std::enable_if<std::is_integral<T>::value, void>::type>
-    T hadd(batch<T, A> const& self, requires_arch<ssse3>) {
-      switch(sizeof(T)) {
-        case 2: {
+        // hadd
+        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        inline T hadd(batch<T, A> const& self, requires_arch<ssse3>) noexcept
+        {
+            switch (sizeof(T))
+            {
+            case 2:
+            {
                 __m128i tmp1 = _mm_hadd_epi16(self, self);
                 __m128i tmp2 = _mm_hadd_epi16(tmp1, tmp1);
                 __m128i tmp3 = _mm_hadd_epi16(tmp2, tmp2);
                 return _mm_cvtsi128_si32(tmp3) & 0xFFFF;
-                }
-        case 4: {
+            }
+            case 4:
+            {
                 __m128i tmp1 = _mm_hadd_epi32(self, self);
                 __m128i tmp2 = _mm_hadd_epi32(tmp1, tmp1);
                 return _mm_cvtsi128_si32(tmp2);
-                }
-        default: return hadd(self, sse3{});
-      }
+            }
+            default:
+                return hadd(self, sse3 {});
+            }
+        }
     }
-  }
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/config/xsimd_arch.hpp b/third_party/xsimd/config/xsimd_arch.hpp
index f88067e4b..7053ec90e 100644
--- a/third_party/xsimd/config/xsimd_arch.hpp
+++ b/third_party/xsimd/config/xsimd_arch.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ARCH_HPP
 #define XSIMD_ARCH_HPP
@@ -16,160 +16,233 @@
 #include <type_traits>
 #include <utility>
 
-#include "./xsimd_config.hpp"
 #include "../types/xsimd_all_registers.hpp"
+#include "./xsimd_config.hpp"
 #include "./xsimd_cpuid.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  namespace detail {
-  // Checks whether T appears in Tys.
-  template <class T, class... Tys> struct contains;
+    namespace detail
+    {
+        // Checks whether T appears in Tys.
+        template <class T, class... Tys>
+        struct contains;
 
-  template <class T> struct contains<T> : std::false_type {};
+        template <class T>
+        struct contains<T> : std::false_type
+        {
+        };
 
-  template <class T, class Ty, class... Tys>
-  struct contains<T, Ty, Tys...>
-      : std::conditional<std::is_same<Ty, T>::value, std::true_type,
-                         contains<T, Tys...>>::type {};
+        template <class T, class Ty, class... Tys>
+        struct contains<T, Ty, Tys...>
+            : std::conditional<std::is_same<Ty, T>::value, std::true_type,
+                               contains<T, Tys...>>::type
+        {
+        };
 
-  template <class... Archs> struct is_sorted;
+        template <class... Archs>
+        struct is_sorted;
 
-  template <> struct is_sorted<> : std::true_type {};
+        template <>
+        struct is_sorted<> : std::true_type
+        {
+        };
 
-  template <class Arch> struct is_sorted<Arch> : std::true_type {};
+        template <class Arch>
+        struct is_sorted<Arch> : std::true_type
+        {
+        };
 
-  template <class A0, class A1, class... Archs>
-  struct is_sorted<A0, A1, Archs...>
-      : std::conditional<(A0::version() >= A1::version()), is_sorted<Archs...>,
-                         std::false_type>::type {};
+        template <class A0, class A1, class... Archs>
+        struct is_sorted<A0, A1, Archs...>
+            : std::conditional<(A0::version() >= A1::version()), is_sorted<Archs...>,
+                               std::false_type>::type
+        {
+        };
+
+        template <typename T>
+        inline constexpr T max_of(T value) noexcept
+        {
+            return value;
+        }
 
-  } // namespace detail
+        template <typename T, typename... Ts>
+        inline constexpr T max_of(T head0, T head1, Ts... tail) noexcept
+        {
+            return max_of((head0 > head1 ? head0 : head1), tail...);
+        }
+
+    } // namespace detail
 
-  // An arch_list is a list of architectures, sorted by version number.
-  template <class... Archs> struct arch_list {
+    // An arch_list is a list of architectures, sorted by version number.
+    template <class... Archs>
+    struct arch_list
+    {
 #ifndef NDEBUG
-    static_assert(detail::is_sorted<Archs...>::value,
-                  "architecture list must be sorted by version");
+        static_assert(detail::is_sorted<Archs...>::value,
+                      "architecture list must be sorted by version");
 #endif
 
-    template <class Arch> using add = arch_list<Archs..., Arch>;
+        template <class Arch>
+        using add = arch_list<Archs..., Arch>;
 
-    template <class... OtherArchs>
-    using extend = arch_list<Archs..., OtherArchs...>;
+        template <class... OtherArchs>
+        using extend = arch_list<Archs..., OtherArchs...>;
 
-    template <class Arch> static constexpr bool contains() {
-      return detail::contains<Arch, Archs...>::value;
-    }
+        template <class Arch>
+        static constexpr bool contains() noexcept
+        {
+            return detail::contains<Arch, Archs...>::value;
+        }
 
-    template <class F> static void for_each(F &&f) {
-      (void)std::initializer_list<bool>{(f(Archs{}), true)...};
-    }
-  };
+        template <class F>
+        static void for_each(F&& f) noexcept
+        {
+            (void)std::initializer_list<bool> { (f(Archs {}), true)... };
+        }
 
-  struct unavailable {};
+        static constexpr std::size_t alignment() noexcept
+        {
+            // all alignments are a power of two
+            return detail::max_of(Archs::alignment()..., static_cast<size_t>(0));
+        }
+    };
 
-  namespace detail {
-    // Pick the best architecture in arch_list L, which is the last
-    // because architectures are sorted by version.
-    template <class L> struct best;
+    struct unavailable
+    {
+        static constexpr bool supported() noexcept { return false; }
+        static constexpr bool available() noexcept { return false; }
+        static constexpr unsigned version() noexcept { return 0; }
+        static constexpr std::size_t alignment() noexcept { return 0; }
+        static constexpr bool requires_alignment() noexcept { return false; }
+        static constexpr char const* name() noexcept { return "<none>"; }
+    };
 
-    template <> struct best<arch_list<>> { using type = unavailable; };
+    namespace detail
+    {
+        // Pick the best architecture in arch_list L, which is the last
+        // because architectures are sorted by version.
+        template <class L>
+        struct best;
 
-    template <class Arch, class... Archs> struct best<arch_list<Arch, Archs...>> {
-      using type = Arch;
-    };
+        template <>
+        struct best<arch_list<>>
+        {
+            using type = unavailable;
+        };
 
-    // Filter archlists Archs, picking only supported archs and adding
-    // them to L.
-    template <class L, class... Archs> struct supported_helper;
+        template <class Arch, class... Archs>
+        struct best<arch_list<Arch, Archs...>>
+        {
+            using type = Arch;
+        };
 
-    template <class L> struct supported_helper<L, arch_list<>> { using type = L; };
+        // Filter archlists Archs, picking only supported archs and adding
+        // them to L.
+        template <class L, class... Archs>
+        struct supported_helper;
 
-    template <class L, class Arch, class... Archs>
-    struct supported_helper<L, arch_list<Arch, Archs...>>
-        : supported_helper<
-              typename std::conditional<Arch::supported(),
-                                        typename L::template add<Arch>, L>::type,
-              arch_list<Archs...>> {};
+        template <class L>
+        struct supported_helper<L, arch_list<>>
+        {
+            using type = L;
+        };
 
-    template <class... Archs>
-    struct supported : supported_helper<arch_list<>, Archs...> {};
+        template <class L, class Arch, class... Archs>
+        struct supported_helper<L, arch_list<Arch, Archs...>>
+            : supported_helper<
+                  typename std::conditional<Arch::supported(),
+                                            typename L::template add<Arch>, L>::type,
+                  arch_list<Archs...>>
+        {
+        };
 
-    // Joins all arch_list Archs in a single arch_list.
-    template <class... Archs> struct join;
+        template <class... Archs>
+        struct supported : supported_helper<arch_list<>, Archs...>
+        {
+        };
 
-    template <class Arch> struct join<Arch> { using type = Arch; };
+        // Joins all arch_list Archs in a single arch_list.
+        template <class... Archs>
+        struct join;
 
-    template <class Arch, class... Archs, class... Args>
-    struct join<Arch, arch_list<Archs...>, Args...>
-        : join<typename Arch::template extend<Archs...>, Args...> {};
-  } // namespace detail
+        template <class Arch>
+        struct join<Arch>
+        {
+            using type = Arch;
+        };
 
-  struct unsupported {};
-  using all_x86_architectures = arch_list<avx512bw, avx512dq, avx512cd, avx512f, fma5, avx2, /*fma3, xop, fma4,*/ avx, sse4_2, sse4_1, /*sse4a,*/ ssse3, sse3, sse2>;
-  using all_arm_architectures = arch_list<neon64, neon>;
-  using all_architectures = typename detail::join<all_arm_architectures, all_x86_architectures>::type;
+        template <class Arch, class... Archs, class... Args>
+        struct join<Arch, arch_list<Archs...>, Args...>
+            : join<typename Arch::template extend<Archs...>, Args...>
+        {
+        };
+    } // namespace detail
 
-  using supported_architectures = typename detail::supported<all_architectures>::type;
+    struct unsupported
+    {
+    };
+    using all_x86_architectures = arch_list<avx512bw, avx512dq, avx512cd, avx512f, fma5, avx2, /*fma3, xop, fma4,*/ avx, sse4_2, sse4_1, /*sse4a,*/ ssse3, sse3, sse2>;
+    using all_arm_architectures = arch_list<neon64, neon>;
+    using all_architectures = typename detail::join<all_arm_architectures, all_x86_architectures>::type;
 
-  using x86_arch = typename detail::best<typename detail::supported<all_x86_architectures>::type>::type;
-  using arm_arch = typename detail::best<typename detail::supported<all_arm_architectures>::type>::type;
-  //using default_arch = typename detail::best<typename detail::supported<arch_list</*arm_arch,*/ x86_arch>>::type>::type;
-  using default_arch = typename std::conditional<std::is_same<x86_arch, unavailable>::value,
-                                                 arm_arch,
-                                                 x86_arch>::type;
+    using supported_architectures = typename detail::supported<all_architectures>::type;
 
+    using x86_arch = typename detail::best<typename detail::supported<all_x86_architectures>::type>::type;
+    using arm_arch = typename detail::best<typename detail::supported<all_arm_architectures>::type>::type;
+    // using default_arch = typename detail::best<typename detail::supported<arch_list</*arm_arch,*/ x86_arch>>::type>::type;
+    using default_arch = typename std::conditional<std::is_same<x86_arch, unavailable>::value,
+                                                   arm_arch,
+                                                   x86_arch>::type;
 
     namespace detail
     {
-        template<class F, class ArchList>
+        template <class F, class ArchList>
         class dispatcher
         {
 
             const unsigned best_arch;
             F functor;
 
-            template<class Arch, class... Tys>
-            auto walk_archs(arch_list<Arch>, Tys&&... args) -> decltype(functor(Arch{}, std::forward<Tys>(args)...))
+            template <class Arch, class... Tys>
+            auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
             {
-                static_assert(Arch::supported(), "dispatching on supported architecture");
                 assert(Arch::available() && "At least one arch must be supported during dispatch");
-                return functor(Arch{}, std::forward<Tys>(args)...);
+                return functor(Arch {}, std::forward<Tys>(args)...);
             }
 
-            template<class Arch, class ArchNext, class... Archs, class... Tys>
-            auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) -> decltype(functor(Arch{}, std::forward<Tys>(args)...))
+            template <class Arch, class ArchNext, class... Archs, class... Tys>
+            auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
             {
-                static_assert(Arch::supported(), "dispatching on supported architecture");
-                if(Arch::version() == best_arch)
-                  return functor(Arch{}, std::forward<Tys>(args)...);
+                if (Arch::version() <= best_arch)
+                    return functor(Arch {}, std::forward<Tys>(args)...);
                 else
-                  return walk_archs(arch_list<ArchNext, Archs...>{}, std::forward<Tys>(args)...);
+                    return walk_archs(arch_list<ArchNext, Archs...> {}, std::forward<Tys>(args)...);
             }
 
-            public:
-
-            dispatcher(F f) : best_arch(available_architectures().best), functor(f)
+        public:
+            dispatcher(F f) noexcept
+                : best_arch(available_architectures().best)
+                , functor(f)
             {
             }
 
-            template<class... Tys>
-            auto operator()(Tys&&... args) -> decltype(functor(default_arch{}, std::forward<Tys>(args)...))
+            template <class... Tys>
+            auto operator()(Tys&&... args) noexcept -> decltype(functor(default_arch {}, std::forward<Tys>(args)...))
             {
-                return walk_archs(ArchList{}, std::forward<Tys>(args)...);
+                return walk_archs(ArchList {}, std::forward<Tys>(args)...);
             }
         };
     }
 
     // Generic function dispatch, à la ifunc
-    template<class F, class ArchList=supported_architectures>
-    inline detail::dispatcher<F, ArchList> dispatch(F&& f)
+    template <class F, class ArchList = supported_architectures>
+    inline detail::dispatcher<F, ArchList> dispatch(F&& f) noexcept
     {
-        return {std::forward<F>(f)};
+        return { std::forward<F>(f) };
     }
 
 } // namespace xsimd
 
 #endif
-
diff --git a/third_party/xsimd/config/xsimd_config.hpp b/third_party/xsimd/config/xsimd_config.hpp
index a65726365..81cb7e11c 100644
--- a/third_party/xsimd/config/xsimd_config.hpp
+++ b/third_party/xsimd/config/xsimd_config.hpp
@@ -1,20 +1,20 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_CONFIG_HPP
 #define XSIMD_CONFIG_HPP
 
 #define XSIMD_VERSION_MAJOR 8
 #define XSIMD_VERSION_MINOR 0
-#define XSIMD_VERSION_PATCH 3
+#define XSIMD_VERSION_PATCH 5
 
 /**
  * high level free functions
@@ -106,7 +106,7 @@
  */
 #ifdef __FMA__
 
-#if defined(__SSE__) && ! defined(__AVX__)
+#if defined(__SSE__) && !defined(__AVX__)
 #define XSIMD_WITH_FMA3 1
 #else
 #define XSIMD_WITH_FMA3 0
@@ -139,19 +139,19 @@
  * Set to 1 if AVX512F is available at compile-time, to 0 otherwise.
  */
 #ifdef __AVX512F__
-    // AVX512 instructions are supported starting with gcc 6
-    // see https://www.gnu.org/software/gcc/gcc-6/changes.html
-    // check clang first, newer clang always defines __GNUC__ = 4
-    #if defined(__clang__) && __clang_major__ >= 6
-        #define XSIMD_WITH_AVX512F 1
-    #elif defined(__GNUC__) && __GNUC__ < 6
-        #define XSIMD_WITH_AVX512F 0
-    #else
-        #define XSIMD_WITH_AVX512F 1
-        #if __GNUC__ == 6
-            #define XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY 1
-        #endif
-    #endif
+// AVX512 instructions are supported starting with gcc 6
+// see https://www.gnu.org/software/gcc/gcc-6/changes.html
+// check clang first, newer clang always defines __GNUC__ = 4
+#if defined(__clang__) && __clang_major__ >= 6
+#define XSIMD_WITH_AVX512F 1
+#elif defined(__GNUC__) && __GNUC__ < 6
+#define XSIMD_WITH_AVX512F 0
+#else
+#define XSIMD_WITH_AVX512F 1
+#if __GNUC__ == 6
+#define XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY 1
+#endif
+#endif
 #else
 #define XSIMD_WITH_AVX512F 0
 #endif
@@ -197,25 +197,25 @@
  *
  * Set to 1 if NEON is available at compile-time, to 0 otherwise.
  */
-    #if __ARM_ARCH >= 7
-        #define XSIMD_WITH_NEON 1
-    #else
-        #define XSIMD_WITH_NEON 0
-    #endif
+#if __ARM_ARCH >= 7
+#define XSIMD_WITH_NEON 1
+#else
+#define XSIMD_WITH_NEON 0
+#endif
 
 /**
  * @ingroup xsimd_config_macro
  *
  * Set to 1 if NEON64 is available at compile-time, to 0 otherwise.
  */
-    #ifdef __aarch64__
-        #define XSIMD_WITH_NEON64 1
-    #else
-        #define XSIMD_WITH_NEON64 0
-    #endif
+#ifdef __aarch64__
+#define XSIMD_WITH_NEON64 1
 #else
-    #define XSIMD_WITH_NEON 0
-    #define XSIMD_WITH_NEON64 0
+#define XSIMD_WITH_NEON64 0
+#endif
+#else
+#define XSIMD_WITH_NEON 0
+#define XSIMD_WITH_NEON64 0
 #endif
 
 // Workaround for MSVC compiler
@@ -229,6 +229,8 @@
 #if XSIMD_WITH_AVX2
 #undef XSIMD_WITH_AVX
 #define XSIMD_WITH_AVX 1
+#undef XSIMD_WITH_FMA5
+#define XSIMD_WITH_FMA5 1
 #endif
 
 #if XSIMD_WITH_AVX
@@ -263,4 +265,8 @@
 
 #endif
 
+#if !XSIMD_WITH_SSE2 && !XSIMD_WITH_SSE3 && !XSIMD_WITH_SSSE3 && !XSIMD_WITH_SSE4_1 && !XSIMD_WITH_SSE4_2 && !XSIMD_WITH_AVX && !XSIMD_WITH_AVX2 && !XSIMD_WITH_FMA3 && !XSIMD_WITH_FMA5 && !XSIMD_WITH_AVX512F && !XSIMD_WITH_AVX512CD && !XSIMD_WITH_AVX512DQ && !XSIMD_WITH_AVX512BW && !XSIMD_WITH_NEON && !XSIMD_WITH_NEON64
+#define XSIMD_NO_SUPPORTED_ARCHITECTURE
+#endif
+
 #endif
diff --git a/third_party/xsimd/config/xsimd_cpuid.hpp b/third_party/xsimd/config/xsimd_cpuid.hpp
index 48b8bd452..869d3e7f8 100644
--- a/third_party/xsimd/config/xsimd_cpuid.hpp
+++ b/third_party/xsimd/config/xsimd_cpuid.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_CPUID_HPP
 #define XSIMD_CPUID_HPP
@@ -16,8 +16,8 @@
 #include <cstring>
 
 #if defined(__linux__) && (defined(__ARM_NEON) || defined(_M_ARM))
-#include <sys/auxv.h>
 #include <asm/hwcap.h>
+#include <sys/auxv.h>
 #endif
 
 #if defined(_MSC_VER)
@@ -45,6 +45,8 @@ namespace xsimd
             unsigned avx : 1;
             unsigned avx2 : 1;
             unsigned avx512f : 1;
+            unsigned avx512cd : 1;
+            unsigned avx512dq : 1;
             unsigned avx512bw : 1;
             unsigned neon : 1;
             unsigned neon64 : 1;
@@ -52,109 +54,113 @@ namespace xsimd
             // version number of the best arch available
             unsigned best;
 
-            supported_arch()
+            supported_arch() noexcept
             {
-                 memset(this, 0, sizeof(supported_arch));
+                memset(this, 0, sizeof(supported_arch));
 
 #if defined(__aarch64__) || defined(_M_ARM64)
-                 neon = 1;
-                 neon64 = 1;
-                 best = neon64::version();
+                neon = 1;
+                neon64 = 1;
+                best = neon64::version();
 #elif defined(__ARM_NEON) || defined(_M_ARM)
 #if defined(__linux__)
-                 neon = bool(getauxval(AT_HWCAP) & HWCAP_NEON);
+                neon = bool(getauxval(AT_HWCAP) & HWCAP_NEON);
 #else
-                 // that's very conservative :-/
-                 neon = 0;
+                // that's very conservative :-/
+                neon = 0;
 #endif
-                 neon64 = 0;
-                 best = neon::version() * neon;
+                neon64 = 0;
+                best = neon::version() * neon;
 
 #elif defined(__x86_64__) || defined(__i386__) || defined(_M_AMD64) || defined(_M_IX86)
-                 auto get_cpuid = [](int reg[4], int func_id)
-                 {
+                auto get_cpuid = [](int reg[4], int func_id) noexcept
+                {
 
 #if defined(_MSC_VER)
-                     __cpuidex(reg, func_id, 0);
+                    __cpuidex(reg, func_id, 0);
 
 #elif defined(__INTEL_COMPILER)
-                     __cpuid(reg, func_id);
+                    __cpuid(reg, func_id);
 
 #elif defined(__GNUC__) || defined(__clang__)
 
-#if defined( __i386__ ) && defined(__PIC__)
-                     // %ebx may be the PIC register
-                     __asm__("xchg{l}\t{%%}ebx, %1\n\t"
-                             "cpuid\n\t"
-                             "xchg{l}\t{%%}ebx, %1\n\t"
-                             : "=a" (reg[0]), "=r" (reg[1]), "=c" (reg[2]),
-                               "=d" (reg[3])
-                             : "a" (func_id), "c" (0)
-                     );
+#if defined(__i386__) && defined(__PIC__)
+                    // %ebx may be the PIC register
+                    __asm__("xchg{l}\t{%%}ebx, %1\n\t"
+                            "cpuid\n\t"
+                            "xchg{l}\t{%%}ebx, %1\n\t"
+                            : "=a"(reg[0]), "=r"(reg[1]), "=c"(reg[2]),
+                              "=d"(reg[3])
+                            : "a"(func_id), "c"(0));
 
 #else
-                     __asm__("cpuid\n\t"
-                             : "=a" (reg[0]), "=b" (reg[1]), "=c" (reg[2]),
-                               "=d" (reg[3])
-                             : "a" (func_id), "c" (0)
-                     );
+                    __asm__("cpuid\n\t"
+                            : "=a"(reg[0]), "=b"(reg[1]), "=c"(reg[2]),
+                              "=d"(reg[3])
+                            : "a"(func_id), "c"(0));
 #endif
 
 #else
 #error "Unsupported configuration"
 #endif
-                 };
+                };
+
+                int regs[4];
+
+                get_cpuid(regs, 0x1);
 
-                 int regs[4];
+                sse2 = regs[2] >> 26 & 1;
+                best = std::max(best, sse2::version() * sse2);
 
-                 get_cpuid(regs, 0x1);
+                sse3 = regs[2] >> 0 & 1;
+                best = std::max(best, sse3::version() * sse3);
 
-                 sse2 = regs[2] >> 26 & 1;
-                 best = std::max(best, sse2::version() * sse2);
+                // ssse3 = regs[2] >> 9 & 1;
+                // best = std::max(best, ssse3::version() * ssse3);
 
-                 sse3 = regs[2] >> 0 & 1;
-                 best = std::max(best, sse3::version() * sse3);
+                sse4_1 = regs[2] >> 19 & 1;
+                best = std::max(best, sse4_1::version() * sse4_1);
 
-                 //ssse3 = regs[2] >> 9 & 1;
-                 //best = std::max(best, ssse3::version() * ssse3);
+                sse4_2 = regs[2] >> 20 & 1;
+                best = std::max(best, sse4_2::version() * sse4_2);
 
-                 sse4_1 = regs[2] >> 19 & 1;
-                 best = std::max(best, sse4_1::version() * sse4_1);
+                // sse4a = regs[2] >> 6 & 1;
+                // best = std::max(best, XSIMD_X86_AMD_SSE4A_VERSION * sse4a);
 
-                 sse4_2 = regs[2] >> 20 & 1;
-                 best = std::max(best, sse4_2::version() * sse4_2);
+                // xop = regs[2] >> 11 & 1;
+                // best = std::max(best, XSIMD_X86_AMD_XOP_VERSION * xop);
 
-                 //sse4a = regs[2] >> 6 & 1;
-                 //best = std::max(best, XSIMD_X86_AMD_SSE4A_VERSION * sse4a);
+                avx = regs[2] >> 28 & 1;
+                best = std::max(best, avx::version() * avx);
 
-                 //xop = regs[2] >> 11 & 1;
-                 //best = std::max(best, XSIMD_X86_AMD_XOP_VERSION * xop);
+                fma3 = regs[2] >> 12 & 1;
 
-                 avx = regs[2] >> 28 & 1;
-                 best = std::max(best, avx::version() * avx);
+                get_cpuid(regs, 0x7);
+                avx2 = regs[1] >> 5 & 1;
+                best = std::max(best, avx2::version() * avx2);
+                best = std::max(best, fma5::version() * avx2 * fma3);
 
-                 //fma3 = regs[2] >> 12 & 1;
-                 //best = std::max(best, XSIMD_X86_FMA3_VERSION * fma3);
+                avx512f = regs[1] >> 16 & 1;
+                best = std::max(best, avx512f::version() * avx512f);
 
-                 get_cpuid(regs, 0x7);
-                 avx2 = regs[1] >> 5 & 1;
-                 best = std::max(best, avx2::version() * avx2);
+                avx512cd = regs[1] >> 28 & 1;
+                best = std::max(best, avx512cd::version() * avx512cd * avx512f);
 
-                 avx512f = regs[1] >> 16 & 1;
-                 best = std::max(best, avx512f::version() * avx512f);
+                avx512dq = regs[1] >> 17 & 1;
+                best = std::max(best, avx512dq::version() * avx512dq * avx512cd * avx512f);
 
-                 avx512bw = regs[1] >> 30 & 1;
-                 best = std::max(best, avx512bw::version() * avx512bw);
+                avx512bw = regs[1] >> 30 & 1;
+                best = std::max(best, avx512bw::version() * avx512bw * avx512dq * avx512cd * avx512f);
 
-                 //get_cpuid(regs, 0x80000001);
-                 //fma4 = regs[2] >> 16 & 1;
-                 //best = std::max(best, XSIMD_X86_AMD_FMA4_VERSION * fma4);
+                // get_cpuid(regs, 0x80000001);
+                // fma4 = regs[2] >> 16 & 1;
+                // best = std::max(best, XSIMD_X86_AMD_FMA4_VERSION * fma4);
 #endif
             }
         };
     }
 
-    inline detail::supported_arch available_architectures()
+    inline detail::supported_arch available_architectures() noexcept
     {
         static detail::supported_arch supported;
         return supported;
diff --git a/third_party/xsimd/math/xsimd_rem_pio2.hpp b/third_party/xsimd/math/xsimd_rem_pio2.hpp
index 65bcc772e..518ed8f0d 100644
--- a/third_party/xsimd/math/xsimd_rem_pio2.hpp
+++ b/third_party/xsimd/math/xsimd_rem_pio2.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <cmath>
 #include <cstdint>
@@ -36,7 +36,7 @@ namespace xsimd
 #define ONCE0 while (0)
 #endif
 
-/*
+        /*
          * ====================================================
          * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
          *
@@ -52,11 +52,9 @@ namespace xsimd
 #define XSIMD_LITTLE_ENDIAN
 #endif
 #elif defined(_WIN32)
-    // We can safely assume that Windows is always little endian
-    #define XSIMD_LITTLE_ENDIAN
-#elif defined(i386) || defined(i486) ||                 \
-    defined(intel) || defined(x86) || defined(i86pc) || \
-    defined(__alpha) || defined(__osf__)
+// We can safely assume that Windows is always little endian
+#define XSIMD_LITTLE_ENDIAN
+#elif defined(i386) || defined(i486) || defined(intel) || defined(x86) || defined(i86pc) || defined(__alpha) || defined(__osf__)
 #define XSIMD_LITTLE_ENDIAN
 #endif
 
@@ -68,53 +66,49 @@ namespace xsimd
 #define HIGH_WORD_IDX 0
 #endif
 
-#define GET_HIGH_WORD(i, d)                             \
-    do                                                  \
-    {                                                   \
-        double f = (d);                                 \
-        std::memcpy(&(i), reinterpret_cast<char*>(&f) + \
-                        HIGH_WORD_IDX,                  \
-                    sizeof(std::uint32_t));             \
-    }                                                   \
-    ONCE0                                               \
-/**/
-
-#define GET_LOW_WORD(i, d)                              \
-    do                                                  \
-    {                                                   \
-        double f = (d);                                 \
-        std::memcpy(&(i), reinterpret_cast<char*>(&f) + \
-                        LOW_WORD_IDX,                   \
-                    sizeof(std::uint32_t));             \
-    }                                                   \
-    ONCE0                                               \
-/**/
-
-#define SET_HIGH_WORD(d, v)                         \
-    do                                              \
-    {                                               \
-        double f = (d);                             \
-        std::uint32_t value = (v);                  \
-        std::memcpy(reinterpret_cast<char*>(&f) +   \
-                        HIGH_WORD_IDX,              \
-                    &value, sizeof(std::uint32_t)); \
-        (d) = f;                                    \
-    }                                               \
-    ONCE0                                           \
-/**/
-
-#define SET_LOW_WORD(d, v)                          \
-    do                                              \
-    {                                               \
-        double f = (d);                             \
-        std::uint32_t value = (v);                  \
-        std::memcpy(reinterpret_cast<char*>(&f) +   \
-                        LOW_WORD_IDX,               \
-                    &value, sizeof(std::uint32_t)); \
-        (d) = f;                                    \
-    }                                               \
-    ONCE0                                           \
-        /**/
+#define GET_HIGH_WORD(i, d)                                            \
+    do                                                                 \
+    {                                                                  \
+        double f = (d);                                                \
+        std::memcpy(&(i), reinterpret_cast<char*>(&f) + HIGH_WORD_IDX, \
+                    sizeof(std::uint32_t));                            \
+    }                                                                  \
+    ONCE0                                                              \
+    /**/
+
+#define GET_LOW_WORD(i, d)                                            \
+    do                                                                \
+    {                                                                 \
+        double f = (d);                                               \
+        std::memcpy(&(i), reinterpret_cast<char*>(&f) + LOW_WORD_IDX, \
+                    sizeof(std::uint32_t));                           \
+    }                                                                 \
+    ONCE0                                                             \
+    /**/
+
+#define SET_HIGH_WORD(d, v)                                      \
+    do                                                           \
+    {                                                            \
+        double f = (d);                                          \
+        std::uint32_t value = (v);                               \
+        std::memcpy(reinterpret_cast<char*>(&f) + HIGH_WORD_IDX, \
+                    &value, sizeof(std::uint32_t));              \
+        (d) = f;                                                 \
+    }                                                            \
+    ONCE0                                                        \
+    /**/
+
+#define SET_LOW_WORD(d, v)                                      \
+    do                                                          \
+    {                                                           \
+        double f = (d);                                         \
+        std::uint32_t value = (v);                              \
+        std::memcpy(reinterpret_cast<char*>(&f) + LOW_WORD_IDX, \
+                    &value, sizeof(std::uint32_t));             \
+        (d) = f;                                                \
+    }                                                           \
+    ONCE0                                                       \
+    /**/
 
         /*
          * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
@@ -223,9 +217,9 @@ namespace xsimd
          *
          */
 
-        inline int32_t __kernel_rem_pio2(double* x, double* y, int32_t e0, int32_t nx, int32_t prec, const int32_t* ipio2)
+        inline int32_t __kernel_rem_pio2(double* x, double* y, int32_t e0, int32_t nx, int32_t prec, const int32_t* ipio2) noexcept
         {
-            static const int32_t init_jk[] = {2, 3, 4, 6}; /* initial value for jk */
+            static const int32_t init_jk[] = { 2, 3, 4, 6 }; /* initial value for jk */
 
             static const double PIo2[] = {
                 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
@@ -239,7 +233,8 @@ namespace xsimd
             };
 
             static const double
-                zero = 0.0,
+                zero
+                = 0.0,
                 one = 1.0,
                 two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
                 twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */
@@ -455,44 +450,125 @@ namespace xsimd
             return n & 7;
         }
 
-
-        inline std::int32_t __ieee754_rem_pio2(double x, double* y)
+        inline std::int32_t __ieee754_rem_pio2(double x, double* y) noexcept
         {
             static const std::int32_t two_over_pi[] = {
-                0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62,
-                0x95993C, 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A,
-                0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129,
-                0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41,
-                0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8,
-                0x97FFDE, 0x05980F, 0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF,
-                0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5,
-                0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08,
-                0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3,
-                0x91615E, 0xE61B08, 0x659985, 0x5F14A0, 0x68408D, 0xFFD880,
-                0x4D7327, 0x310606, 0x1556CA, 0x73A8C9, 0x60E27B, 0xC08C6B,
+                0xA2F983,
+                0x6E4E44,
+                0x1529FC,
+                0x2757D1,
+                0xF534DD,
+                0xC0DB62,
+                0x95993C,
+                0x439041,
+                0xFE5163,
+                0xABDEBB,
+                0xC561B7,
+                0x246E3A,
+                0x424DD2,
+                0xE00649,
+                0x2EEA09,
+                0xD1921C,
+                0xFE1DEB,
+                0x1CB129,
+                0xA73EE8,
+                0x8235F5,
+                0x2EBB44,
+                0x84E99C,
+                0x7026B4,
+                0x5F7E41,
+                0x3991D6,
+                0x398353,
+                0x39F49C,
+                0x845F8B,
+                0xBDF928,
+                0x3B1FF8,
+                0x97FFDE,
+                0x05980F,
+                0xEF2F11,
+                0x8B5A0A,
+                0x6D1F6D,
+                0x367ECF,
+                0x27CB09,
+                0xB74F46,
+                0x3F669E,
+                0x5FEA2D,
+                0x7527BA,
+                0xC7EBE5,
+                0xF17B3D,
+                0x0739F7,
+                0x8A5292,
+                0xEA6BFB,
+                0x5FB11F,
+                0x8D5D08,
+                0x560330,
+                0x46FC7B,
+                0x6BABF0,
+                0xCFBC20,
+                0x9AF436,
+                0x1DA9E3,
+                0x91615E,
+                0xE61B08,
+                0x659985,
+                0x5F14A0,
+                0x68408D,
+                0xFFD880,
+                0x4D7327,
+                0x310606,
+                0x1556CA,
+                0x73A8C9,
+                0x60E27B,
+                0xC08C6B,
             };
 
             static const std::int32_t npio2_hw[] = {
-                0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C,
-                0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C,
-                0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A,
-                0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C,
-                0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB,
-                0x404858EB, 0x404921FB,
+                0x3FF921FB,
+                0x400921FB,
+                0x4012D97C,
+                0x401921FB,
+                0x401F6A7A,
+                0x4022D97C,
+                0x4025FDBB,
+                0x402921FB,
+                0x402C463A,
+                0x402F6A7A,
+                0x4031475C,
+                0x4032D97C,
+                0x40346B9C,
+                0x4035FDBB,
+                0x40378FDB,
+                0x403921FB,
+                0x403AB41B,
+                0x403C463A,
+                0x403DD85A,
+                0x403F6A7A,
+                0x40407E4C,
+                0x4041475C,
+                0x4042106C,
+                0x4042D97C,
+                0x4043A28C,
+                0x40446B9C,
+                0x404534AC,
+                0x4045FDBB,
+                0x4046C6CB,
+                0x40478FDB,
+                0x404858EB,
+                0x404921FB,
             };
 
             /*
-            * invpio2:  53 bits of 2/pi
-            * pio2_1:   first  33 bit of pi/2
-            * pio2_1t:  pi/2 - pio2_1
-            * pio2_2:   second 33 bit of pi/2
-            * pio2_2t:  pi/2 - (pio2_1+pio2_2)
-            * pio2_3:   third  33 bit of pi/2
-            * pio2_3t:  pi/2 - (pio2_1+pio2_2+pio2_3)
-            */
+             * invpio2:  53 bits of 2/pi
+             * pio2_1:   first  33 bit of pi/2
+             * pio2_1t:  pi/2 - pio2_1
+             * pio2_2:   second 33 bit of pi/2
+             * pio2_2t:  pi/2 - (pio2_1+pio2_2)
+             * pio2_3:   third  33 bit of pi/2
+             * pio2_3t:  pi/2 - (pio2_1+pio2_2+pio2_3)
+             */
 
             static const double
-                zero = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
+                zero
+                = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
                 half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
                 two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
                 invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
@@ -600,8 +676,8 @@ namespace xsimd
                     return n;
             }
             /*
-            * all other (large) arguments
-            */
+             * all other (large) arguments
+             */
             if (ix >= 0x7ff00000)
             { /* x is inf or NaN */
                 y[0] = y[1] = x - x;
diff --git a/third_party/xsimd/memory/xsimd_aligned_allocator.hpp b/third_party/xsimd/memory/xsimd_aligned_allocator.hpp
index c620861ff..d599c7c2b 100644
--- a/third_party/xsimd/memory/xsimd_aligned_allocator.hpp
+++ b/third_party/xsimd/memory/xsimd_aligned_allocator.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ALIGNED_ALLOCATOR_HPP
 #define XSIMD_ALIGNED_ALLOCATOR_HPP
@@ -39,11 +39,10 @@ namespace xsimd
      * @tparam T type of objects to allocate.
      * @tparam Align alignment in bytes.
      */
-    template <class T, size_t Align=default_arch::alignment()>
+    template <class T, size_t Align = default_arch::alignment()>
     class aligned_allocator
     {
     public:
-
         using value_type = T;
         using pointer = T*;
         using const_pointer = const T*;
@@ -92,14 +91,12 @@ namespace xsimd
     bool operator!=(const aligned_allocator<T1, Align1>& lhs,
                     const aligned_allocator<T2, Align2>& rhs) noexcept;
 
-
     void* aligned_malloc(size_t size, size_t alignment);
     void aligned_free(void* ptr);
 
     template <class T>
     size_t get_alignment_offset(const T* p, size_t size, size_t block_size);
 
-
     /************************************
      * aligned_allocator implementation *
      ************************************/
@@ -258,7 +255,7 @@ namespace xsimd
     }
 
     /**
-    * @ingroup allocator_comparison
+     * @ingroup allocator_comparison
      * Compares two aligned memory allocator for inequality. Since allocators
      * are stateless, return \c true iff <tt>A1 != A2</tt>.
      * @param lhs aligned_allocator to compare.
@@ -272,7 +269,6 @@ namespace xsimd
         return !(lhs == rhs);
     }
 
-
     /****************************************
      * aligned malloc / free implementation *
      ****************************************/
@@ -287,7 +283,7 @@ namespace xsimd
 #ifdef _WIN32
             res = _aligned_malloc(size, alignment);
 #else
-            if(posix_memalign(&res, alignment, size) != 0)
+            if (posix_memalign(&res, alignment, size) != 0)
             {
                 res = nullptr;
             }
@@ -342,11 +338,10 @@ namespace xsimd
         }
     }
 
-    template<class T, class A=default_arch>
+    template <class T, class A = default_arch>
     using default_allocator = typename std::conditional<A::requires_alignment(),
-              aligned_allocator<T, A::alignment()>,
-              std::allocator<T>
-            >::type;
+                                                        aligned_allocator<T, A::alignment()>,
+                                                        std::allocator<T>>::type;
 }
 
 #endif
diff --git a/third_party/xsimd/memory/xsimd_alignment.hpp b/third_party/xsimd/memory/xsimd_alignment.hpp
index 40f75c5e2..70c1117b5 100644
--- a/third_party/xsimd/memory/xsimd_alignment.hpp
+++ b/third_party/xsimd/memory/xsimd_alignment.hpp
@@ -1,34 +1,34 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ALIGNMENT_HPP
 #define XSIMD_ALIGNMENT_HPP
 
-#include "xsimd_aligned_allocator.hpp"
 #include "../types/xsimd_utils.hpp"
+#include "xsimd_aligned_allocator.hpp"
 
 namespace xsimd
 {
     /**
-    * @struct aligned_mode
-    * @brief tag for load and store of aligned memory.
-    */
+     * @struct aligned_mode
+     * @brief tag for load and store of aligned memory.
+     */
     struct aligned_mode
     {
     };
 
     /**
-    * @struct unaligned_mode
-    * @brief tag for load and store of unaligned memory.
-    */
+     * @struct unaligned_mode
+     * @brief tag for load and store of unaligned memory.
+     */
     struct unaligned_mode
     {
     };
diff --git a/third_party/xsimd/stl/algorithms.hpp b/third_party/xsimd/stl/algorithms.hpp
index ad9b02889..8e163582c 100644
--- a/third_party/xsimd/stl/algorithms.hpp
+++ b/third_party/xsimd/stl/algorithms.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ALGORITHMS_HPP
 #define XSIMD_ALGORITHMS_HPP
@@ -21,8 +21,8 @@
 
 namespace xsimd
 {
-    template <class Arch=default_arch, class I1, class I2, class O1, class UF>
-    void transform(I1 first, I2 last, O1 out_first, UF&& f)
+    template <class Arch = default_arch, class I1, class I2, class O1, class UF>
+    void transform(I1 first, I2 last, O1 out_first, UF&& f) noexcept
     {
         using value_type = typename std::decay<decltype(*first)>::type;
         using batch_type = batch<value_type, Arch>;
@@ -75,8 +75,8 @@ namespace xsimd
         }
     }
 
-    template <class Arch=default_arch, class I1, class I2, class I3, class O1, class UF>
-    void transform(I1 first_1, I2 last_1, I3 first_2, O1 out_first, UF&& f)
+    template <class Arch = default_arch, class I1, class I2, class I3, class O1, class UF>
+    void transform(I1 first_1, I2 last_1, I3 first_2, O1 out_first, UF&& f) noexcept
     {
         using value_type = typename std::decay<decltype(*first_1)>::type;
         using batch_type = batch<value_type, Arch>;
@@ -93,24 +93,24 @@ namespace xsimd
         std::size_t out_align = xsimd::get_alignment_offset(ptr_out, size, simd_size);
         std::size_t align_end = align_begin_1 + ((size - align_begin_1) & ~(simd_size - 1));
 
-        #define XSIMD_LOOP_MACRO(A1, A2, A3)                                    \
-            for (std::size_t i = 0; i < align_begin_1; ++i)                     \
-            {                                                                   \
-                out_first[i] = f(first_1[i], first_2[i]);                       \
-            }                                                                   \
-                                                                                \
-            batch_type batch_1, batch_2;                                        \
-            for (std::size_t i = align_begin_1; i < align_end; i += simd_size)  \
-            {                                                                   \
-                batch_1 = batch_type::A1(&first_1[i]);                                \
-                batch_2 = batch_type::A2(&first_2[i]);                                \
-                xsimd::A3(&out_first[i], f(batch_1, batch_2));                  \
-            }                                                                   \
-                                                                                \
-            for (std::size_t i = align_end; i < size; ++i)                      \
-            {                                                                   \
-                out_first[i] = f(first_1[i], first_2[i]);                       \
-            }                                                                   \
+#define XSIMD_LOOP_MACRO(A1, A2, A3)                                   \
+    for (std::size_t i = 0; i < align_begin_1; ++i)                    \
+    {                                                                  \
+        out_first[i] = f(first_1[i], first_2[i]);                      \
+    }                                                                  \
+                                                                       \
+    batch_type batch_1, batch_2;                                       \
+    for (std::size_t i = align_begin_1; i < align_end; i += simd_size) \
+    {                                                                  \
+        batch_1 = batch_type::A1(&first_1[i]);                         \
+        batch_2 = batch_type::A2(&first_2[i]);                         \
+        xsimd::A3(&out_first[i], f(batch_1, batch_2));                 \
+    }                                                                  \
+                                                                       \
+    for (std::size_t i = align_end; i < size; ++i)                     \
+    {                                                                  \
+        out_first[i] = f(first_1[i], first_2[i]);                      \
+    }
 
         if (align_begin_1 == out_align && align_begin_1 == align_begin_2)
         {
@@ -129,23 +129,21 @@ namespace xsimd
             XSIMD_LOOP_MACRO(load_aligned, load_unaligned, store_unaligned);
         }
 
-        #undef XSIMD_LOOP_MACRO
+#undef XSIMD_LOOP_MACRO
     }
 
-
     // TODO: Remove this once we drop C++11 support
     namespace detail
     {
         struct plus
         {
             template <class X, class Y>
-            auto operator()(X&& x, Y&& y) -> decltype(x + y) { return x + y; }
+            auto operator()(X&& x, Y&& y) noexcept -> decltype(x + y) { return x + y; }
         };
     }
 
-
-    template <class Arch=default_arch, class Iterator1, class Iterator2, class Init, class BinaryFunction = detail::plus>
-    Init reduce(Iterator1 first, Iterator2 last, Init init, BinaryFunction&& binfun = detail::plus{})
+    template <class Arch = default_arch, class Iterator1, class Iterator2, class Init, class BinaryFunction = detail::plus>
+    Init reduce(Iterator1 first, Iterator2 last, Init init, BinaryFunction&& binfun = detail::plus {}) noexcept
     {
         using value_type = typename std::decay<decltype(*first)>::type;
         using batch_type = batch<value_type, Arch>;
@@ -153,9 +151,9 @@ namespace xsimd
         std::size_t size = static_cast<std::size_t>(std::distance(first, last));
         constexpr std::size_t simd_size = batch_type::size;
 
-        if(size < simd_size)
+        if (size < simd_size)
         {
-            while(first != last)
+            while (first != last)
             {
                 init = binfun(init, *first++);
             }
@@ -186,7 +184,8 @@ namespace xsimd
         // reduce across batch
         alignas(batch_type) std::array<value_type, simd_size> arr;
         xsimd::store_aligned(arr.data(), batch_init);
-        for (auto x : arr) init = binfun(init, x);
+        for (auto x : arr)
+            init = binfun(init, x);
 
         // reduce final unaligned part
         for (std::size_t i = align_end; i < size; ++i)
diff --git a/third_party/xsimd/types/xsimd_all_registers.hpp b/third_party/xsimd/types/xsimd_all_registers.hpp
index 46f8ca6cb..5894ea1e1 100644
--- a/third_party/xsimd/types/xsimd_all_registers.hpp
+++ b/third_party/xsimd/types/xsimd_all_registers.hpp
@@ -1,29 +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. *
-****************************************************************************/
+ * 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 "../types/xsimd_fma3_register.hpp"
 #include "../types/xsimd_sse2_register.hpp"
 #include "../types/xsimd_sse3_register.hpp"
 #include "../types/xsimd_sse4_1_register.hpp"
 #include "../types/xsimd_sse4_2_register.hpp"
-#include "../types/xsimd_fma3_register.hpp"
 
-#include "../types/xsimd_avx_register.hpp"
 #include "../types/xsimd_avx2_register.hpp"
+#include "../types/xsimd_avx_register.hpp"
 #include "../types/xsimd_fma5_register.hpp"
 
-#include "../types/xsimd_avx512f_register.hpp"
+#include "../types/xsimd_avx512bw_register.hpp"
 #include "../types/xsimd_avx512cd_register.hpp"
 #include "../types/xsimd_avx512dq_register.hpp"
-#include "../types/xsimd_avx512bw_register.hpp"
+#include "../types/xsimd_avx512f_register.hpp"
 
-#include "xsimd_neon_register.hpp"
 #include "xsimd_neon64_register.hpp"
-
+#include "xsimd_neon_register.hpp"
diff --git a/third_party/xsimd/types/xsimd_api.hpp b/third_party/xsimd/types/xsimd_api.hpp
index e2e1795e0..0cc372743 100644
--- a/third_party/xsimd/types/xsimd_api.hpp
+++ b/third_party/xsimd/types/xsimd_api.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_API_HPP
 #define XSIMD_API_HPP
@@ -17,1750 +17,1877 @@
 #include <limits>
 #include <ostream>
 
+#include "../arch/xsimd_isa.hpp"
 #include "../types/xsimd_batch.hpp"
 #include "../types/xsimd_traits.hpp"
-#include "../arch/xsimd_isa.hpp"
-
-namespace xsimd {
-
-/**
- * high level free functions
- *
- * @defgroup batch_arithmetic Arithmetic operators
- * @defgroup batch_constant Constant batches
- * @defgroup batch_data_transfer Memory operators
- * @defgroup batch_math Basic math operators
- * @defgroup batch_math_extra Extra math operators
- * @defgroup batch_fp Floating point manipulation
- * @defgroup batch_rounding Rounding operators
- * @defgroup batch_conversion Conversion operators
- * @defgroup batch_complex_op Complex operators
- * @defgroup batch_logical Logical operators
- * @defgroup batch_bitwise Bitwise operators
- * @defgroup batch_reducers Reducers
- * @defgroup batch_miscellaneous Miscellaneous
- * @defgroup batch_trigo Trigonometry
- *
- * @defgroup batch_bool_logical Boolean logical operators
- * @defgroup batch_bool_reducers Boolean reducers
- */
-
-/**
- * @ingroup batch_math
- *
- * Computes the absolute values of each scalar in the batch \c x.
- * @param x batch of integer or floating point values.
- * @return the absolute values of \c x.
- */
-template<class T, class A>
-batch<T, A> abs(batch<T, A> const& x) {
-  return kernel::abs<A>(x, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the absolute values of each complex in the batch \c z.
- * @param z batch of complex values.
- * @return the absolute values of \c z.
- */
-template<class T, class A>
-batch<T, A> abs(batch<std::complex<T>, A> const& z) {
-  return kernel::abs<A>(z, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the sum of the batches \c x and \c y.
- * @param x batch or scalar involved in the addition.
- * @param y batch or scalar involved in the addition.
- * @return the sum of \c x and \c y
- */
-template<class T, class Tp>
-auto add(T const& x, Tp const& y) -> decltype(x + y){
-  return x + y;
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the arc cosine of the batch \c x.
- * @param x batch of floating point values.
- * @return the arc cosine of \c x.
- */
-template<class T, class A>
-batch<T, A> acos(batch<T, A> const& x) {
-  return kernel::acos<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the inverse hyperbolic cosine of the batch \c x.
- * @param x batch of floating point values.
- * @return the inverse hyperbolic cosine of \c x.
- */
-template<class T, class A>
-batch<T, A> acosh(batch<T, A> const& x) {
-  return kernel::acosh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the argument of the batch \c z.
- * @param z batch of complex or real values.
- * @return the argument of \c z.
- */
-template<class T, class A>
-real_batch_type_t<batch<T, A>> arg(batch<T, A> const& z) {
-  return kernel::arg<A>(z, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the arc sine of the batch \c x.
- * @param x batch of floating point values.
- * @return the arc sine of \c x.
- */
-template<class T, class A>
-batch<T, A> asin(batch<T, A> const& x) {
-  return kernel::asin<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the inverse hyperbolic sine of the batch \c x.
- * @param x batch of floating point values.
- * @return the inverse hyperbolic sine of \c x.
- */
-template<class T, class A>
-batch<T, A> asinh(batch<T, A> const& x) {
-  return kernel::asinh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the arc tangent of the batch \c x.
- * @param x batch of floating point values.
- * @return the arc tangent of \c x.
- */
-template<class T, class A>
-batch<T, A> atan(batch<T, A> const& x) {
-  return kernel::atan<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the arc tangent of the batch \c x/y, using the signs of the
- * arguments to determine the correct quadrant.
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return the arc tangent of \c x/y.
- */
-template<class T, class A>
-batch<T, A> atan2(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::atan2<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the inverse hyperbolic tangent of the batch \c x.
- * @param x batch of floating point values.
- * @return the inverse hyperbolic tangent of \c x.
- */
-template<class T, class A>
-batch<T, A> atanh(batch<T, A> const& x) {
-  return kernel::atanh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_conversion
- *
- * Perform a static_cast from \c T_in to \c T_out on \c \c x.
- * @param x batch of \c T_in
- * @return \c x casted to \c T_out
- */
-template<class T_out, class T_in, class A>
-batch<T_out, A> batch_cast(batch<T_in, A> const & x) {
-  return kernel::batch_cast<A>(x, batch<T_out, A>{}, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Computes the bit of sign of \c x
- * @param x batch of scalar
- * @return bit of sign of \c x
- */
-template<class T, class A>
-batch<T, A> bitofsign(batch<T, A> const& x) {
-  return kernel::bitofsign<A>(x, A{});
-}
-
-/**
- * @ingroup batch_bitwise
- *
- * Computes the bitwise and of the batches \c x and \c y.
- * @param x batch involved in the operation.
- * @param y batch involved in the operation.
- * @return the result of the bitwise and.
- */
-template<class T, class Tp>
-auto bitwise_and(T const& x, Tp const& y) -> decltype(x & y){
-  return x & y;
-}
-
-/**
- * @ingroup batch_bitwise
- *
- * Computes the bitwise and not of batches \c x and \c y.
- * @param x batch involved in the operation.
- * @param y batch involved in the operation.
- * @return the result of the bitwise and not.
- */
-template<class T, class A>
-batch<T, A> bitwise_andnot(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::bitwise_andnot<A>(x, y, A{});
-}
-
-
-/**
- * @ingroup batch_bool_logical
- *
- * Computes the bitwise and not of batches \c x and \c y.
- * @param x batch involved in the operation.
- * @param y batch involved in the operation.
- * @return the result of the bitwise and not.
- */
-template<class T, class A>
-batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& x, batch_bool<T, A> const& y) {
-  return kernel::bitwise_andnot<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_conversion
- *
- * Perform a reinterpret_cast from \c T_in to \c T_out on \c x.
- * @param x batch of \c T_in
- * @return \c x reinterpreted as \c T_out
- */
-template<class B, class T, class A>
-B bitwise_cast(batch<T, A> const& x) {
-  return kernel::bitwise_cast<A>(x, B{}, A{});
-}
-
-/**
- * @ingroup batch_bitwise
- *
- * Computes the bitwise not of batch \c x.
- * @param x batch involved in the operation.
- * @return the result of the bitwise not.
- */
-template<class T, class A>
-batch<T, A> bitwise_not(batch<T, A> const& x) {
-  return kernel::bitwise_not<A>(x, A{});
-}
-
-/**
- * @ingroup batch_bitwise
- *
- * Computes the bitwise or of the batches \c x and \c y.
- * @param x scalar or batch of scalars
- * @param y scalar or batch of scalars
- * @return the result of the bitwise or.
- */
-template<class T, class Tp>
-auto bitwise_or(T const& x, Tp const& y) -> decltype(x | y){
-  return x | y;
-}
-
-/**
- * @ingroup batch_bitwise
- *
- * Computes the bitwise xor of the batches \c x and \c y.
- * @param x scalar or batch of scalars
- * @param y scalar or batch of scalars
- * @return the result of the bitwise xor.
- */
-template<class T, class Tp>
-auto bitwise_xor(T const& x, Tp const& y) -> decltype(x ^ y){
-  return x ^ y;
-}
-
-// FIXME: check if these need to be exposed, or removed (?)
-template<class A>
-batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& x) {
-  return kernel::bool_cast<A>(x, A{});
-}
-template<class A>
-batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& x) {
-  return kernel::bool_cast<A>(x, A{});
-}
-template<class A>
-batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& x) {
-  return kernel::bool_cast<A>(x, A{});
-}
-template<class A>
-batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& x) {
-  return kernel::bool_cast<A>(x, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the single value \c v.
- * @param v the value used to initialize the batch
- * @return a new batch instance
- */
-template<class T, class A=default_arch>
-batch<T, A> broadcast(T v) {
-  return kernel::broadcast<A>(v, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the single value \c v and
- * the specified batch value type \c To.
- * @param v the value used to initialize the batch
- * @return a new batch instance
- */
-template <class To, class A=default_arch, class From>
-simd_return_type<From, To> broadcast_as(From v) {
-    using batch_value_type = typename simd_return_type<From, To>::value_type;
-    using value_type = typename std::conditional<std::is_same<From, bool>::value,
-                                                 bool,
-                                                 batch_value_type>::type;
-    return simd_return_type<From, To>(value_type(v));
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the cubic root of the batch \c x.
- * @param x batch of floating point values.
- * @return the cubic root of \c x.
- */
-template<class T, class A>
-batch<T, A> cbrt(batch<T, A> const& x) {
-  return kernel::cbrt<A>(x, A{});
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Computes the batch of smallest integer values not less than
- * scalars in \c x.
- * @param x batch of floating point values.
- * @return the batch of smallest integer values not less than \c x.
- */
-template<class T, class A>
-batch<T, A> ceil(batch<T, A> const& x) {
-  return kernel::ceil<A>(x, A{});
-}
-
-
-/**
- * @ingroup batch_math
- *
- * Clips the values of the batch \c x between those of the batches \c lo and \c hi.
- * @param x batch of floating point values.
- * @param lo batch of floating point values.
- * @param hi batch of floating point values.
- * @return the result of the clipping.
- */
-template<class A, class T>
-batch<T, A> clip(batch<T, A> const& x, batch<T, A> const& lo, batch<T, A> const& hi) {
-  return kernel::clip(x, lo, hi, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the conjugate of the batch \c z.
- * @param z batch of complex values.
- * @return the argument of \c z.
- */
-template<class A, class T>
-complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& z) {
-  return kernel::conj(z, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Computes a value whose  absolute  value  matches
- *        that of \c x, but whose sign bit matches that of \c y.
- * @param x batch of scalars
- * @param y batch of scalars
- * @return batch whose absolute  value  matches that of \c x, but whose sign bit
- * matches that of \c y.
- */
-template<class A, class T>
-batch<T, A> copysign(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::copysign<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the cosine of the batch \c x.
- * @param x batch of floating point values.
- * @return the cosine of \c x.
- */
-template<class T, class A>
-batch<T, A> cos(batch<T, A> const& x) {
-  return kernel::cos<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * computes the hyperbolic cosine of the batch \c x.
- * @param x batch of floating point values.
- * @return the hyperbolic cosine of \c x.
- */
-template<class T, class A>
-batch<T, A> cosh(batch<T, A> const& x) {
-  return kernel::cosh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the division of the batch \c x by the batch \c y.
- * @param x scalar or batch of scalars
- * @param y scalar or batch of scalars
- * @return the result of the division.
- */
-template<class T, class Tp>
-auto div(T const& x, Tp const& y) -> decltype(x / y){
-  return x / y;
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise equality comparison of batches \c x and \c y.
- * @param x batch of scalars
- * @param y batch of scalars
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> eq(batch<T, A> const& x, batch<T, A> const& y) {
-  return x == y;
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the natural exponential of the batch \c x.
- * @param x batch of floating point values.
- * @return the natural exponential of \c x.
- */
-template<class T, class A>
-batch<T, A> exp(batch<T, A> const& x) {
-  return kernel::exp<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the base 10 exponential of the batch \c x.
- * @param x batch of floating point values.
- * @return the base 10 exponential of \c x.
- */
-template<class T, class A>
-batch<T, A> exp10(batch<T, A> const& x) {
-  return kernel::exp10<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the base 2 exponential of the batch \c x.
- * @param x batch of floating point values.
- * @return the base 2 exponential of \c x.
- */
-template<class T, class A>
-batch<T, A> exp2(batch<T, A> const& x) {
-  return kernel::exp2<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the natural exponential of the batch \c x, minus one.
- * @param x batch of floating point values.
- * @return the natural exponential of \c x, minus one.
- */
-template<class T, class A>
-batch<T, A> expm1(batch<T, A> const& x) {
-  return kernel::expm1<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes the error function of the batch \c x.
- * @param x batch of floating point values.
- * @return the error function of \c x.
- */
-template<class T, class A>
-batch<T, A> erf(batch<T, A> const& x) {
-  return kernel::erf<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes the complementary error function of the batch \c x.
- * @param x batch of floating point values.
- * @return the error function of \c x.
- */
-template<class T, class A>
-batch<T, A> erfc(batch<T, A> const& x) {
-  return kernel::erfc<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Evaluate polynomial with coefficient \c Coefs on point \c x using estrin
- * method.
- * @param x batch of floating point values.
- * @return the evaluation ofpolynomial with coefficient \c Coefs on point \c x.
- */
-template <class T, class A, uint64_t... Coefs>
-batch<T, A> estrin(const batch<T, A>& x) {
-  return kernel::estrin<T, A, Coefs...>(x);
-}
-
-/**
- * Extract vector from pair of vectors
- * extracts the lowest vector elements from the second source \c x
- * and the highest vector elements from the first source \c y
- * Concatenates the results into th Return value.
- * @param x batch of integer or floating point values.
- * @param y batch of integer or floating point values.
- * @param i integer specifuing the lowest vector element to extract from the first source register
- * @return.
- */
-template <class T, class A>
-batch<T, A> extract_pair(batch<T, A> const & x, batch<T, A> const& y, std::size_t i) {
-  return kernel::extract_pair<A>(x, y, i, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the absolute values of each scalar in the batch \c x.
- * @param x batch floating point values.
- * @return the asbolute values of \c x.
- */
-template<class T, class A>
-batch<T, A> fabs(batch<T, A> const& x) {
-  return kernel::abs<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the positive difference between \c x and \c y, that is,
- * <tt>max(0, x-y)</tt>.
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return the positive difference.
- */
-template<class T, class A>
-batch<T, A> fdim(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::fdim<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Computes the batch of largest integer values not greater than
- * scalars in \c x.
- * @param x batch of floating point values.
- * @return the batch of largest integer values not greater than \c x.
- */
-template<class T, class A>
-batch<T, A> floor(batch<T, A> const& x) {
-  return kernel::floor<A>(x, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes <tt>(x*y) + z</tt> in a single instruction when possible.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @param z a batch of integer or floating point values.
- * @return the result of the fused multiply-add operation.
- */
-template<class T, class A>
-batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) {
-  return kernel::fma<A>(x, y, z, A{});
-}
-
-
-/**
- * @ingroup batch_math
- *
- * Computes the larger values of the batches \c x and \c y.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @return a batch of the larger values.
- */
-template<class T, class A>
-batch<T, A> fmax(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::max<A>(x, y, A{});
-}
-
-
-/**
- * @ingroup batch_math
- *
- * Computes the smaller values of the batches \c x and \c y.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @return a batch of the larger values.
- */
-template<class T, class A>
-batch<T, A> fmin(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::min<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the modulo of the batch \c x by the batch \c y.
- * @param x batch involved in the modulo.
- * @param y batch involved in the modulo.
- * @return the result of the modulo.
- */
-template<class T, class A>
-batch<T, A> fmod(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::fmod<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes <tt>(x*y) - z</tt> in a single instruction when possible.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @param z a batch of integer or floating point values.
- * @return the result of the fused multiply-sub operation.
- */
-template<class T, class A>
-batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) {
-  return kernel::fms<A>(x, y, z, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes <tt>-(x*y) + z</tt> in a single instruction when possible.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @param z a batch of integer or floating point values.
- * @return the result of the fused negated multiply-add operation.
- */
-template<class T, class A>
-batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) {
-  return kernel::fnma<A>(x, y, z, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes <tt>-(x*y) - z</tt> in a single instruction when possible.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @param z a batch of integer or floating point values.
- * @return the result of the fused negated multiply-sub operation.
- */
-template<class T, class A>
-batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) {
-  return kernel::fnms<A>(x, y, z, A{});
-}
-
-/**
- * @ingroup batch_fp
- *
- * Split split the number x into a normalized fraction and an exponent which is stored in exp
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @return the normalized fraction of x
- */
-template <class T, class A>
-batch<T, A> frexp(const batch<T, A>& x, batch<as_integer_t<T>, A>& y) {
-  return kernel::frexp<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise greater or equal comparison of batches \c x and \c y.
- * @tparam X the actual type of batch.
- * @param x batch involved in the comparison.
- * @param y batch involved in the comparison.
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> ge(batch<T, A> const& x, batch<T, A> const& y) {
-  return x >= y;
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise greater than comparison of batches \c x and \c y.
- * @tparam X the actual type of batch.
- * @param x batch involved in the comparison.
- * @param y batch involved in the comparison.
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> gt(batch<T, A> const& x, batch<T, A> const& y) {
-  return x > y;
-}
-
-/**
- * @ingroup batch_reducers
- *
- * Adds all the scalars of the batch \c x.
- * @param x batch involved in the reduction
- * @return the result of the reduction.
- */
-template<class T, class A>
-T hadd(batch<T, A> const& x) {
-  return kernel::hadd<A>(x, A{});
-}
-
-/**
- * @ingroup batch_reducers
- *
- * Parallel horizontal addition: adds the scalars of each batch
- * in the array pointed by \c row and store them in a returned
- * batch.
- * @param row an array of \c N batches
- * @return the result of the reduction.
- */
-template<class T, class A>
-batch<T, A> haddp(batch<T, A> const* row) {
-  return kernel::haddp<A>(row, A{});
-}
-
-
-/**
- * @ingroup batch_math_extra
- *
- * Evaluate polynomial with coefficient \c Coefs on point \c x using horner
- * method.
- * @param x batch of floating point values.
- * @return the evaluation ofpolynomial with coefficient \c Coefs on point \c x.
- */
-template <class T, class A, uint64_t... Coefs>
-batch<T, A> horner(const batch<T, A>& x) {
-  return kernel::horner<T, A, Coefs...>(x);
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the square root of the sum of the squares of the batches
- * \c x, and \c y.
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return the square root of the sum of the squares of \c x and \c y.
- */
-template<class T, class A>
-batch<T, A> hypot(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::hypot<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the imaginary part of the batch \c z.
- * @param z batch of complex or real values.
- * @return the argument of \c z.
- */
-template <class T, class A>
-real_batch_type_t<batch<T, A>> imag(batch<T, A> const& x) {
-  return kernel::imag<A>(x, A{});
-}
-
-/**
- * @ingroup batch_constant
- *
- * Return a batch of scalars representing positive infinity
- * @return a batch of positive infinity
- */
-template<class B>
-B infinity() {
-  using T = typename B::value_type;
-  return B(std::numeric_limits<T>::infinity());
-}
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the scalars in the given batch \c x represent an even integer value
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-batch_bool<T, A> is_even(batch<T, A> const& x) {
-  return kernel::is_even<A>(x, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the floating-point scalars in the given batch \c x represent integer value
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-batch_bool<T, A> is_flint(batch<T, A> const& x) {
-  return kernel::is_flint<A>(x, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the scalars in the given batch \c x represent an odd integer value
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-batch_bool<T, A> is_odd(batch<T, A> const& x) {
-  return kernel::is_odd<A>(x, A{});
-}
-
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the scalars in the given batch \c x are inf values.
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-batch_bool<T, A> isinf(batch<T, A> const& x) {
-  return kernel::isinf<A>(x, A{});
-}
-
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the scalars in the given batch \c x are finite values.
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-batch_bool<T, A> isfinite(batch<T, A> const& x) {
-  return kernel::isfinite<A>(x, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Determines if the scalars in the given batch \c x are NaN values.
- * @param x batch of floating point values.
- * @return a batch of booleans.
- */
-template<class T, class A>
-typename batch<T, A>::batch_bool_type isnan(batch<T, A> const& x) {
-  return kernel::isnan<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes the multiplication of the floating- point number x by 2 raised to the power exp.
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return the natural logarithm of the gamma function of \c x.
- */
-template <class T, class A>
-batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& y) {
-  return kernel::ldexp<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise lesser or equal to comparison of batches \c x and \c y.
- * @param x batch involved in the comparison.
- * @param y batch involved in the comparison.
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> le(batch<T, A> const& x, batch<T, A> const& y) {
-  return x <= y;
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes the natural logarithm of the gamma function of the batch \c x.
- * @param x batch of floating point values.
- * @return the natural logarithm of the gamma function of \c x.
- */
-template<class T, class A>
-batch<T, A> lgamma(batch<T, A> const& x) {
-  return kernel::lgamma<A>(x, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr and the specifed
- * batch value type \c To. The memory needs to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template <class To, class A=default_arch, class From>
-simd_return_type<From, To> load_as(From const* ptr, aligned_mode) {
-  using batch_value_type = typename simd_return_type<From, To>::value_type;
-  return kernel::load_aligned<A>(ptr, kernel::convert<batch_value_type>{}, A{});
-}
-
-template <class To, class A = default_arch>
-simd_return_type<bool, To> load_as(bool const* ptr, aligned_mode) {
-  return simd_return_type<bool, To>::load_aligned(ptr);
-}
 
-template <class To, class A=default_arch, class From>
-simd_return_type<std::complex<From>, To> load_as(std::complex<From> const* ptr, aligned_mode)
+namespace xsimd
 {
-  using batch_value_type = typename simd_return_type<std::complex<From>, To>::value_type;
-  return kernel::load_complex_aligned<A>(ptr, kernel::convert<batch_value_type>{}, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr and the specifed
- * batch value type \c To. The memory does not need to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template <class To, class A=default_arch, class From>
-simd_return_type<From, To> load_as(From const* ptr, unaligned_mode) {
-  using batch_value_type = typename simd_return_type<From, To>::value_type;
-  return kernel::load_unaligned<A>(ptr, kernel::convert<batch_value_type>{}, A{});
-}
-
-template <class To, class A = default_arch>
-simd_return_type<bool, To> load_as(bool const* ptr, unaligned_mode) {
-  return simd_return_type<bool, To>::load_unaligned(ptr);
-}
-
-template <class To, class A=default_arch, class From>
-simd_return_type<std::complex<From>, To> load_as(std::complex<From> const* ptr, unaligned_mode)
-{
-  using batch_value_type = typename simd_return_type<std::complex<From>, To>::value_type;
-  return kernel::load_complex_unaligned<A>(ptr, kernel::convert<batch_value_type>{}, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr. The
- * memory needs to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template<class A=default_arch, class From>
-batch<From, A> load(From const* ptr, aligned_mode= {}) {
-  return load_as<From, A>(ptr, aligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr. The
- * memory does not need to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template<class A=default_arch, class From>
-batch<From, A> load(From const* ptr, unaligned_mode) {
-  return load_as<From, A>(ptr, unaligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr. The
- * memory needs to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template<class A=default_arch, class From>
-batch<From, A> load_aligned(From const* ptr) {
-  return load_as<From, A>(ptr, aligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Creates a batch from the buffer \c ptr. The
- * memory does not need to be aligned.
- * @param ptr the memory buffer to read
- * @return a new batch instance
- */
-template <class A=default_arch, class From>
-batch<From, A> load_unaligned(From const* ptr) {
-  return load_as<From, A>(ptr, unaligned_mode{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the natural logarithm of the batch \c x.
- * @param x batch of floating point values.
- * @return the natural logarithm of \c x.
- */
-template<class T, class A>
-batch<T, A> log(batch<T, A> const& x) {
-  return kernel::log<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- * Computes the base 2 logarithm of the batch \c x.
- * @param x batch of floating point values.
- * @return the base 2 logarithm of \c x.
- */
-template<class T, class A>
-batch<T, A> log2(batch<T, A> const& x) {
-  return kernel::log2<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- * Computes the base 10 logarithm of the batch \c x.
- * @param x batch of floating point values.
- * @return the base 10 logarithm of \c x.
- */
-template<class T, class A>
-batch<T, A> log10(batch<T, A> const& x) {
-  return kernel::log10<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- * Computes the natural logarithm of one plus the batch \c x.
- * @param x batch of floating point values.
- * @return the natural logarithm of one plus \c x.
- */
-template<class T, class A>
-batch<T, A> log1p(batch<T, A> const& x) {
-  return kernel::log1p<A>(x, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise lesser than comparison of batches \c x and \c y.
- * @param x batch involved in the comparison.
- * @param y batch involved in the comparison.
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> lt(batch<T, A> const& x, batch<T, A> const& y) {
-  return x < y;
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the larger values of the batches \c x and \c y.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @return a batch of the larger values.
- */
-template<class T, class A>
-batch<T, A> max(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::max<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the smaller values of the batches \c x and \c y.
- * @param x a batch of integer or floating point values.
- * @param y a batch of integer or floating point values.
- * @return a batch of the smaller values.
- */
-template<class T, class A>
-batch<T, A> min(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::min<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_constant
- *
- * Return a batch of scalars representing positive infinity
- * @return a batch of positive infinity
- */
-template<class B>
-B minusinfinity() {
-  using T = typename B::value_type;
-  return B(-std::numeric_limits<T>::infinity());
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the integer modulo of the batch \c x by the batch \c y.
- * @param x batch involved in the modulo.
- * @param y batch involved in the modulo.
- * @return the result of the modulo.
- */
-template<class T, class Tp>
-auto mod(T const& x, Tp const& y) -> decltype(x % y){
-  return x % y;
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the product of the batches \c x and \c y.
- * @tparam X the actual type of batch.
- * @param x batch involved in the product.
- * @param y batch involved in the product.
- * @return the result of the product.
- */
-template<class T, class Tp>
-auto mul(T const& x, Tp const& y) -> decltype(x * y){
-  return x * y;
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Rounds the scalars in \c x to integer values (in floating point format), using
- * the current rounding mode.
- * @param x batch of flaoting point values.
- * @return the batch of nearest integer values.
- */
-template<class T, class A>
-batch<T, A> nearbyint(batch<T, A> const& x) {
-  return kernel::nearbyint<A>(x, A{});
-}
-
-/**
- * @ingroup batch_logical
- *
- * Element-wise inequality comparison of batches \c x and \c y.
- * @param x batch involved in the comparison.
- * @param y batch involved in the comparison.
- * @return a boolean batch.
- */
-template<class T, class A>
-batch_bool<T, A> neq(batch<T, A> const& x, batch<T, A> const& y) {
-  return x != y;
-}
-
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the opposite of the batch \c x.
- * @param x batch involved in the operation.
- * @return the opposite of \c x.
- */
-template<class T, class A>
-batch<T, A> neg(batch<T, A> const& x) {
-  return -x;
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes  the next representable  floating-point
- *        value  following  x  in the direction of y
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return \c x raised to the power \c y.
- */
-template<class T, class A>
-batch<T, A> nextafter(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::nextafter<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the norm of the batch \c x.
- * @param x batch of complex or real values.
- * @return the norm of \c x.
- */
-template<class A, class T>
-real_batch_type_t<batch<T, A>> norm(batch<T, A> const& x) {
-  return kernel::norm(x, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * No-op on \c x.
- * @param x batch involved in the operation.
- * @return \c x.
- */
-template<class T, class A>
-batch<T, A> pos(batch<T, A> const& x) {
-  return +x;
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the value of the batch \c x raised to the power
- * \c y.
- * @param x batch of floating point values.
- * @param y batch of floating point values.
- * @return \c x raised to the power \c y.
- */
-template<class T, class A>
-batch<T, A> pow(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::pow<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the value of the batch \c x raised to the power
- * \c y.
- * @param x batch of integral values.
- * @param y batch of integral values.
- * @return \c x raised to the power \c y.
- */
-template<class T, class ITy, class A, class=typename std::enable_if<std::is_integral<ITy>::value, void>::type>
-batch<T, A> pow(batch<T, A> const& x, ITy y) {
-  return kernel::ipow<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the projection of the batch \c x.
- * @param x batch of complex or real values.
- * @return the projection of \c x.
- */
-template<class A, class T>
-complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& x) {
-  return kernel::proj(x, A{});
-}
-
-/**
- * @ingroup batch_complex
- *
- * Computes the real part of the batch \c z.
- * @param z batch of complex or real values.
- * @return the argument of \c z.
- */
-template <class T, class A>
-real_batch_type_t<batch<T, A>> real(batch<T, A> const& x) {
-  return kernel::real<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the remainder of dividing \c x by \c y
- * @param x batch of scalar values
- * @param y batch of scalar values
- * @return the result of the addition.
- */
-template<class T, class A>
-batch<T, A> remainder(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::remainder<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Rounds the scalars in \c x to integer values (in floating point format), using
- * the current rounding mode.
- * @param x batch of floating point values.
- * @return the batch of rounded values.
- */
-template<class T, class A>
-batch<T, A> rint(batch<T, A> const& x) {
-  return nearbyint(x);
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Computes the batch of nearest integer values to scalars in \c x (in
- * floating point format), rounding halfway cases away from zero, regardless
- * of the current rounding mode.
- * @param x batch of flaoting point values.
- * @return the batch of nearest integer values. 
- */
-template<class T, class A>
-batch<T, A> round(batch<T, A> const& x) {
-  return kernel::round<A>(x, A{});
-}
 
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the saturate sum of the batch \c x and the batch \c y.
- * \c x.
- * @tparam X the actual type of batch.
- * @param x batch involved in the saturated addition.
- * @param y batch involved in the saturated addition.
- * @return the result of the saturated addition.
- */
-template<class T, class Tp>
-auto sadd(T const& x, Tp const& y) -> decltype(x + y) {
-  using B = decltype(x + y);
-  using A = typename B::arch_type;
-  return kernel::sadd<A>(B(x), B(y), A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
- * depending on the boolean values in the constant batch \c cond. Equivalent to
- * \code{.cpp}
- * for(std::size_t i = 0; i < N; ++i)
- *     res[i] = cond[i] ? true_br[i] : false_br[i];
- * \endcode
- * @param cond constant batch condition.
- * @param true_br batch values for truthy condition.
- * @param false_br batch value for falsy condition.
- * @return the result of the selection.
- */
-template<class T, class A>
-batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br) {
-  return kernel::select<A>(cond, true_br, false_br, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
- * depending on the boolean values in the constant batch \c cond. Equivalent to
- * \code{.cpp}
- * for(std::size_t i = 0; i < N; ++i)
- *     res[i] = cond[i] ? true_br[i] : false_br[i];
- * \endcode
- * @param cond constant batch condition.
- * @param true_br batch values for truthy condition.
- * @param false_br batch value for falsy condition.
- * @return the result of the selection.
- */
-template<class T, class A>
-batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br) {
-  return kernel::select<A>(cond, true_br, false_br, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
- * depending on the boolean values in the constant batch \c cond. Equivalent to
- * \code{.cpp}
- * for(std::size_t i = 0; i < N; ++i)
- *     res[i] = cond[i] ? true_br[i] : false_br[i];
- * \endcode
- * @param cond constant batch condition.
- * @param true_br batch values for truthy condition.
- * @param false_br batch value for falsy condition.
- * @return the result of the selection.
- */
-template<class T, class A, bool... Values>
-batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br) {
-  return kernel::select<A>(cond, true_br, false_br, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Computes the sign of \c x
- * @param x batch
- * @return -1 for each negative element, -1 or +1 for each null element and +1 for each element
- */
-template<class T, class A>
-batch<T, A> sign(batch<T, A> const& x) {
-  return kernel::sign<A>(x, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Computes the sign of \c x, assuming x doesn't have any zero
- * @param x batch
- * @return -1 for each negative element, -1 or +1 for each null element and +1 for each element
- */
-template<class T, class A>
-batch<T, A> signnz(batch<T, A> const& x) {
-  return kernel::signnz<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the sine of the batch \c x.
- * @param x batch of floating point values.
- * @return the sine of \c x.
- */
-template<class T, class A>
-batch<T, A> sin(batch<T, A> const& x) {
-  return kernel::sin<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the hyperbolic sine of the batch \c x.
- * @param x batch of floating point values.
- * @return the hyperbolic sine of \c x.
- */
-template<class T, class A>
-batch<T, A> sinh(batch<T, A> const& x) {
-  return kernel::sinh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the sine and the cosine of the batch \c x. This method is faster
- * than calling sine and cosine independently.
- * @param x batch of floating point values.
- * @return a pair containing the sine then the cosine of  batch \c x
- */
-template<class T, class A>
-std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& x) {
-  return kernel::sincos<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math
- *
- * Computes the square root of the batch \c x.
- * @param x batch of floating point values.
- * @return the square root of \c x.
- */
-template<class T, class A>
-batch<T, A> sqrt(batch<T, A> const& x) {
-  return kernel::sqrt<A>(x, A{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the saturate difference of the batch \c x and the batch \c y.
- * \c x.
- * @tparam X the actual type of batch.
- * @param x batch involved in the saturated difference.
- * @param y batch involved in the saturated difference.
- * @return the result of the saturated difference.
- */
-template<class T, class Tp>
-auto ssub(T const& x, Tp const& y) -> decltype(x - y) {
-  using B = decltype(x + y);
-  using A = typename B::arch_type;
-  return kernel::ssub<A>(B(x), B(y), A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c src to the buffer \c dst. The
- * memory needs to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy
- */
-template <class To, class A=default_arch, class From>
-void store_as(To* dst, batch<From, A> const& src, aligned_mode) {
-  kernel::store_aligned(dst, src, A{});
-}
-
-template <class A=default_arch, class From>
-void store_as(bool* dst, batch_bool<From, A> const& src, aligned_mode) {
-  kernel::store(src, dst, A{});
-}
-
-template <class To, class A=default_arch, class From>
-void store_as(std::complex<To>* dst, batch<std::complex<From>,A> const& src, aligned_mode) {
-  kernel::store_complex_aligned(dst, src, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c src to the buffer \c dst. The
- * memory does not need to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy
- */
-template <class To, class A=default_arch, class From>
-void store_as(To* dst, batch<From, A> const& src, unaligned_mode) {
-  kernel::store_unaligned(dst, src, A{});
-}
-
-template <class A=default_arch, class From>
-void store_as(bool* dst, batch_bool<From, A> const& src, unaligned_mode) {
-  kernel::store(src, dst, A{});
-}
-
-template <class To, class A=default_arch, class From>
-void store_as(std::complex<To>* dst, batch<std::complex<From>, A> const& src, unaligned_mode) {
-  kernel::store_complex_unaligned(dst, src, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c val to the buffer \c mem. The
- * memory does not need to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy from
- */
-template<class A, class T>
-void store(T* mem, batch<T, A> const& val, aligned_mode={}) {
-  store_as<T, A>(mem, val, aligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c val to the buffer \c mem. The
- * memory does not need to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy from
- */
-template<class A, class T>
-void store(T* mem, batch<T, A> const& val, unaligned_mode) {
-  store_as<T, A>(mem, val, unaligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c val to the buffer \c mem. The
- * memory needs to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy from
- */
-template<class A, class T>
-void store_aligned(T* mem, batch<T, A> const& val) {
-  store_as<T, A>(mem, val, aligned_mode{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Copy content of batch \c val to the buffer \c mem. The
- * memory does not need to be aligned.
- * @param mem the memory buffer to write to
- * @param val the batch to copy
- */
-template<class A, class T>
-void store_unaligned(T* mem, batch<T, A> const& val) {
-  store_as<T, A>(mem, val, unaligned_mode{});
-}
-
-/**
- * @ingroup batch_arithmetic
- *
- * Computes the difference between \c x and \c y
- * @tparam X the actual type of batch.
- * @param x scalar or batch of scalars
- * @param y scalar or batch of scalars
- * @return the difference between \c x and \c y
- */
-template<class T, class Tp>
-auto sub(T const& x, Tp const& y) -> decltype(x - y){
-  return x - y;
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the tangent of the batch \c x.
- * @param x batch of floating point values.
- * @return the tangent of \c x.
- */
-template<class T, class A>
-batch<T, A> tan(batch<T, A> const& x) {
-  return kernel::tan<A>(x, A{});
-}
-
-/**
- * @ingroup batch_trigo
- *
- * Computes the hyperbolic tangent of the batch \c x.
- * @param x batch of floating point values.
- * @return the hyperbolic tangent of \c x.
- */
-template<class T, class A>
-batch<T, A> tanh(batch<T, A> const& x) {
-  return kernel::tanh<A>(x, A{});
-}
-
-/**
- * @ingroup batch_math_extra
- *
- * Computes the gamma function of the batch \c x.
- * @param x batch of floating point values.
- * @return the gamma function of \c x.
- */
-template<class T, class A>
-batch<T, A> tgamma(batch<T, A> const& x) {
-  return kernel::tgamma<A>(x, A{});
-}
-
-/**
- * @ingroup batch_conversion
- *
- * Perform a conversion from \c i to a value of an floating point type of the same size as \c T
- * @param i batch of integers.
- * @return \c i converted to a value of an floating point type of the same size as \c T
- */
-template<class T, class A>
-batch<as_float_t<T>, A> to_float(batch<T, A> const& i) {
-  return kernel::to_float<A>(i, A{});
-}
-
-/**
- * @ingroup batch_conversion
- *
- * Perform a conversion from \c x to a value of an integer type of the same size as \c T
- * @param x batch.
- * @return \c x converted to a value of an integer type of the same size as \c T
- */
-template<class T, class A>
-batch<as_integer_t<T>, A> to_int(batch<T, A> const& x) {
-  return kernel::to_int<A>(x, A{});
-}
-
-/**
- * @ingroup batch_rounding
- *
- * Computes the batch of nearest integer values not greater in magnitude
- * than scalars in \c x.
- * @param x batch of floating point values.
- * @return the batch of nearest integer values not greater in magnitude than \c x.
- */
-template<class T, class A>
-batch<T, A> trunc(batch<T, A> const& x) {
-  return kernel::trunc<A>(x, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Unpack and interleave data from the HIGH half of batches \c x and \c y.
- * Store the results in the Return value.
- * @param x a batch of integer or floating point or double precision values.
- * @param y a batch of integer or floating point or double precision values.
- * @return a batch of the high part of shuffled values.
- */
-template<class T, class A>
-batch<T, A> zip_hi(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::zip_hi<A>(x, y, A{});
-}
-
-/**
- * @ingroup batch_data_transfer
- *
- * Unpack and interleave data from the LOW half of batches \c x and \c y.
- * Store the results in the Return value.
- * @param x a batch of integer or floating point or double precision values.
- * @param y a batch of integer or floating point or double precision values.
- * @return a batch of the low part of shuffled values.
- */
-template<class T, class A>
-batch<T, A> zip_lo(batch<T, A> const& x, batch<T, A> const& y) {
-  return kernel::zip_lo<A>(x, y, A{});
-}
-
-// bitwise_cast
-template <class A, class T, typename std::enable_if<std::is_integral<T>::value, int>::type = 3>
-batch<T, A> bitwise_cast(batch_bool<T, A> const& self)
-{
-  T z(0);
-  return select(self, batch<T, A>(T(~z)), batch<T, A>(z));
-}
-    
-template <class A, class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 3>
-batch<T, A> bitwise_cast(batch_bool<T, A> const& self)
-{
-    T z0(0), z1(0);
-    using int_type = as_unsigned_integer_t<T>;
-    int_type value(~int_type(0));
-    std::memcpy(&z1, &value, sizeof(int_type));
-    return select(self, batch<T, A>(z1), batch<T, A>(z0)); 
-}
-
-/**
- * @ingroup batch_bool_reducers
- *
- * Returns true if all the boolean values in the batch are true,
- * false otherwise.
- * @param x the batch to reduce.
- * @return a boolean scalar.
- */
-template<class T, class A>
-bool all(batch_bool<T, A> const& x) {
-  return kernel::all<A>(x, A{});
-}
-
-/**
- * @ingroup batch_bool_reducers
- *
- * Return true if any of the boolean values in the batch is true,
- * false otherwise.
- * @param x the batch to reduce.
- * @return a boolean scalar.
- */
-template<class T, class A>
-bool any(batch_bool<T, A> const& x) {
-  return kernel::any<A>(x, A{});
-}
-
-/**
- * @ingroup batch_miscellaneous
- *
- * Dump the content of batch \c x to stream \c o
- * @param o the stream where the batch is dumped
- * @param x batch to dump.
- * @return a reference to \c o
- */
-template<class T, class A>
-std::ostream& operator<<(std::ostream& o, batch<T, A> const& x) {
-  constexpr auto size = batch<T, A>::size;
-  alignas(A::alignment()) T buffer[size];
-  x.store_aligned(&buffer[0]);
-  o << '(';
-  for(std::size_t i = 0; i < size - 1; ++i)
-    o << buffer[i] << ", ";
-  return o << buffer[size - 1] << ')';
-}
+    /**
+     * high level free functions
+     *
+     * @defgroup batch_arithmetic Arithmetic operators
+     * @defgroup batch_constant Constant batches
+     * @defgroup batch_data_transfer Memory operators
+     * @defgroup batch_math Basic math operators
+     * @defgroup batch_math_extra Extra math operators
+     * @defgroup batch_fp Floating point manipulation
+     * @defgroup batch_rounding Rounding operators
+     * @defgroup batch_conversion Conversion operators
+     * @defgroup batch_complex_op Complex operators
+     * @defgroup batch_logical Logical operators
+     * @defgroup batch_bitwise Bitwise operators
+     * @defgroup batch_reducers Reducers
+     * @defgroup batch_miscellaneous Miscellaneous
+     * @defgroup batch_trigo Trigonometry
+     *
+     * @defgroup batch_bool_logical Boolean logical operators
+     * @defgroup batch_bool_reducers Boolean reducers
+     */
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the absolute values of each scalar in the batch \c x.
+     * @param x batch of integer or floating point values.
+     * @return the absolute values of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> abs(batch<T, A> const& x) noexcept
+    {
+        return kernel::abs<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the absolute values of each complex in the batch \c z.
+     * @param z batch of complex values.
+     * @return the absolute values of \c z.
+     */
+    template <class T, class A>
+    inline batch<T, A> abs(batch<std::complex<T>, A> const& z) noexcept
+    {
+        return kernel::abs<A>(z, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the sum of the batches \c x and \c y.
+     * @param x batch or scalar involved in the addition.
+     * @param y batch or scalar involved in the addition.
+     * @return the sum of \c x and \c y
+     */
+    template <class T, class Tp>
+    inline auto add(T const& x, Tp const& y) noexcept -> decltype(x + y)
+    {
+        return x + y;
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the arc cosine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the arc cosine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> acos(batch<T, A> const& x) noexcept
+    {
+        return kernel::acos<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the inverse hyperbolic cosine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the inverse hyperbolic cosine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> acosh(batch<T, A> const& x) noexcept
+    {
+        return kernel::acosh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the argument of the batch \c z.
+     * @param z batch of complex or real values.
+     * @return the argument of \c z.
+     */
+    template <class T, class A>
+    inline real_batch_type_t<batch<T, A>> arg(batch<T, A> const& z) noexcept
+    {
+        return kernel::arg<A>(z, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the arc sine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the arc sine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> asin(batch<T, A> const& x) noexcept
+    {
+        return kernel::asin<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the inverse hyperbolic sine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the inverse hyperbolic sine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> asinh(batch<T, A> const& x) noexcept
+    {
+        return kernel::asinh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the arc tangent of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the arc tangent of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> atan(batch<T, A> const& x) noexcept
+    {
+        return kernel::atan<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the arc tangent of the batch \c x/y, using the signs of the
+     * arguments to determine the correct quadrant.
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return the arc tangent of \c x/y.
+     */
+    template <class T, class A>
+    inline batch<T, A> atan2(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::atan2<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the inverse hyperbolic tangent of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the inverse hyperbolic tangent of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> atanh(batch<T, A> const& x) noexcept
+    {
+        return kernel::atanh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_conversion
+     *
+     * Perform a static_cast from \c T_in to \c T_out on \c \c x.
+     * @param x batch of \c T_in
+     * @return \c x casted to \c T_out
+     */
+    template <class T_out, class T_in, class A>
+    inline batch<T_out, A> batch_cast(batch<T_in, A> const& x) noexcept
+    {
+        return kernel::batch_cast<A>(x, batch<T_out, A> {}, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Computes the bit of sign of \c x
+     * @param x batch of scalar
+     * @return bit of sign of \c x
+     */
+    template <class T, class A>
+    inline batch<T, A> bitofsign(batch<T, A> const& x) noexcept
+    {
+        return kernel::bitofsign<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_bitwise
+     *
+     * Computes the bitwise and of the batches \c x and \c y.
+     * @param x batch involved in the operation.
+     * @param y batch involved in the operation.
+     * @return the result of the bitwise and.
+     */
+    template <class T, class Tp>
+    inline auto bitwise_and(T const& x, Tp const& y) noexcept -> decltype(x & y)
+    {
+        return x & y;
+    }
+
+    /**
+     * @ingroup batch_bitwise
+     *
+     * Computes the bitwise and not of batches \c x and \c y.
+     * @param x batch involved in the operation.
+     * @param y batch involved in the operation.
+     * @return the result of the bitwise and not.
+     */
+    template <class T, class A>
+    inline batch<T, A> bitwise_andnot(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::bitwise_andnot<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_bool_logical
+     *
+     * Computes the bitwise and not of batches \c x and \c y.
+     * @param x batch involved in the operation.
+     * @param y batch involved in the operation.
+     * @return the result of the bitwise and not.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
+    {
+        return kernel::bitwise_andnot<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_conversion
+     *
+     * Perform a reinterpret_cast from \c T_in to \c T_out on \c x.
+     * @param x batch of \c T_in
+     * @return \c x reinterpreted as \c T_out
+     */
+    template <class B, class T, class A>
+    inline B bitwise_cast(batch<T, A> const& x) noexcept
+    {
+        return kernel::bitwise_cast<A>(x, B {}, A {});
+    }
+
+    /**
+     * @ingroup batch_bitwise
+     *
+     * Computes the bitwise not of batch \c x.
+     * @param x batch involved in the operation.
+     * @return the result of the bitwise not.
+     */
+    template <class T, class A>
+    inline batch<T, A> bitwise_not(batch<T, A> const& x) noexcept
+    {
+        return kernel::bitwise_not<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_bitwise
+     *
+     * Computes the bitwise or of the batches \c x and \c y.
+     * @param x scalar or batch of scalars
+     * @param y scalar or batch of scalars
+     * @return the result of the bitwise or.
+     */
+    template <class T, class Tp>
+    inline auto bitwise_or(T const& x, Tp const& y) noexcept -> decltype(x | y)
+    {
+        return x | y;
+    }
+
+    /**
+     * @ingroup batch_bitwise
+     *
+     * Computes the bitwise xor of the batches \c x and \c y.
+     * @param x scalar or batch of scalars
+     * @param y scalar or batch of scalars
+     * @return the result of the bitwise xor.
+     */
+    template <class T, class Tp>
+    inline auto bitwise_xor(T const& x, Tp const& y) noexcept -> decltype(x ^ y)
+    {
+        return x ^ y;
+    }
+
+    // FIXME: check if these need to be exposed, or removed (?)
+    template <class A>
+    inline batch_bool<float, A> bool_cast(batch_bool<int32_t, A> const& x) noexcept
+    {
+        return kernel::bool_cast<A>(x, A {});
+    }
+    template <class A>
+    inline batch_bool<int32_t, A> bool_cast(batch_bool<float, A> const& x) noexcept
+    {
+        return kernel::bool_cast<A>(x, A {});
+    }
+    template <class A>
+    inline batch_bool<double, A> bool_cast(batch_bool<int64_t, A> const& x) noexcept
+    {
+        return kernel::bool_cast<A>(x, A {});
+    }
+    template <class A>
+    inline batch_bool<int64_t, A> bool_cast(batch_bool<double, A> const& x) noexcept
+    {
+        return kernel::bool_cast<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the single value \c v.
+     * @param v the value used to initialize the batch
+     * @return a new batch instance
+     */
+    template <class T, class A = default_arch>
+    inline batch<T, A> broadcast(T v) noexcept
+    {
+        return kernel::broadcast<A>(v, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the single value \c v and
+     * the specified batch value type \c To.
+     * @param v the value used to initialize the batch
+     * @return a new batch instance
+     */
+    template <class To, class A = default_arch, class From>
+    inline simd_return_type<From, To> broadcast_as(From v) noexcept
+    {
+        using batch_value_type = typename simd_return_type<From, To>::value_type;
+        using value_type = typename std::conditional<std::is_same<From, bool>::value,
+                                                     bool,
+                                                     batch_value_type>::type;
+        return simd_return_type<From, To>(value_type(v));
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the cubic root of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the cubic root of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> cbrt(batch<T, A> const& x) noexcept
+    {
+        return kernel::cbrt<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Computes the batch of smallest integer values not less than
+     * scalars in \c x.
+     * @param x batch of floating point values.
+     * @return the batch of smallest integer values not less than \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> ceil(batch<T, A> const& x) noexcept
+    {
+        return kernel::ceil<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Clips the values of the batch \c x between those of the batches \c lo and \c hi.
+     * @param x batch of floating point values.
+     * @param lo batch of floating point values.
+     * @param hi batch of floating point values.
+     * @return the result of the clipping.
+     */
+    template <class A, class T>
+    inline batch<T, A> clip(batch<T, A> const& x, batch<T, A> const& lo, batch<T, A> const& hi) noexcept
+    {
+        return kernel::clip(x, lo, hi, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the conjugate of the batch \c z.
+     * @param z batch of complex values.
+     * @return the argument of \c z.
+     */
+    template <class A, class T>
+    inline complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& z) noexcept
+    {
+        return kernel::conj(z, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Computes a value whose  absolute  value  matches
+     *        that of \c x, but whose sign bit matches that of \c y.
+     * @param x batch of scalars
+     * @param y batch of scalars
+     * @return batch whose absolute  value  matches that of \c x, but whose sign bit
+     * matches that of \c y.
+     */
+    template <class A, class T>
+    inline batch<T, A> copysign(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::copysign<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the cosine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the cosine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> cos(batch<T, A> const& x) noexcept
+    {
+        return kernel::cos<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * computes the hyperbolic cosine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the hyperbolic cosine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> cosh(batch<T, A> const& x) noexcept
+    {
+        return kernel::cosh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the division of the batch \c x by the batch \c y.
+     * @param x scalar or batch of scalars
+     * @param y scalar or batch of scalars
+     * @return the result of the division.
+     */
+    template <class T, class Tp>
+    inline auto div(T const& x, Tp const& y) noexcept -> decltype(x / y)
+    {
+        return x / y;
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise equality comparison of batches \c x and \c y.
+     * @param x batch of scalars
+     * @param y batch of scalars
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> eq(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x == y;
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the natural exponential of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the natural exponential of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> exp(batch<T, A> const& x) noexcept
+    {
+        return kernel::exp<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the base 10 exponential of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the base 10 exponential of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> exp10(batch<T, A> const& x) noexcept
+    {
+        return kernel::exp10<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the base 2 exponential of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the base 2 exponential of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> exp2(batch<T, A> const& x) noexcept
+    {
+        return kernel::exp2<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the natural exponential of the batch \c x, minus one.
+     * @param x batch of floating point values.
+     * @return the natural exponential of \c x, minus one.
+     */
+    template <class T, class A>
+    inline batch<T, A> expm1(batch<T, A> const& x) noexcept
+    {
+        return kernel::expm1<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes the error function of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the error function of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> erf(batch<T, A> const& x) noexcept
+    {
+        return kernel::erf<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes the complementary error function of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the error function of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> erfc(batch<T, A> const& x) noexcept
+    {
+        return kernel::erfc<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Evaluate polynomial with coefficient \c Coefs on point \c x using estrin
+     * method.
+     * @param x batch of floating point values.
+     * @return the evaluation ofpolynomial with coefficient \c Coefs on point \c x.
+     */
+    template <class T, class A, uint64_t... Coefs>
+    inline batch<T, A> estrin(const batch<T, A>& x) noexcept
+    {
+        return kernel::estrin<T, A, Coefs...>(x);
+    }
+
+    /**
+     * Extract vector from pair of vectors
+     * extracts the lowest vector elements from the second source \c x
+     * and the highest vector elements from the first source \c y
+     * Concatenates the results into th Return value.
+     * @param x batch of integer or floating point values.
+     * @param y batch of integer or floating point values.
+     * @param i integer specifuing the lowest vector element to extract from the first source register
+     * @return.
+     */
+    template <class T, class A>
+    inline batch<T, A> extract_pair(batch<T, A> const& x, batch<T, A> const& y, std::size_t i) noexcept
+    {
+        return kernel::extract_pair<A>(x, y, i, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the absolute values of each scalar in the batch \c x.
+     * @param x batch floating point values.
+     * @return the asbolute values of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> fabs(batch<T, A> const& x) noexcept
+    {
+        return kernel::abs<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the positive difference between \c x and \c y, that is,
+     * <tt>max(0, x-y)</tt>.
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return the positive difference.
+     */
+    template <class T, class A>
+    inline batch<T, A> fdim(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::fdim<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Computes the batch of largest integer values not greater than
+     * scalars in \c x.
+     * @param x batch of floating point values.
+     * @return the batch of largest integer values not greater than \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> floor(batch<T, A> const& x) noexcept
+    {
+        return kernel::floor<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes <tt>(x*y) + z</tt> in a single instruction when possible.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @param z a batch of integer or floating point values.
+     * @return the result of the fused multiply-add operation.
+     */
+    template <class T, class A>
+    inline batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept
+    {
+        return kernel::fma<A>(x, y, z, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the larger values of the batches \c x and \c y.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @return a batch of the larger values.
+     */
+    template <class T, class A>
+    inline batch<T, A> fmax(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::max<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the smaller values of the batches \c x and \c y.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @return a batch of the larger values.
+     */
+    template <class T, class A>
+    inline batch<T, A> fmin(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::min<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the modulo of the batch \c x by the batch \c y.
+     * @param x batch involved in the modulo.
+     * @param y batch involved in the modulo.
+     * @return the result of the modulo.
+     */
+    template <class T, class A>
+    inline batch<T, A> fmod(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::fmod<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes <tt>(x*y) - z</tt> in a single instruction when possible.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @param z a batch of integer or floating point values.
+     * @return the result of the fused multiply-sub operation.
+     */
+    template <class T, class A>
+    inline batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept
+    {
+        return kernel::fms<A>(x, y, z, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes <tt>-(x*y) + z</tt> in a single instruction when possible.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @param z a batch of integer or floating point values.
+     * @return the result of the fused negated multiply-add operation.
+     */
+    template <class T, class A>
+    inline batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept
+    {
+        return kernel::fnma<A>(x, y, z, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes <tt>-(x*y) - z</tt> in a single instruction when possible.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @param z a batch of integer or floating point values.
+     * @return the result of the fused negated multiply-sub operation.
+     */
+    template <class T, class A>
+    inline batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z) noexcept
+    {
+        return kernel::fnms<A>(x, y, z, A {});
+    }
+
+    /**
+     * @ingroup batch_fp
+     *
+     * Split split the number x into a normalized fraction and an exponent which is stored in exp
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @return the normalized fraction of x
+     */
+    template <class T, class A>
+    inline batch<T, A> frexp(const batch<T, A>& x, batch<as_integer_t<T>, A>& y) noexcept
+    {
+        return kernel::frexp<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise greater or equal comparison of batches \c x and \c y.
+     * @tparam X the actual type of batch.
+     * @param x batch involved in the comparison.
+     * @param y batch involved in the comparison.
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> ge(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x >= y;
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise greater than comparison of batches \c x and \c y.
+     * @tparam X the actual type of batch.
+     * @param x batch involved in the comparison.
+     * @param y batch involved in the comparison.
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> gt(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x > y;
+    }
+
+    /**
+     * @ingroup batch_reducers
+     *
+     * Adds all the scalars of the batch \c x.
+     * @param x batch involved in the reduction
+     * @return the result of the reduction.
+     */
+    template <class T, class A>
+    inline T hadd(batch<T, A> const& x) noexcept
+    {
+        return kernel::hadd<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_reducers
+     *
+     * Parallel horizontal addition: adds the scalars of each batch
+     * in the array pointed by \c row and store them in a returned
+     * batch.
+     * @param row an array of \c N batches
+     * @return the result of the reduction.
+     */
+    template <class T, class A>
+    inline batch<T, A> haddp(batch<T, A> const* row) noexcept
+    {
+        return kernel::haddp<A>(row, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Evaluate polynomial with coefficient \c Coefs on point \c x using horner
+     * method.
+     * @param x batch of floating point values.
+     * @return the evaluation ofpolynomial with coefficient \c Coefs on point \c x.
+     */
+    template <class T, class A, uint64_t... Coefs>
+    inline batch<T, A> horner(const batch<T, A>& x) noexcept
+    {
+        return kernel::horner<T, A, Coefs...>(x);
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the square root of the sum of the squares of the batches
+     * \c x, and \c y.
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return the square root of the sum of the squares of \c x and \c y.
+     */
+    template <class T, class A>
+    inline batch<T, A> hypot(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::hypot<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the imaginary part of the batch \c z.
+     * @param z batch of complex or real values.
+     * @return the argument of \c z.
+     */
+    template <class T, class A>
+    inline real_batch_type_t<batch<T, A>> imag(batch<T, A> const& x) noexcept
+    {
+        return kernel::imag<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_constant
+     *
+     * Return a batch of scalars representing positive infinity
+     * @return a batch of positive infinity
+     */
+    template <class B>
+    B infinity()
+    {
+        using T = typename B::value_type;
+        return B(std::numeric_limits<T>::infinity());
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the scalars in the given batch \c x represent an even integer value
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> is_even(batch<T, A> const& x) noexcept
+    {
+        return kernel::is_even<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the floating-point scalars in the given batch \c x represent integer value
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> is_flint(batch<T, A> const& x) noexcept
+    {
+        return kernel::is_flint<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the scalars in the given batch \c x represent an odd integer value
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> is_odd(batch<T, A> const& x) noexcept
+    {
+        return kernel::is_odd<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the scalars in the given batch \c x are inf values.
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> isinf(batch<T, A> const& x) noexcept
+    {
+        return kernel::isinf<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the scalars in the given batch \c x are finite values.
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> isfinite(batch<T, A> const& x) noexcept
+    {
+        return kernel::isfinite<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Determines if the scalars in the given batch \c x are NaN values.
+     * @param x batch of floating point values.
+     * @return a batch of booleans.
+     */
+    template <class T, class A>
+    inline typename batch<T, A>::batch_bool_type isnan(batch<T, A> const& x) noexcept
+    {
+        return kernel::isnan<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes the multiplication of the floating- point number x by 2 raised to the power exp.
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return the natural logarithm of the gamma function of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& y) noexcept
+    {
+        return kernel::ldexp<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise lesser or equal to comparison of batches \c x and \c y.
+     * @param x batch involved in the comparison.
+     * @param y batch involved in the comparison.
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> le(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x <= y;
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes the natural logarithm of the gamma function of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the natural logarithm of the gamma function of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> lgamma(batch<T, A> const& x) noexcept
+    {
+        return kernel::lgamma<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr and the specifed
+     * batch value type \c To. The memory needs to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class To, class A = default_arch, class From>
+    inline simd_return_type<From, To> load_as(From const* ptr, aligned_mode) noexcept
+    {
+        using batch_value_type = typename simd_return_type<From, To>::value_type;
+        return kernel::load_aligned<A>(ptr, kernel::convert<batch_value_type> {}, A {});
+    }
+
+    template <class To, class A = default_arch>
+    inline simd_return_type<bool, To> load_as(bool const* ptr, aligned_mode) noexcept
+    {
+        return simd_return_type<bool, To>::load_aligned(ptr);
+    }
+
+    template <class To, class A = default_arch, class From>
+    inline simd_return_type<std::complex<From>, To> load_as(std::complex<From> const* ptr, aligned_mode) noexcept
+    {
+        using batch_value_type = typename simd_return_type<std::complex<From>, To>::value_type;
+        return kernel::load_complex_aligned<A>(ptr, kernel::convert<batch_value_type> {}, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr and the specifed
+     * batch value type \c To. The memory does not need to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class To, class A = default_arch, class From>
+    inline simd_return_type<From, To> load_as(From const* ptr, unaligned_mode) noexcept
+    {
+        using batch_value_type = typename simd_return_type<From, To>::value_type;
+        return kernel::load_unaligned<A>(ptr, kernel::convert<batch_value_type> {}, A {});
+    }
+
+    template <class To, class A = default_arch>
+    inline simd_return_type<bool, To> load_as(bool const* ptr, unaligned_mode) noexcept
+    {
+        return simd_return_type<bool, To>::load_unaligned(ptr);
+    }
+
+    template <class To, class A = default_arch, class From>
+    inline simd_return_type<std::complex<From>, To> load_as(std::complex<From> const* ptr, unaligned_mode) noexcept
+    {
+        using batch_value_type = typename simd_return_type<std::complex<From>, To>::value_type;
+        return kernel::load_complex_unaligned<A>(ptr, kernel::convert<batch_value_type> {}, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr. The
+     * memory needs to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class A = default_arch, class From>
+    inline batch<From, A> load(From const* ptr, aligned_mode = {}) noexcept
+    {
+        return load_as<From, A>(ptr, aligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr. The
+     * memory does not need to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class A = default_arch, class From>
+    inline batch<From, A> load(From const* ptr, unaligned_mode) noexcept
+    {
+        return load_as<From, A>(ptr, unaligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr. The
+     * memory needs to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class A = default_arch, class From>
+    inline batch<From, A> load_aligned(From const* ptr) noexcept
+    {
+        return load_as<From, A>(ptr, aligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Creates a batch from the buffer \c ptr. The
+     * memory does not need to be aligned.
+     * @param ptr the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class A = default_arch, class From>
+    inline batch<From, A> load_unaligned(From const* ptr) noexcept
+    {
+        return load_as<From, A>(ptr, unaligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the natural logarithm of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the natural logarithm of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> log(batch<T, A> const& x) noexcept
+    {
+        return kernel::log<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     * Computes the base 2 logarithm of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the base 2 logarithm of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> log2(batch<T, A> const& x) noexcept
+    {
+        return kernel::log2<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     * Computes the base 10 logarithm of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the base 10 logarithm of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> log10(batch<T, A> const& x) noexcept
+    {
+        return kernel::log10<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     * Computes the natural logarithm of one plus the batch \c x.
+     * @param x batch of floating point values.
+     * @return the natural logarithm of one plus \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> log1p(batch<T, A> const& x) noexcept
+    {
+        return kernel::log1p<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise lesser than comparison of batches \c x and \c y.
+     * @param x batch involved in the comparison.
+     * @param y batch involved in the comparison.
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> lt(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x < y;
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the larger values of the batches \c x and \c y.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @return a batch of the larger values.
+     */
+    template <class T, class A>
+    inline batch<T, A> max(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::max<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the smaller values of the batches \c x and \c y.
+     * @param x a batch of integer or floating point values.
+     * @param y a batch of integer or floating point values.
+     * @return a batch of the smaller values.
+     */
+    template <class T, class A>
+    inline batch<T, A> min(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::min<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_constant
+     *
+     * Return a batch of scalars representing positive infinity
+     * @return a batch of positive infinity
+     */
+    template <class B>
+    inline B minusinfinity() noexcept
+    {
+        using T = typename B::value_type;
+        return B(-std::numeric_limits<T>::infinity());
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the integer modulo of the batch \c x by the batch \c y.
+     * @param x batch involved in the modulo.
+     * @param y batch involved in the modulo.
+     * @return the result of the modulo.
+     */
+    template <class T, class Tp>
+    inline auto mod(T const& x, Tp const& y) noexcept -> decltype(x % y)
+    {
+        return x % y;
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the product of the batches \c x and \c y.
+     * @tparam X the actual type of batch.
+     * @param x batch involved in the product.
+     * @param y batch involved in the product.
+     * @return the result of the product.
+     */
+    template <class T, class Tp>
+    inline auto mul(T const& x, Tp const& y) noexcept -> decltype(x * y)
+    {
+        return x * y;
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Rounds the scalars in \c x to integer values (in floating point format), using
+     * the current rounding mode.
+     * @param x batch of flaoting point values.
+     * @return the batch of nearest integer values.
+     */
+    template <class T, class A>
+    inline batch<T, A> nearbyint(batch<T, A> const& x) noexcept
+    {
+        return kernel::nearbyint<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_logical
+     *
+     * Element-wise inequality comparison of batches \c x and \c y.
+     * @param x batch involved in the comparison.
+     * @param y batch involved in the comparison.
+     * @return a boolean batch.
+     */
+    template <class T, class A>
+    inline batch_bool<T, A> neq(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return x != y;
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the opposite of the batch \c x.
+     * @param x batch involved in the operation.
+     * @return the opposite of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> neg(batch<T, A> const& x) noexcept
+    {
+        return -x;
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes  the next representable  floating-point
+     *        value  following  x  in the direction of y
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return \c x raised to the power \c y.
+     */
+    template <class T, class A>
+    inline batch<T, A> nextafter(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::nextafter<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the norm of the batch \c x.
+     * @param x batch of complex or real values.
+     * @return the norm of \c x.
+     */
+    template <class A, class T>
+    inline real_batch_type_t<batch<T, A>> norm(batch<T, A> const& x) noexcept
+    {
+        return kernel::norm(x, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * No-op on \c x.
+     * @param x batch involved in the operation.
+     * @return \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> pos(batch<T, A> const& x) noexcept
+    {
+        return +x;
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the value of the batch \c x raised to the power
+     * \c y.
+     * @param x batch of floating point values.
+     * @param y batch of floating point values.
+     * @return \c x raised to the power \c y.
+     */
+    template <class T, class A>
+    inline batch<T, A> pow(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::pow<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the value of the batch \c x raised to the power
+     * \c y.
+     * @param x batch of integral values.
+     * @param y batch of integral values.
+     * @return \c x raised to the power \c y.
+     */
+    template <class T, class ITy, class A, class = typename std::enable_if<std::is_integral<ITy>::value, void>::type>
+    inline batch<T, A> pow(batch<T, A> const& x, ITy y) noexcept
+    {
+        return kernel::ipow<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the projection of the batch \c x.
+     * @param x batch of complex or real values.
+     * @return the projection of \c x.
+     */
+    template <class A, class T>
+    inline complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& x) noexcept
+    {
+        return kernel::proj(x, A {});
+    }
+
+    /**
+     * @ingroup batch_complex
+     *
+     * Computes the real part of the batch \c z.
+     * @param z batch of complex or real values.
+     * @return the argument of \c z.
+     */
+    template <class T, class A>
+    inline real_batch_type_t<batch<T, A>> real(batch<T, A> const& x) noexcept
+    {
+        return kernel::real<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the remainder of dividing \c x by \c y
+     * @param x batch of scalar values
+     * @param y batch of scalar values
+     * @return the result of the addition.
+     */
+    template <class T, class A>
+    inline batch<T, A> remainder(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::remainder<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Rounds the scalars in \c x to integer values (in floating point format), using
+     * the current rounding mode.
+     * @param x batch of floating point values.
+     * @return the batch of rounded values.
+     */
+    template <class T, class A>
+    inline batch<T, A> rint(batch<T, A> const& x) noexcept
+    {
+        return nearbyint(x);
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Computes the batch of nearest integer values to scalars in \c x (in
+     * floating point format), rounding halfway cases away from zero, regardless
+     * of the current rounding mode.
+     * @param x batch of flaoting point values.
+     * @return the batch of nearest integer values.
+     */
+    template <class T, class A>
+    inline batch<T, A> round(batch<T, A> const& x) noexcept
+    {
+        return kernel::round<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the saturate sum of the batch \c x and the batch \c y.
+     * \c x.
+     * @tparam X the actual type of batch.
+     * @param x batch involved in the saturated addition.
+     * @param y batch involved in the saturated addition.
+     * @return the result of the saturated addition.
+     */
+    template <class T, class Tp>
+    inline auto sadd(T const& x, Tp const& y) noexcept -> decltype(x + y)
+    {
+        using B = decltype(x + y);
+        using A = typename B::arch_type;
+        return kernel::sadd<A>(B(x), B(y), A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
+     * depending on the boolean values in the constant batch \c cond. Equivalent to
+     * \code{.cpp}
+     * for(std::size_t i = 0; i < N; ++i)
+     *     res[i] = cond[i] ? true_br[i] : false_br[i];
+     * \endcode
+     * @param cond constant batch condition.
+     * @param true_br batch values for truthy condition.
+     * @param false_br batch value for falsy condition.
+     * @return the result of the selection.
+     */
+    template <class T, class A>
+    inline batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br) noexcept
+    {
+        return kernel::select<A>(cond, true_br, false_br, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
+     * depending on the boolean values in the constant batch \c cond. Equivalent to
+     * \code{.cpp}
+     * for(std::size_t i = 0; i < N; ++i)
+     *     res[i] = cond[i] ? true_br[i] : false_br[i];
+     * \endcode
+     * @param cond constant batch condition.
+     * @param true_br batch values for truthy condition.
+     * @param false_br batch value for falsy condition.
+     * @return the result of the selection.
+     */
+    template <class T, class A>
+    inline batch<std::complex<T>, A> select(batch_bool<T, A> const& cond, batch<std::complex<T>, A> const& true_br, batch<std::complex<T>, A> const& false_br) noexcept
+    {
+        return kernel::select<A>(cond, true_br, false_br, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Ternary operator for batches: selects values from the batches \c true_br or \c false_br
+     * depending on the boolean values in the constant batch \c cond. Equivalent to
+     * \code{.cpp}
+     * for(std::size_t i = 0; i < N; ++i)
+     *     res[i] = cond[i] ? true_br[i] : false_br[i];
+     * \endcode
+     * @param cond constant batch condition.
+     * @param true_br batch values for truthy condition.
+     * @param false_br batch value for falsy condition.
+     * @return the result of the selection.
+     */
+    template <class T, class A, bool... Values>
+    inline batch<T, A> select(batch_bool_constant<batch<T, A>, Values...> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br) noexcept
+    {
+        return kernel::select<A>(cond, true_br, false_br, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Computes the sign of \c x
+     * @param x batch
+     * @return -1 for each negative element, -1 or +1 for each null element and +1 for each element
+     */
+    template <class T, class A>
+    inline batch<T, A> sign(batch<T, A> const& x) noexcept
+    {
+        return kernel::sign<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Computes the sign of \c x, assuming x doesn't have any zero
+     * @param x batch
+     * @return -1 for each negative element, -1 or +1 for each null element and +1 for each element
+     */
+    template <class T, class A>
+    inline batch<T, A> signnz(batch<T, A> const& x) noexcept
+    {
+        return kernel::signnz<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the sine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the sine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> sin(batch<T, A> const& x) noexcept
+    {
+        return kernel::sin<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the hyperbolic sine of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the hyperbolic sine of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> sinh(batch<T, A> const& x) noexcept
+    {
+        return kernel::sinh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the sine and the cosine of the batch \c x. This method is faster
+     * than calling sine and cosine independently.
+     * @param x batch of floating point values.
+     * @return a pair containing the sine then the cosine of  batch \c x
+     */
+    template <class T, class A>
+    inline std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const& x) noexcept
+    {
+        return kernel::sincos<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the square root of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the square root of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> sqrt(batch<T, A> const& x) noexcept
+    {
+        return kernel::sqrt<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the saturate difference of the batch \c x and the batch \c y.
+     * \c x.
+     * @tparam X the actual type of batch.
+     * @param x batch involved in the saturated difference.
+     * @param y batch involved in the saturated difference.
+     * @return the result of the saturated difference.
+     */
+    template <class T, class Tp>
+    inline auto ssub(T const& x, Tp const& y) noexcept -> decltype(x - y)
+    {
+        using B = decltype(x + y);
+        using A = typename B::arch_type;
+        return kernel::ssub<A>(B(x), B(y), A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c src to the buffer \c dst. The
+     * memory needs to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy
+     */
+    template <class To, class A = default_arch, class From>
+    inline void store_as(To* dst, batch<From, A> const& src, aligned_mode) noexcept
+    {
+        kernel::store_aligned(dst, src, A {});
+    }
+
+    template <class A = default_arch, class From>
+    inline void store_as(bool* dst, batch_bool<From, A> const& src, aligned_mode) noexcept
+    {
+        kernel::store(src, dst, A {});
+    }
+
+    template <class To, class A = default_arch, class From>
+    inline void store_as(std::complex<To>* dst, batch<std::complex<From>, A> const& src, aligned_mode) noexcept
+    {
+        kernel::store_complex_aligned(dst, src, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c src to the buffer \c dst. The
+     * memory does not need to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy
+     */
+    template <class To, class A = default_arch, class From>
+    inline void store_as(To* dst, batch<From, A> const& src, unaligned_mode) noexcept
+    {
+        kernel::store_unaligned(dst, src, A {});
+    }
+
+    template <class A = default_arch, class From>
+    inline void store_as(bool* dst, batch_bool<From, A> const& src, unaligned_mode) noexcept
+    {
+        kernel::store(src, dst, A {});
+    }
+
+    template <class To, class A = default_arch, class From>
+    inline void store_as(std::complex<To>* dst, batch<std::complex<From>, A> const& src, unaligned_mode) noexcept
+    {
+        kernel::store_complex_unaligned(dst, src, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c val to the buffer \c mem. The
+     * memory does not need to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy from
+     */
+    template <class A, class T>
+    inline void store(T* mem, batch<T, A> const& val, aligned_mode = {}) noexcept
+    {
+        store_as<T, A>(mem, val, aligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c val to the buffer \c mem. The
+     * memory does not need to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy from
+     */
+    template <class A, class T>
+    inline void store(T* mem, batch<T, A> const& val, unaligned_mode) noexcept
+    {
+        store_as<T, A>(mem, val, unaligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c val to the buffer \c mem. The
+     * memory needs to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy from
+     */
+    template <class A, class T>
+    inline void store_aligned(T* mem, batch<T, A> const& val) noexcept
+    {
+        store_as<T, A>(mem, val, aligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Copy content of batch \c val to the buffer \c mem. The
+     * memory does not need to be aligned.
+     * @param mem the memory buffer to write to
+     * @param val the batch to copy
+     */
+    template <class A, class T>
+    inline void store_unaligned(T* mem, batch<T, A> const& val) noexcept
+    {
+        store_as<T, A>(mem, val, unaligned_mode {});
+    }
+
+    /**
+     * @ingroup batch_arithmetic
+     *
+     * Computes the difference between \c x and \c y
+     * @tparam X the actual type of batch.
+     * @param x scalar or batch of scalars
+     * @param y scalar or batch of scalars
+     * @return the difference between \c x and \c y
+     */
+    template <class T, class Tp>
+    inline auto sub(T const& x, Tp const& y) noexcept -> decltype(x - y)
+    {
+        return x - y;
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the tangent of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the tangent of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> tan(batch<T, A> const& x) noexcept
+    {
+        return kernel::tan<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_trigo
+     *
+     * Computes the hyperbolic tangent of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the hyperbolic tangent of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> tanh(batch<T, A> const& x) noexcept
+    {
+        return kernel::tanh<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_math_extra
+     *
+     * Computes the gamma function of the batch \c x.
+     * @param x batch of floating point values.
+     * @return the gamma function of \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> tgamma(batch<T, A> const& x) noexcept
+    {
+        return kernel::tgamma<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_conversion
+     *
+     * Perform a conversion from \c i to a value of an floating point type of the same size as \c T
+     * @param i batch of integers.
+     * @return \c i converted to a value of an floating point type of the same size as \c T
+     */
+    template <class T, class A>
+    inline batch<as_float_t<T>, A> to_float(batch<T, A> const& i) noexcept
+    {
+        return kernel::to_float<A>(i, A {});
+    }
+
+    /**
+     * @ingroup batch_conversion
+     *
+     * Perform a conversion from \c x to a value of an integer type of the same size as \c T
+     * @param x batch.
+     * @return \c x converted to a value of an integer type of the same size as \c T
+     */
+    template <class T, class A>
+    inline batch<as_integer_t<T>, A> to_int(batch<T, A> const& x) noexcept
+    {
+        return kernel::to_int<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_rounding
+     *
+     * Computes the batch of nearest integer values not greater in magnitude
+     * than scalars in \c x.
+     * @param x batch of floating point values.
+     * @return the batch of nearest integer values not greater in magnitude than \c x.
+     */
+    template <class T, class A>
+    inline batch<T, A> trunc(batch<T, A> const& x) noexcept
+    {
+        return kernel::trunc<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Unpack and interleave data from the HIGH half of batches \c x and \c y.
+     * Store the results in the Return value.
+     * @param x a batch of integer or floating point or double precision values.
+     * @param y a batch of integer or floating point or double precision values.
+     * @return a batch of the high part of shuffled values.
+     */
+    template <class T, class A>
+    inline batch<T, A> zip_hi(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::zip_hi<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_data_transfer
+     *
+     * Unpack and interleave data from the LOW half of batches \c x and \c y.
+     * Store the results in the Return value.
+     * @param x a batch of integer or floating point or double precision values.
+     * @param y a batch of integer or floating point or double precision values.
+     * @return a batch of the low part of shuffled values.
+     */
+    template <class T, class A>
+    inline batch<T, A> zip_lo(batch<T, A> const& x, batch<T, A> const& y) noexcept
+    {
+        return kernel::zip_lo<A>(x, y, A {});
+    }
+
+    // bitwise_cast
+    template <class A, class T, typename std::enable_if<std::is_integral<T>::value, int>::type = 3>
+    inline batch<T, A> bitwise_cast(batch_bool<T, A> const& self) noexcept
+    {
+        T z(0);
+        return select(self, batch<T, A>(T(~z)), batch<T, A>(z));
+    }
+
+    template <class A, class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 3>
+    inline batch<T, A> bitwise_cast(batch_bool<T, A> const& self) noexcept
+    {
+        T z0(0), z1(0);
+        using int_type = as_unsigned_integer_t<T>;
+        int_type value(~int_type(0));
+        std::memcpy(&z1, &value, sizeof(int_type));
+        return select(self, batch<T, A>(z1), batch<T, A>(z0));
+    }
+
+    /**
+     * @ingroup batch_bool_reducers
+     *
+     * Returns true if all the boolean values in the batch are true,
+     * false otherwise.
+     * @param x the batch to reduce.
+     * @return a boolean scalar.
+     */
+    template <class T, class A>
+    inline bool all(batch_bool<T, A> const& x) noexcept
+    {
+        return kernel::all<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_bool_reducers
+     *
+     * Return true if any of the boolean values in the batch is true,
+     * false otherwise.
+     * @param x the batch to reduce.
+     * @return a boolean scalar.
+     */
+    template <class T, class A>
+    inline bool any(batch_bool<T, A> const& x) noexcept
+    {
+        return kernel::any<A>(x, A {});
+    }
+
+    /**
+     * @ingroup batch_miscellaneous
+     *
+     * Dump the content of batch \c x to stream \c o
+     * @param o the stream where the batch is dumped
+     * @param x batch to dump.
+     * @return a reference to \c o
+     */
+    template <class T, class A>
+    inline std::ostream& operator<<(std::ostream& o, batch<T, A> const& x) noexcept
+    {
+        constexpr auto size = batch<T, A>::size;
+        alignas(A::alignment()) T buffer[size];
+        x.store_aligned(&buffer[0]);
+        o << '(';
+        for (std::size_t i = 0; i < size - 1; ++i)
+            o << buffer[i] << ", ";
+        return o << buffer[size - 1] << ')';
+    }
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx2_register.hpp b/third_party/xsimd/types/xsimd_avx2_register.hpp
index 5f55f4308..a02cdf848 100644
--- a/third_party/xsimd/types/xsimd_avx2_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx2_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX2_REGISTER_HPP
 #define XSIMD_AVX2_REGISTER_HPP
@@ -23,10 +23,10 @@ namespace xsimd
      */
     struct avx2 : avx
     {
-        static constexpr bool supported() { return XSIMD_WITH_AVX2; }
-        static constexpr bool available() { return true; }
-        static constexpr unsigned version() { return generic::version(2, 2, 0); }
-        static constexpr char const* name() { return "avx2"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX2; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(2, 2, 0); }
+        static constexpr char const* name() noexcept { return "avx2"; }
     };
 
 #if XSIMD_WITH_AVX2
@@ -38,4 +38,3 @@ namespace xsimd
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx512bw_register.hpp b/third_party/xsimd/types/xsimd_avx512bw_register.hpp
index 0cabe1fa0..49633f5db 100644
--- a/third_party/xsimd/types/xsimd_avx512bw_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx512bw_register.hpp
@@ -1,44 +1,48 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512BW_REGISTER_HPP
 #define XSIMD_AVX512BW_REGISTER_HPP
 
 #include "./xsimd_avx512dq_register.hpp"
 
-namespace xsimd {
-
-  /**
-   * @ingroup arch
-   *
-   * AVX512BW instructions
-   */
-  struct avx512bw : avx512dq {
-    static constexpr bool supported() { return XSIMD_WITH_AVX512BW; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(3, 4, 0); }
-    static constexpr char const* name() { return "avx512bw"; }
-  };
+namespace xsimd
+{
+
+    /**
+     * @ingroup arch
+     *
+     * AVX512BW instructions
+     */
+    struct avx512bw : avx512dq
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX512BW; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(3, 4, 0); }
+        static constexpr char const* name() noexcept { return "avx512bw"; }
+    };
 
 #if XSIMD_WITH_AVX512BW
 
-namespace types {
-template <class T> struct get_bool_simd_register<T, avx512bw> {
-  using type = simd_avx512_bool_register<T>;
-};
+    namespace types
+    {
+        template <class T>
+        struct get_bool_simd_register<T, avx512bw>
+        {
+            using type = simd_avx512_bool_register<T>;
+        };
 
-    XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512bw, avx512dq);
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512bw, avx512dq);
 
-  }
+    }
 #endif
 }
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx512cd_register.hpp b/third_party/xsimd/types/xsimd_avx512cd_register.hpp
index d7d55423a..a63a546e1 100644
--- a/third_party/xsimd/types/xsimd_avx512cd_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx512cd_register.hpp
@@ -1,44 +1,48 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512CD_REGISTER_HPP
 #define XSIMD_AVX512CD_REGISTER_HPP
 
-#include "./xsimd_avx512cd_register.hpp"
+#include "./xsimd_avx512f_register.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  /**
-   * @ingroup arch
-   *
-   * AVX512CD instrutions
-   */
-  struct avx512cd : avx512f {
-    static constexpr bool supported() { return XSIMD_WITH_AVX512BW; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(3, 2, 0); }
-    static constexpr char const* name() { return "avx512cd"; }
-  };
+    /**
+     * @ingroup arch
+     *
+     * AVX512CD instrutions
+     */
+    struct avx512cd : avx512f
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX512CD; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(3, 2, 0); }
+        static constexpr char const* name() noexcept { return "avx512cd"; }
+    };
 
 #if XSIMD_WITH_AVX512BW
 
-namespace types {
-template <class T> struct get_bool_simd_register<T, avx512cd> {
-  using type = simd_avx512_bool_register<T>;
-};
+    namespace types
+    {
+        template <class T>
+        struct get_bool_simd_register<T, avx512cd>
+        {
+            using type = simd_avx512_bool_register<T>;
+        };
 
-    XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512cd, avx512f);
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512cd, avx512f);
 
-  }
+    }
 #endif
 }
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx512dq_register.hpp b/third_party/xsimd/types/xsimd_avx512dq_register.hpp
index 37550bafb..41846e711 100644
--- a/third_party/xsimd/types/xsimd_avx512dq_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx512dq_register.hpp
@@ -1,44 +1,48 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512DQ_REGISTER_HPP
 #define XSIMD_AVX512DQ_REGISTER_HPP
 
 #include "./xsimd_avx512cd_register.hpp"
 
-namespace xsimd {
-
-  /**
-   * @ingroup arch
-   *
-   * AVX512DQ instructions
-   */
-  struct avx512dq : avx512cd {
-    static constexpr bool supported() { return XSIMD_WITH_AVX512DQ; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(3, 3, 0); }
-    static constexpr char const* name() { return "avx512dq"; }
-  };
+namespace xsimd
+{
+
+    /**
+     * @ingroup arch
+     *
+     * AVX512DQ instructions
+     */
+    struct avx512dq : avx512cd
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX512DQ; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(3, 3, 0); }
+        static constexpr char const* name() noexcept { return "avx512dq"; }
+    };
 
 #if XSIMD_WITH_AVX512DQ
 
-namespace types {
-template <class T> struct get_bool_simd_register<T, avx512dq> {
-  using type = simd_avx512_bool_register<T>;
-};
+    namespace types
+    {
+        template <class T>
+        struct get_bool_simd_register<T, avx512dq>
+        {
+            using type = simd_avx512_bool_register<T>;
+        };
 
-    XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512dq, avx512cd);
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(avx512dq, avx512cd);
 
-  }
+    }
 #endif
 }
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx512f_register.hpp b/third_party/xsimd/types/xsimd_avx512f_register.hpp
index b54412494..c24a91af5 100644
--- a/third_party/xsimd/types/xsimd_avx512f_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx512f_register.hpp
@@ -1,71 +1,75 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX512F_REGISTER_HPP
 #define XSIMD_AVX512F_REGISTER_HPP
 
 #include "./xsimd_generic_arch.hpp"
 
-namespace xsimd {
+namespace xsimd
+{
 
-  /**
-   * @ingroup arch
-   *
-   * AVX512F instructions
-   */
-  struct avx512f : generic {
-    static constexpr bool supported() { return XSIMD_WITH_AVX512F; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(3, 1, 0); }
-    static constexpr std::size_t alignment() { return 64; }
-    static constexpr bool requires_alignment() { return true; }
-    static constexpr char const* name() { return "avx512f"; }
-  };
+    /**
+     * @ingroup arch
+     *
+     * AVX512F instructions
+     */
+    struct avx512f : generic
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX512F; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(3, 1, 0); }
+        static constexpr std::size_t alignment() noexcept { return 64; }
+        static constexpr bool requires_alignment() noexcept { return true; }
+        static constexpr char const* name() noexcept { return "avx512f"; }
+    };
 
 #if XSIMD_WITH_AVX512F
 
-namespace types {
-template <class T> struct simd_avx512_bool_register {
-  using register_type = typename std::conditional<
-      (sizeof(T) < 4), std::conditional<(sizeof(T) == 1), __mmask64, __mmask32>,
-      std::conditional<(sizeof(T) == 4), __mmask16, __mmask8>>::type::type;
-  register_type data;
-  simd_avx512_bool_register() = default;
-  simd_avx512_bool_register(register_type r) { data = r; }
-  operator register_type() const { return data; }
-};
-template <class T> struct get_bool_simd_register<T, avx512f> {
-  using type = simd_avx512_bool_register<T>;
-};
+    namespace types
+    {
+        template <class T>
+        struct simd_avx512_bool_register
+        {
+            using register_type = typename std::conditional<
+                (sizeof(T) < 4), std::conditional<(sizeof(T) == 1), __mmask64, __mmask32>,
+                std::conditional<(sizeof(T) == 4), __mmask16, __mmask8>>::type::type;
+            register_type data;
+            simd_avx512_bool_register() = default;
+            simd_avx512_bool_register(register_type r) { data = r; }
+            operator register_type() const noexcept { return data; }
+        };
+        template <class T>
+        struct get_bool_simd_register<T, avx512f>
+        {
+            using type = simd_avx512_bool_register<T>;
+        };
 
+        XSIMD_DECLARE_SIMD_REGISTER(bool, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(signed char, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned char, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(char, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned short, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(short, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned long int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(long int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned long long int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(long long int, avx512f, __m512i);
+        XSIMD_DECLARE_SIMD_REGISTER(float, avx512f, __m512);
+        XSIMD_DECLARE_SIMD_REGISTER(double, avx512f, __m512d);
 
-
-    XSIMD_DECLARE_SIMD_REGISTER(bool, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(signed char, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned char, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(char, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned short, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(short, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned long int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(long int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned long long int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(long long int, avx512f, __m512i);
-    XSIMD_DECLARE_SIMD_REGISTER(float, avx512f, __m512);
-    XSIMD_DECLARE_SIMD_REGISTER(double, avx512f, __m512d);
-
-  }
+    }
 #endif
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_avx_register.hpp b/third_party/xsimd/types/xsimd_avx_register.hpp
index e24bd0215..596a6b702 100644
--- a/third_party/xsimd/types/xsimd_avx_register.hpp
+++ b/third_party/xsimd/types/xsimd_avx_register.hpp
@@ -1,58 +1,62 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_AVX_REGISTER_HPP
 #define XSIMD_AVX_REGISTER_HPP
 
 #include "./xsimd_generic_arch.hpp"
 
-namespace xsimd {
-
-  /**
-   * @ingroup arch
-   *
-   * AVX instructions
-   */
-  struct avx : generic {
-    static constexpr bool supported() { return XSIMD_WITH_AVX; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(2, 1, 0); }
-    static constexpr std::size_t alignment() { return 32; }
-    static constexpr bool requires_alignment() { return true; }
-    static constexpr char const* name() { return "avx"; }
-  };
+namespace xsimd
+{
+
+    /**
+     * @ingroup arch
+     *
+     * AVX instructions
+     */
+    struct avx : generic
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_AVX; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(2, 1, 0); }
+        static constexpr std::size_t alignment() noexcept { return 32; }
+        static constexpr bool requires_alignment() noexcept { return true; }
+        static constexpr char const* name() noexcept { return "avx"; }
+    };
 }
 
 #if XSIMD_WITH_AVX
 
 #include <immintrin.h>
 
-namespace xsimd {
-  namespace types {
-
-    XSIMD_DECLARE_SIMD_REGISTER(bool, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(signed char, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned char, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(char, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned short, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(short, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned long int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(long int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(unsigned long long int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(long long int, avx, __m256i);
-    XSIMD_DECLARE_SIMD_REGISTER(float, avx, __m256);
-    XSIMD_DECLARE_SIMD_REGISTER(double, avx, __m256d);
-  }
+namespace xsimd
+{
+    namespace types
+    {
+
+        XSIMD_DECLARE_SIMD_REGISTER(bool, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(signed char, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned char, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(char, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned short, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(short, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned long int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(long int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(unsigned long long int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(long long int, avx, __m256i);
+        XSIMD_DECLARE_SIMD_REGISTER(float, avx, __m256);
+        XSIMD_DECLARE_SIMD_REGISTER(double, avx, __m256d);
+    }
 }
 #endif
 #endif
diff --git a/third_party/xsimd/types/xsimd_batch.hpp b/third_party/xsimd/types/xsimd_batch.hpp
index f0481de87..96c105962 100644
--- a/third_party/xsimd/types/xsimd_batch.hpp
+++ b/third_party/xsimd/types/xsimd_batch.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_BATCH_HPP
 #define XSIMD_BATCH_HPP
@@ -31,11 +31,10 @@ namespace xsimd
      * @tparam T the type of the underlying values.
      * @tparam A the architecture this batch is tied too.
      **/
-    template<class T, class A=default_arch>
+    template <class T, class A = default_arch>
     class batch : public types::simd_register<T, A>
     {
     public:
-
         static constexpr std::size_t size = sizeof(types::simd_register<T, A>) / sizeof(T);
 
         using value_type = T;
@@ -45,148 +44,148 @@ namespace xsimd
 
         // constructors
         batch() = default;
-        batch(T val);
-        batch(std::initializer_list<T> data);
-        explicit batch(batch_bool_type const &b);
-        batch(register_type reg);
+        batch(T val) noexcept;
+        batch(std::initializer_list<T> data) noexcept;
+        explicit batch(batch_bool_type const& b) noexcept;
+        batch(register_type reg) noexcept;
 
-        template<class U>
-        static XSIMD_NO_DISCARD batch broadcast(U val);
+        template <class U>
+        static XSIMD_NO_DISCARD batch broadcast(U val) noexcept;
 
         // memory operators
-        template<class U>
-        void store_aligned(U * mem) const;
-        template<class U>
-        void store_unaligned(U * mem) const;
-        template<class U>
-        void store(U * mem, aligned_mode) const;
-        template<class U>
-        void store(U * mem, unaligned_mode) const;
-
-        template<class U>
-        static XSIMD_NO_DISCARD batch load_aligned(U const* mem) ;
-        template<class U>
-        static XSIMD_NO_DISCARD batch load_unaligned(U const* mem);
-        template<class U>
-        static XSIMD_NO_DISCARD batch load(U const* mem, aligned_mode);
-        template<class U>
-        static XSIMD_NO_DISCARD batch load(U const* mem, unaligned_mode);
-
-        T get(std::size_t i) const;
+        template <class U>
+        void store_aligned(U* mem) const noexcept;
+        template <class U>
+        void store_unaligned(U* mem) const noexcept;
+        template <class U>
+        void store(U* mem, aligned_mode) const noexcept;
+        template <class U>
+        void store(U* mem, unaligned_mode) const noexcept;
+
+        template <class U>
+        static XSIMD_NO_DISCARD batch load_aligned(U const* mem) noexcept;
+        template <class U>
+        static XSIMD_NO_DISCARD batch load_unaligned(U const* mem) noexcept;
+        template <class U>
+        static XSIMD_NO_DISCARD batch load(U const* mem, aligned_mode) noexcept;
+        template <class U>
+        static XSIMD_NO_DISCARD batch load(U const* mem, unaligned_mode) noexcept;
+
+        T get(std::size_t i) const noexcept;
 
         // comparison operators
-        batch_bool_type operator==(batch const& other) const;
-        batch_bool_type operator!=(batch const& other) const;
-        batch_bool_type operator>=(batch const& other) const;
-        batch_bool_type operator<=(batch const& other) const;
-        batch_bool_type operator>(batch const& other) const;
-        batch_bool_type operator<(batch const& other) const;
+        batch_bool_type operator==(batch const& other) const noexcept;
+        batch_bool_type operator!=(batch const& other) const noexcept;
+        batch_bool_type operator>=(batch const& other) const noexcept;
+        batch_bool_type operator<=(batch const& other) const noexcept;
+        batch_bool_type operator>(batch const& other) const noexcept;
+        batch_bool_type operator<(batch const& other) const noexcept;
 
         // Update operators
-        batch& operator+=(batch const& other);
-        batch& operator-=(batch const& other);
-        batch& operator*=(batch const& other);
-        batch& operator/=(batch const& other);
-        batch& operator%=(batch const& other);
-        batch& operator&=(batch const& other);
-        batch& operator|=(batch const& other);
-        batch& operator^=(batch const& other);
-        batch& operator>>=(int32_t other);
-        batch& operator>>=(batch const& other);
-        batch& operator<<=(int32_t other);
-        batch& operator<<=(batch const& other);
+        batch& operator+=(batch const& other) noexcept;
+        batch& operator-=(batch const& other) noexcept;
+        batch& operator*=(batch const& other) noexcept;
+        batch& operator/=(batch const& other) noexcept;
+        batch& operator%=(batch const& other) noexcept;
+        batch& operator&=(batch const& other) noexcept;
+        batch& operator|=(batch const& other) noexcept;
+        batch& operator^=(batch const& other) noexcept;
+        batch& operator>>=(int32_t other) noexcept;
+        batch& operator>>=(batch const& other) noexcept;
+        batch& operator<<=(int32_t other) noexcept;
+        batch& operator<<=(batch const& other) noexcept;
 
         // incr/decr operators
-        batch& operator++();
-        batch& operator--();
-        batch operator++(int);
-        batch operator--(int);
+        batch& operator++() noexcept;
+        batch& operator--() noexcept;
+        batch operator++(int) noexcept;
+        batch operator--(int) noexcept;
 
         // unary operators
-        batch_bool_type operator!() const;
-        batch operator~() const;
-        batch operator-() const;
-        batch operator+() const;
+        batch_bool_type operator!() const noexcept;
+        batch operator~() const noexcept;
+        batch operator-() const noexcept;
+        batch operator+() const noexcept;
 
         // arithmetic operators. They are defined as friend to enable automatic
         // conversion of parameters from scalar to batch. Inline implementation
         // is required to avoid warnings.
-        friend batch operator+(batch const& self, batch const& other)
+        friend batch operator+(batch const& self, batch const& other) noexcept
         {
             return batch(self) += other;
         }
 
-        friend batch operator-(batch const& self, batch const& other)
+        friend batch operator-(batch const& self, batch const& other) noexcept
         {
             return batch(self) -= other;
         }
-        
-        friend batch operator*(batch const& self, batch const& other)
+
+        friend batch operator*(batch const& self, batch const& other) noexcept
         {
             return batch(self) *= other;
         }
-        
-        friend batch operator/(batch const& self, batch const& other)
+
+        friend batch operator/(batch const& self, batch const& other) noexcept
         {
             return batch(self) /= other;
         }
-        
-        friend batch operator%(batch const& self, batch const& other)
+
+        friend batch operator%(batch const& self, batch const& other) noexcept
         {
             return batch(self) %= other;
         }
 
-        friend batch operator&(batch const& self, batch const& other)
+        friend batch operator&(batch const& self, batch const& other) noexcept
         {
             return batch(self) &= other;
         }
 
-        friend batch operator|(batch const& self, batch const& other)
+        friend batch operator|(batch const& self, batch const& other) noexcept
         {
             return batch(self) |= other;
         }
 
-        friend batch operator^(batch const& self, batch const& other)
+        friend batch operator^(batch const& self, batch const& other) noexcept
         {
             return batch(self) ^= other;
         }
 
-        friend batch operator>>(batch const& self, batch const& other)
+        friend batch operator>>(batch const& self, batch const& other) noexcept
         {
-           return batch(self) >>= other;
+            return batch(self) >>= other;
         }
 
-        friend batch operator<<(batch const& self, batch const& other)
+        friend batch operator<<(batch const& self, batch const& other) noexcept
         {
             return batch(self) <<= other;
         }
 
-        friend batch operator>>(batch const& self, int32_t other)
+        friend batch operator>>(batch const& self, int32_t other) noexcept
         {
             return batch(self) >>= other;
         }
 
-        friend batch operator<<(batch const& self, int32_t other)
+        friend batch operator<<(batch const& self, int32_t other) noexcept
         {
             return batch(self) <<= other;
         }
 
-        friend batch operator&&(batch const& self, batch const& other)
+        friend batch operator&&(batch const& self, batch const& other) noexcept
         {
             return batch(self).logical_and(other);
         }
 
-        friend batch operator||(batch const& self, batch const& other)
+        friend batch operator||(batch const& self, batch const& other) noexcept
         {
             return batch(self).logical_or(other);
         }
+
     private:
-  
-        template<size_t... Is>
-        batch(T const* data, detail::index_sequence<Is...>);
+        template <size_t... Is>
+        batch(T const* data, detail::index_sequence<Is...>) noexcept;
 
-        batch logical_and(batch const& other) const;
-        batch logical_or(batch const& other) const;
+        batch logical_and(batch const& other) const noexcept;
+        batch logical_or(batch const& other) const noexcept;
     };
 
     template <class T, class A>
@@ -201,11 +200,10 @@ namespace xsimd
      * @tparam T the type of the predicated values.
      * @tparam A the architecture this batch is tied too.
      **/
-    template<class T, class A=default_arch>
+    template <class T, class A = default_arch>
     class batch_bool : public types::get_bool_simd_register_t<T, A>
     {
     public:
-
         static constexpr std::size_t size = sizeof(types::simd_register<T, A>) / sizeof(T);
 
         using value_type = bool;
@@ -215,40 +213,39 @@ namespace xsimd
 
         // constructors
         batch_bool() = default;
-        batch_bool(bool val);
-        batch_bool(register_type reg);
-        batch_bool(std::initializer_list<bool> data);
+        batch_bool(bool val) noexcept;
+        batch_bool(register_type reg) noexcept;
+        batch_bool(std::initializer_list<bool> data) noexcept;
 
         // memory operators
-        void store_aligned(bool * mem) const;
-        void store_unaligned(bool * mem) const;
-        static XSIMD_NO_DISCARD batch_bool load_aligned(bool const * mem);
-        static XSIMD_NO_DISCARD batch_bool load_unaligned(bool const * mem);
+        void store_aligned(bool* mem) const noexcept;
+        void store_unaligned(bool* mem) const noexcept;
+        static XSIMD_NO_DISCARD batch_bool load_aligned(bool const* mem) noexcept;
+        static XSIMD_NO_DISCARD batch_bool load_unaligned(bool const* mem) noexcept;
 
-        bool get(std::size_t i) const;
+        bool get(std::size_t i) const noexcept;
 
         // comparison operators
-        batch_bool operator==(batch_bool const& other) const;
-        batch_bool operator!=(batch_bool const& other) const;
+        batch_bool operator==(batch_bool const& other) const noexcept;
+        batch_bool operator!=(batch_bool const& other) const noexcept;
 
         // logical operators
-        batch_bool operator~() const;
-        batch_bool operator!() const;
-        batch_bool operator&(batch_bool const& other) const;
-        batch_bool operator|(batch_bool const& other) const;
-        batch_bool operator&&(batch_bool const& other) const;
-        batch_bool operator||(batch_bool const& other) const;
+        batch_bool operator~() const noexcept;
+        batch_bool operator!() const noexcept;
+        batch_bool operator&(batch_bool const& other) const noexcept;
+        batch_bool operator|(batch_bool const& other) const noexcept;
+        batch_bool operator&&(batch_bool const& other) const noexcept;
+        batch_bool operator||(batch_bool const& other) const noexcept;
 
     private:
-
-        template<size_t... Is>
-        batch_bool(bool const* data, detail::index_sequence<Is...>);
+        template <size_t... Is>
+        batch_bool(bool const* data, detail::index_sequence<Is...>) noexcept;
 
         template <class U, class... V, size_t I, size_t... Is>
-        static register_type make_register(detail::index_sequence<I, Is...>, U u, V... v);
+        static register_type make_register(detail::index_sequence<I, Is...>, U u, V... v) noexcept;
 
         template <class... V>
-        static register_type make_register(detail::index_sequence<>, V... v);
+        static register_type make_register(detail::index_sequence<>, V... v) noexcept;
     };
 
     template <class T, class A>
@@ -262,11 +259,10 @@ namespace xsimd
      * @tparam T the type of the underlying values.
      * @tparam A the architecture this batch is tied too.
      **/
-    template<class T, class A>
+    template <class T, class A>
     class batch<std::complex<T>, A>
     {
     public:
-
         using value_type = std::complex<T>;
         using real_batch = batch<T, A>;
         using arch_type = A;
@@ -275,102 +271,101 @@ namespace xsimd
 
         // constructors
         batch() = default;
-        batch(value_type const& val);
-        batch(real_batch const& real, real_batch const& imag);
-        
-        batch(real_batch const& real);
-        batch(T val);
-        batch(std::initializer_list<value_type> data);
-        explicit batch(batch_bool_type const& b);
+        batch(value_type const& val) noexcept;
+        batch(real_batch const& real, real_batch const& imag) noexcept;
+
+        batch(real_batch const& real) noexcept;
+        batch(T val) noexcept;
+        batch(std::initializer_list<value_type> data) noexcept;
+        explicit batch(batch_bool_type const& b) noexcept;
 
         // memory operators
-        static XSIMD_NO_DISCARD batch load_aligned(const T* real_src, const T* imag_src=nullptr);
-        static XSIMD_NO_DISCARD batch load_unaligned(const T* real_src, const T* imag_src=nullptr);
-        void store_aligned(T* real_dst, T* imag_dst) const;
-        void store_unaligned(T* real_dst, T* imag_dst) const;
-
-        static XSIMD_NO_DISCARD batch load_aligned(const value_type* src);
-        static XSIMD_NO_DISCARD batch load_unaligned(const value_type* src);
-        void store_aligned(value_type* dst) const;
-        void store_unaligned(value_type* dst) const;
-
-        template<class U>
-        static XSIMD_NO_DISCARD batch load(U const* mem, aligned_mode);
-        template<class U>
-        static XSIMD_NO_DISCARD batch load(U const* mem, unaligned_mode);
-        template<class U>
-        void store(U * mem, aligned_mode) const;
-        template<class U>
-        void store(U * mem, unaligned_mode) const;
-
-        real_batch real() const;
-        real_batch imag() const;
-
-        value_type get(std::size_t i) const;
+        static XSIMD_NO_DISCARD batch load_aligned(const T* real_src, const T* imag_src = nullptr) noexcept;
+        static XSIMD_NO_DISCARD batch load_unaligned(const T* real_src, const T* imag_src = nullptr) noexcept;
+        void store_aligned(T* real_dst, T* imag_dst) const noexcept;
+        void store_unaligned(T* real_dst, T* imag_dst) const noexcept;
+
+        static XSIMD_NO_DISCARD batch load_aligned(const value_type* src) noexcept;
+        static XSIMD_NO_DISCARD batch load_unaligned(const value_type* src) noexcept;
+        void store_aligned(value_type* dst) const noexcept;
+        void store_unaligned(value_type* dst) const noexcept;
+
+        template <class U>
+        static XSIMD_NO_DISCARD batch load(U const* mem, aligned_mode) noexcept;
+        template <class U>
+        static XSIMD_NO_DISCARD batch load(U const* mem, unaligned_mode) noexcept;
+        template <class U>
+        void store(U* mem, aligned_mode) const noexcept;
+        template <class U>
+        void store(U* mem, unaligned_mode) const noexcept;
+
+        real_batch real() const noexcept;
+        real_batch imag() const noexcept;
+
+        value_type get(std::size_t i) const noexcept;
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
         // xtl-related methods
-        template<bool i3ec>
-        batch(xtl::xcomplex<T, T, i3ec> const& val);
-        template<bool i3ec>
-        batch(std::initializer_list<xtl::xcomplex<T, T, i3ec>> data);
-
-        template<bool i3ec>
-        static XSIMD_NO_DISCARD batch load_aligned(const xtl::xcomplex<T, T, i3ec>* src);
-        template<bool i3ec>
-        static XSIMD_NO_DISCARD batch load_unaligned(const xtl::xcomplex<T, T, i3ec>* src);
-        template<bool i3ec>
-        void store_aligned(xtl::xcomplex<T, T, i3ec>* dst) const;
-        template<bool i3ec>
-        void store_unaligned(xtl::xcomplex<T, T, i3ec>* dst) const;
+        template <bool i3ec>
+        batch(xtl::xcomplex<T, T, i3ec> const& val) noexcept;
+        template <bool i3ec>
+        batch(std::initializer_list<xtl::xcomplex<T, T, i3ec>> data) noexcept;
+
+        template <bool i3ec>
+        static XSIMD_NO_DISCARD batch load_aligned(const xtl::xcomplex<T, T, i3ec>* src) noexcept;
+        template <bool i3ec>
+        static XSIMD_NO_DISCARD batch load_unaligned(const xtl::xcomplex<T, T, i3ec>* src) noexcept;
+        template <bool i3ec>
+        void store_aligned(xtl::xcomplex<T, T, i3ec>* dst) const noexcept;
+        template <bool i3ec>
+        void store_unaligned(xtl::xcomplex<T, T, i3ec>* dst) const noexcept;
 #endif
 
         // comparison operators
-        batch_bool<T, A> operator==(batch const& other) const;
-        batch_bool<T, A> operator!=(batch const& other) const;
+        batch_bool<T, A> operator==(batch const& other) const noexcept;
+        batch_bool<T, A> operator!=(batch const& other) const noexcept;
 
         // Update operators
-        batch& operator+=(batch const& other);
-        batch& operator-=(batch const& other);
-        batch& operator*=(batch const& other);
-        batch& operator/=(batch const& other);
+        batch& operator+=(batch const& other) noexcept;
+        batch& operator-=(batch const& other) noexcept;
+        batch& operator*=(batch const& other) noexcept;
+        batch& operator/=(batch const& other) noexcept;
 
         // incr/decr operators
-        batch& operator++();
-        batch& operator--();
-        batch operator++(int);
-        batch operator--(int);
+        batch& operator++() noexcept;
+        batch& operator--() noexcept;
+        batch operator++(int) noexcept;
+        batch operator--(int) noexcept;
 
         // unary operators
-        batch_bool_type operator!() const;
-        batch operator~() const;
-        batch operator-() const;
-        batch operator+() const;
+        batch_bool_type operator!() const noexcept;
+        batch operator~() const noexcept;
+        batch operator-() const noexcept;
+        batch operator+() const noexcept;
 
         // arithmetic operators. They are defined as friend to enable automatic
         // conversion of parameters from scalar to batch
-        friend batch operator+(batch const& self, batch const& other)
+        friend batch operator+(batch const& self, batch const& other) noexcept
         {
             return batch(self) += other;
         }
 
-        friend batch operator-(batch const& self, batch const& other)
+        friend batch operator-(batch const& self, batch const& other) noexcept
         {
             return batch(self) -= other;
         }
-        
-        friend batch operator*(batch const& self, batch const& other)
+
+        friend batch operator*(batch const& self, batch const& other) noexcept
         {
             return batch(self) *= other;
         }
 
-        friend batch operator/(batch const& self, batch const& other)
+        friend batch operator/(batch const& self, batch const& other) noexcept
         {
             return batch(self) /= other;
         }
 
     private:
-
         real_batch m_real;
         real_batch m_imag;
     };
@@ -378,49 +373,10 @@ namespace xsimd
     template <class T, class A>
     constexpr std::size_t batch<std::complex<T>, A>::size;
 
-    /*******************
-     * real_batch_type *
-     *******************/
-
-    template <class B>
-    struct real_batch_type
-    {
-        using type = B;
-    };
-
-    template <class T, class A>
-    struct real_batch_type<batch<std::complex<T>, A>>
-    {
-        using type = batch<T, A>;
-    };
-
-    template <class B>
-    using real_batch_type_t = typename real_batch_type<B>::type;
-
-    /**********************
-     * complex_batch_type *
-     **********************/
-
-    template <class B>
-    struct complex_batch_type
-    {
-        using real_value_type = typename B::value_type;
-        using arch_type = typename B::arch_type;
-        using type = batch<std::complex<real_value_type>, arch_type>;
-    };
-
-    template <class T, class A>
-    struct complex_batch_type<batch<std::complex<T>, A>>
-    {
-        using type = batch<std::complex<T>, A>;
-    };
-
-    template <class B>
-    using complex_batch_type_t = typename complex_batch_type<B>::type;
 }
 
-#include "../types/xsimd_batch_constant.hpp"
 #include "../arch/xsimd_isa.hpp"
+#include "../types/xsimd_batch_constant.hpp"
 
 namespace xsimd
 {
@@ -429,40 +385,41 @@ namespace xsimd
      * batch constructors *
      **********************/
 
-    template<class T, class A>
-    batch<T, A>::batch(T val)
-        : types::simd_register<T, A>(kernel::broadcast<A>(val, A{}))
+    template <class T, class A>
+    inline batch<T, A>::batch(T val) noexcept
+        : types::simd_register<T, A>(kernel::broadcast<A>(val, A {}))
     {
     }
 
-    template<class T, class A>
-    batch<T, A>::batch(std::initializer_list<T> data)
+    template <class T, class A>
+    inline batch<T, A>::batch(std::initializer_list<T> data) noexcept
         : batch(data.begin(), detail::make_index_sequence<size>())
     {
+        assert(data.size() == size && "consistent initialization");
     }
 
-    template<class T, class A>
-    batch<T, A>::batch(batch_bool<T, A> const &b)
-        : batch(kernel::from_bool(b, A{}))
+    template <class T, class A>
+    inline batch<T, A>::batch(batch_bool<T, A> const& b) noexcept
+        : batch(kernel::from_bool(b, A {}))
     {
     }
 
-    template<class T, class A>
-    batch<T, A>::batch(register_type reg)
-        : types::simd_register<T, A>({reg})
+    template <class T, class A>
+    inline batch<T, A>::batch(register_type reg) noexcept
+        : types::simd_register<T, A>({ reg })
     {
     }
 
-    template<class T, class A>
-    template<size_t... Is>
-    batch<T, A>::batch(T const*data, detail::index_sequence<Is...>)
-        : batch(kernel::set<A>(batch{}, A{}, data[Is]...))
+    template <class T, class A>
+    template <size_t... Is>
+    inline batch<T, A>::batch(T const* data, detail::index_sequence<Is...>) noexcept
+        : batch(kernel::set<A>(batch {}, A {}, data[Is]...))
     {
     }
 
     template <class T, class A>
-    template<class U>
-    XSIMD_NO_DISCARD batch<T, A> batch<T, A>::broadcast(U val)
+    template <class U>
+    inline XSIMD_NO_DISCARD batch<T, A> batch<T, A>::broadcast(U val) noexcept
     {
         return batch(static_cast<T>(val));
     }
@@ -472,15 +429,15 @@ namespace xsimd
      **************************/
 
     /**
-    * Copy content of this batch to the buffer \c mem. The
-    * memory needs to be aligned.
-    * @param mem the memory buffer to read
-    */
-    template<class T, class A>
-    template<class U>
-    void batch<T, A>::store_aligned(U* mem) const
+     * Copy content of this batch to the buffer \c mem. The
+     * memory needs to be aligned.
+     * @param mem the memory buffer to read
+     */
+    template <class T, class A>
+    template <class U>
+    inline void batch<T, A>::store_aligned(U* mem) const noexcept
     {
-        kernel::store_aligned<A>(mem, *this, A{});
+        kernel::store_aligned<A>(mem, *this, A {});
     }
 
     /**
@@ -488,23 +445,23 @@ namespace xsimd
      * memory does not need to be aligned.
      * @param mem the memory buffer to write to
      */
-    template<class T, class A>
-    template<class U>
-    void batch<T, A>::store_unaligned(U* mem) const
+    template <class T, class A>
+    template <class U>
+    inline void batch<T, A>::store_unaligned(U* mem) const noexcept
     {
-        kernel::store_unaligned<A>(mem, *this, A{});
+        kernel::store_unaligned<A>(mem, *this, A {});
     }
 
-    template<class T, class A>
-    template<class U>
-    void batch<T, A>::store(U * mem, aligned_mode) const
+    template <class T, class A>
+    template <class U>
+    inline void batch<T, A>::store(U* mem, aligned_mode) const noexcept
     {
         return store_aligned(mem);
     }
 
-    template<class T, class A>
-    template<class U>
-    void batch<T, A>::store(U * mem, unaligned_mode) const
+    template <class T, class A>
+    template <class U>
+    inline void batch<T, A>::store(U* mem, unaligned_mode) const noexcept
     {
         return store_unaligned(mem);
     }
@@ -516,11 +473,11 @@ namespace xsimd
      * @param mem the memory buffer to read from.
      * @return a new batch instance.
      */
-    template<class T, class A>
-    template<class U>
-    batch<T, A> batch<T, A>::load_aligned(U const* mem)
+    template <class T, class A>
+    template <class U>
+    inline batch<T, A> batch<T, A>::load_aligned(U const* mem) noexcept
     {
-        return kernel::load_aligned<A>(mem, kernel::convert<T>{}, A{});
+        return kernel::load_aligned<A>(mem, kernel::convert<T> {}, A {});
     }
 
     /**
@@ -530,29 +487,29 @@ namespace xsimd
      * @param mem the memory buffer to read from.
      * @return a new batch instance.
      */
-    template<class T, class A>
-    template<class U>
-    batch<T, A> batch<T, A>::load_unaligned(U const* mem)
+    template <class T, class A>
+    template <class U>
+    inline batch<T, A> batch<T, A>::load_unaligned(U const* mem) noexcept
     {
-        return kernel::load_unaligned<A>(mem, kernel::convert<T>{}, A{});
+        return kernel::load_unaligned<A>(mem, kernel::convert<T> {}, A {});
     }
 
-    template<class T, class A>
-    template<class U>
-    batch<T, A> batch<T, A>::load(U const* mem, aligned_mode)
+    template <class T, class A>
+    template <class U>
+    inline batch<T, A> batch<T, A>::load(U const* mem, aligned_mode) noexcept
     {
         return load_aligned(mem);
     }
 
-    template<class T, class A>
-    template<class U>
-    batch<T, A> batch<T, A>::load(U const* mem, unaligned_mode)
+    template <class T, class A>
+    template <class U>
+    inline batch<T, A> batch<T, A>::load(U const* mem, unaligned_mode) noexcept
     {
         return load_unaligned(mem);
     }
 
     template <class T, class A>
-    T batch<T, A>::get(std::size_t i) const
+    inline T batch<T, A>::get(std::size_t i) const noexcept
     {
         alignas(A::alignment()) T buffer[size];
         store_aligned(&buffer[0]);
@@ -563,145 +520,145 @@ namespace xsimd
      * batch comparison operators *
      ******************************/
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator==(batch<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator==(batch<T, A> const& other) const noexcept
     {
-        return kernel::eq<A>(*this, other, A{});
+        return kernel::eq<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator!=(batch<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator!=(batch<T, A> const& other) const noexcept
     {
-        return kernel::neq<A>(*this, other, A{});
+        return kernel::neq<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator>=(batch<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator>=(batch<T, A> const& other) const noexcept
     {
-        return kernel::ge<A>(*this, other, A{});
+        return kernel::ge<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator<=(batch<T, A> const& other) const
-    { 
-        return kernel::le<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator<=(batch<T, A> const& other) const noexcept
+    {
+        return kernel::le<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator>(batch<T, A> const& other) const
-    { 
-        return kernel::gt<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator>(batch<T, A> const& other) const noexcept
+    {
+        return kernel::gt<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator<(batch<T, A> const& other) const
-    { 
-        return kernel::lt<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator<(batch<T, A> const& other) const noexcept
+    {
+        return kernel::lt<A>(*this, other, A {});
     }
-    
+
     /**************************
      * batch update operators *
      **************************/
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator+=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator+=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::add<A>(*this, other, A{});
+        return *this = kernel::add<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator-=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator-=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::sub<A>(*this, other, A{});
+        return *this = kernel::sub<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator*=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator*=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::mul<A>(*this, other, A{});
+        return *this = kernel::mul<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator/=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator/=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::div<A>(*this, other, A{});
+        return *this = kernel::div<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator%=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator%=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::mod<A>(*this, other, A{});
+        return *this = kernel::mod<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator&=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator&=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::bitwise_and<A>(*this, other, A{});
+        return *this = kernel::bitwise_and<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator|=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator|=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::bitwise_or<A>(*this, other, A{});
+        return *this = kernel::bitwise_or<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator^=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator^=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::bitwise_xor<A>(*this, other, A{});
+        return *this = kernel::bitwise_xor<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator>>=(batch<T, A> const& other)
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator>>=(batch<T, A> const& other) noexcept
     {
-        return *this = kernel::bitwise_rshift<A>(*this, other, A{});
+        return *this = kernel::bitwise_rshift<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator<<=(batch<T, A> const& other)
-    { 
-        return *this = kernel::bitwise_lshift<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator<<=(batch<T, A> const& other) noexcept
+    {
+        return *this = kernel::bitwise_lshift<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator>>=(int32_t other)
-    { 
-        return *this = kernel::bitwise_rshift<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator>>=(int32_t other) noexcept
+    {
+        return *this = kernel::bitwise_rshift<A>(*this, other, A {});
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator<<=(int32_t other)
-    { 
-        return *this = kernel::bitwise_lshift<A>(*this, other, A{});
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator<<=(int32_t other) noexcept
+    {
+        return *this = kernel::bitwise_lshift<A>(*this, other, A {});
     }
 
     /*****************************
      * batch incr/decr operators *
      *****************************/
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator++()
-    { 
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator++() noexcept
+    {
         return operator+=(1);
     }
 
-    template<class T, class A>
-    batch<T, A>& batch<T, A>::operator--()
-    { 
+    template <class T, class A>
+    inline batch<T, A>& batch<T, A>::operator--() noexcept
+    {
         return operator-=(1);
     }
-    
-    template<class T, class A>
-    batch<T, A> batch<T, A>::operator++(int)
+
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::operator++(int) noexcept
     {
         batch<T, A> copy(*this);
         operator+=(1);
         return copy;
     }
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::operator--(int)
-    { 
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::operator--(int) noexcept
+    {
         batch copy(*this);
         operator-=(1);
         return copy;
@@ -711,26 +668,26 @@ namespace xsimd
      * batch unary operators *
      *************************/
 
-    template<class T, class A>
-    batch_bool<T, A> batch<T, A>::operator!() const
+    template <class T, class A>
+    inline batch_bool<T, A> batch<T, A>::operator!() const noexcept
     {
-        return kernel::eq<A>(*this, batch(0), A{});
+        return kernel::eq<A>(*this, batch(0), A {});
     }
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::operator~() const
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::operator~() const noexcept
     {
-        return kernel::bitwise_not<A>(*this, A{});
+        return kernel::bitwise_not<A>(*this, A {});
     }
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::operator-() const
-    { 
-        return kernel::neg<A>(*this, A{});
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::operator-() const noexcept
+    {
+        return kernel::neg<A>(*this, A {});
     }
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::operator+() const
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::operator+() const noexcept
     {
         return *this;
     }
@@ -739,14 +696,14 @@ namespace xsimd
      * batch private method *
      ************************/
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::logical_and(batch<T, A> const& other) const
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::logical_and(batch<T, A> const& other) const noexcept
     {
         return kernel::logical_and<A>(*this, other, A());
     }
 
-    template<class T, class A>
-    batch<T, A> batch<T, A>::logical_or(batch<T, A> const& other) const
+    template <class T, class A>
+    inline batch<T, A> batch<T, A>::logical_or(batch<T, A> const& other) const noexcept
     {
         return kernel::logical_or<A>(*this, other, A());
     }
@@ -755,21 +712,21 @@ namespace xsimd
      * batch_bool constructors *
      ***************************/
 
-    template<class T, class A>
-    template<size_t... Is>
-    batch_bool<T, A>::batch_bool(bool const*data, detail::index_sequence<Is...>)
-        : batch_bool(kernel::set<A>(batch_bool{}, A{}, data[Is]...))
+    template <class T, class A>
+    template <size_t... Is>
+    inline batch_bool<T, A>::batch_bool(bool const* data, detail::index_sequence<Is...>) noexcept
+        : batch_bool(kernel::set<A>(batch_bool {}, A {}, data[Is]...))
     {
     }
 
-    template<class T, class A>
-    batch_bool<T, A>::batch_bool(register_type reg)
-        : types::get_bool_simd_register_t<T, A>({reg})
+    template <class T, class A>
+    inline batch_bool<T, A>::batch_bool(register_type reg) noexcept
+        : types::get_bool_simd_register_t<T, A>({ reg })
     {
     }
 
-    template<class T, class A>
-    batch_bool<T, A>::batch_bool(std::initializer_list<bool> data)
+    template <class T, class A>
+    inline batch_bool<T, A>::batch_bool(std::initializer_list<bool> data) noexcept
         : batch_bool(data.begin(), detail::make_index_sequence<size>())
     {
     }
@@ -778,36 +735,36 @@ namespace xsimd
      * batch_bool memory operators *
      *******************************/
 
-    template<class T, class A>
-    void batch_bool<T, A>::store_aligned(bool* mem) const
+    template <class T, class A>
+    inline void batch_bool<T, A>::store_aligned(bool* mem) const noexcept
     {
-        kernel::store(*this, mem, A{});
+        kernel::store(*this, mem, A {});
     }
 
-    template<class T, class A>
-    void batch_bool<T, A>::store_unaligned(bool* mem) const
+    template <class T, class A>
+    inline void batch_bool<T, A>::store_unaligned(bool* mem) const noexcept
     {
         store_aligned(mem);
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::load_aligned(bool const* mem)
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::load_aligned(bool const* mem) noexcept
     {
         batch_type ref(0);
         alignas(A::alignment()) T buffer[size];
-        for(std::size_t i = 0; i < size; ++i)
+        for (std::size_t i = 0; i < size; ++i)
             buffer[i] = mem[i] ? 1 : 0;
         return ref != batch_type::load_aligned(&buffer[0]);
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::load_unaligned(bool const* mem)
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::load_unaligned(bool const* mem) noexcept
     {
         return load_aligned(mem);
     }
 
-    template<class T, class A>
-    bool batch_bool<T, A>::get(std::size_t i) const
+    template <class T, class A>
+    inline bool batch_bool<T, A>::get(std::size_t i) const noexcept
     {
         alignas(A::alignment()) bool buffer[size];
         store_aligned(&buffer[0]);
@@ -818,54 +775,54 @@ namespace xsimd
      * batch_bool comparison operators *
      ***********************************/
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator==(batch_bool<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator==(batch_bool<T, A> const& other) const noexcept
     {
-        return kernel::eq<A>(*this, other, A{}).data;
+        return kernel::eq<A>(*this, other, A {}).data;
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator!=(batch_bool<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator!=(batch_bool<T, A> const& other) const noexcept
     {
-        return kernel::neq<A>(*this, other, A{}).data;
+        return kernel::neq<A>(*this, other, A {}).data;
     }
 
     /********************************
      * batch_bool logical operators *
      ********************************/
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator~() const
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator~() const noexcept
     {
-        return kernel::bitwise_not<A>(*this, A{}).data;
+        return kernel::bitwise_not<A>(*this, A {}).data;
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator!() const
-    { 
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator!() const noexcept
+    {
         return operator==(batch_bool(false));
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator&(batch_bool<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator&(batch_bool<T, A> const& other) const noexcept
     {
-        return kernel::bitwise_and<A>(*this, other, A{}).data;
+        return kernel::bitwise_and<A>(*this, other, A {}).data;
     }
 
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator|(batch_bool<T, A> const& other) const
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator|(batch_bool<T, A> const& other) const noexcept
     {
-        return kernel::bitwise_or<A>(*this, other, A{}).data;
+        return kernel::bitwise_or<A>(*this, other, A {}).data;
     }
-        
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator&&(batch_bool const& other) const
+
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator&&(batch_bool const& other) const noexcept
     {
         return operator&(other);
     }
-    
-    template<class T, class A>
-    batch_bool<T, A> batch_bool<T, A>::operator||(batch_bool const& other) const
+
+    template <class T, class A>
+    inline batch_bool<T, A> batch_bool<T, A>::operator||(batch_bool const& other) const noexcept
     {
         return operator|(other);
     }
@@ -874,24 +831,24 @@ namespace xsimd
      * batch_bool private methods *
      ******************************/
 
-    template<class T, class A>
-    batch_bool<T, A>::batch_bool(bool val)
-        : base_type{make_register(detail::make_index_sequence<size-1>(), val)}
+    template <class T, class A>
+    inline batch_bool<T, A>::batch_bool(bool val) noexcept
+        : base_type { make_register(detail::make_index_sequence<size - 1>(), val) }
     {
     }
 
     template <class T, class A>
     template <class U, class... V, size_t I, size_t... Is>
-    auto batch_bool<T, A>::make_register(detail::index_sequence<I, Is...>, U u, V... v) -> register_type
+    inline auto batch_bool<T, A>::make_register(detail::index_sequence<I, Is...>, U u, V... v) noexcept -> register_type
     {
         return make_register(detail::index_sequence<Is...>(), u, u, v...);
     }
 
     template <class T, class A>
     template <class... V>
-    auto batch_bool<T, A>::make_register(detail::index_sequence<>, V... v) -> register_type
+    inline auto batch_bool<T, A>::make_register(detail::index_sequence<>, V... v) noexcept -> register_type
     {
-        return kernel::set<A>(batch_bool<T, A>(), A{}, v...).data;
+        return kernel::set<A>(batch_bool<T, A>(), A {}, v...).data;
     }
 
     /*******************************
@@ -899,38 +856,43 @@ namespace xsimd
      *******************************/
 
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(value_type const& val)
-        : m_real(val.real()), m_imag(val.imag())
+    inline batch<std::complex<T>, A>::batch(value_type const& val) noexcept
+        : m_real(val.real())
+        , m_imag(val.imag())
     {
     }
-    
+
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(real_batch const& real, real_batch const& imag)
-        : m_real(real), m_imag(imag)
+    inline batch<std::complex<T>, A>::batch(real_batch const& real, real_batch const& imag) noexcept
+        : m_real(real)
+        , m_imag(imag)
     {
     }
-        
+
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(real_batch const& real)
-        : m_real(real), m_imag(0)
+    inline batch<std::complex<T>, A>::batch(real_batch const& real) noexcept
+        : m_real(real)
+        , m_imag(0)
     {
     }
-    
+
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(T val)
-        : m_real(val), m_imag(0)
+    inline batch<std::complex<T>, A>::batch(T val) noexcept
+        : m_real(val)
+        , m_imag(0)
     {
     }
-    
+
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(std::initializer_list<value_type> data)
-    { 
+    inline batch<std::complex<T>, A>::batch(std::initializer_list<value_type> data) noexcept
+    {
         *this = load_unaligned(data.begin());
     }
 
     template <class T, class A>
-    batch<std::complex<T>, A>::batch(batch_bool_type const& b)
-        : m_real(b), m_imag(0)
+    inline batch<std::complex<T>, A>::batch(batch_bool_type const& b) noexcept
+        : m_real(b)
+        , m_imag(0)
     {
     }
 
@@ -939,96 +901,96 @@ namespace xsimd
      ***********************************/
 
     template <class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const T* real_src, const T* imag_src)
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const T* real_src, const T* imag_src) noexcept
     {
-        return {batch<T, A>::load_aligned(real_src), imag_src ? batch<T, A>::load_aligned(imag_src) : batch<T, A>(0)};
+        return { batch<T, A>::load_aligned(real_src), imag_src ? batch<T, A>::load_aligned(imag_src) : batch<T, A>(0) };
     }
     template <class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const T* real_src, const T* imag_src)
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const T* real_src, const T* imag_src) noexcept
     {
-        return {batch<T, A>::load_unaligned(real_src), imag_src?batch<T, A>::load_unaligned(imag_src):batch<T, A>(0)};
+        return { batch<T, A>::load_unaligned(real_src), imag_src ? batch<T, A>::load_unaligned(imag_src) : batch<T, A>(0) };
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const value_type* src)
+    template <class T, class A>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const value_type* src) noexcept
     {
-        return kernel::load_complex_aligned<A>(src, kernel::convert<value_type>{}, A{});
+        return kernel::load_complex_aligned<A>(src, kernel::convert<value_type> {}, A {});
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const value_type* src)
+    template <class T, class A>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const value_type* src) noexcept
     {
-        return kernel::load_complex_unaligned<A>(src, kernel::convert<value_type>{}, A{});
+        return kernel::load_complex_unaligned<A>(src, kernel::convert<value_type> {}, A {});
     }
 
-    template<class T, class A>
-    void batch<std::complex<T>, A>::store_aligned(value_type* dst) const
+    template <class T, class A>
+    inline void batch<std::complex<T>, A>::store_aligned(value_type* dst) const noexcept
     {
-        return kernel::store_complex_aligned(dst, *this, A{});
+        return kernel::store_complex_aligned(dst, *this, A {});
     }
 
-    template<class T, class A>
-    void batch<std::complex<T>, A>::store_unaligned(value_type* dst) const
+    template <class T, class A>
+    inline void batch<std::complex<T>, A>::store_unaligned(value_type* dst) const noexcept
     {
-        return kernel::store_complex_unaligned(dst, *this, A{});
+        return kernel::store_complex_unaligned(dst, *this, A {});
     }
 
-    template<class T, class A>
-    void batch<std::complex<T>, A>::store_aligned(T* real_dst, T* imag_dst) const
+    template <class T, class A>
+    inline void batch<std::complex<T>, A>::store_aligned(T* real_dst, T* imag_dst) const noexcept
     {
         m_real.store_aligned(real_dst);
         m_imag.store_aligned(imag_dst);
     }
 
-    template<class T, class A>
-    void batch<std::complex<T>, A>::store_unaligned(T* real_dst, T* imag_dst) const
+    template <class T, class A>
+    inline void batch<std::complex<T>, A>::store_unaligned(T* real_dst, T* imag_dst) const noexcept
     {
         m_real.store_unaligned(real_dst);
         m_imag.store_unaligned(imag_dst);
     }
 
-    template<class T, class A>
-    template<class U>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load(U const* mem, aligned_mode)
+    template <class T, class A>
+    template <class U>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load(U const* mem, aligned_mode) noexcept
     {
         return load_aligned(mem);
     }
 
-    template<class T, class A>
-    template<class U>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load(U const* mem, unaligned_mode)
-    { 
+    template <class T, class A>
+    template <class U>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load(U const* mem, unaligned_mode) noexcept
+    {
         return load_unaligned(mem);
     }
 
-    template<class T, class A>
-    template<class U>
-    void batch<std::complex<T>, A>::store(U * mem, aligned_mode) const
+    template <class T, class A>
+    template <class U>
+    inline void batch<std::complex<T>, A>::store(U* mem, aligned_mode) const noexcept
     {
         return store_aligned(mem);
     }
-    
-    template<class T, class A>
-    template<class U>
-    void batch<std::complex<T>, A>::store(U * mem, unaligned_mode) const
-    { 
+
+    template <class T, class A>
+    template <class U>
+    inline void batch<std::complex<T>, A>::store(U* mem, unaligned_mode) const noexcept
+    {
         return store_unaligned(mem);
     }
 
-    template<class T, class A>
-    auto batch<std::complex<T>, A>::real() const -> real_batch
+    template <class T, class A>
+    inline auto batch<std::complex<T>, A>::real() const noexcept -> real_batch
     {
-        return m_real; 
+        return m_real;
     }
-    
-    template<class T, class A>
-    auto batch<std::complex<T>, A>::imag() const -> real_batch 
+
+    template <class T, class A>
+    inline auto batch<std::complex<T>, A>::imag() const noexcept -> real_batch
     {
         return m_imag;
     }
 
-    template<class T, class A>
-    auto batch<std::complex<T>, A>::get(std::size_t i) const -> value_type
+    template <class T, class A>
+    inline auto batch<std::complex<T>, A>::get(std::size_t i) const noexcept -> value_type
     {
         alignas(A::alignment()) value_type buffer[size];
         store_aligned(&buffer[0]);
@@ -1041,16 +1003,17 @@ namespace xsimd
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
 
-    template<class T, class A>
-    template<bool i3ec>
-    batch<std::complex<T>, A>::batch(xtl::xcomplex<T, T, i3ec> const& val)
-        : m_real(val.real()), m_imag(val.imag())
+    template <class T, class A>
+    template <bool i3ec>
+    inline batch<std::complex<T>, A>::batch(xtl::xcomplex<T, T, i3ec> const& val) noexcept
+        : m_real(val.real())
+        , m_imag(val.imag())
     {
     }
 
-    template<class T, class A>
-    template<bool i3ec>
-    batch<std::complex<T>, A>::batch(std::initializer_list<xtl::xcomplex<T, T, i3ec>> data)
+    template <class T, class A>
+    template <bool i3ec>
+    inline batch<std::complex<T>, A>::batch(std::initializer_list<xtl::xcomplex<T, T, i3ec>> data) noexcept
     {
         *this = load_unaligned(data.begin());
     }
@@ -1059,30 +1022,30 @@ namespace xsimd
     // stores values and not reference. Unfortunately, this breaks strict
     // aliasing...
 
-    template<class T, class A>
-    template<bool i3ec>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const xtl::xcomplex<T, T, i3ec>* src)
+    template <class T, class A>
+    template <bool i3ec>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_aligned(const xtl::xcomplex<T, T, i3ec>* src) noexcept
     {
         return load_aligned(reinterpret_cast<std::complex<T> const*>(src));
     }
 
-    template<class T, class A>
-    template<bool i3ec>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const xtl::xcomplex<T, T, i3ec>* src)
+    template <class T, class A>
+    template <bool i3ec>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::load_unaligned(const xtl::xcomplex<T, T, i3ec>* src) noexcept
     {
         return load_unaligned(reinterpret_cast<std::complex<T> const*>(src));
     }
 
-    template<class T, class A>
-    template<bool i3ec>
-    void batch<std::complex<T>, A>::store_aligned(xtl::xcomplex<T, T, i3ec>* dst) const
+    template <class T, class A>
+    template <bool i3ec>
+    inline void batch<std::complex<T>, A>::store_aligned(xtl::xcomplex<T, T, i3ec>* dst) const noexcept
     {
-        store_aligned(reinterpret_cast<std::complex<T> *>(dst));
+        store_aligned(reinterpret_cast<std::complex<T>*>(dst));
     }
 
-    template<class T, class A>
-    template<bool i3ec>
-    void batch<std::complex<T>, A>::store_unaligned(xtl::xcomplex<T, T, i3ec>* dst) const
+    template <class T, class A>
+    template <bool i3ec>
+    inline void batch<std::complex<T>, A>::store_unaligned(xtl::xcomplex<T, T, i3ec>* dst) const noexcept
     {
         store_unaligned(reinterpret_cast<std::complex<T>*>(dst));
     }
@@ -1094,14 +1057,14 @@ namespace xsimd
      ***************************************/
 
     template <class T, class A>
-    batch_bool<T, A> batch<std::complex<T>, A>::operator==(batch const& other) const
+    inline batch_bool<T, A> batch<std::complex<T>, A>::operator==(batch const& other) const noexcept
     {
         return m_real == other.m_real && m_imag == other.m_imag;
     }
-    
+
     template <class T, class A>
-    batch_bool<T, A> batch<std::complex<T>, A>::operator!=(batch const& other) const
-    { 
+    inline batch_bool<T, A> batch<std::complex<T>, A>::operator!=(batch const& other) const noexcept
+    {
         return m_real != other.m_real || m_imag != other.m_imag;
     }
 
@@ -1110,15 +1073,15 @@ namespace xsimd
      ***********************************/
 
     template <class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator+=(batch const& other)
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator+=(batch const& other) noexcept
     {
         m_real += other.m_real;
         m_imag += other.m_imag;
         return *this;
     }
-    
+
     template <class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator-=(batch const& other)
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator-=(batch const& other) noexcept
     {
         m_real -= other.m_real;
         m_imag -= other.m_imag;
@@ -1126,7 +1089,7 @@ namespace xsimd
     }
 
     template <class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator*=(batch const& other)
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator*=(batch const& other) noexcept
     {
         real_batch new_real = real() * other.real() - imag() * other.imag();
         real_batch new_imag = real() * other.imag() + imag() * other.real();
@@ -1135,16 +1098,16 @@ namespace xsimd
         return *this;
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator/=(batch const& other)
+    template <class T, class A>
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator/=(batch const& other) noexcept
     {
         real_batch a = real();
         real_batch b = imag();
         real_batch c = other.real();
         real_batch d = other.imag();
-        real_batch e = c*c + d*d;
-        m_real = (c*a + d*b) / e;
-        m_imag = (c*b - d*a) / e;
+        real_batch e = c * c + d * d;
+        m_real = (c * a + d * b) / e;
+        m_imag = (c * b - d * a) / e;
         return *this;
     }
 
@@ -1152,28 +1115,28 @@ namespace xsimd
      * batch<complex> incr/decr operators *
      **************************************/
 
-    template<class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator++()
-    { 
+    template <class T, class A>
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator++() noexcept
+    {
         return operator+=(1);
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator--()
-    { 
+    template <class T, class A>
+    inline batch<std::complex<T>, A>& batch<std::complex<T>, A>::operator--() noexcept
+    {
         return operator-=(1);
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::operator++(int)
+    template <class T, class A>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::operator++(int) noexcept
     {
         batch copy(*this);
         operator+=(1);
         return copy;
     }
 
-    template<class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::operator--(int)
+    template <class T, class A>
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::operator--(int) noexcept
     {
         batch copy(*this);
         operator-=(1);
@@ -1185,29 +1148,28 @@ namespace xsimd
      **********************************/
 
     template <class T, class A>
-    batch_bool<T, A> batch<std::complex<T>, A>::operator!() const
-    { 
+    inline batch_bool<T, A> batch<std::complex<T>, A>::operator!() const noexcept
+    {
         return operator==(batch(0));
     }
-    
+
     template <class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::operator~() const
-    { 
-        return {~m_real, ~m_imag};
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::operator~() const noexcept
+    {
+        return { ~m_real, ~m_imag };
     }
 
     template <class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::operator-() const
-    { 
-        return {-m_real, -m_imag};
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::operator-() const noexcept
+    {
+        return { -m_real, -m_imag };
     }
 
     template <class T, class A>
-    batch<std::complex<T>, A> batch<std::complex<T>, A>::operator+() const
-    { 
-        return {+m_real, +m_imag};
+    inline batch<std::complex<T>, A> batch<std::complex<T>, A>::operator+() const noexcept
+    {
+        return { +m_real, +m_imag };
     }
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_batch_constant.hpp b/third_party/xsimd/types/xsimd_batch_constant.hpp
index c37784fa9..b2052adb3 100644
--- a/third_party/xsimd/types/xsimd_batch_constant.hpp
+++ b/third_party/xsimd/types/xsimd_batch_constant.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_BATCH_CONSTANT_HPP
 #define XSIMD_BATCH_CONSTANT_HPP
@@ -25,22 +25,22 @@ namespace xsimd
         using value_type = bool;
         static_assert(sizeof...(Values) == batch_type::size, "consistent batch size");
 
-        operator batch_bool<typename batch_type::value_type, arch_type>() const { return {Values...}; }
+        operator batch_bool<typename batch_type::value_type, arch_type>() const noexcept { return { Values... }; }
 
-        bool get(size_t i) const
+        bool get(size_t i) const noexcept
         {
-            return std::array<value_type, size>{{Values...}}[i];
+            return std::array<value_type, size> { { Values... } }[i];
         }
 
-        static constexpr int mask()
+        static constexpr int mask() noexcept
         {
             return mask_helper(0, static_cast<int>(Values)...);
         }
 
-      private:
-        static constexpr int mask_helper(int acc) { return acc; }
+    private:
+        static constexpr int mask_helper(int acc) noexcept { return acc; }
         template <class... Tys>
-        static constexpr int mask_helper(int acc, int mask, Tys... masks)
+        static constexpr int mask_helper(int acc, int mask, Tys... masks) noexcept
         {
             return mask_helper(acc | mask, (masks << 1)...);
         }
@@ -54,24 +54,24 @@ namespace xsimd
         using value_type = typename batch_type::value_type;
         static_assert(sizeof...(Values) == batch_type::size, "consistent batch size");
 
-        operator batch_type() const { return {Values...}; }
+        operator batch_type() const noexcept { return { Values... }; }
 
-        constexpr value_type get(size_t i) const
+        constexpr value_type get(size_t i) const noexcept
         {
-            return std::array<value_type, size>{Values...}[i];
+            return std::array<value_type, size> { Values... }[i];
         }
     };
 
     namespace detail
     {
         template <class batch_type, class G, std::size_t... Is>
-        constexpr auto make_batch_constant(detail::index_sequence<Is...>)
+        inline constexpr auto make_batch_constant(detail::index_sequence<Is...>) noexcept
             -> batch_constant<batch_type, G::get(Is, sizeof...(Is))...>
         {
             return {};
         }
         template <class batch_type, class G, std::size_t... Is>
-        constexpr auto make_batch_bool_constant(detail::index_sequence<Is...>)
+        inline constexpr auto make_batch_bool_constant(detail::index_sequence<Is...>) noexcept
             -> batch_bool_constant<batch_type, G::get(Is, sizeof...(Is))...>
         {
             return {};
@@ -80,14 +80,13 @@ namespace xsimd
     } // namespace detail
 
     template <class batch_type, class G>
-    constexpr auto make_batch_constant() -> decltype(
-        detail::make_batch_constant<batch_type, G>(detail::make_index_sequence<batch_type::size>()))
+    inline constexpr auto make_batch_constant() noexcept -> decltype(detail::make_batch_constant<batch_type, G>(detail::make_index_sequence<batch_type::size>()))
     {
         return detail::make_batch_constant<batch_type, G>(detail::make_index_sequence<batch_type::size>());
     }
 
     template <class batch_type, class G>
-    constexpr auto make_batch_bool_constant()
+    inline constexpr auto make_batch_bool_constant() noexcept
         -> decltype(detail::make_batch_bool_constant<batch_type, G>(
             detail::make_index_sequence<batch_type::size>()))
     {
diff --git a/third_party/xsimd/types/xsimd_fma3_register.hpp b/third_party/xsimd/types/xsimd_fma3_register.hpp
index 38e0d2a8d..493d52e9e 100644
--- a/third_party/xsimd/types/xsimd_fma3_register.hpp
+++ b/third_party/xsimd/types/xsimd_fma3_register.hpp
@@ -1,40 +1,42 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FMA3_REGISTER_HPP
 #define XSIMD_FMA3_REGISTER_HPP
 
 #include "./xsimd_sse4_2_register.hpp"
 
-namespace xsimd {
-
-  /**
-   * @ingroup arch
-   *
-   * SSE4.2 + FMA instructions
-   */
-  struct fma3 : sse4_2 {
-    static constexpr bool supported() { return XSIMD_WITH_FMA3; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(1, 5, 0); }
-    static constexpr char const* name() { return "sse4.2+fma"; }
-  };
+namespace xsimd
+{
+
+    /**
+     * @ingroup arch
+     *
+     * SSE4.2 + FMA instructions
+     */
+    struct fma3 : sse4_2
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_FMA3; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 5, 0); }
+        static constexpr char const* name() noexcept { return "sse4.2+fma"; }
+    };
 
 #if XSIMD_WITH_FMA3
-  namespace types {
+    namespace types
+    {
 
-    XSIMD_DECLARE_SIMD_REGISTER_ALIAS(fma3, sse4_2);
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(fma3, sse4_2);
 
-  }
+    }
 #endif
 }
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_fma5_register.hpp b/third_party/xsimd/types/xsimd_fma5_register.hpp
index 6c5cdb2eb..8cd0f3ded 100644
--- a/third_party/xsimd/types/xsimd_fma5_register.hpp
+++ b/third_party/xsimd/types/xsimd_fma5_register.hpp
@@ -1,41 +1,42 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FMA5_REGISTER_HPP
 #define XSIMD_FMA5_REGISTER_HPP
 
 #include "./xsimd_avx2_register.hpp"
 
-namespace xsimd {
-
-  /**
-   * @ingroup arch
-   *
-   * AVX2 + FMA instructions
-   */
-  struct fma5 : avx2 {
-    static constexpr bool supported() { return XSIMD_WITH_FMA5; }
-    static constexpr bool available() { return true; }
-    static constexpr unsigned version() { return generic::version(2, 3, 0); }
-    static constexpr char const* name() { return "avx2+fma"; }
-  };
+namespace xsimd
+{
+
+    /**
+     * @ingroup arch
+     *
+     * AVX2 + FMA instructions
+     */
+    struct fma5 : avx2
+    {
+        static constexpr bool supported() noexcept { return XSIMD_WITH_FMA5; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(2, 3, 0); }
+        static constexpr char const* name() noexcept { return "avx2+fma"; }
+    };
 
 #if XSIMD_WITH_FMA5
-  namespace types {
+    namespace types
+    {
 
-    XSIMD_DECLARE_SIMD_REGISTER_ALIAS(fma5, avx2);
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(fma5, avx2);
 
-  }
+    }
 #endif
 }
 #endif
-
-
diff --git a/third_party/xsimd/types/xsimd_generic_arch.hpp b/third_party/xsimd/types/xsimd_generic_arch.hpp
index 3755f999b..e0349b1f5 100644
--- a/third_party/xsimd/types/xsimd_generic_arch.hpp
+++ b/third_party/xsimd/types/xsimd_generic_arch.hpp
@@ -1,17 +1,19 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERIC_ARCH_HPP
 #define XSIMD_GENERIC_ARCH_HPP
 
+#include "../config/xsimd_config.hpp"
+
 /**
  * @defgroup arch
  * */
@@ -19,15 +21,14 @@ namespace xsimd
 {
     struct generic
     {
-        static constexpr bool supported() { return true; }
-        static constexpr bool available() { return true; }
-        static constexpr bool requires_alignment() { return false; }
+        static constexpr bool supported() noexcept { return true; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr std::size_t alignment() noexcept { return 0; }
+        static constexpr bool requires_alignment() noexcept { return false; }
 
     protected:
-
-        static constexpr unsigned version(unsigned major, unsigned minor, unsigned patch) { return major * 10000u + minor * 100u + patch; }
+        static constexpr unsigned version(unsigned major, unsigned minor, unsigned patch) noexcept { return major * 10000u + minor * 100u + patch; }
     };
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_neon64_register.hpp b/third_party/xsimd/types/xsimd_neon64_register.hpp
index 68f75eb3b..64a159dc9 100644
--- a/third_party/xsimd/types/xsimd_neon64_register.hpp
+++ b/third_party/xsimd/types/xsimd_neon64_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NEON64_REGISTER_HPP
 #define XSIMD_NEON64_REGISTER_HPP
@@ -23,12 +23,12 @@ namespace xsimd
      */
     struct neon64 : neon
     {
-        static constexpr bool supported() { return XSIMD_WITH_NEON64; }
-        static constexpr bool available() { return true; }
-        static constexpr bool requires_alignment() { return true; }
-        static constexpr std::size_t alignment() { return 16; }
-        static constexpr unsigned version() { return generic::version(8, 1, 0); }
-        static constexpr char const* name() { return "arm64+neon"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_NEON64; }
+        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 unsigned version() noexcept { return generic::version(8, 1, 0); }
+        static constexpr char const* name() noexcept { return "arm64+neon"; }
     };
 
 #if XSIMD_WITH_NEON64
@@ -50,5 +50,3 @@ namespace xsimd
 }
 
 #endif
-
-
diff --git a/third_party/xsimd/types/xsimd_neon_register.hpp b/third_party/xsimd/types/xsimd_neon_register.hpp
index 43a7db442..67a477d9b 100644
--- a/third_party/xsimd/types/xsimd_neon_register.hpp
+++ b/third_party/xsimd/types/xsimd_neon_register.hpp
@@ -1,19 +1,19 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NEON_REGISTER_HPP
 #define XSIMD_NEON_REGISTER_HPP
 
-#include "xsimd_register.hpp"
 #include "xsimd_generic_arch.hpp"
+#include "xsimd_register.hpp"
 
 #if XSIMD_WITH_NEON
 #include <arm_neon.h>
@@ -28,12 +28,12 @@ namespace xsimd
      */
     struct neon : generic
     {
-        static constexpr bool supported() { return XSIMD_WITH_NEON; }
-        static constexpr bool available() { return true; }
-        static constexpr bool requires_alignment() { return true; }
-        static constexpr std::size_t alignment() { return 16; }
-        static constexpr unsigned version() { return generic::version(7, 0, 0); }
-        static constexpr char const* name() { return "arm32+neon"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_NEON; }
+        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 unsigned version() noexcept { return generic::version(7, 0, 0); }
+        static constexpr char const* name() noexcept { return "arm32+neon"; }
     };
 
 #if XSIMD_WITH_NEON
@@ -73,21 +73,19 @@ namespace xsimd
             };
 
             template <class T>
-            using signed_neon_vector_type = typename neon_vector_type_impl<8*sizeof(T)>::signed_type;
+            using signed_neon_vector_type = typename neon_vector_type_impl<8 * sizeof(T)>::signed_type;
 
             template <class T>
-            using unsigned_neon_vector_type = typename neon_vector_type_impl<8*sizeof(T)>::unsigned_type;
+            using unsigned_neon_vector_type = typename neon_vector_type_impl<8 * sizeof(T)>::unsigned_type;
 
             template <class T>
             using neon_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                              signed_neon_vector_type<T>,
-                                                              unsigned_neon_vector_type<T>
-                                                             >::type;
+                                                               signed_neon_vector_type<T>,
+                                                               unsigned_neon_vector_type<T>>::type;
 
             using char_neon_vector_type = typename std::conditional<std::is_signed<char>::value,
-                                                                   signed_neon_vector_type<char>,
-                                                                   unsigned_neon_vector_type<char>
-                                                                  >::type;
+                                                                    signed_neon_vector_type<char>,
+                                                                    unsigned_neon_vector_type<char>>::type;
         }
 
         XSIMD_DECLARE_SIMD_REGISTER(signed char, neon, detail::neon_vector_type<signed char>);
@@ -103,7 +101,9 @@ namespace xsimd
         XSIMD_DECLARE_SIMD_REGISTER(unsigned long long int, neon, detail::neon_vector_type<unsigned long long int>);
         XSIMD_DECLARE_SIMD_REGISTER(float, neon, float32x4_t);
 
-        struct invalid_register {};
+        struct invalid_register
+        {
+        };
         XSIMD_DECLARE_SIMD_REGISTER(double, neon, invalid_register);
 
         namespace detail
@@ -132,7 +132,7 @@ namespace xsimd
             template <>
             struct get_unsigned_type<8>
             {
-                using type  = uint64_t;
+                using type = uint64_t;
             };
 
             template <size_t S>
@@ -150,11 +150,10 @@ namespace xsimd
             : detail::neon_bool_simd_register<T, neon>
         {
         };
-        
+
     }
 #endif
 
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_register.hpp b/third_party/xsimd/types/xsimd_register.hpp
index 5c9551fa4..f8dd99bb0 100644
--- a/third_party/xsimd/types/xsimd_register.hpp
+++ b/third_party/xsimd/types/xsimd_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_REGISTER_HPP
 #define XSIMD_REGISTER_HPP
@@ -19,8 +19,11 @@ namespace xsimd
     namespace types
     {
 
-        template<class T, class Arch>
-        struct simd_register;
+        template <class T, class Arch>
+        struct simd_register
+        {
+            static_assert(Arch::supported(), "usage of simd_register with unsupported architecture");
+        };
 
         template <class T, class A>
         struct has_simd_register : std::false_type
@@ -28,28 +31,33 @@ namespace xsimd
         };
 
 #define XSIMD_DECLARE_SIMD_REGISTER(SCALAR_TYPE, ISA, VECTOR_TYPE) \
-    template<> \
-    struct simd_register<SCALAR_TYPE, ISA>\
-    {\
-        using register_type = VECTOR_TYPE;\
-        register_type data;\
-        operator register_type() const { return data; }\
-    };\
-    template <>\
-    struct has_simd_register<SCALAR_TYPE, ISA> : std::true_type\
-    {}
+    template <>                                                    \
+    struct simd_register<SCALAR_TYPE, ISA>                         \
+    {                                                              \
+        using register_type = VECTOR_TYPE;                         \
+        register_type data;                                        \
+        operator register_type() const noexcept { return data; }   \
+    };                                                             \
+    template <>                                                    \
+    struct has_simd_register<SCALAR_TYPE, ISA> : std::true_type    \
+    {                                                              \
+    }
 
-#define XSIMD_DECLARE_SIMD_REGISTER_ALIAS(ISA, ISA_BASE)\
-    template<class T> \
-    struct simd_register<T, ISA> : simd_register<T, ISA_BASE>\
-    {\
-        using register_type = typename simd_register<T, ISA_BASE>::register_type;\
-        simd_register(register_type reg) : simd_register<T, ISA_BASE>{reg} {}\
-        simd_register() = default;\
-    };\
-    template<class T>\
-    struct has_simd_register<T, ISA> : has_simd_register<T, ISA_BASE>\
-    {}
+#define XSIMD_DECLARE_SIMD_REGISTER_ALIAS(ISA, ISA_BASE)                          \
+    template <class T>                                                            \
+    struct simd_register<T, ISA> : simd_register<T, ISA_BASE>                     \
+    {                                                                             \
+        using register_type = typename simd_register<T, ISA_BASE>::register_type; \
+        simd_register(register_type reg) noexcept                                 \
+            : simd_register<T, ISA_BASE> { reg }                                  \
+        {                                                                         \
+        }                                                                         \
+        simd_register() = default;                                                \
+    };                                                                            \
+    template <class T>                                                            \
+    struct has_simd_register<T, ISA> : has_simd_register<T, ISA_BASE>             \
+    {                                                                             \
+    }
 
         template <class T, class Arch>
         struct get_bool_simd_register
@@ -65,10 +73,12 @@ namespace xsimd
     {
         // TODO: rename this, as it might conflict with C++20 keyword.
         // We should use add_const and add_reference to build A const&
-        template<class A>
+        template <class A>
         using requires_arch = A const&;
-        template<class T>
-        struct convert {};
+        template <class T>
+        struct convert
+        {
+        };
     }
 }
 
diff --git a/third_party/xsimd/types/xsimd_sse2_register.hpp b/third_party/xsimd/types/xsimd_sse2_register.hpp
index 217541723..60aab8689 100644
--- a/third_party/xsimd/types/xsimd_sse2_register.hpp
+++ b/third_party/xsimd/types/xsimd_sse2_register.hpp
@@ -1,23 +1,23 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE2_REGISTER_HPP
 #define XSIMD_SSE2_REGISTER_HPP
 
-#include "./xsimd_register.hpp"
 #include "./xsimd_generic_arch.hpp"
+#include "./xsimd_register.hpp"
 
 #if XSIMD_WITH_SSE2
-#include <xmmintrin.h>
 #include <emmintrin.h>
+#include <xmmintrin.h>
 #endif
 
 namespace xsimd
@@ -29,12 +29,12 @@ namespace xsimd
      */
     struct sse2 : generic
     {
-        static constexpr bool supported() { return XSIMD_WITH_SSE2; }
-        static constexpr bool available() { return true; }
-        static constexpr bool requires_alignment() { return true; }
-        static constexpr unsigned version() { return generic::version(1, 2, 0); }
-        static constexpr std::size_t alignment() { return 16; }
-        static constexpr char const* name() { return "sse2"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_SSE2; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr bool requires_alignment() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 2, 0); }
+        static constexpr std::size_t alignment() noexcept { return 16; }
+        static constexpr char const* name() noexcept { return "sse2"; }
     };
 
 #if XSIMD_WITH_SSE2
@@ -59,4 +59,3 @@ namespace xsimd
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_sse3_register.hpp b/third_party/xsimd/types/xsimd_sse3_register.hpp
index 928ca8dd1..d8dec5ae4 100644
--- a/third_party/xsimd/types/xsimd_sse3_register.hpp
+++ b/third_party/xsimd/types/xsimd_sse3_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE3_REGISTER_HPP
 #define XSIMD_SSE3_REGISTER_HPP
@@ -27,10 +27,10 @@ namespace xsimd
      */
     struct sse3 : sse2
     {
-        static constexpr bool supported() { return XSIMD_WITH_SSE3; }
-        static constexpr bool available() { return true; }
-        static constexpr unsigned version() { return generic::version(1, 3, 0); }
-        static constexpr char const* name() { return "sse3"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_SSE3; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 3, 0); }
+        static constexpr char const* name() noexcept { return "sse3"; }
     };
 
 #if XSIMD_WITH_SSE3
@@ -43,4 +43,3 @@ namespace xsimd
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_sse4_1_register.hpp b/third_party/xsimd/types/xsimd_sse4_1_register.hpp
index 636b2a2cf..2cf0085b0 100644
--- a/third_party/xsimd/types/xsimd_sse4_1_register.hpp
+++ b/third_party/xsimd/types/xsimd_sse4_1_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE4_1_REGISTER_HPP
 #define XSIMD_SSE4_1_REGISTER_HPP
@@ -27,10 +27,10 @@ namespace xsimd
      */
     struct sse4_1 : ssse3
     {
-        static constexpr bool supported() { return XSIMD_WITH_SSE4_1; }
-        static constexpr bool available() { return true; }
-        static constexpr unsigned version() { return generic::version(1, 4, 1); }
-        static constexpr char const* name() { return "sse4.1"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_SSE4_1; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 4, 1); }
+        static constexpr char const* name() noexcept { return "sse4.1"; }
     };
 
 #if XSIMD_WITH_SSE4_1
diff --git a/third_party/xsimd/types/xsimd_sse4_2_register.hpp b/third_party/xsimd/types/xsimd_sse4_2_register.hpp
index f96275683..10c2fe23c 100644
--- a/third_party/xsimd/types/xsimd_sse4_2_register.hpp
+++ b/third_party/xsimd/types/xsimd_sse4_2_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSE4_2_REGISTER_HPP
 #define XSIMD_SSE4_2_REGISTER_HPP
@@ -27,10 +27,10 @@ namespace xsimd
      */
     struct sse4_2 : sse4_1
     {
-        static constexpr bool supported() { return XSIMD_WITH_SSE4_2; }
-        static constexpr bool available() { return true; }
-        static constexpr unsigned version() { return generic::version(1, 4, 2); }
-        static constexpr char const* name() { return "sse4.2"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_SSE4_2; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 4, 2); }
+        static constexpr char const* name() noexcept { return "sse4.2"; }
     };
 
 #if XSIMD_WITH_SSE4_2
@@ -42,4 +42,3 @@ namespace xsimd
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_ssse3_register.hpp b/third_party/xsimd/types/xsimd_ssse3_register.hpp
index e6d8c2bb0..0f70633bb 100644
--- a/third_party/xsimd/types/xsimd_ssse3_register.hpp
+++ b/third_party/xsimd/types/xsimd_ssse3_register.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SSSE3_REGISTER_HPP
 #define XSIMD_SSSE3_REGISTER_HPP
@@ -27,19 +27,18 @@ namespace xsimd
      */
     struct ssse3 : sse3
     {
-        static constexpr bool supported() { return XSIMD_WITH_SSSE3; }
-        static constexpr bool available() { return true; }
-        static constexpr unsigned version() { return generic::version(1, 3, 1); }
-        static constexpr char const* name() { return "ssse3"; }
+        static constexpr bool supported() noexcept { return XSIMD_WITH_SSSE3; }
+        static constexpr bool available() noexcept { return true; }
+        static constexpr unsigned version() noexcept { return generic::version(1, 3, 1); }
+        static constexpr char const* name() noexcept { return "ssse3"; }
     };
 
 #if XSIMD_WITH_SSSE3
-  namespace types
-  {
-      XSIMD_DECLARE_SIMD_REGISTER_ALIAS(ssse3, sse3);
-  }
+    namespace types
+    {
+        XSIMD_DECLARE_SIMD_REGISTER_ALIAS(ssse3, sse3);
+    }
 #endif
 }
 
 #endif
-
diff --git a/third_party/xsimd/types/xsimd_traits.hpp b/third_party/xsimd/types/xsimd_traits.hpp
index 7b208373f..891eebf2a 100644
--- a/third_party/xsimd/types/xsimd_traits.hpp
+++ b/third_party/xsimd/types/xsimd_traits.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_TRAITS_HPP
 #define XSIMD_TRAITS_HPP
@@ -113,21 +113,7 @@ namespace xsimd
         template <class T1, class T2>
         struct simd_condition
         {
-            static constexpr bool value =
-                (std::is_same<T1, T2>::value && !std::is_same<T1, bool>::value) ||
-                (std::is_same<T1, bool>::value && !std::is_same<T2, bool>::value) ||
-                std::is_same<T1, float>::value ||
-                std::is_same<T1, double>::value ||
-                std::is_same<T1, int8_t>::value ||
-                std::is_same<T1, uint8_t>::value ||
-                std::is_same<T1, int16_t>::value ||
-                std::is_same<T1, uint16_t>::value ||
-                std::is_same<T1, int32_t>::value ||
-                std::is_same<T1, uint32_t>::value ||
-                std::is_same<T1, int64_t>::value ||
-                std::is_same<T1, uint64_t>::value ||
-                std::is_same<T1, char>::value ||
-                detail::is_complex<T1>::value;
+            static constexpr bool value = (std::is_same<T1, T2>::value && !std::is_same<T1, bool>::value) || (std::is_same<T1, bool>::value && !std::is_same<T2, bool>::value) || std::is_same<T1, float>::value || std::is_same<T1, double>::value || std::is_same<T1, int8_t>::value || std::is_same<T1, uint8_t>::value || std::is_same<T1, int16_t>::value || std::is_same<T1, uint16_t>::value || std::is_same<T1, int32_t>::value || std::is_same<T1, uint32_t>::value || std::is_same<T1, int64_t>::value || std::is_same<T1, uint64_t>::value || std::is_same<T1, char>::value || detail::is_complex<T1>::value;
         };
 
         template <class T1, class T2, class A>
diff --git a/third_party/xsimd/types/xsimd_utils.hpp b/third_party/xsimd/types/xsimd_utils.hpp
index 87f6afccb..7014f64ae 100644
--- a/third_party/xsimd/types/xsimd_utils.hpp
+++ b/third_party/xsimd/types/xsimd_utils.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_UTILS_HPP
 #define XSIMD_UTILS_HPP
@@ -177,18 +177,18 @@ namespace xsimd
      * bit_cast *
      ********************/
 
-    template<class To, class From>
-    To bit_cast(From val) {
-      static_assert(sizeof(From) == sizeof(To), "casting between compatible layout");
-      // FIXME: Some old version of GCC don't support that trait
-      //static_assert(std::is_trivially_copyable<From>::value, "input type is trivially copyable");
-      //static_assert(std::is_trivially_copyable<To>::value, "output type is trivially copyable");
-      To res;
-      std::memcpy(&res, &val, sizeof(val));
-      return res;
+    template <class To, class From>
+    inline To bit_cast(From val) noexcept
+    {
+        static_assert(sizeof(From) == sizeof(To), "casting between compatible layout");
+        // FIXME: Some old version of GCC don't support that trait
+        // static_assert(std::is_trivially_copyable<From>::value, "input type is trivially copyable");
+        // static_assert(std::is_trivially_copyable<To>::value, "output type is trivially copyable");
+        To res;
+        std::memcpy(&res, &val, sizeof(val));
+        return res;
     }
 
-
     /*****************************************
      * Backport of index_sequence from c++14 *
      *****************************************/
@@ -197,68 +197,78 @@ namespace xsimd
     namespace detail
     {
         template <typename T>
-        struct identity { using type = T; };
-
-        #ifdef __cpp_lib_integer_sequence
-            using std::integer_sequence;
-            using std::make_integer_sequence;
-            using std::index_sequence;
-            using std::make_index_sequence;
-
-            using std::index_sequence_for;
-        #else
-            template <typename T, T... Is>
-            struct integer_sequence {
-              using value_type = T;
-              static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-            };
+        struct identity
+        {
+            using type = T;
+        };
 
-            template <typename Lhs, typename Rhs>
-            struct make_integer_sequence_concat;
+#ifdef __cpp_lib_integer_sequence
+        using std::index_sequence;
+        using std::integer_sequence;
+        using std::make_index_sequence;
+        using std::make_integer_sequence;
 
-            template <typename T, T... Lhs, T... Rhs>
-            struct make_integer_sequence_concat<integer_sequence<T, Lhs...>,
-                                                integer_sequence<T, Rhs...>>
-              : identity<integer_sequence<T, Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
+        using std::index_sequence_for;
+#else
+        template <typename T, T... Is>
+        struct integer_sequence
+        {
+            using value_type = T;
+            static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+        };
 
-            template <typename T>
-            struct make_integer_sequence_impl;
+        template <typename Lhs, typename Rhs>
+        struct make_integer_sequence_concat;
 
-            template <typename T>
-            struct make_integer_sequence_impl<std::integral_constant<T, (T)0>> : identity<integer_sequence<T>> {};
+        template <typename T, T... Lhs, T... Rhs>
+        struct make_integer_sequence_concat<integer_sequence<T, Lhs...>,
+                                            integer_sequence<T, Rhs...>>
+            : identity<integer_sequence<T, Lhs..., (sizeof...(Lhs) + Rhs)...>>
+        {
+        };
 
-            template <typename T>
-            struct make_integer_sequence_impl<std::integral_constant<T, (T)1>> : identity<integer_sequence<T, 0>> {};
+        template <typename T>
+        struct make_integer_sequence_impl;
 
-            template <typename T, T N>
-            struct make_integer_sequence_impl<std::integral_constant<T, N>>
-              : make_integer_sequence_concat<typename make_integer_sequence_impl<std::integral_constant<T, N / 2>>::type,
-                                             typename make_integer_sequence_impl<std::integral_constant<T, N - (N / 2)>>::type> {};
+        template <typename T>
+        struct make_integer_sequence_impl<std::integral_constant<T, (T)0>> : identity<integer_sequence<T>>
+        {
+        };
 
+        template <typename T>
+        struct make_integer_sequence_impl<std::integral_constant<T, (T)1>> : identity<integer_sequence<T, 0>>
+        {
+        };
 
-            template <typename T, T N>
-            using make_integer_sequence = typename make_integer_sequence_impl<std::integral_constant<T, N>>::type;
+        template <typename T, T N>
+        struct make_integer_sequence_impl<std::integral_constant<T, N>>
+            : make_integer_sequence_concat<typename make_integer_sequence_impl<std::integral_constant<T, N / 2>>::type,
+                                           typename make_integer_sequence_impl<std::integral_constant<T, N - (N / 2)>>::type>
+        {
+        };
 
+        template <typename T, T N>
+        using make_integer_sequence = typename make_integer_sequence_impl<std::integral_constant<T, N>>::type;
 
-            template <std::size_t... Is>
-            using index_sequence = integer_sequence<std::size_t, Is...>;
+        template <std::size_t... Is>
+        using index_sequence = integer_sequence<std::size_t, Is...>;
 
-            template <std::size_t N>
-            using make_index_sequence = make_integer_sequence<std::size_t, N>;
+        template <std::size_t N>
+        using make_index_sequence = make_integer_sequence<std::size_t, N>;
 
-            template <typename... Ts>
-            using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+        template <typename... Ts>
+        using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 
-        #endif
+#endif
 
-          template <int... Is>
-          using int_sequence = integer_sequence<int, Is...>;
+        template <int... Is>
+        using int_sequence = integer_sequence<int, Is...>;
 
-          template <int N>
-          using make_int_sequence = make_integer_sequence<int, N>;
+        template <int N>
+        using make_int_sequence = make_integer_sequence<int, N>;
 
-          template <typename... Ts>
-          using int_sequence_for = make_int_sequence<sizeof...(Ts)>;
+        template <typename... Ts>
+        using int_sequence_for = make_int_sequence<sizeof...(Ts)>;
 
     }
 
@@ -269,20 +279,20 @@ namespace xsimd
     namespace detail
     {
         template <class T, class... Types, size_t I, size_t... Is>
-        const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, T>, index_sequence<I, Is...>)
+        inline const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, T>, index_sequence<I, Is...>) noexcept
         {
             return std::get<I>(t);
         }
 
         template <class T, class U, class... Types, size_t I, size_t... Is>
-        const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, U>, index_sequence<I, Is...>)
+        inline const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, U>, index_sequence<I, Is...>) noexcept
         {
-            using tuple_elem = typename std::tuple_element<I+1, std::tuple<Types...>>::type;
+            using tuple_elem = typename std::tuple_element<I + 1, std::tuple<Types...>>::type;
             return get_impl<T>(t, std::is_same<T, tuple_elem>(), index_sequence<Is...>());
         }
 
         template <class T, class... Types>
-        const T& get(const std::tuple<Types...>& t)
+        inline const T& get(const std::tuple<Types...>& t) noexcept
         {
             using tuple_elem = typename std::tuple_element<0, std::tuple<Types...>>::type;
             return get_impl<T>(t, std::is_same<T, tuple_elem>(), make_index_sequence<sizeof...(Types)>());
@@ -329,32 +339,32 @@ namespace xsimd
     {
         // std::array constructor from scalar value ("broadcast")
         template <typename T, std::size_t... Is>
-        constexpr std::array<T, sizeof...(Is)>
-        array_from_scalar_impl(const T& scalar, index_sequence<Is...>)
+        inline constexpr std::array<T, sizeof...(Is)>
+        array_from_scalar_impl(const T& scalar, index_sequence<Is...>) noexcept
         {
             // You can safely ignore this silly ternary, the "scalar" is all
             // that matters. The rest is just a dirty workaround...
-            return std::array<T, sizeof...(Is)>{ (Is+1) ? scalar : T() ... };
+            return std::array<T, sizeof...(Is)> { (Is + 1) ? scalar : T()... };
         }
 
         template <typename T, std::size_t N>
-        constexpr std::array<T, N>
-        array_from_scalar(const T& scalar)
+        inline constexpr std::array<T, N>
+        array_from_scalar(const T& scalar) noexcept
         {
             return array_from_scalar_impl(scalar, make_index_sequence<N>());
         }
 
         // std::array constructor from C-style pointer (handled as an array)
         template <typename T, std::size_t... Is>
-        constexpr std::array<T, sizeof...(Is)>
-        array_from_pointer_impl(const T* c_array, index_sequence<Is...>)
+        inline constexpr std::array<T, sizeof...(Is)>
+        array_from_pointer_impl(const T* c_array, index_sequence<Is...>) noexcept
         {
-            return std::array<T, sizeof...(Is)>{ c_array[Is]... };
+            return std::array<T, sizeof...(Is)> { c_array[Is]... };
         }
 
         template <typename T, std::size_t N>
-        constexpr std::array<T, N>
-        array_from_pointer(const T* c_array)
+        inline constexpr std::array<T, N>
+        array_from_pointer(const T* c_array) noexcept
         {
             return array_from_pointer_impl(c_array, make_index_sequence<N>());
         }
@@ -366,20 +376,19 @@ namespace xsimd
 
     namespace detail
     {
-        template <bool...> struct bool_pack;
+        template <bool...>
+        struct bool_pack;
 
         template <bool... bs>
         using all_true = std::is_same<
-            bool_pack<bs..., true>, bool_pack<true, bs...>
-        >;
+            bool_pack<bs..., true>, bool_pack<true, bs...>>;
 
         template <typename T, typename... Args>
         using is_all_convertible = all_true<std::is_convertible<Args, T>::value...>;
 
         template <typename T, std::size_t N, typename... Args>
         using is_array_initializer = std::enable_if<
-            (sizeof...(Args) == N) && is_all_convertible<T, Args...>::value
-        >;
+            (sizeof...(Args) == N) && is_all_convertible<T, Args...>::value>;
 
         // Check that a variadic argument pack is a list of N values of type T,
         // as usable for instantiating a value of type std::array<T, N>.
@@ -416,7 +425,46 @@ namespace xsimd
         };
 #endif
     }
+
+    /*******************
+     * real_batch_type *
+     *******************/
+
+    template <class B>
+    struct real_batch_type
+    {
+        using type = B;
+    };
+
+    template <class T, class A>
+    struct real_batch_type<batch<std::complex<T>, A>>
+    {
+        using type = batch<T, A>;
+    };
+
+    template <class B>
+    using real_batch_type_t = typename real_batch_type<B>::type;
+
+    /**********************
+     * complex_batch_type *
+     **********************/
+
+    template <class B>
+    struct complex_batch_type
+    {
+        using real_value_type = typename B::value_type;
+        using arch_type = typename B::arch_type;
+        using type = batch<std::complex<real_value_type>, arch_type>;
+    };
+
+    template <class T, class A>
+    struct complex_batch_type<batch<std::complex<T>, A>>
+    {
+        using type = batch<std::complex<T>, A>;
+    };
+
+    template <class B>
+    using complex_batch_type_t = typename complex_batch_type<B>::type;
 }
 
 #endif
-
diff --git a/third_party/xsimd/xsimd.hpp b/third_party/xsimd/xsimd.hpp
index 12ff609ad..79bdd03d5 100644
--- a/third_party/xsimd/xsimd.hpp
+++ b/third_party/xsimd/xsimd.hpp
@@ -1,13 +1,13 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_HPP
 #define XSIMD_HPP
@@ -18,11 +18,19 @@
 #define XSIMD_NO_DISCARD
 #endif
 
+#include "config/xsimd_config.hpp"
 
-#include "types/xsimd_batch.hpp"
-#include "types/xsimd_batch_constant.hpp"
-#include "types/xsimd_api.hpp"
 #include "arch/xsimd_scalar.hpp"
 #include "memory/xsimd_aligned_allocator.hpp"
+
+#if defined(XSIMD_NO_SUPPORTED_ARCHITECTURE)
+// to type definition or anything appart from scalar definition and aligned allocator
+#else
+#include "types/xsimd_batch.hpp"
+#include "types/xsimd_batch_constant.hpp"
 #include "types/xsimd_traits.hpp"
+
+// This include must come last
+#include "types/xsimd_api.hpp"
+#endif
 #endif