react-native-executorch 0.10.5 → 0.10.7

package/third-party/common/phonemis/src/phonemis/protophone/tensor_utils.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "types.h"
+#include <third-party/xsimd/xsimd.hpp>
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// Forward declarations
+namespace phonemis::protophone {
+  template <typename T> class Tensor;
+  template <typename T> class TensorView;
+}
+
+namespace phonemis::protophone::utils {
+
+/**
+ * Calculates strides (from scratch) for given tensor shape.
+ * @param shape a tensor shape to calculate stride for
+ */
+inline std::vector<size_t> compute_strides(const std::vector<size_t>& shape) {
+  if (shape.empty()) return {};
+
+  std::vector<size_t> strides(shape.size());
+
+  size_t stride = 1;
+  for (int i = static_cast<int>(shape.size()) - 1; i >= 0; --i) {
+    strides[i] = stride;
+    stride *= shape[i];
+  }
+
+  return strides;
+}
+
+/**
+ * Reorganizes the data pointed to by a TensorView in-place to match canonical row-major strides.
+ * Generic implementation for any rank R that uses a temporary buffer.
+ * 
+ * @tparam T The data type of the tensor elements.
+ * @param view The view to repack in-place.
+ */
+template <typename T>
+inline void repack(TensorView<T>& view) {
+  const auto& shape = view.shape();
+  const auto& old_strides = view.strides();
+  const T* view_data = view.data() + view.offset();
+
+  std::vector<size_t> new_strides = compute_strides(shape);
+  size_t total_size = view.size();
+  
+  std::vector<T, xsimd::default_allocator<T>> buffer(total_size);
+  
+  for (size_t i = 0; i < total_size; ++i) {
+    size_t offset = 0;
+    size_t remaining = i;
+    for (size_t d = 0; d < shape.size(); ++d) {
+      size_t idx = remaining / new_strides[d];
+      remaining %= new_strides[d];
+      offset += idx * old_strides[d];
+    }
+    buffer[i] = view_data[offset];
+  }
+
+  T* dest = view.data() + view.offset();
+  std::ranges::copy(buffer, dest);
+
+  // Update view metadata to reflect canonical strides
+  view.strides_ = std::move(new_strides);
+}
+
+/**
+ * Reorganizes the data of the input Tensor in-place to match canonical row-major strides.
+ * After this operation, the physical memory layout will be contiguous.
+ * 
+ * @tparam T The data type of the tensor elements.
+ * @param tensor The tensor to be repacked in-place.
+ */
+template <typename T>
+inline void repack(Tensor<T>& tensor) {
+  auto v = tensor.view();
+  repack<T>(v);
+  
+  // Update tensor metadata to reflect canonical strides
+  tensor.strides_ = v.strides();
+}
+
+} // namespace phonemis::protophone

package/third-party/common/phonemis/src/phonemis/protophone/tensor_view.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include "meta.h"
+#include "numeric.h"
+#include "tensor_utils.h"
+#include "types.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <numeric>
+#include <stdexcept>
+#include <variant>
+#include <vector>
+
+namespace phonemis::protophone {
+
+/**
+ * A non-owning view into a Tensor or a subset of its data.
+ * Facilitates slicing and zero-copy operations.
+ */
+template <typename T>
+class TensorView {
+public:
+  TensorView(T* data, std::vector<size_t> shape, std::vector<size_t> strides, size_t offset = 0)
+      : data_(data), shape_(std::move(shape)), strides_(std::move(strides)), offset_(offset) {}
+
+  // Simple accessors
+  T* data() { return data_; }
+  const T* data() const { return data_; }
+  const std::vector<size_t>& shape() const { return shape_; }
+  const std::vector<size_t>& strides() const { return strides_; }
+  size_t offset() const { return offset_; }
+  size_t size() const { return !shape_.empty() ? numeric::product(shape_) : 0; }
+
+  /**
+   * Returns a reshaped view with the same data.
+   * @param new_shape The desired dimensions.
+   * @return A new TensorView with the updated shape.
+   * @throws std::invalid_argument if the new shape is incompatible with the total size.
+   */
+  TensorView reshape(std::vector<size_t> new_shape) const {
+    if (numeric::product(shape_) != numeric::product(new_shape)) {
+      throw std::invalid_argument("New shape must have the same total size as the original.");
+    }
+
+    // Logic for stride calculation in a reshaped view (assuming row-major linearized data)
+    std::vector<size_t> new_strides = utils::compute_strides(new_shape);
+
+    return TensorView(data_, std::move(new_shape), std::move(new_strides), offset_);
+  }
+
+  /**
+   * Returns a sliced view along multiple dimensions.
+   * Supports both single index and Range<size_t> slicing.
+   * @param args Pack of variants (size_t or Range<size_t>) for each dimension.
+   *             A single size_t value corresponds to an index lookup (reduces dimensionality),
+   *             while a Range<size_t> corresponds to range slicing (preserves dimensionality).
+   * @return A new TensorView representing the sub-region.
+   */
+  template <typename... Args>
+  TensorView slice(Args... args) const {
+    // Aggregate all slices in iterable structure
+    std::vector<std::variant<size_t, Range<size_t>, All>> slices = {
+      meta::to_slice_variant(args)...
+    };
+    
+    std::vector<size_t> new_shape;
+    std::vector<size_t> new_strides;
+    size_t new_offset = offset_;
+
+    for (size_t i = 0; i < slices.size(); ++i) {
+      if (std::holds_alternative<size_t>(slices[i])) {
+        size_t idx = std::get<size_t>(slices[i]);
+        new_offset += strides_[i] * idx;
+      } else if (std::holds_alternative<All>(slices[i])) {
+        new_shape.push_back(shape_[i]);
+        new_strides.push_back(strides_[i]);
+      } else {
+        Range<size_t> range = std::get<Range<size_t>>(slices[i]);
+        new_offset += strides_[i] * range.begin;
+        new_shape.push_back(range.end - range.begin);
+        new_strides.push_back(strides_[i]);
+      }
+    }
+
+    // Add remaining dimensions that weren't sliced
+    for (size_t i = slices.size(); i < shape_.size(); ++i) {
+      new_shape.push_back(shape_[i]);
+      new_strides.push_back(strides_[i]);
+    }
+
+    return TensorView(data_, std::move(new_shape), std::move(new_strides), new_offset);
+  }
+
+  /**
+   * Returns a transposed view by swapping two dimensions.
+   * @param dim0 First dimension to swap.
+   * @param dim1 Second dimension to swap.
+   * @return A new TensorView with swapped shape and strides.
+   */
+  TensorView transpose(size_t dim0 = 0, size_t dim1 = 1) const {
+    std::vector<size_t> new_shape = shape_;
+    std::vector<size_t> new_strides = strides_;
+    
+    std::swap(new_shape[dim0], new_shape[dim1]);
+    std::swap(new_strides[dim0], new_strides[dim1]);
+
+    return TensorView(data_, std::move(new_shape), std::move(new_strides), offset_);
+  }
+
+private:
+  // Friends declarations
+  template <typename U>
+  friend void utils::repack(TensorView<U>& view);
+
+  // Pointer to the original data buffer (non-owning)
+  T* data_;
+
+  // View metadata
+  std::vector<size_t> shape_;
+  std::vector<size_t> strides_;
+  size_t offset_;
+};
+
+} // namespace phonemis::protophone

package/third-party/common/phonemis/src/phonemis/protophone/types.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstdint>
+
+namespace phonemis::protophone {
+
+// Forward declarations
+template <typename T> class Tensor;
+
+/**
+ * General type definitions for custom neural inference.
+ */
+using Float = float;
+using Long = int64_t;
+
+/**
+ * Placeholder type for 'Entire range' semantic.
+ */
+struct All {};
+
+/**
+ * Defines a pair of indices (i, j), which logicaly corresponds to a range
+ * i, i + 1, i + 2, ..., j - 2, j - 1.
+ */
+template <typename T>
+struct Range {
+  T begin;
+  T end;
+
+  // Convenient alias for the global All type.
+  using ALL = All;
+};
+
+/**
+ * Defines weights of an affine transormation Wx + b.
+ */
+template <typename T>
+struct Weights {
+  Tensor<T> weight;
+  Tensor<T> bias;
+};
+
+} // namespace phonemis::protophone

package/third-party/common/phonemis/src/phonemis/utils/strings.h

@@ -33,8 +33,7 @@ inline bool is_alpha(const StringT& str) {
 	using std::isalpha;
 	using unicode::isalpha;
 
-	return std::all_of(str.cbegin(), str.cend(), 
-										 [](auto c) -> bool { return isalpha(c); });
+	return std::ranges::all_of(str, [](auto c) -> bool { return isalpha(c); });
 }
 
 /**
@@ -47,8 +46,7 @@ inline bool is_all_lower(const StringT& str) {
 	using std::islower;
 	using unicode::islower;
 
-	return std::all_of(str.cbegin(), str.cend(), 
-										 [](auto c) -> bool { return islower(c); });
+	return std::ranges::all_of(str, [](auto c) -> bool { return islower(c); });
 }
 
 /**
@@ -61,8 +59,7 @@ inline bool is_all_upper(const StringT& str) {
 	using std::isupper;
 	using unicode::isupper;
 
-	return std::all_of(str.cbegin(), str.cend(), 
-										 [](auto c) -> bool { return isupper(c); });
+	return std::ranges::all_of(str, [](auto c) -> bool { return isupper(c); });
 }
 
 /**
@@ -91,6 +88,17 @@ inline bool starts_with(const StringT1& str, const PrefixT& prefix) {
 				 str.substr(0, prefix_view.size()) == prefix_view;
 }
 
+/**
+ * Checks if given string contains a given character.
+ * @param str The string to check.
+ * @param c The character to look for.
+ * @return True if c occurs in str.
+ */
+template <typename StringT, typename CharT>
+inline bool contains(const StringT& str, CharT c) {
+  return std::ranges::find(str, c) != std::ranges::end(str);
+}
+
 
 // --------------------------------------------
 // ----- Lower/Upper case transformations -----
@@ -135,8 +143,7 @@ inline void to_lower__(StringT& str) {
 	using std::tolower;
 	using unicode::tolower;
 
-	std::transform(str.cbegin(), str.cend(), str.begin(), 
-								 [](auto c) { return tolower(c); });
+	std::ranges::transform(str, str.begin(), [](auto c) { return tolower(c); });
 }
 
 /**
@@ -148,8 +155,7 @@ inline void to_upper__(StringT& str) {
 	using std::toupper;
 	using unicode::toupper;
 
-	std::transform(str.cbegin(), str.cend(), str.begin(),
-								 [](auto c) { return toupper(c); });
+	std::ranges::transform(str, str.begin(), [](auto c) { return toupper(c); });
 }
 
 
@@ -165,7 +171,7 @@ inline void to_upper__(StringT& str) {
  */
 template <typename StringT, typename Pred>
 inline void filter__(StringT& str, Pred pred) {
-	str.erase(std::remove_if(str.begin(), str.end(), pred), str.end());
+	str.erase(std::ranges::remove_if(str, pred).begin(), str.end());
 }
 
 /**
@@ -176,7 +182,7 @@ inline void filter__(StringT& str, Pred pred) {
  */
 template <typename StringT, typename CharT>
 inline void replace__(StringT& str, CharT a, CharT b) {
-	std::replace(str.begin(), str.end(), a, b);
+	std::ranges::replace(str, a, b);
 }
 
 /**
@@ -186,7 +192,7 @@ inline void replace__(StringT& str, CharT a, CharT b) {
  */
 template <typename StringT, typename CharT>
 inline void remove__(StringT& str, CharT a) {
-	str.erase(std::remove(str.begin(), str.end(), a), str.end());
+	str.erase(std::ranges::remove(str, a).begin(), str.end());
 }
 
 /**
@@ -200,7 +206,7 @@ inline StringT strip(const StringT& str, std::optional<CharT> c = std::nullopt)
 	using std::isspace;
 	using unicode::isspace;
 
-	auto lbound = std::find_if(str.cbegin(), str.cend(), 
+	auto lbound = std::find_if(str.cbegin(), str.cend(),
 														 [&c](CharT a) -> bool { return c.has_value() ? a != c : !isspace(a); });
 	auto rbound = std::find_if(str.crbegin(), str.crend(),
 														 [&c](CharT a) -> bool { return c.has_value() ? a != c : !isspace(a); });

package/third-party/common/phonemis/src/phonemis/utils/unicode.h

@@ -16,6 +16,12 @@ constexpr inline bool is_ascii(char32_t c) {
   return (c & ~0x7F) == 0;
 }
 
+// A Latin letter, accented ones included
+constexpr inline bool is_latin(char32_t c) {
+  return (c >= U'A' && c <= U'Z') || (c >= U'a' && c <= U'z') || (c >= U'À' && c <= U'Ö') || (c >= U'Ø' && c <= U'ö') ||
+         (c >= U'ø' && c <= U'ɏ');
+}
+
 constexpr inline bool isalpha(char32_t c) {
   return (c < kLutSize) ? kUnicodeLut[c].is_alpha : false;
 }
@@ -28,8 +34,16 @@ constexpr inline bool isalnum(char32_t c) {
   return isalpha(c) || isdigit(c);
 }
 
+// A letter, a digit or "_": a word character of a regex (\w)
+constexpr inline bool isword(char32_t c) {
+  return isalnum(c) || c == U'_';
+}
+
+// Also the Unicode spaces: no-break, thin (14 h 20), ideographic, ...
 constexpr inline bool isspace(char32_t c) {
-  return is_ascii(c) && std::isspace(static_cast<unsigned char>(c));
+  return (is_ascii(c) && std::isspace(static_cast<unsigned char>(c))) || c == U'\u0085' || c == U'\u00a0' ||
+         c == U'\u1680' || (c >= U'\u2000' && c <= U'\u200a') || c == U'\u2028' || c == U'\u2029' || c == U'\u202f' ||
+         c == U'\u205f' || c == U'\u3000';
 }
 
 constexpr inline bool islower(char32_t c) {

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

@@ -0,0 +1,267 @@
+/***************************************************************************
+ * 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_ARITHMETIC_HPP
+#define XSIMD_COMMON_ARITHMETIC_HPP
+
+#include <complex>
+#include <limits>
+#include <type_traits>
+
+#include "../../types/xsimd_batch_constant.hpp"
+#include "./xsimd_common_details.hpp"
+
+namespace xsimd
+{
+
+    namespace kernel
+    {
+
+        using namespace types;
+
+        // bitwise_lshift
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x << y; },
+                                 self, other);
+        }
+        template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            static_assert(shift < bits, "Shift must be less than the number of bits in T");
+            return bitwise_lshift(self, shift, A {});
+        }
+
+        // bitwise_rshift
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept
+                                 { return x >> y; },
+                                 self, other);
+        }
+        template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            static_assert(shift < bits, "Shift must be less than the number of bits in T");
+            return bitwise_rshift(self, shift, A {});
+        }
+
+        // decr
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> decr(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return self - T(1);
+        }
+
+        // decr_if
+        template <class A, class T, class Mask>
+        XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept
+        {
+            return select(mask, decr(self), self);
+        }
+
+        // div
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
+        XSIMD_INLINE batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept -> T
+                                 { return x / y; },
+                                 self, other);
+        }
+
+        // fma
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
+        {
+            return x * y + z;
+        }
+
+        template <class A, class T>
+        XSIMD_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<common>) 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>
+        XSIMD_INLINE batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
+        {
+            return x * y - z;
+        }
+
+        template <class A, class T>
+        XSIMD_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<common>) 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>
+        XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
+        {
+            return -x * y + z;
+        }
+
+        template <class A, class T>
+        XSIMD_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<common>) 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>
+        XSIMD_INLINE batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
+        {
+            return -x * y - z;
+        }
+
+        template <class A, class T>
+        XSIMD_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<common>) 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 };
+        }
+
+        // fmas
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> fmas(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<common>) noexcept
+        {
+            struct even_lane
+            {
+                static constexpr bool get(unsigned const i, unsigned) noexcept { return (i & 1u) == 0; }
+            };
+            const auto mask = make_batch_bool_constant<T, even_lane, A>();
+            return fma(x, y, select(mask, neg(z), z));
+        }
+
+        // incr
+        template <class A, class T>
+        XSIMD_INLINE batch<T, A> incr(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            return self + T(1);
+        }
+
+        // incr_if
+        template <class A, class T, class Mask>
+        XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, Mask const& mask, requires_arch<common>) noexcept
+        {
+            return select(mask, incr(self), self);
+        }
+
+        // mul
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            return detail::apply([](T x, T y) noexcept -> T
+                                 { return x * y; },
+                                 self, other);
+        }
+
+        // rotl
+        template <class A, class T, class STy>
+        XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, STy other, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            return (self << other) | (self >> (bits - other));
+        }
+        template <size_t count, class A, class T>
+        XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            static_assert(count < bits, "Count amount must be less than the number of bits in T");
+            return bitwise_lshift<count>(self) | bitwise_rshift<bits - count>(self);
+        }
+
+        // rotr
+        template <class A, class T, class STy>
+        XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, STy other, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            return (self >> other) | (self << (bits - other));
+        }
+        template <size_t count, class A, class T>
+        XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<common>) noexcept
+        {
+            constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
+            static_assert(count < bits, "Count must be less than the number of bits in T");
+            return bitwise_rshift<count>(self) | bitwise_lshift<bits - count>(self);
+        }
+
+        // sadd
+        template <class A>
+        XSIMD_INLINE batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                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(other >= 0, self_pos_branch, self_neg_branch);
+            }
+            else
+            {
+                const auto diffmax = std::numeric_limits<T>::max() - self;
+                const auto mindiff = min(diffmax, other);
+                return self + mindiff;
+            }
+        }
+        template <class A>
+        XSIMD_INLINE batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<common>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+
+        // ssub
+        template <class A>
+        XSIMD_INLINE batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<common>) noexcept
+        {
+            return sub(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
+        XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
+        {
+            if (std::is_signed<T>::value)
+            {
+                return sadd(self, -other);
+            }
+            else
+            {
+                const auto diff = min(self, other);
+                return self - diff;
+            }
+        }
+        template <class A>
+        XSIMD_INLINE batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<common>) noexcept
+        {
+            return sub(self, other); // no saturated arithmetic on floating point numbers
+        }
+
+    }
+
+}
+
+#endif