react-native-executorch 0.10.5 → 0.10.7

package/third-party/common/phonemis/src/third-party/xsimd/arch/common/xsimd_common_bit.hpp

@@ -0,0 +1,232 @@
+/****************************************************************
+ * Partial backport of `__cpp_lib_bitops == 201907L` from C++20 *
+ ****************************************************************/
+
+#ifndef XSIMD_BIT_HPP
+#define XSIMD_BIT_HPP
+
+#include "../../config/xsimd_config.hpp"
+
+#if XSIMD_CPP_VERSION > 202002L
+
+#include <version>
+
+#if __cpp_lib_bitops >= 201907L
+
+#include <bit>
+
+namespace xsimd
+{
+    namespace detail
+    {
+        using std::countl_one;
+        using std::countl_zero;
+        using std::countr_one;
+        using std::countr_zero;
+        using std::popcount;
+    }
+}
+
+#endif
+
+#else
+
+#include <climits>
+#include <type_traits>
+
+#ifdef __has_builtin
+#define XSIMD_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define XSIMD_HAS_BUILTIN(x) 0
+#endif
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace xsimd
+{
+    namespace detail
+    {
+        // FIXME: We could do better by dispatching to the appropriate popcount instruction
+        // depending on the arch.
+
+        template <class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
+        XSIMD_INLINE int popcount(T x) noexcept
+        {
+#if XSIMD_HAS_BUILTIN(__builtin_popcountg)
+            return __builtin_popcountg(x);
+#else
+            XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
+            {
+#if XSIMD_HAS_BUILTIN(__builtin_popcount)
+                return __builtin_popcount(x);
+#elif defined(_MSC_VER)
+                return __popcnt(x);
+#else
+                // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSet64
+                return ((uint64_t)x * 0x200040008001ULL & 0x111111111111111ULL) % 0xf;
+#endif
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
+            {
+#if XSIMD_HAS_BUILTIN(__builtin_popcount)
+                return __builtin_popcount(x);
+#elif defined(_MSC_VER)
+                return __popcnt16(x);
+#else
+                // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSet64
+                constexpr unsigned long long msb12 = 0x1001001001001ULL;
+                constexpr unsigned long long mask5 = 0x84210842108421ULL;
+
+                unsigned int v = (unsigned int)x;
+
+                return ((v & 0xfff) * msb12 & mask5) % 0x1f
+                    + (((v & 0xfff000) >> 12) * msb12 & mask5) % 0x1f;
+#endif
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
+            {
+#if XSIMD_HAS_BUILTIN(__builtin_popcount)
+                return __builtin_popcount(x);
+#elif defined(_MSC_VER)
+                return __popcnt(x);
+#else
+                // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+                x = x - ((x >> 1) & (T) ~(T)0 / 3);
+                x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3);
+                x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15;
+                return (x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * CHAR_BIT;
+#endif
+            }
+            else
+            {
+                // sizeof(T) == 8
+#if XSIMD_HAS_BUILTIN(__builtin_popcountll)
+                return __builtin_popcountll(x);
+#elif XSIMD_HAS_BUILTIN(__builtin_popcount)
+                return __builtin_popcount((unsigned int)x) + __builtin_popcount((unsigned int)(x >> 32));
+#elif defined(_MSC_VER)
+#ifdef _M_X64
+                return (int)__popcnt64(x);
+#else
+                return (int)(__popcnt((unsigned int)x) + __popcnt((unsigned int)(x >> 32)));
+#endif
+#else
+                // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+                x = x - ((x >> 1) & (T) ~(T)0 / 3);
+                x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3);
+                x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15;
+                return (x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * CHAR_BIT;
+#endif
+            }
+#endif
+        }
+
+        template <class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
+        XSIMD_INLINE int countl_zero(T x) noexcept
+        {
+#if XSIMD_HAS_BUILTIN(__builtin_clzg)
+            return __builtin_clzg(x, (int)(sizeof(T) * CHAR_BIT));
+#else
+            if (x == 0)
+                return sizeof(T) * CHAR_BIT;
+
+            XSIMD_IF_CONSTEXPR(sizeof(T) <= 4)
+            {
+#if XSIMD_HAS_BUILTIN(__builtin_clz)
+                return __builtin_clz((unsigned int)x) - (4 - sizeof(T)) * CHAR_BIT;
+#elif defined(_MSC_VER)
+                unsigned long index;
+                _BitScanReverse(&index, (unsigned long)x);
+                return sizeof(T) * CHAR_BIT - index - 1;
+#else
+                x |= x >> 1;
+                x |= x >> 2;
+                x |= x >> 4;
+                XSIMD_IF_CONSTEXPR(sizeof(T) >= 2)
+                {
+                    x |= x >> 8;
+                }
+                XSIMD_IF_CONSTEXPR(sizeof(T) >= 4)
+                {
+                    x |= x >> 16;
+                }
+                return sizeof(T) * CHAR_BIT - popcount(x);
+#endif
+            }
+            else
+            {
+                // sizeof(T) == 8
+#if XSIMD_HAS_BUILTIN(__builtin_clzll)
+                return __builtin_clzll((unsigned long long)x);
+#elif defined(_MSC_VER) && defined(_M_X64)
+                unsigned long index;
+                _BitScanReverse64(&index, (unsigned long long)x);
+                return sizeof(T) * CHAR_BIT - index - 1;
+#else
+                x |= x >> 1;
+                x |= x >> 2;
+                x |= x >> 4;
+                x |= x >> 8;
+                x |= x >> 16;
+                x |= x >> 32;
+                return sizeof(T) * CHAR_BIT - popcount(x);
+#endif
+            }
+#endif
+        }
+
+        template <class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
+        XSIMD_INLINE int countl_one(T x) noexcept
+        {
+            return countl_zero(T(~x));
+        }
+
+        template <class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
+        XSIMD_INLINE int countr_zero(T x) noexcept
+        {
+#if XSIMD_HAS_BUILTIN(__builtin_ctzg)
+            return __builtin_ctzg(x, (int)(sizeof(T) * CHAR_BIT));
+#else
+            if (x == 0)
+                return sizeof(T) * CHAR_BIT;
+
+            XSIMD_IF_CONSTEXPR(sizeof(T) <= 4)
+            {
+#if XSIMD_HAS_BUILTIN(__builtin_ctz)
+                return __builtin_ctz((unsigned int)x);
+#elif defined(_MSC_VER)
+                unsigned long index;
+                _BitScanForward(&index, (unsigned long)x);
+                return index;
+#endif
+            }
+            else
+            {
+                // sizeof(T) == 8
+#if XSIMD_HAS_BUILTIN(__builtin_ctzll)
+                return __builtin_ctzll((unsigned long long)x);
+#elif defined(_MSC_VER) && defined(_M_X64)
+                unsigned long index;
+                _BitScanForward64(&index, (unsigned long long)x);
+                return index;
+#endif
+            }
+
+            // https://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightMultLookup
+            return popcount((T)((x & -x) - 1));
+#endif
+        }
+
+        template <class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
+        XSIMD_INLINE int countr_one(T x) noexcept
+        {
+            return countr_zero(T(~x));
+        }
+
+    }
+}
+
+#endif
+#endif

package/third-party/common/phonemis/src/third-party/xsimd/arch/common/xsimd_common_cast.hpp

@@ -0,0 +1,43 @@
+/***************************************************************************
+ * 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_COMMON_CAST_HPP
+#define XSIMD_COMMON_CAST_HPP
+
+#include <array>
+
+#include "../../config/xsimd_macros.hpp"
+#include "../../utils/xsimd_type_traits.hpp"
+
+namespace xsimd
+{
+    namespace kernel
+    {
+        template <class A, class T>
+        XSIMD_INLINE std::array<batch<widen_t<T>, A>, 2> widen(batch<T, A> const& x, requires_arch<common>) noexcept
+        {
+            alignas(A::alignment()) T buffer[batch<T, A>::size];
+            x.store_aligned(&buffer[0]);
+
+            using T_out = widen_t<T>;
+            alignas(A::alignment()) T_out out_buffer[batch<T, A>::size];
+            for (size_t i = 0; i < batch<T, A>::size; ++i)
+                out_buffer[i] = static_cast<T_out>(buffer[i]);
+
+            return { batch<T_out, A>::load_aligned(&out_buffer[0]),
+                     batch<T_out, A>::load_aligned(&out_buffer[batch<T_out, A>::size]) };
+        }
+
+    }
+
+}
+
+#endif

package/third-party/common/phonemis/src/third-party/xsimd/arch/common/xsimd_common_complex.hpp

@@ -0,0 +1,112 @@
+/***************************************************************************
+ * 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_COMMON_COMPLEX_HPP
+#define XSIMD_COMMON_COMPLEX_HPP
+
+#include <complex>
+
+#include "./xsimd_common_details.hpp"
+
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // real
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> real(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return self;
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> real(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            return self.real();
+        }
+
+        // imag
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> imag(batch<T, A> const& /*self*/, requires_arch<common>) noexcept
+        {
+            return batch<T, A>(T(0));
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> imag(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            return self.imag();
+        }
+
+        // arg
+        template <class A, class T>
+        XSIMD_INLINE real_batch_type_t<batch<T, A>> arg(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return atan2(imag(self), real(self));
+        }
+
+        // conj
+        template <class A, class T>
+        XSIMD_INLINE complex_batch_type_t<batch<T, A>> conj(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return { real(self), -imag(self) };
+        }
+
+        // norm
+        template <class A, class T>
+        XSIMD_INLINE real_batch_type_t<batch<T, A>> norm(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return { fma(real(self), real(self), imag(self) * imag(self)) };
+        }
+
+        // proj
+        template <class A, class T>
+        XSIMD_INLINE complex_batch_type_t<batch<T, A>> proj(batch<T, A> const& self, requires_arch<common>) 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;
+#ifdef __FAST_MATH__
+            return { self };
+#else
+            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));
+#endif
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE batch_bool<T, A> isnan(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            return batch_bool<T, A>(isnan(self.real()) || isnan(self.imag()));
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE batch_bool<T, A> isinf(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            return batch_bool<T, A>(isinf(self.real()) || isinf(self.imag()));
+        }
+
+        template <class A, class T>
+        XSIMD_INLINE batch_bool<T, A> isfinite(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
+        {
+            return batch_bool<T, A>(isfinite(self.real()) && isfinite(self.imag()));
+        }
+    }
+}
+
+#endif