Standard library header <simd> (C++26)

From cppreference.net

< cpp ‎ | header

Cet en-tête fait partie de la bibliothèque numeric .

Table des matières

Classes

datapar::basic_simd

(C++26)

type vectoriel parallèle de données
(modèle de classe)

datapar::simd

(C++26)

modèle d'alias de commodité pour


          basic_simd

qui peut spécifier sa largeur
(modèle d'alias)

datapar::basic_simd_mask

(C++26)

type parallèle de données avec le type d'élément bool
(modèle de classe)

datapar::simd_mask

(C++26)

modèle d'alias de commodité pour


          basic_simd_mask

qui peut spécifier sa largeur
(modèle d'alias)

datapar::flags

(C++26)

indicateurs de chargement et de stockage pour les types de données parallèles
(modèle de classe)

datapar::alignment

(C++26)

obtient un alignement approprié pour


          datapar::flag_aligned

(modèle de classe)

datapar::rebind

(C++26)

modifie le type d'élément du type parallèle de données
(modèle de classe)

datapar::resize

(C++26)

modifie la largeur du type parallèle de données
(modèle de classe)

Fonctions

datapar::unchecked_load datapar::partial_load

(C++26)

charge les éléments d'une plage contiguë vers


          basic_simd

(modèle de fonction)

datapar::unchecked_store datapar::partial_store

(C++26)

stocke les éléments de


          basic_simd

dans une plage contiguë
(modèle de fonction)

datapar::chunk

(C++26)

divise un objet parallèle de données unique en plusieurs objets
(modèle de fonction)

datapar::cat

(C++26)

concatène plusieurs objets data-parallel en un seul
(modèle de fonction)

datapar::all_of datapar::any_of datapar::none_of

(C++26)

réductions de


          basic_simd_mask

vers bool
(modèle de fonction)

datapar::reduce_count

(C++26)

réduction de


          basic_simd_mask

au nombre de valeurs true
(modèle de fonction)

datapar::reduce_min_index datapar::reduce_max_index

(C++26)

réductions de


          basic_simd_mask

vers l'indice du premier ou dernier true valeur
(modèle de fonction)

datapar::reduce datapar::reduce_min datapar::reduce_max

(C++26)

réduit toutes les valeurs dans


          basic_simd

via une opération binaire spécifiée en une seule valeur
(modèle de fonction)

datapar::min datapar::max datapar::minmax

(C++26)

opérations min/max élément par élément pour


          basic_simd

(modèle de fonction)

datapar::clamp

(C++26)

opération de clamp élément par élément pour


          basic_simd

(modèle de fonction)

datapar::select

(C++26)

sélection élément par élément utilisant l'opérateur conditionnel
(modèle de fonction)

Constantes

datapar::flag_default

(C++26)

drapeau par défaut utilisé pour les opérations de chargement et de stockage
(constante)

datapar::flag_convert

(C++26)

drapeau activant les conversions non conservatrices de valeurs lors des opérations de chargement et de stockage
(constante)

datapar::flag_aligned

(C++26)

indicateur d'alignement de l'adresse de chargement-stockage sur un stockage spécifié à la valeur de


          datapar::alignment

(constante)

datapar::flag_overaligned

(C++26)

indicateur d'alignement de l'adresse de chargement-stockage sur un stockage spécifié à l'alignement spécifié
(modèle de variable)

Synopsis

namespace std::datapar {
// Traits de type SIMD
template <class T, class U = typename T::value_type> struct alignment;
template <class T, class U = typename T::value_type>
constexpr size_t alignment_v = alignment<T, U>::value;
template <class T, class V> struct rebind {
  using type = /* voir description */;
};
template <class T, class V> using rebind_t = typename rebind<T, V>::type;
template </*simd-size-type*/ N, class V> struct resize {
  using type = /* voir description */;
};
template </*simd-size-type*/ N, class V>
using resize_t = typename resize<N, V>::type;
// Indicateurs de chargement et de stockage
template <class... Flags> struct flags;
inline constexpr flags<> flag_default{};
inline constexpr flags</*convertir-drapeau*/> flag_convert{};
inline constexpr flags</*aligned-flag*/> flag_aligned{};
template <size_t N>
  requires(has_single_bit(N))
constexpr flags</*overaligned-flag*/<N>> flag_overaligned{};
// Modèle de classe basic_simd
template <class T, class Abi = /*native-abi*/<T>> class basic_simd;
template <class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
using simd = basic_simd<T, /*deduce-abi-t*/<T, N>>;
// Modèle de classe basic_simd_mask
template <size_t Bytes, class Abi = /*native-abi*/</*entier-depuis*/<Bytes>>>
class basic_simd_mask;
template <class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
using simd_mask = basic_simd_mask<sizeof(T), /*deduce-abi-t*/<T, N>>;
// fonctions de chargement et de stockage basic_simd
template <class V = /* voir description */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V unchecked_load(R &&r, flags<Flags...> f = {});
template <class V = /* voir description */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V unchecked_load(R &&r, const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          class... Flags>
constexpr V unchecked_load(I first, iter_difference_t<I> n,
                           flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          class... Flags>
constexpr V unchecked_load(I first, iter_difference_t<I> n,
                           const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Flags>
constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Flags>
constexpr V unchecked_load(I first, S last, const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* voir description */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V partial_load(R &&r, flags<Flags...> f = {});
template <class V = /* voir description */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V partial_load(R &&r, const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          class... Flags>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          class... Drapeaux>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Drapeaux>
constexpr V partial_load(I first, S last, flags<Flags...> f = {});
template <class V = /* voir description */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Drapeaux>
constexpr V partial_load(I first, S last, const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... Drapeaux>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t<R>, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, R &&r,
                               flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... Drapeaux>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t<R>, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, R &&r,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, I first,
                               iter_difference_t<I> n, flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, I first, iter_difference_t<I> n,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, I first, S last,
                               flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, I first, S last,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... Drapeaux>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t<R>, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, R &&r,
                             flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... Drapeaux>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t<R>, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, R &&r,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first,
                             iter_difference_t<I> n, flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first,
                             iter_difference_t<I> n,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... Drapeaux>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first, S last,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... Flags>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first, S last,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
// création de basic_simd et basic_simd_mask
template <class T, class Abi>
constexpr auto chunk(const basic_simd<typename T::value_type, Abi> &x) noexcept;
template <class T, class Abi>
constexpr auto
chunk(const basic_simd_mask</*mask-element-size*/<T>, Abi> &x) noexcept;
template <size_t N, class T, class Abi>
constexpr auto chunk(const basic_simd<T, Abi> &x) noexcept;
template <size_t N, size_t Bytes, class Abi>
constexpr auto chunk(const basic_simd_mask<Bytes, Abi> &x) noexcept;
template <class T, class... Abis>
constexpr basic_simd<T,
                     /*deduce-abi-t*/<T, (basic_simd<T, Abis>::size() + ...)>>
cat(const basic_simd<T, Abis> &...) noexcept;
template <size_t Bytes, class... Abis>
constexpr basic_simd_mask<
    Bytes, /*deduce-abi-t*/</*entier-depuis*/<Bytes>,
                            (basic_simd_mask<Bytes, Abis>::size() + ...)>>
cat(const basic_simd_mask<Bytes, Abis> &...) noexcept;
// réductions de masque basic_simd
template <size_t Bytes, class Abi>
constexpr bool all_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr bool any_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr bool none_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_count(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_min_index(const basic_simd_mask<Bytes, Abi> &);
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_max_index(const basic_simd_mask<Bytes, Abi> &);
constexpr bool all_of(same_as<bool> auto) noexcept;
constexpr bool any_of(same_as<bool> auto) noexcept;
constexpr bool none_of(same_as<bool> auto) noexcept;
constexpr /*simd-size-type*/ reduce_count(same_as<bool> auto) noexcept;
constexpr /*simd-size-type*/ reduce_min_index(same_as<bool> auto);
constexpr /*simd-size-type*/ reduce_max_index(same_as<bool> auto);
// réductions basic_simd
template <class T, class Abi, class BinaryOperation = plus<>>
constexpr T reduce(const basic_simd<T, Abi> &, BinaryOperation = {});
template <class T, class Abi, class BinaryOperation = plus<>>
constexpr T reduce(const basic_simd<T, Abi> &x,
                   const typename basic_simd<T, Abi>::mask_type &mask,
                   BinaryOperation binary_op = {},
                   type_identity_t<T> identity_element = /* voir description */);
template <class T, class Abi>
constexpr T reduce_min(const basic_simd<T, Abi> &) noexcept;
template <class T, class Abi>
constexpr T reduce_min(const basic_simd<T, Abi> &,
                       const typename basic_simd<T, Abi>::mask_type &) noexcept;
template <class T, class Abi>
constexpr T reduce_max(const basic_simd<T, Abi> &) noexcept;
template <class T, class Abi>
constexpr T reduce_max(const basic_simd<T, Abi> &,
                       const typename basic_simd<T, Abi>::mask_type &) noexcept;
// Algorithmes
template <class T, class Abi>
constexpr basic_simd<T, Abi> min(const basic_simd<T, Abi> &a,
                                 const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr basic_simd<T, Abi> max(const basic_simd<T, Abi> &a,
                                 const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr pair<basic_simd<T, Abi>, basic_simd<T, Abi>>
minmax(const basic_simd<T, Abi> &a, const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr basic_simd<T, Abi> clamp(const basic_simd<T, Abi> &v,
                                   const basic_simd<T, Abi> &lo,
                                   const basic_simd<T, Abi> &hi);
template <class T, class U>
constexpr auto select(bool c, const T &a, const U &b)
    -> remove_cvref_t<decltype(c ? a : b)>;
template <size_t Bytes, class Abi, class T, class U>
constexpr auto select(const basic_simd_mask<Bytes, Abi> &c, const T &a,
                      const U &b) noexcept
    -> decltype(/*simd-select-impl*/(c, a, b));
// Fonctions mathématiques
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> acos(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> asin(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> atan(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> atan2(const V0 &y, const V1 &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cos(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sin(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tan(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> acosh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> asinh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> atanh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cosh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sinh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tanh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> exp(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> exp2(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> expm1(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
frexp(const V &value, rebind_t<int, /*deduced-simd-t*/<V>> *exp);
template </*math-floating-point*/ V>
constexpr rebind_t<int, /*deduced-simd-t*/<V>> ilogb(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
ldexp(const V &x, const rebind_t<int, /*deduced-simd-t*/<V>> &exp);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log10(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log1p(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log2(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> logb(const V &x);
template <class T, class Abi>
constexpr basic_simd<T, Abi>
modf(const type_identity_t<basic_simd<T, Abi>> &value,
     basic_simd<T, Abi> *iptr);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
scalbn(const V &x, const rebind_t<int, /*deduced-simd-t*/<V>> &n);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
scalbln(const V &x, const rebind_t<long int, /*deduced-simd-t*/<V>> &n);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cbrt(const V &x);
template <signed_integral T, class Abi>
constexpr basic_simd<T, Abi> abs(const basic_simd<T, Abi> &j);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> abs(const V &j);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> fabs(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> hypot(const V0 &x, const V1 &y);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> hypot(const V0 &x, const V1 &y,
                                                   const V2 &z);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> pow(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sqrt(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> erf(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> erfc(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> lgamma(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tgamma(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> ceil(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> floor(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> nearbyint(const V &x);
template </*math-floating-point*/ V> /*deduced-simd-t*/<V> rint(const V &x);
template </*math-floating-point*/ V>
rebind_t<long int, /*deduced-simd-t*/<V>> lrint(const V &x);
template </*math-floating-point*/ V>
rebind_t<long long int, V> llrint(const /*deduced-simd-t*/<V> &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> round(const V &x);
template </*math-floating-point*/ V>
constexpr rebind_t<long int, /*deduced-simd-t*/<V>> lround(const V &x);
template </*math-floating-point*/ V>
constexpr rebind_t<long long int, /*deduced-simd-t*/<V>> llround(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> trunc(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmod(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> remainder(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1>
remquo(const V0 &x, const V1 &y,
       rebind_t<int, /*math-common-simd-t*/<V0, V1>> *quo);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> copysign(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> nextafter(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fdim(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmax(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmin(const V0 &x, const V1 &y);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> fma(const V0 &x, const V1 &y,
                                                 const V2 &z);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> lerp(const V0 &a, const V1 &b,
                                                  const V2 &t) noexcept;
template </*math-floating-point*/ V>
constexpr rebind_t<int, /*deduced-simd-t*/<V>> fpclassify(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isfinite(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isinf(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isnan(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isnormal(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type signbit(const V &x);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isgreater(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isgreaterequal(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isless(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
islessequal(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
islessgreater(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isunordered(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
assoc_laguerre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n,
               const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
assoc_legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l,
               const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m, const V &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> beta(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> comp_ellint_1(const V &k);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> comp_ellint_2(const V &k);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> comp_ellint_3(const V0 &k, const V1 &nu);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_i(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_j(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_k(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_neumann(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> ellint_1(const V0 &k, const V1 &phi);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> ellint_2(const V0 &k, const V1 &phi);
template <class V0, class V1, class V2>
/*math-common-simd-t*/<V0, V1, V2> ellint_3(const V0 &k, const V1 &nu,
                                            const V2 &phi);
template </*math-floating-point*/ V> /*deduced-simd-t*/<V> expint(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
hermite(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
laguerre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> riemann_zeta(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_bessel(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l,
             const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m,
             const V &theta);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_neumann(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
// Manipulation de bits
template </*simd-type*/ V> constexpr V byteswap(const V &v) noexcept;
template </*simd-type*/ V> constexpr V bit_ceil(const V &v) noexcept;
template </*type simd*/ V> constexpr V bit_floor(const V &v) noexcept;
template </*type simd*/ V>
constexpr typename V::mask_type has_single_bit(const V &v) noexcept;
template </*type simd*/ V0, /*simd-type*/ V1>
constexpr V0 rotl(const V0 &v, const V1 &s) noexcept;
template </*simd-type*/ V> constexpr V rotl(const V &v, int s) noexcept;
template </*simd-type*/ V0, /*simd-type*/ V1>
constexpr V0 rotr(const V0 &v, const V1 &s) noexcept;
template </*type simd*/ V> constexpr V rotr(const V &v, int s) noexcept;
template </*type simd*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
bit_width(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countl_zero(const V &v) noexcept;
template </*type simd*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countl_one(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countr_zero(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countr_one(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
popcount(const V &v) noexcept;
// mathématiques complexes simd
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> real(const V &) noexcept;
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> imag(const V &) noexcept;
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> abs(const V &);
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> arg(const V &);
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> norm(const V &);
template </*simd-complex*/ V> constexpr V conj(const V &);
template </*simd-complex*/ V> constexpr V proj(const V &);
template </*simd-complex*/ V> constexpr V exp(const V &v);
template </*simd-complex*/ V> constexpr V log(const V &v);
template </*simd-complex*/ V> constexpr V log10(const V &v);
template </*simd-complex*/ V> constexpr V sqrt(const V &v);
template </*simd-complex*/ V> constexpr V sin(const V &v);
template </*simd-complex*/ V> constexpr V asin(const V &v);
template </*simd-complex*/ V> constexpr V cos(const V &v);
template </*simd-complex*/ V> constexpr V acos(const V &v);
template </*simd-complex*/ V> constexpr V tan(const V &v);
template </*simd-complex*/ V> constexpr V atan(const V &v);
template </*simd-complex*/ V> constexpr V sinh(const V &v);
template </*simd-complex*/ V> constexpr V asinh(const V &v);
template </*simd-complex*/ V> constexpr V cosh(const V &v);
template </*simd-complex*/ V> constexpr V acosh(const V &v);
template </*simd-complex*/ V> constexpr V tanh(const V &v);
template </*simd-complex*/ V> constexpr V atanh(const V &v);
template </*simd-floating-point*/ V>
rebind_t<complex<typename V::value_type>, V> polar(const V &x, const V &y = {});
template </*simd-complex*/ V> constexpr V pow(const V &x, const V &y);
}
namespace std {
// Voir Algorithmes
using datapar::clamp;
using datapar::max;
using datapar::min;
using datapar::minmax;
// Voir Fonctions mathématiques
using datapar::abs;
using datapar::acos;
using datapar::acosh;
using datapar::asin;
using datapar::asinh;
using datapar::assoc_laguerre;
using datapar::assoc_legendre;
using datapar::atan;
using datapar::atan2;
using datapar::atanh;
using datapar::beta;
using datapar::cbrt;
using datapar::ceil;
using datapar::comp_ellint_1;
using datapar::comp_ellint_2;
using datapar::comp_ellint_3;
using datapar::copysign;
using datapar::cos;
using datapar::cosh;
using datapar::cyl_bessel_i;
using datapar::cyl_bessel_j;
using datapar::cyl_bessel_k;
using datapar::cyl_neumann;
using datapar::ellint_1;
using datapar::ellint_2;
using datapar::ellint_3;
using datapar::erf;
using datapar::erfc;
using datapar::exp;
using datapar::exp2;
using datapar::expint;
using datapar::expm1;
using datapar::fabs;
using datapar::fdim;
using datapar::floor;
using datapar::fma;
using datapar::fmax;
using datapar::fmin;
using datapar::fmod;
using datapar::fpclassify;
using datapar::frexp;
using datapar::hermite;
using datapar::hypot;
using datapar::ilogb;
using datapar::isfinite;
using datapar::isgreater;
using datapar::isgreaterequal;
using datapar::isinf;
using datapar::isless;
using datapar::islessequal;
using datapar::islessgreater;
using datapar::isnan;
using datapar::isnormal;
using datapar::isunordered;
using datapar::laguerre;
using datapar::ldexp;
using datapar::legendre;
using datapar::lerp;
using datapar::lgamma;
using datapar::llrint;
using datapar::llround;
using datapar::log;
using datapar::log10;
using datapar::log1p;
using datapar::log2;
using datapar::logb;
using datapar::lrint;
using datapar::lround;
using datapar::modf;
using datapar::nearbyint;
using datapar::nextafter;
using datapar::pow;
using datapar::reste;
using datapar::remquo;
using datapar::fonction zêta de Riemann;
using datapar::rint;
using datapar::round;
using datapar::scalbln;
using datapar::scalbn;
using datapar::signbit;
using datapar::sin;
using datapar::sinh;
using datapar::sph_bessel;
using datapar::sph_legendre;
using datapar::sph_neumann;
using datapar::sqrt;
using datapar::tan;
using datapar::tanh;
using datapar::tgamma;
using datapar::trunc;
// Voir Manipulation de bits
using datapar::bit_ceil;
using datapar::bit_floor;
using datapar::bit_width;
using datapar::byteswap;
using datapar::countl_one;
using datapar::countl_zero;
using datapar::countr_one;
using datapar::countr_zero;
using datapar::has_single_bit;
using datapar::popcount;
using datapar::rotl;
using datapar::rotr;
// Voir les mathématiques complexes SIMD
using datapar::arg;
using datapar::conj;
using datapar::imag;
using datapar::norme;
using datapar::polaire;
using datapar::proj;
using datapar::real;
}

Modèle de classe std::datapar::flags

namespace std::datapar {
template <class... Flags> struct flags {
  // opérateurs de flags
  template <class... Other>
  friend consteval auto operator|(flags, flags<Other...>);
};
}

Modèle de classe std::datapar::basic_simd

namespace std::datapar {
template <class T, class Abi> class basic_simd {
public:
  using value_type = T;
  using mask_type = basic_simd_mask<sizeof(T), Abi>;
  using abi_type = Abi;
  static constexpr integral_constant</*simd-size-type*/,
                                     /*simd-size-v*/<T, Abi>>
      size{};
  constexpr basic_simd() noexcept = default;
  // constructeurs basic_simd
  template <class U>
  constexpr explicit(/* voir description */) basic_simd(U &&value) noexcept;
  template <class U, class UAbi>
  constexpr explicit(/* voir description */)
      basic_simd(const basic_simd<U, UAbi> &) noexcept;
  template <class G> constexpr explicit basic_simd(G &&gen) noexcept;
  template <class R, class... Flags>
  constexpr basic_simd(R &&range, flags<Flags...> = {});
  template <class R, class... Flags>
  constexpr basic_simd(R &&range, const mask_type &mask, flags<Flags...> = {});
  template </*simd-floating-point*/ V>
  constexpr explicit(/* voir description */)
      basic_simd(const V &reals, const V &imags = {}) noexcept;
  // opérateurs d'indice basic_simd
  constexpr value_type operator[](/*simd-size-type*/) const;
  // opérateurs unaires basic_simd
  constexpr basic_simd &operator++() noexcept;
  constexpr basic_simd operator++(int) noexcept;
  constexpr basic_simd &operator--() noexcept;
  constexpr basic_simd operator--(int) noexcept;
  constexpr mask_type operator!() const noexcept;
  constexpr basic_simd operator~() const noexcept;
  constexpr basic_simd operator+() const noexcept;
  constexpr basic_simd operator-() const noexcept;
  // opérateurs binaires basic_simd
  friend constexpr basic_simd operator+(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator-(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator*(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator/(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator%(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator&(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator|(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator^(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator<<(const basic_simd &,
                                         const basic_simd &) noexcept;
  friend constexpr basic_simd operator>>(const basic_simd &,
                                         const basic_simd &) noexcept;
  friend constexpr basic_simd operator<<(const basic_simd &,
                                         /*simd-size-type*/) noexcept;
  friend constexpr basic_simd operator>>(const basic_simd &,
                                         /*simd-size-type*/) noexcept;
  // affectation composée basic_simd
  friend constexpr basic_simd &operator+=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator-=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator*=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator/=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator%=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator&=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator|=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator^=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator<<=(basic_simd &,
                                           const basic_simd &) noexcept;
  friend constexpr basic_simd &operator>>=(basic_simd &,
                                           const basic_simd &) noexcept;
  friend constexpr basic_simd &operator<<=(basic_simd &,
                                           /*simd-size-type*/) noexcept;
  friend constexpr basic_simd &operator>>=(basic_simd &,
                                           /*simd-size-type*/) noexcept;
  // opérateurs de comparaison basic_simd
  friend constexpr mask_type operator==(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator!=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator>=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator<=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator>(const basic_simd &,
                                       const basic_simd &) noexcept;
  friend constexpr mask_type operator<(const basic_simd &,
                                       const basic_simd &) noexcept;
  // accesseurs de valeurs complexes basic_simd
  constexpr auto real() const noexcept;
  constexpr auto imag() const noexcept;
  template </*simd-floating-point*/ V> constexpr void real(const V &v) noexcept;
  template </*simd-floating-point*/ V> constexpr void imag(const V &v) noexcept;
  // basic_simd exposition seulement opérateurs conditionnels
  friend constexpr basic_simd /*simd-select-impl*/( // exposition uniquement
      const mask_type &, const basic_simd &, const basic_simd &) noexcept;
};
template <class R, class... Ts> basic_simd(R &&r, Ts...)->/* voir description */;
}

Modèle de classe std::datapar::basic_simd_mask

namespace std::datapar {
template <size_t Bytes, class Abi> class basic_simd_mask {
public:
  using value_type = bool;
  using abi_type = Abi;
  static constexpr integral_constant<
      /*simd-size-type*/, /*simd-size-v*/</*entier-depuis*/<Bytes>, Abi>>
      size{};
  constexpr basic_simd_mask() noexcept = default;
  // constructeurs basic_simd_mask
  constexpr explicit basic_simd_mask(value_type) noexcept;
  template <size_t UBytes, class UAbi>
  constexpr explicit basic_simd_mask(
      const basic_simd_mask<UBytes, UAbi> &) noexcept;
  template <class G> constexpr explicit basic_simd_mask(G &&gen) noexcept;
  // opérateurs d'indice de masque basic_simd
  constexpr value_type operator[](/*simd-size-type*/) const;
  // Opérateurs unaires basic_simd_mask
  constexpr basic_simd_mask operator!() const noexcept;
  constexpr basic_simd</*integer-from*/<Bytes>, Abi> operator+() const noexcept;
  constexpr basic_simd</*integer-from*/<Bytes>, Abi> operator-() const noexcept;
  constexpr basic_simd</*entier-depuis*/<Bytes>, Abi> operator~() const noexcept;
  // opérateurs de conversion basic_simd_mask
  template <class U, class A>
  constexpr explicit(sizeof(U) != Bytes)
  operator basic_simd<U, A>() const noexcept;
  // opérateurs binaires basic_simd_mask
  friend constexpr basic_simd_mask operator&&(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator||(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator&(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator|(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator^(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  // assignation composée de masque basic_simd
  friend constexpr basic_simd_mask &
  operator&=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask &
  operator|=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask &
  operator^=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  // comparaisons de masques basic_simd
  friend constexpr basic_simd_mask operator==(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator!=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator>=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator<=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator>(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator<(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  // basic_simd_mask exposition seulement des opérateurs conditionnels
  friend constexpr basic_simd_mask /*simd-select-impl*/( // exposition uniquement
      const basic_simd_mask &, const basic_simd_mask &,
      const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask /*simd-select-impl*/( // exposition uniquement
      const basic_simd_mask &, same_as<bool> auto, same_as<bool> auto) noexcept;
  template <class T0, class T1>
  friend constexpr simd</* voir description */, size()>
  /*simd-select-impl*/(const basic_simd_mask &, const T0 &,
                       const T1 &) noexcept; // exposition uniquement
};
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <simd> (C++26)

Table des matières

Classes

Fonctions

Constantes

Synopsis

Modèle de classe std::datapar::flags

Modèle de classe std::datapar::basic_simd

Modèle de classe std::datapar::basic_simd_mask