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

From cppreference.net

< cpp ‎ | header

Este encabezado es parte de la biblioteca numeric .

Contenidos

Clases

datapar::basic_simd

(C++26)

tipo vectorial de procesamiento paralelo de datos
(plantilla de clase)

datapar::simd

(C++26)

plantilla de alias de conveniencia para


          basic_simd

que puede especificar su ancho
(plantilla de alias)

datapar::basic_simd_mask

(C++26)

tipo de datos paralelos con el tipo de elemento bool
(plantilla de clase)

datapar::simd_mask

(C++26)

plantilla de alias de conveniencia para


          basic_simd_mask

que puede especificar su ancho
(plantilla de alias)

datapar::flags

(C++26)

banderas de carga y almacenamiento para tipos de datos paralelos
(plantilla de clase)

datapar::alignment

(C++26)

obtiene una alineación apropiada para


          datapar::flag_aligned

(plantilla de clase)

datapar::rebind

(C++26)

cambia el tipo de elemento del tipo de datos paralelos
(plantilla de clase)

datapar::resize

(C++26)

cambia el ancho del tipo de datos paralelos
(plantilla de clase)

Funciones

datapar::unchecked_load datapar::partial_load

(C++26)

carga elementos desde un rango contiguo a


          basic_simd

(plantilla de función)

datapar::unchecked_store datapar::partial_store

(C++26)

almacena elementos desde


          basic_simd

a un rango contiguo
(plantilla de función)

datapar::chunk

(C++26)

divide un único objeto de datos paralelos en múltiples objetos
(plantilla de función)

datapar::cat

(C++26)

concatena múltiples objetos de datos paralelos en uno solo
(plantilla de función)

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

(C++26)

reducciones de


          basic_simd_mask

a bool
(plantilla de función)

datapar::reduce_count

(C++26)

reducción de


          basic_simd_mask

al número de valores true
(plantilla de función)

datapar::reduce_min_index datapar::reduce_max_index

(C++26)

reducciones de


          basic_simd_mask

al índice del primer o último valor true
(plantilla de función)

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

(C++26)

reduce todos los valores en


          basic_simd

mediante una operación binaria especificada a un único valor
(plantilla de función)

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

(C++26)

operaciones min/max elemento a elemento para


          basic_simd

(plantilla de función)

datapar::clamp

(C++26)

operación de sujeción elemento a elemento para


          basic_simd

(plantilla de función)

datapar::select

(C++26)

selección elemento por elemento usando operador condicional
(plantilla de función)

Constantes

datapar::flag_default

(C++26)

bandera predeterminada utilizada en operaciones de carga y almacenamiento
(constante)

datapar::flag_convert

(C++26)

bandera que habilita conversiones que no preservan valores en operaciones de carga y almacenamiento
(constante)

datapar::flag_aligned

(C++26)

bandera que indica la alineación de la dirección de carga-almacenamiento respecto a algún almacenamiento especificado con el valor de


          datapar::alignment

(constante)

datapar::flag_overaligned

(C++26)

bandera que indica la alineación de la dirección de carga-almacenamiento a algún almacenamiento especificado con la alineación especificada
(plantilla de variable)

Sinopsis

namespace std::datapar {
// simd type Traits
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>::valor;
template <class T, class V> struct rebind {
  using type = /* ver descripción */;
};
template <class T, class V> using rebind_t = typename rebind<T, V>::type;
template </*simd-size-type*/ N, class V> struct resize {
  using type = /* ver descripción */;
};
template </*simd-size-type*/ N, class V>
using resize_t = typename resize<N, V>::type;
// Banderas de carga y almacenamiento
template <class... Flags> struct flags;
inline constexpr flags<> flag_default{};
inline constexpr flags</*convert-flag*/> 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{};
// Class template 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>>;
// Plantilla de clase basic_simd_mask
template <size_t Bytes, class Abi = /*native-abi*/</*integer-from*/<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>>;
// funciones básicas de carga y almacenamiento SIMD
template <class V = /* ver descripción */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V unchecked_load(R &&r, flags<Flags...> f = {});
template <class V = /* ver descripción */, 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 = /* ver descripción */, contiguous_iterator I,
          class... Flags>
constexpr V unchecked_load(I first, iter_difference_t<I> n,
                           flags<Flags...> f = {});
template <class V = /* ver descripción */, 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 = /* ver descripción */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Flags>
constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
template <class V = /* ver descripción */, 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 = /* ver descripción */, ranges::contiguous_range R,
          class... Flags>
  requires ranges::sized_range<R>
constexpr V partial_load(R &&r, flags<Flags...> f = {});
template <class V = /* ver descripción */, 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 = /* ver descripción */, contiguous_iterator I,
          class... Flags>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         flags<Flags...> f = {});
template <class V = /* ver descripción */, contiguous_iterator I,
          class... Flags>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class V = /* ver descripción */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Flags>
constexpr V partial_load(I first, S last, flags<Flags...> f = {});
template <class V = /* ver descripción */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... Flags>
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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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... Flags>
  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 = {});
// Creación de basic_simd y 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*/</*integer-from*/<Bytes>,
                            (basic_simd_mask<Bytes, Abis>::size() + ...)>>
cat(const basic_simd_mask<Bytes, Abis> &...) noexcept;
// reducciones básicas de máscara 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);
// reducciones básicas de 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 = /* ver descripción */);
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;
// Algoritmos
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));
// Funciones matemáticas
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);
// Manipulación 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 </*simd-type*/ V> constexpr V bit_floor(const V &v) noexcept;
template </*simd-type*/ V>
constexpr typename V::mask_type has_single_bit(const V &v) noexcept;
template </*simd-type*/ 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 </*simd-type*/ V> constexpr V rotr(const V &v, int s) noexcept;
template </*simd-type*/ 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 </*simd-type*/ 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;
// matemáticas complejas simd
template </*simd-complejo*/ V>
constexpr </*simd-complex-value-type*/<V>, V> real(const V &) noexcept;
template </*simd-complejo*/ V>
constexpr </*simd-complex-value-type*/<V>, V> imag(const V &) noexcept;
template </*simd-complejo*/ V>
constexpr </*simd-complex-value-type*/<V>, V> abs(const V &);
template </*simd-complejo*/ V>
constexpr </*simd-complex-value-type*/<V>, V> arg(const V &);
template </*simd-complejo*/ V>
constexpr </*simd-complex-value-type*/<V>, V> norm(const V &);
template </*simd-complejo*/ V> constexpr V conj(const V &);
template </*simd-complejo*/ V> constexpr V proj(const V &);
template </*simd-complejo*/ V> constexpr V exp(const V &v);
template </*simd-complejo*/ V> constexpr V log(const V &v);
template </*simd-complejo*/ V> constexpr V log10(const V &v);
template </*simd-complejo*/ V> constexpr V sqrt(const V &v);
template </*simd-complejo*/ V> constexpr V sin(const V &v);
template </*simd-complejo*/ V> constexpr V asin(const V &v);
template </*simd-complejo*/ V> constexpr V cos(const V &v);
template </*simd-complejo*/ V> constexpr V acos(const V &v);
template </*simd-complejo*/ V> constexpr V tan(const V &v);
template </*simd-complejo*/ V> constexpr V atan(const V &v);
template </*simd-complejo*/ V> constexpr V sinh(const V &v);
template </*simd-complejo*/ V> constexpr V asinh(const V &v);
template </*simd-complejo*/ V> constexpr V cosh(const V &v);
template </*simd-complejo*/ V> constexpr V acosh(const V &v);
template </*simd-complejo*/ V> constexpr V tanh(const V &v);
template </*simd-complejo*/ 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-complejo*/ V> constexpr V pow(const V &x, const V &y);
}
namespace std {
// Ver Algoritmos
using datapar::clamp;
using datapar::max;
using datapar::min;
using datapar::minmax;
// Ver Funciones matemáticas
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::remainder;
using datapar::remquo;
using datapar::riemann_zeta;
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;
// Ver Manipulación 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;
// Ver simd math complejo
using datapar::arg;
using datapar::conj;
using datapar::imag;
using datapar::norm;
using datapar::polar;
using datapar::proj;
using datapar::real;
}

Plantilla de clase std::datapar::flags

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

Plantilla de clase 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;
  // constructores basic_simd
  template <class U>
  constexpr explicit(/* ver descripción */) basic_simd(U &&value) noexcept;
  template <class U, class UAbi>
  constexpr explicit(/* ver descripción */)
      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(/* ver descripción */)
      basic_simd(const V &reals, const V &imags = {}) noexcept;
  // operadores de subíndice basic_simd
  constexpr value_type operator[](/*simd-size-type*/) const;
  // operadores unarios 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;
  // operadores binarios 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;
  // asignación compuesta 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;
  // operadores de comparación 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;
  // basic_simd complex-value accessors
  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;
  // operadores condicionales de exposición básica de simd únicamente
  friend constexpr basic_simd /*simd-select-impl*/( // exposición solamente
      const mask_type &, const basic_simd &, const basic_simd &) noexcept;
};
template <class R, class... Ts> basic_simd(R &&r, Ts...)->/* ver descripción */;
}

Plantilla de clase 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*/</*integer-from*/<Bytes>, Abi>>
      size{};
  constexpr basic_simd_mask() noexcept = default;
  // constructores de 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;
  // operadores de subíndice de máscara basic_simd
  constexpr value_type operator[](/*simd-size-type*/) const;
  // operadores unarios de basic_simd_mask
  constexpr basic_simd_mask operator!() const noexcept;
  constexpr basic_simd</*entero-desde*/<Bytes>, Abi> operator+() const noexcept;
  constexpr basic_simd</*entero-desde*/<Bytes>, Abi> operator-() const noexcept;
  constexpr basic_simd</*entero-desde*/<Bytes>, Abi> operator~() const noexcept;
  // operadores de conversión de basic_simd_mask
  template <class U, class A>
  constexpr explicit(sizeof(U) != Bytes)
  operator basic_simd<U, A>() const noexcept;
  // operadores binarios de 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;
  // asignación compuesta de máscara 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;
  // comparaciones de máscaras 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;
  // operadores condicionales de exposición solo de máscara básica_simd
  friend constexpr basic_simd_mask /*simd-select-impl*/( // exposición solamente
      const basic_simd_mask &, const basic_simd_mask &,
      const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask /*simd-select-impl*/( // exposición solamente
      const basic_simd_mask &, same_as<bool> auto, same_as<bool> auto) noexcept;
  template <class T0, class T1>
  friend constexpr simd</* ver descripción */, size()>
  /*simd-select-impl*/(const basic_simd_mask &, const T0 &,
                       const T1 &) noexcept; // exposición solamente
};
}

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)

Contenidos

Clases

Funciones

Constantes

Sinopsis

Plantilla de clase std::datapar::flags

Plantilla de clase std::datapar::basic_simd

Plantilla de clase std::datapar::basic_simd_mask