Encabezado de la biblioteca estándar <simd> (C++26)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Encabezados de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)   <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnóstico <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <meta> (C++26) <ratio> (C++11) <type_traits> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <stdbit.h> (C++26) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)   <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)   Numérica <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <stdckdint.h> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo de concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

Este encabezado es parte de la biblioteca numeric.

Clases
simd::basic_vec (C++26)	Tipo de vector de paralelismo de datos. (plantilla de clase)
simd::vec (C++26)	Plantilla de alias de conveniencia para basic_vec que permite especificar su anchura. (plantilla de alias)
simd::basic_mask (C++26)	Tipo de paralelismo de datos con el tipo de elemento bool. (plantilla de clase)
simd::mask (C++26)	Plantilla de alias de conveniencia para basic_mask que permite especificar su anchura. (plantilla de alias)
simd::flags (C++26)	Indicadores de carga y almacenamiento para tipos de paralelismo de datos. (plantilla de clase)
simd::alignment (C++26)	Obtiene una alineación adecuada para simd::flag_aligned. (plantilla de clase)
simd::rebind (C++26)	Cambia el tipo de elemento del tipo de paralelismo de datos. (plantilla de clase)
simd::resize (C++26)	Cambia la anchura del tipo de paralelismo de datos. (plantilla de clase)
Funciones
simd::unchecked_loadsimd::partial_load (C++26)	Carga elementos desde un rango contiguo a basic_vec. (plantilla de función)
simd::unchecked_storesimd::partial_store (C++26)	Almacena elementos de basic_vec en un rango contiguo. (plantilla de función)
simd::chunk (C++26)	Divide un único objeto de paralelismo de datos en varios. (plantilla de función)
simd::cat (C++26)	Concatena múltiples objetos de paralelismo de datos en uno solo. (plantilla de función)
simd::all_ofsimd::any_ofsimd::none_of (C++26)	Reducciones de basic_mask a bool. (plantilla de función)
simd::reduce_count (C++26)	Reducción de basic_mask al número de valores true. (plantilla de función)
simd::reduce_min_indexsimd::reduce_max_index (C++26)	Reducciones de basic_mask al índice del primer o último valor true. (plantilla de función)
simd::reducesimd::reduce_minsimd::reduce_max (C++26)	Reduce todos los valores de basic_vec a un único valor mediante una operación binaria especificada. (plantilla de función)
simd::minsimd::maxsimd::minmax (C++26)	Operaciones de mínimo/máximo elemento a elemento para basic_vec. (plantilla de función)
simd::clamp (C++26)	Operación de acotado elemento a elemento para basic_vec. (plantilla de función)
simd::select (C++26)	Selección elemento a elemento mediante el operador condicional. (plantilla de función)
Constantes
simd::flag_default (C++26)	Indicador predeterminado utilizado en operaciones de carga y almacenamiento. (constante)
simd::flag_convert (C++26)	Indicador que habilita conversiones que no preservan el valor en operaciones de carga y almacenamiento. (constante)
simd::flag_aligned (C++26)	Indicador de que la dirección de carga o almacenamiento está alineada según simd::alignment. (constante)
simd::flag_overaligned (C++26)	Indicador de que la dirección de carga o almacenamiento está alineada según una alineación específica. (plantilla de variables)

Sinopsis

namespace std::simd {
  // Tipo rasgos
  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 = /* véase descripción */;
  };
  template<class T, class V> using rebind_t = rebind<T, V>::type;
  template</*simd-size-type*/ N, class V> struct resize
  {
    using type = /* véase descripción */;
  };
  template</*simd-size-type*/ N, class V> using resize_t = resize<N, V>::type;

  // indicadores 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{};

  // plantilla de clase simd-iterator
  template<class V> class /*simd-iterator*/; // solo para exposición

  // plantilla de clase basic_vec
  template<class T, class Abi = /*native-abi*/<T>> class basic_vec;
  template<class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
  using vec = basic_vec<T, /*deduce-abi-t*/<T, N>>;

  // reducciones
  template<class T, class Abi, class BinaryOperation = plus<>>
  constexpr T reduce(const basic_vec<T, Abi>&, BinaryOperation = {});
  template<class T, class Abi, class BinaryOperation = plus<>>
  constexpr T reduce(const basic_vec<T, Abi>& x,
                     const typename basic_vec<T, Abi>::mask_type& mask,
                     BinaryOperation binary_op = {},
                     type_identity_t<T> identity_element = /* véase descripción */);

  template<class T, class BinaryOperation = plus<>>
  constexpr T reduce(const T&, BinaryOperation = {});
  template<class T, class BinaryOperation = plus<>>
  constexpr T reduce(const T& x,
                     same_as<bool> auto mask,
                     BinaryOperation binary_op = {},
                     type_identity_t<T> identity_element = /* véase descripción */);

  template<class T, class Abi> constexpr T reduce_min(const basic_vec<T, Abi>&) noexcept;
  template<class T, class Abi>
  constexpr T reduce_min(const basic_vec<T, Abi>&,
                         const typename basic_vec<T, Abi>::mask_type&) noexcept;
  template<class T, class Abi> constexpr T reduce_max(const basic_vec<T, Abi>&) noexcept;
  template<class T, class Abi>
  constexpr T reduce_max(const basic_vec<T, Abi>&,
                         const typename basic_vec<T, Abi>::mask_type&) noexcept;

  template<class T> constexpr T reduce_min(const T&) noexcept;
  template<class T> constexpr T reduce_min(const T&, same_as<bool> auto) noexcept;
  template<class T> constexpr T reduce_max(const T&) noexcept;
  template<class T> constexpr T reduce_max(const T&, same_as<bool> auto) noexcept;

  // funciones de carga y almacenamiento
  template<class V = /* véase 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 = /* véase 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 = /* véase descripción */, contiguous_iterator I, class... Flags>
  constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
  template<class V = /* véase 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 = /* véase 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 = /* véase 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 = /* véase 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 = /* véase 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 = /* véase descripción */, contiguous_iterator I, class... Flags>
  constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
  template<class V = /* véase 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 = /* véase 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 = /* véase 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>
  constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                 R&& r,
                                 flags<Flags...> f = {});
  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
    requires ranges::sized_range<R>
  constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                 R&& r,
                                 const typename basic_vec<T, Abi>::mask_type& mask,
                                 flags<Flags...> f = {});
  template<class T, class Abi, contiguous_iterator I, class... Flags>
  constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                 I first,
                                 iter_difference_t<I> n,
                                 flags<Flags...> f = {});
  template<class T, class Abi, contiguous_iterator I, class... Flags>
  constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                 I first,
                                 iter_difference_t<I> n,
                                 const typename basic_vec<T, Abi>::mask_type& mask,
                                 flags<Flags...> f = {});
  template<class T,
           class Abi,
           contiguous_iterator I,
           sized_sentinel_for<I> S,
           class... Flags>
  constexpr void unchecked_store(const basic_vec<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>
  constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                 I first,
                                 S last,
                                 const typename basic_vec<T, Abi>::mask_type& mask,
                                 flags<Flags...> f = {});

  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
    requires ranges::sized_range<R>
  constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
    requires ranges::sized_range<R>
  constexpr void partial_store(const basic_vec<T, Abi>& v,
                               R&& r,
                               const typename basic_vec<T, Abi>::mask_type& mask,
                               flags<Flags...> f = {});
  template<class T, class Abi, contiguous_iterator I, class... Flags>
  constexpr void partial_store(const basic_vec<T, Abi>& v,
                               I first,
                               iter_difference_t<I> n,
                               flags<Flags...> f = {});
  template<class T, class Abi, contiguous_iterator I, class... Flags>
  constexpr void partial_store(const basic_vec<T, Abi>& v,
                               I first,
                               iter_difference_t<I> n,
                               const typename basic_vec<T, Abi>::mask_type& mask,
                               flags<Flags...> f = {});
  template<class T,
           class Abi,
           contiguous_iterator I,
           sized_sentinel_for<I> S,
           class... Flags>
  constexpr void partial_store(const basic_vec<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>
  constexpr void partial_store(const basic_vec<T, Abi>& v,
                               I first,
                               S last,
                               const typename basic_vec<T, Abi>::mask_type& mask,
                               flags<Flags...> f = {});

  // permutación estática
  inline constexpr /*simd-size-type*/ zero_element = /* definido por la implementación */;
  inline constexpr /*simd-size-type*/ uninit_element = /* definido por la implementación */;

  template</*simd-size-type*/ N =
             /* véase descripción */, /*simd-vec-type*/ V, class IdxMap>
  constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap);
  template</*simd-size-type*/ N =
             /* véase descripción */, /*simd-mask-type*/ V, class IdxMap>
  constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap);

  // permutación dinámica
  template</*simd-vec-type*/ V, /*simd-integral*/ I>
  constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);
  template</*simd-mask-type*/ V, /*simd-integral*/ I>
  constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);

  // permutación de máscara
  template</*simd-vec-type*/ V>
  constexpr V compress(const V& v, const typename V::mask_type& selector);
  template</*simd-mask-type*/ V>
  constexpr V compress(const V& v, const type_identity_t<V>& selector);
  template</*simd-vec-type*/ V>
  constexpr V compress(const V& v,
                       const typename V::mask_type& selector,
                       const typename V::value_type& fill_value);
  template</*simd-mask-type*/ V>
  constexpr V compress(const V& v,
                       const type_identity_t<V>& selector,
                       const typename V::value_type& fill_value);

  template</*simd-vec-type*/ V>
  constexpr V expand(const V& v,
                     const typename V::mask_type& selector,
                     const V& original = {});
  template</*simd-mask-type*/ V>
  constexpr V expand(const V& v,
                     const type_identity_t<V>& selector,
                     const V& original = {});

  // permutación de memoria
  template<class V = /* véase descripción */,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
  template<class V = /* véase descripción */,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr V unchecked_gather_from(R&& in,
                                    const typename I::mask_type& mask,
                                    const I& indices,
                                    flags<Flags...> f = {});

  template<class V = /* véase descripción */,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
  template<class V = /* véase descripción */,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr V partial_gather_from(R&& in,
                                  const typename I::mask_type& mask,
                                  const I& indices,
                                  flags<Flags...> f = {});

  template</*simd-vec-type*/ V,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr void unchecked_scatter_to(const V& v,
                                      R&& out,
                                      const I& indices,
                                      flags<Flags...> f = {});
  template</*simd-vec-type*/ V,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr void unchecked_scatter_to(const V& v,
                                      R&& out,
                                      const typename I::mask_type& mask,
                                      const I& indices,
                                      flags<Flags...> f = {});

  template</*simd-vec-type*/ V,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr void partial_scatter_to(const V& v,
                                    R&& out,
                                    const I& indices,
                                    flags<Flags...> f = {});
  template</*simd-vec-type*/ V,
           ranges::contiguous_range R,
           /*simd-integral*/ I,
           class... Flags>
    requires ranges::sized_range<R>
  constexpr void partial_scatter_to(const V& v,
                                    R&& out,
                                    const typename I::mask_type& mask,
                                    const I& indices,
                                    flags<Flags...> f = {});

  // creación
  template<class T, class Abi>
  constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept;
  template<class T, class Abi>
  constexpr auto chunk(const basic_mask</*mask-element-size*/<T>, Abi>& x) noexcept;

  template</*simd-size-type*/ N, class T, class Abi>
  constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;
  template</*simd-size-type*/ N, size_t Bytes, class Abi>
  constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept;

  template<class T, class... Abis>
  constexpr resize_t<(basic_vec<T, Abis>::size() + ...), basic_vec<T, Abis...[0]>> cat(
    const basic_vec<T, Abis>&...) noexcept;
  template<size_t Bytes, class... Abis>
  constexpr resize_t<(basic_mask<Bytes, Abis>::size() + ...),
                     basic_mask<Bytes, Abis...[0]>>
  cat(const basic_mask<Bytes, Abis>&...) noexcept;

  // algoritmos
  template<class T, class Abi>
  constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a,
                                  const basic_vec<T, Abi>& b) noexcept;
  template<class T, class Abi>
  constexpr basic_vec<T, Abi> max(const basic_vec<T, Abi>& a,
                                  const basic_vec<T, Abi>& b) noexcept;
  template<class T, class Abi>
  constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>> minmax(
    const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
  template<class T, class Abi>
  constexpr basic_vec<T, Abi> clamp(const basic_vec<T, Abi>& v,
                                    const basic_vec<T, Abi>& lo,
                                    const basic_vec<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_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-vec-t*/<V> acos(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> asin(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> atan(const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> atan2(const V& y, const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> atan2(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> atan2(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cos(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sin(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tan(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> acosh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> asinh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> atanh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cosh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sinh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tanh(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> exp(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> exp2(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> expm1(const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> frexp(const V& value,
                                       rebind_t<int, /*deduced-vec-t*/<V>>* exp);
  template</*math-floating-point*/ V>
  constexpr rebind_t<int, /*deduced-vec-t*/<V>> ilogb(const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> ldexp(const V& x,
                                       const rebind_t<int, /*deduced-vec-t*/<V>>& exp);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log10(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log1p(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log2(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> logb(const V& x);
  template<class T, class Abi>
  constexpr basic_vec<T, Abi> modf(const type_identity_t<basic_vec<T, Abi>>& value,
                                   basic_vec<T, Abi>* iptr);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> scalbn(const V& x,
                                        const rebind_t<int, /*deduced-vec-t*/<V>>& n);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> scalbln(
    const V& x, const rebind_t<long int, /*deduced-vec-t*/<V>>& n);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cbrt(const V& x);
  template<signed_integral T, class Abi>
  constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> abs(const V& j);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> fabs(const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x, const V& y, const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                       const V& y,
                                       const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                       const /*deduced-vec-t*/<V>& y,
                                       const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                       const V& y,
                                       const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                       const /*deduced-vec-t*/<V>& y,
                                       const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                       const V& y,
                                       const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                       const /*deduced-vec-t*/<V>& y,
                                       const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> pow(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> pow(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> pow(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sqrt(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> erf(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> erfc(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> lgamma(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tgamma(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> ceil(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> floor(const V& x);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> nearbyint(const V& x);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> rint(const V& x);
  template</*math-floating-point*/ V>
  rebind_t<long int, /*deduced-vec-t*/<V>> lrint(const V& x);
  template</*math-floating-point*/ V>
  rebind_t<long long int, V> llrint(const /*deduced-vec-t*/<V>& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> round(const V& x);
  template</*math-floating-point*/ V>
  constexpr rebind_t<long int, /*deduced-vec-t*/<V>> lround(const V& x);
  template</*math-floating-point*/ V>
  constexpr rebind_t<long long int, /*deduced-vec-t*/<V>> llround(const V& x);
  template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> trunc(const V& x);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmod(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmod(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmod(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remainder(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remainder(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remainder(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remquo(const V& x,
                                        const V& y,
                                        rebind_t<int, /*deduced-vec-t*/<V>>* quo);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remquo(const /*deduced-vec-t*/<V>& x,
                                        const V& y,
                                        rebind_t<int, /*deduced-vec-t*/<V>>* quo);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> remquo(const V& x,
                                        const /*deduced-vec-t*/<V>& y,
                                        rebind_t<int, /*deduced-vec-t*/<V>>* quo);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> copysign(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> copysign(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> copysign(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> nextafter(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> nextafter(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> nextafter(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fdim(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fdim(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fdim(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmax(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmax(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmax(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmin(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmin(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fmin(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const V& x, const V& y, const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                     const V& y,
                                     const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                     const V& y,
                                     const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                     const V& y,
                                     const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const V& a, const V& b, const V& t) noexcept;
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                      const V& y,
                                      const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                      const V& y,
                                      const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const V& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                      const V& y,
                                      const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const /*deduced-vec-t*/<V>& z);
  template</*math-floating-point*/ V>
  constexpr rebind_t<int, /*deduced-vec-t*/<V>> fpclassify(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isfinite(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isinf(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isnan(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isnormal(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type signbit(const V& x);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(
    const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(const V& x,
                                                                    const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(
    const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isless(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isless(const /*deduced-vec-t*/<V>& x,
                                                            const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isless(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(
    const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(const V& x,
                                                                   const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(
    const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(const V& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(
    const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(
    const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> assoc_laguerre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                      const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                      const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> assoc_legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                                      const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                      const V& x);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> beta(const V& x, const V& y);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> beta(const /*deduced-vec-t*/<V>& x, const V& y);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> beta(const V& x, const /*deduced-vec-t*/<V>& y);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> comp_ellint_1(const V& k);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> comp_ellint_2(const V& k);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> comp_ellint_3(const V& k, const V& nu);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> comp_ellint_3(const /*deduced-vec-t*/<V>& k, const V& nu);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> comp_ellint_3(const V& k, const /*deduced-vec-t*/<V>& nu);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_i(const V& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_i(const /*deduced-vec-t*/<V>& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_i(const V& nu, const /*deduced-vec-t*/<V>& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_j(const V& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_j(const /*deduced-vec-t*/<V>& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_j(const V& nu, const /*deduced-vec-t*/<V>& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_k(const V& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_k(const /*deduced-vec-t*/<V>& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_bessel_k(const V& nu, const /*deduced-vec-t*/<V>& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_neumann(const V& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_neumann(const /*deduced-vec-t*/<V>& nu, const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> cyl_neumann(const V& nu, const /*deduced-vec-t*/<V>& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_1(const V& k, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_1(const /*deduced-vec-t*/<V>& k, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_1(const V& k, const /*deduced-vec-t*/<V>& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_2(const V& k, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_2(const /*deduced-vec-t*/<V>& k, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_2(const V& k, const /*deduced-vec-t*/<V>& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const V& k, const V& nu, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k, const V& nu, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const V& k, const /*deduced-vec-t*/<V>& nu, const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const V& k, const V& nu, const /*deduced-vec-t*/<V>& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k,
                                const /*deduced-vec-t*/<V>& nu,
                                const V& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k,
                                const V& nu,
                                const /*deduced-vec-t*/<V>& phi);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> ellint_3(const V& k,
                                const /*deduced-vec-t*/<V>& nu,
                                const /*deduced-vec-t*/<V>& phi);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> expint(const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> hermite(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                               const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> laguerre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                                const V& x);
  template</*math-floating-point*/ V> /*deduced-vec-t*/<V> riemann_zeta(const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> sph_bessel(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                  const V& x);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> sph_legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                                    const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                    const V& theta);
  template</*math-floating-point*/ V>
  /*deduced-vec-t*/<V> sph_neumann(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                   const V& x);

  // manipulación de bits
  template</*simd-vec-type*/ V> constexpr V byteswap(const V& v) noexcept;
  template</*simd-vec-type*/ V> constexpr V bit_ceil(const V& v);
  template</*simd-vec-type*/ V> constexpr V bit_floor(const V& v) noexcept;

  template</*simd-vec-type*/ V>
  constexpr typename V::mask_type has_single_bit(const V& v) noexcept;

  template</*simd-vec-type*/ V0, /*simd-vec-type*/ V1>
  constexpr V0 rotl(const V0& v, const V1& s) noexcept;
  template</*simd-vec-type*/ V> constexpr V rotl(const V& v, int s) noexcept;

  template</*simd-vec-type*/ V0, /*simd-vec-type*/ V1>
  constexpr V0 rotr(const V0& v, const V1& s) noexcept;
  template</*simd-vec-type*/ V> constexpr V rotr(const V& v, int s) noexcept;

  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(
    const V& v) noexcept;
  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(
    const V& v) noexcept;
  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(
    const V& v) noexcept;
  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(
    const V& v) noexcept;
  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(
    const V& v) noexcept;
  template</*simd-vec-type*/ V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(
    const V& v) noexcept;

  // matemáticas complejas
  template</*simd-complex*/ V>
  constexpr rebind_t</*simd-complex-value-type*/<V>, V> real(const V&) noexcept;

  template</*simd-complex*/ V>
  constexpr rebind_t</*simd-complex-value-type*/<V>, V> imag(const V&) noexcept;

  template</*simd-complex*/ V>
  constexpr rebind_t</*simd-complex-value-type*/<V>, V> abs(const V&);

  template</*simd-complex*/ V>
  constexpr rebind_t</*simd-complex-value-type*/<V>, V> arg(const V&);

  template</*simd-complex*/ V>
  constexpr rebind_t</*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);

  // plantilla de clase basic_mask
  template<size_t Bytes, class Abi> class basic_mask;
  template<class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
  using mask = vec<T, N>::mask_type;

  // reducciones
  template<size_t Bytes, class Abi>
  constexpr bool all_of(const basic_mask<Bytes, Abi>&) noexcept;
  template<size_t Bytes, class Abi>
  constexpr bool any_of(const basic_mask<Bytes, Abi>&) noexcept;
  template<size_t Bytes, class Abi>
  constexpr bool none_of(const basic_mask<Bytes, Abi>&) noexcept;
  template<size_t Bytes, class Abi>
  constexpr /*simd-size-type*/ reduce_count(const basic_mask<Bytes, Abi>&) noexcept;
  template<size_t Bytes, class Abi>
  constexpr /*simd-size-type*/ reduce_min_index(const basic_mask<Bytes, Abi>&);
  template<size_t Bytes, class Abi>
  constexpr /*simd-size-type*/ reduce_max_index(const basic_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);
}

namespace std {
  // algoritmos
  using simd::min;
  using simd::max;
  using simd::minmax;
  using simd::clamp;

  // funciones matemáticas
  using simd::acos;
  using simd::asin;
  using simd::atan;
  using simd::atan2;
  using simd::cos;
  using simd::sin;
  using simd::tan;
  using simd::acosh;
  using simd::asinh;
  using simd::atanh;
  using simd::cosh;
  using simd::sinh;
  using simd::tanh;
  using simd::exp;
  using simd::exp2;
  using simd::expm1;
  using simd::frexp;
  using simd::ilogb;
  using simd::ldexp;
  using simd::log;
  using simd::log10;
  using simd::log1p;
  using simd::log2;
  using simd::logb;
  using simd::modf;
  using simd::scalbn;
  using simd::scalbln;
  using simd::cbrt;
  using simd::abs;
  using simd::fabs;
  using simd::hypot;
  using simd::pow;
  using simd::sqrt;
  using simd::erf;
  using simd::erfc;
  using simd::lgamma;
  using simd::tgamma;
  using simd::ceil;
  using simd::floor;
  using simd::nearbyint;
  using simd::rint;
  using simd::lrint;
  using simd::llrint;
  using simd::round;
  using simd::lround;
  using simd::llround;
  using simd::trunc;
  using simd::fmod;
  using simd::remainder;
  using simd::remquo;
  using simd::copysign;
  using simd::nextafter;
  using simd::fdim;
  using simd::fmax;
  using simd::fmin;
  using simd::fma;
  using simd::lerp;
  using simd::fpclassify;
  using simd::isfinite;
  using simd::isinf;
  using simd::isnan;
  using simd::isnormal;
  using simd::signbit;
  using simd::isgreater;
  using simd::isgreaterequal;
  using simd::isless;
  using simd::islessequal;
  using simd::islessgreater;
  using simd::isunordered;
  using simd::assoc_laguerre;
  using simd::assoc_legendre;
  using simd::beta;
  using simd::comp_ellint_1;
  using simd::comp_ellint_2;
  using simd::comp_ellint_3;
  using simd::cyl_bessel_i;
  using simd::cyl_bessel_j;
  using simd::cyl_bessel_k;
  using simd::cyl_neumann;
  using simd::ellint_1;
  using simd::ellint_2;
  using simd::ellint_3;
  using simd::expint;
  using simd::hermite;
  using simd::laguerre;
  using simd::legendre;
  using simd::riemann_zeta;
  using simd::sph_bessel;
  using simd::sph_legendre;
  using simd::sph_neumann;

  // manipulación de bits
  using simd::byteswap;
  using simd::bit_ceil;
  using simd::bit_floor;
  using simd::has_single_bit;
  using simd::rotl;
  using simd::rotr;
  using simd::bit_width;
  using simd::countl_zero;
  using simd::countl_one;
  using simd::countr_zero;
  using simd::countr_one;
  using simd::popcount;

  // matemáticas complejas de vectores
  using simd::real;
  using simd::imag;
  using simd::arg;
  using simd::norm;
  using simd::conj;
  using simd::proj;
  using simd::polar;
}

Plantilla de clase std::simd::flags

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

Plantilla de clase std::simd::simd-iterator

namespace std::simd {
  template<class V> class /*simd-iterator*/
  {                                                                     // solo para exposición
    V* /*data_*/ = nullptr;                                             // solo para exposición
    /*simd-size-type*/ /*offset_*/ = 0;                                 // solo para exposición

    constexpr /*simd-iterator*/(V& d, /*simd-size-type*/ off) noexcept; // solo para exposición

  public:
    using value_type = V::value_type;
    using iterator_category = input_iterator_tag;
    using iterator_concept = random_access_iterator_tag;
    using difference_type = /*simd-size-type*/;

    constexpr /*simd-iterator*/() = default;

    constexpr /*simd-iterator*/(const /*simd-iterator*/&) = default;
    constexpr /*simd-iterator*/& operator=(const /*simd-iterator*/&) = default;

    constexpr /*simd-iterator*/(const /*simd-iterator*/<remove_const_t<V>>&)
      requires is_const_v<V>;

    constexpr value_type operator*() const;

    constexpr /*simd-iterator*/& operator++();
    constexpr /*simd-iterator*/ operator++(int);
    constexpr /*simd-iterator*/& operator--();
    constexpr /*simd-iterator*/ operator--(int);

    constexpr /*simd-iterator*/& operator+=(difference_type n);
    constexpr /*simd-iterator*/& operator-=(difference_type n);

    constexpr value_type operator[](difference_type n) const;

    friend constexpr bool operator==(/*simd-iterator*/ a, /*simd-iterator*/ b) = default;
    friend constexpr bool operator==(/*simd-iterator*/ a, default_sentinel_t) noexcept;
    friend constexpr auto operator<=>(/*simd-iterator*/ a, /*simd-iterator*/ b);

    friend constexpr /*simd-iterator*/ operator+(/*simd-iterator*/ i, difference_type n);
    friend constexpr /*simd-iterator*/ operator+(difference_type n, /*simd-iterator*/ i);
    friend constexpr /*simd-iterator*/ operator-(/*simd-iterator*/ i, difference_type n);

    friend constexpr difference_type operator-(/*simd-iterator*/ a, /*simd-iterator*/ b);
    friend constexpr difference_type operator-(/*simd-iterator*/ i,
                                               default_sentinel_t) noexcept;
    friend constexpr difference_type operator-(default_sentinel_t,
                                               /*simd-iterator*/ i) noexcept;
  };
}

Plantilla de clase std::simd::basic_vec

namespace std::simd {
  template<class T, class Abi> class basic_vec
  {
    using /*real-type*/ = /* véase descripción */; // solo para exposición
  public:
    using value_type = T;
    using mask_type = basic_mask<sizeof(T), Abi>;
    using abi_type = Abi;
    using iterator = /*simd-iterator*/<basic_vec>;
    using const_iterator = /*simd-iterator*/<const basic_vec>;

    constexpr iterator begin() noexcept { return { *this, 0 }; }
    constexpr const_iterator begin() const noexcept { return { *this, 0 }; }
    constexpr const_iterator cbegin() const noexcept { return { *this, 0 }; }
    constexpr default_sentinel_t end() const noexcept { return {}; }
    constexpr default_sentinel_t cend() const noexcept { return {}; }

    static constexpr integral_constant</*simd-size-type*/, /*simd-size-v*/<T, Abi>>
      size{};

    constexpr basic_vec() noexcept = default;

    // simd.ctor, constructores de basic_vec
    template<class U> constexpr basic_vec(U&& value) noexcept;
    template<class U, class UAbi>
    constexpr explicit(/* véase descripción */)
      basic_vec(const basic_vec<U, UAbi>&) noexcept;
    template<class G> constexpr explicit basic_vec(G&& gen);
    template<class R, class... Flags>
    constexpr basic_vec(R&& range, flags<Flags...> = {});
    template<class R, class... Flags>
    constexpr basic_vec(R&& range, const mask_type& mask, flags<Flags...> = {});
    constexpr basic_vec(const /*real-type*/& reals,
                        const /*real-type*/& imags = {}) noexcept;

    // simd.subscr, operadores de subíndice de basic_vec
    constexpr value_type operator[](/*simd-size-type*/) const;
    template</*simd-integral*/ I>
    constexpr resize_t<I::size(), basic_vec> operator[](const I& indices) const;

    // simd.complex.access, accesores complejos de basic_vec
    constexpr /*real-type*/ real() const noexcept;
    constexpr /*real-type*/ imag() const noexcept;
    constexpr void real(const /*real-type*/& v) noexcept;
    constexpr void imag(const /*real-type*/& v) noexcept;

    // simd.unary, operadores unarios de basic_vec
    constexpr basic_vec& operator++() noexcept;
    constexpr basic_vec operator++(int) noexcept;
    constexpr basic_vec& operator--() noexcept;
    constexpr basic_vec operator--(int) noexcept;
    constexpr mask_type operator!() const noexcept;
    constexpr basic_vec operator~() const noexcept;
    constexpr basic_vec operator+() const noexcept;
    constexpr basic_vec operator-() const noexcept;

    // simd.binary, operadores binarios de basic_vec
    friend constexpr basic_vec operator+(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator-(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator*(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator/(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator%(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator&(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator|(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator^(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator<<(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator>>(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator<<(const basic_vec&, /*simd-size-type*/) noexcept;
    friend constexpr basic_vec operator>>(const basic_vec&, /*simd-size-type*/) noexcept;

    // simd.cassign, asignación compuesta de basic_vec
    friend constexpr basic_vec& operator+=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator-=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator*=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator/=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator%=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator&=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator|=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator^=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator<<=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator>>=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator<<=(basic_vec&, /*simd-size-type*/) noexcept;
    friend constexpr basic_vec& operator>>=(basic_vec&, /*simd-size-type*/) noexcept;

    // simd.comparison, operadores de comparación de basic_vec
    friend constexpr mask_type operator==(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator!=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator>=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator<=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator>(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator<(const basic_vec&, const basic_vec&) noexcept;

    // simd.cond, operadores condicionales de basic_vec solo para exposición
    friend constexpr basic_vec /*simd-select-impl*/( // solo para exposición
      const mask_type&,
      const basic_vec&,
      const basic_vec&) noexcept;
  };

  template<class R, class... Ts> basic_vec(R&& r, Ts...)->/* véase descripción */;

  template<size_t Bytes, class Abi>
  basic_vec(basic_mask<Bytes, Abi>)->/* véase descripción */;
}

Plantilla de clase std::simd::basic_mask

namespace std::simd {
  template<size_t Bytes, class Abi> class basic_mask
  {
  public:
    using value_type = bool;
    using abi_type = Abi;
    using iterator = /*simd-iterator*/<basic_mask>;
    using const_iterator = /*simd-iterator*/<const basic_mask>;

    constexpr iterator begin() noexcept { return { *this, 0 }; }
    constexpr const_iterator begin() const noexcept { return { *this, 0 }; }
    constexpr const_iterator cbegin() const noexcept { return { *this, 0 }; }
    constexpr default_sentinel_t end() const noexcept { return {}; }
    constexpr default_sentinel_t cend() const noexcept { return {}; }

    static constexpr integral_constant</*simd-size-type*/, /*mask-size-v*/<Bytes, Abi>>
      size{};

    constexpr basic_mask() noexcept = default;

    // simd.mask.ctor, constructores de basic_mask
    constexpr explicit basic_mask(same_as<value_type> auto) noexcept;
    template<size_t UBytes, class UAbi>
    constexpr explicit basic_mask(const basic_mask<UBytes, UAbi>&) noexcept;
    template<class G> constexpr explicit basic_mask(G&& gen);
    template<same_as<bitset<size()>> T> constexpr basic_mask(const T& b) noexcept;
    template<unsigned_integral T>
      requires(!same_as<T, value_type>)
    constexpr explicit basic_mask(T val) noexcept;

    // simd.mask.subscr, operadores de subíndice de basic_mask
    constexpr value_type operator[](/*simd-size-type*/) const;
    template</*simd-integral*/ I>
    constexpr resize_t<I::size(), basic_mask> operator[](const I& indices) const;

    // simd.mask.unary, operadores unarios de basic_mask
    constexpr basic_mask operator!() const noexcept;
    constexpr /* véase descripción */ operator+() const noexcept;
    constexpr /* véase descripción */ operator-() const noexcept;
    constexpr /* véase descripción */ operator~() const noexcept;

    // simd.mask.conv, conversiones de basic_mask
    template<class U, class A>
    constexpr explicit(sizeof(U) != Bytes) operator basic_vec<U, A>() const noexcept;
    constexpr bitset<size()> to_bitset() const noexcept;
    constexpr unsigned long long to_ullong() const;

    // simd.mask.binary, operadores binarios de basic_mask
    friend constexpr basic_mask operator&&(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator||(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator&(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator|(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator^(const basic_mask&, const basic_mask&) noexcept;

    // simd.mask.cassign, asignación compuesta de basic_mask
    friend constexpr basic_mask& operator&=(basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask& operator|=(basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask& operator^=(basic_mask&, const basic_mask&) noexcept;

    // simd.mask.comparison, comparaciones de basic_mask
    friend constexpr basic_mask operator==(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator!=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator>=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator<=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator>(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator<(const basic_mask&, const basic_mask&) noexcept;

    // simd.mask.cond, operadores condicionales de basic_mask solo para exposición
    friend constexpr basic_mask /*simd-select-impl*/(    // solo para exposición
      const basic_mask&,
      const basic_mask&,
      const basic_mask&) noexcept;
    friend constexpr basic_mask /*simd-select-impl*/(    // solo para exposición
      const basic_mask&,
      same_as<bool> auto,
      same_as<bool> auto) noexcept;
    template<class T0, class T1>
    friend constexpr vec</* véase descripción */, size()> /*simd-select-impl*/(
      const basic_mask&, const T0&, const T1&) noexcept; // solo para exposición
  };
}

simd-iterator
 template<class V> class /*simd-iterator*/; // solo para exposición

 // plantilla de clase basic_vec
 template<class T, class Abi = /*native-abi*/<T>> class basic_vec;
 template<class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
 using vec = basic_vec<T, /*deduce-abi-t*/<T, N>>;

 // reducciones
 template<class T, class Abi, class BinaryOperation = plus<>>
 constexpr T reduce(const basic_vec<T, Abi>&, BinaryOperation = {});
 template<class T, class Abi, class BinaryOperation = plus<>>
 constexpr T reduce(const basic_vec<T, Abi>& x,
                    const typename basic_vec<T, Abi>::mask_type& mask,
                    BinaryOperation binary_op = {},
                    type_identity_t<T> identity_element = /* véase descripción */);

 template<class T, class BinaryOperation = plus<>>
 constexpr T reduce(const T&, BinaryOperation = {});
 template<class T, class BinaryOperation = plus<>>
 constexpr T reduce(const T& x,
                    same_as<bool> auto mask,
                    BinaryOperation binary_op = {},
                    type_identity_t<T> identity_element = /* véase descripción */);

 template<class T, class Abi> constexpr T reduce_min(const basic_vec<T, Abi>&) noexcept;
 template<class T, class Abi>
 constexpr T reduce_min(const basic_vec<T, Abi>&,
                        const typename basic_vec<T, Abi>::mask_type&) noexcept;
 template<class T, class Abi> constexpr T reduce_max(const basic_vec<T, Abi>&) noexcept;
 template<class T, class Abi>
 constexpr T reduce_max(const basic_vec<T, Abi>&,
                        const typename basic_vec<T, Abi>::mask_type&) noexcept;

 template<class T> constexpr T reduce_min(const T&) noexcept;
 template<class T> constexpr T reduce_min(const T&, same_as<bool> auto) noexcept;
 template<class T> constexpr T reduce_max(const T&) noexcept;
 template<class T> constexpr T reduce_max(const T&, same_as<bool> auto) noexcept;

 // funciones de carga y almacenamiento
 template<class V = /* véase 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 = /* véase 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 = /* véase descripción */, contiguous_iterator I, class... Flags>
 constexpr V unchecked_load(I first, iter_difference_t n, flags<Flags...> f = {});
 template<class V = /* véase descripción */, contiguous_iterator I, class... Flags>
 constexpr V unchecked_load(I first,
                            iter_difference_t n,
                            const typename V::mask_type& k,
                            flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr V unchecked_load(I first,
                            S last,
                            const typename V::mask_type& k,
                            flags<Flags...> f = {});

 template<class V = /* véase 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 = /* véase 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 = /* véase descripción */, contiguous_iterator I, class... Flags>
 constexpr V partial_load(I first, iter_difference_t n, flags<Flags...> f = {});
 template<class V = /* véase descripción */, contiguous_iterator I, class... Flags>
 constexpr V partial_load(I first,
                          iter_difference_t n,
                          const typename V::mask_type& k,
                          flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr V partial_load(I first, S last, flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          contiguous_iterator I,
          sized_sentinel_for 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>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                R&& r,
                                flags<Flags...> f = {});
 template<class T, class Abi, ranges::contiguous_range R, class... Flags>
   requires ranges::sized_range<R>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                R&& r,
                                const typename basic_vec<T, Abi>::mask_type& mask,
                                flags<Flags...> f = {});
 template<class T, class Abi, contiguous_iterator I, class... Flags>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                I first,
                                iter_difference_t n,
                                flags<Flags...> f = {});
 template<class T, class Abi, contiguous_iterator I, class... Flags>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                I first,
                                iter_difference_t n,
                                const typename basic_vec<T, Abi>::mask_type& mask,
                                flags<Flags...> f = {});
 template<class T,
          class Abi,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                I first,
                                S last,
                                flags<Flags...> f = {});
 template<class T,
          class Abi,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr void unchecked_store(const basic_vec<T, Abi>& v,
                                I first,
                                S last,
                                const typename basic_vec<T, Abi>::mask_type& mask,
                                flags<Flags...> f = {});

 template<class T, class Abi, ranges::contiguous_range R, class... Flags>
   requires ranges::sized_range<R>
 constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
 template<class T, class Abi, ranges::contiguous_range R, class... Flags>
   requires ranges::sized_range<R>
 constexpr void partial_store(const basic_vec<T, Abi>& v,
                              R&& r,
                              const typename basic_vec<T, Abi>::mask_type& mask,
                              flags<Flags...> f = {});
 template<class T, class Abi, contiguous_iterator I, class... Flags>
 constexpr void partial_store(const basic_vec<T, Abi>& v,
                              I first,
                              iter_difference_t n,
                              flags<Flags...> f = {});
 template<class T, class Abi, contiguous_iterator I, class... Flags>
 constexpr void partial_store(const basic_vec<T, Abi>& v,
                              I first,
                              iter_difference_t n,
                              const typename basic_vec<T, Abi>::mask_type& mask,
                              flags<Flags...> f = {});
 template<class T,
          class Abi,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr void partial_store(const basic_vec<T, Abi>& v,
                              I first,
                              S last,
                              flags<Flags...> f = {});
 template<class T,
          class Abi,
          contiguous_iterator I,
          sized_sentinel_for S,
          class... Flags>
 constexpr void partial_store(const basic_vec<T, Abi>& v,
                              I first,
                              S last,
                              const typename basic_vec<T, Abi>::mask_type& mask,
                              flags<Flags...> f = {});

 // permutación estática
 inline constexpr /*simd-size-type*/ zero_element = /* definido por la implementación */;
 inline constexpr /*simd-size-type*/ uninit_element = /* definido por la implementación */;

 template</*simd-size-type*/ N =
            /* véase descripción */, /*simd-vec-type*/ V, class IdxMap>
 constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap);
 template</*simd-size-type*/ N =
            /* véase descripción */, /*simd-mask-type*/ V, class IdxMap>
 constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap);

 // permutación dinámica
 template</*simd-vec-type*/ V, /*simd-integral*/ I>
 constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);
 template</*simd-mask-type*/ V, /*simd-integral*/ I>
 constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);

 // permutación de máscara
 template</*simd-vec-type*/ V>
 constexpr V compress(const V& v, const typename V::mask_type& selector);
 template</*simd-mask-type*/ V>
 constexpr V compress(const V& v, const type_identity_t<V>& selector);
 template</*simd-vec-type*/ V>
 constexpr V compress(const V& v,
                      const typename V::mask_type& selector,
                      const typename V::value_type& fill_value);
 template</*simd-mask-type*/ V>
 constexpr V compress(const V& v,
                      const type_identity_t<V>& selector,
                      const typename V::value_type& fill_value);

 template</*simd-vec-type*/ V>
 constexpr V expand(const V& v,
                    const typename V::mask_type& selector,
                    const V& original = {});
 template</*simd-mask-type*/ V>
 constexpr V expand(const V& v,
                    const type_identity_t<V>& selector,
                    const V& original = {});

 // permutación de memoria
 template<class V = /* véase descripción */,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr V unchecked_gather_from(R&& in,
                                   const typename I::mask_type& mask,
                                   const I& indices,
                                   flags<Flags...> f = {});

 template<class V = /* véase descripción */,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
 template<class V = /* véase descripción */,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr V partial_gather_from(R&& in,
                                 const typename I::mask_type& mask,
                                 const I& indices,
                                 flags<Flags...> f = {});

 template</*simd-vec-type*/ V,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr void unchecked_scatter_to(const V& v,
                                     R&& out,
                                     const I& indices,
                                     flags<Flags...> f = {});
 template</*simd-vec-type*/ V,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr void unchecked_scatter_to(const V& v,
                                     R&& out,
                                     const typename I::mask_type& mask,
                                     const I& indices,
                                     flags<Flags...> f = {});

 template</*simd-vec-type*/ V,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr void partial_scatter_to(const V& v,
                                   R&& out,
                                   const I& indices,
                                   flags<Flags...> f = {});
 template</*simd-vec-type*/ V,
          ranges::contiguous_range R,
          /*simd-integral*/ I,
          class... Flags>
   requires ranges::sized_range<R>
 constexpr void partial_scatter_to(const V& v,
                                   R&& out,
                                   const typename I::mask_type& mask,
                                   const I& indices,
                                   flags<Flags...> f = {});

 // creación
 template<class T, class Abi>
 constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept;
 template<class T, class Abi>
 constexpr auto chunk(const basic_mask</*mask-element-size*/<T>, Abi>& x) noexcept;

 template</*simd-size-type*/ N, class T, class Abi>
 constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;
 template</*simd-size-type*/ N, size_t Bytes, class Abi>
 constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept;

 template<class T, class... Abis>
 constexpr resize_t<(basic_vec<T, Abis>::size() + ...), basic_vec<T, Abis...[0]>> cat(
   const basic_vec<T, Abis>&...) noexcept;
 template<size_t Bytes, class... Abis>
 constexpr resize_t<(basic_mask<Bytes, Abis>::size() + ...),
                    basic_mask<Bytes, Abis...[0]>>
 cat(const basic_mask<Bytes, Abis>&...) noexcept;

 // algoritmos
 template<class T, class Abi>
 constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a,
                                 const basic_vec<T, Abi>& b) noexcept;
 template<class T, class Abi>
 constexpr basic_vec<T, Abi> max(const basic_vec<T, Abi>& a,
                                 const basic_vec<T, Abi>& b) noexcept;
 template<class T, class Abi>
 constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>> minmax(
   const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
 template<class T, class Abi>
 constexpr basic_vec<T, Abi> clamp(const basic_vec<T, Abi>& v,
                                   const basic_vec<T, Abi>& lo,
                                   const basic_vec<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_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-vec-t*/<V> acos(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> asin(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> atan(const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> atan2(const V& y, const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> atan2(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> atan2(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cos(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sin(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tan(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> acosh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> asinh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> atanh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cosh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sinh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tanh(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> exp(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> exp2(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> expm1(const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> frexp(const V& value,
                                      rebind_t<int, /*deduced-vec-t*/<V>>* exp);
 template</*math-floating-point*/ V>
 constexpr rebind_t<int, /*deduced-vec-t*/<V>> ilogb(const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> ldexp(const V& x,
                                      const rebind_t<int, /*deduced-vec-t*/<V>>& exp);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log10(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log1p(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> log2(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> logb(const V& x);
 template<class T, class Abi>
 constexpr basic_vec<T, Abi> modf(const type_identity_t<basic_vec<T, Abi>>& value,
                                  basic_vec<T, Abi>* iptr);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> scalbn(const V& x,
                                       const rebind_t<int, /*deduced-vec-t*/<V>>& n);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> scalbln(
   const V& x, const rebind_t<long int, /*deduced-vec-t*/<V>>& n);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> cbrt(const V& x);
 template<signed_integral T, class Abi>
 constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> abs(const V& j);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> fabs(const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x, const V& y, const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                      const V& y,
                                      const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                      const V& y,
                                      const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const /*deduced-vec-t*/<V>& x,
                                      const V& y,
                                      const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> hypot(const V& x,
                                      const /*deduced-vec-t*/<V>& y,
                                      const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> pow(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> pow(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> pow(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> sqrt(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> erf(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> erfc(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> lgamma(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> tgamma(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> ceil(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> floor(const V& x);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> nearbyint(const V& x);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> rint(const V& x);
 template</*math-floating-point*/ V>
 rebind_t<long int, /*deduced-vec-t*/<V>> lrint(const V& x);
 template</*math-floating-point*/ V>
 rebind_t<long long int, V> llrint(const /*deduced-vec-t*/<V>& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> round(const V& x);
 template</*math-floating-point*/ V>
 constexpr rebind_t<long int, /*deduced-vec-t*/<V>> lround(const V& x);
 template</*math-floating-point*/ V>
 constexpr rebind_t<long long int, /*deduced-vec-t*/<V>> llround(const V& x);
 template</*math-floating-point*/ V> constexpr /*deduced-vec-t*/<V> trunc(const V& x);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmod(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmod(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmod(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remainder(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remainder(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remainder(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remquo(const V& x,
                                       const V& y,
                                       rebind_t<int, /*deduced-vec-t*/<V>>* quo);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remquo(const /*deduced-vec-t*/<V>& x,
                                       const V& y,
                                       rebind_t<int, /*deduced-vec-t*/<V>>* quo);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> remquo(const V& x,
                                       const /*deduced-vec-t*/<V>& y,
                                       rebind_t<int, /*deduced-vec-t*/<V>>* quo);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> copysign(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> copysign(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> copysign(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> nextafter(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> nextafter(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> nextafter(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fdim(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fdim(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fdim(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmax(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmax(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmax(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmin(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmin(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fmin(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const V& x, const V& y, const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                    const V& y,
                                    const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                    const /*deduced-vec-t*/<V>& y,
                                    const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                    const V& y,
                                    const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                    const /*deduced-vec-t*/<V>& y,
                                    const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const /*deduced-vec-t*/<V>& x,
                                    const V& y,
                                    const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> fma(const V& x,
                                    const /*deduced-vec-t*/<V>& y,
                                    const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const V& a, const V& b, const V& t) noexcept;
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                     const V& y,
                                     const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                     const V& y,
                                     const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const V& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const /*deduced-vec-t*/<V>& x,
                                     const V& y,
                                     const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr /*deduced-vec-t*/<V> lerp(const V& x,
                                     const /*deduced-vec-t*/<V>& y,
                                     const /*deduced-vec-t*/<V>& z);
 template</*math-floating-point*/ V>
 constexpr rebind_t<int, /*deduced-vec-t*/<V>> fpclassify(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isfinite(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isinf(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isnan(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isnormal(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type signbit(const V& x);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(
   const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreater(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(const V& x,
                                                                   const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(
   const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isgreaterequal(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isless(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isless(const /*deduced-vec-t*/<V>& x,
                                                           const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isless(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(
   const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessequal(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(const V& x,
                                                                  const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(
   const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type islessgreater(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(const V& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(
   const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 constexpr typename /*deduced-vec-t*/<V>::mask_type isunordered(
   const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> assoc_laguerre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                     const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                     const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> assoc_legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                                     const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                     const V& x);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> beta(const V& x, const V& y);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> beta(const /*deduced-vec-t*/<V>& x, const V& y);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> beta(const V& x, const /*deduced-vec-t*/<V>& y);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> comp_ellint_1(const V& k);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> comp_ellint_2(const V& k);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> comp_ellint_3(const V& k, const V& nu);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> comp_ellint_3(const /*deduced-vec-t*/<V>& k, const V& nu);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> comp_ellint_3(const V& k, const /*deduced-vec-t*/<V>& nu);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_i(const V& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_i(const /*deduced-vec-t*/<V>& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_i(const V& nu, const /*deduced-vec-t*/<V>& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_j(const V& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_j(const /*deduced-vec-t*/<V>& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_j(const V& nu, const /*deduced-vec-t*/<V>& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_k(const V& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_k(const /*deduced-vec-t*/<V>& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_bessel_k(const V& nu, const /*deduced-vec-t*/<V>& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_neumann(const V& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_neumann(const /*deduced-vec-t*/<V>& nu, const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> cyl_neumann(const V& nu, const /*deduced-vec-t*/<V>& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_1(const V& k, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_1(const /*deduced-vec-t*/<V>& k, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_1(const V& k, const /*deduced-vec-t*/<V>& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_2(const V& k, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_2(const /*deduced-vec-t*/<V>& k, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_2(const V& k, const /*deduced-vec-t*/<V>& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const V& k, const V& nu, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k, const V& nu, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const V& k, const /*deduced-vec-t*/<V>& nu, const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const V& k, const V& nu, const /*deduced-vec-t*/<V>& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k,
                               const /*deduced-vec-t*/<V>& nu,
                               const V& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const /*deduced-vec-t*/<V>& k,
                               const V& nu,
                               const /*deduced-vec-t*/<V>& phi);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> ellint_3(const V& k,
                               const /*deduced-vec-t*/<V>& nu,
                               const /*deduced-vec-t*/<V>& phi);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> expint(const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> hermite(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                              const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> laguerre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                               const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                               const V& x);
 template</*math-floating-point*/ V> /*deduced-vec-t*/<V> riemann_zeta(const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> sph_bessel(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                 const V& x);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> sph_legendre(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& l,
                                   const rebind_t<unsigned, /*deduced-vec-t*/<V>>& m,
                                   const V& theta);
 template</*math-floating-point*/ V>
 /*deduced-vec-t*/<V> sph_neumann(const rebind_t<unsigned, /*deduced-vec-t*/<V>>& n,
                                  const V& x);

 // manipulación de bits
 template</*simd-vec-type*/ V> constexpr V byteswap(const V& v) noexcept;
 template</*simd-vec-type*/ V> constexpr V bit_ceil(const V& v);
 template</*simd-vec-type*/ V> constexpr V bit_floor(const V& v) noexcept;

 template</*simd-vec-type*/ V>
 constexpr typename V::mask_type has_single_bit(const V& v) noexcept;

 template</*simd-vec-type*/ V0, /*simd-vec-type*/ V1>
 constexpr V0 rotl(const V0& v, const V1& s) noexcept;
 template</*simd-vec-type*/ V> constexpr V rotl(const V& v, int s) noexcept;

 template</*simd-vec-type*/ V0, /*simd-vec-type*/ V1>
 constexpr V0 rotr(const V0& v, const V1& s) noexcept;
 template</*simd-vec-type*/ V> constexpr V rotr(const V& v, int s) noexcept;

 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(
   const V& v) noexcept;
 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(
   const V& v) noexcept;
 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(
   const V& v) noexcept;
 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(
   const V& v) noexcept;
 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(
   const V& v) noexcept;
 template</*simd-vec-type*/ V>
 constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(
   const V& v) noexcept;

 // matemáticas complejas
 template</*simd-complex*/ V>
 constexpr rebind_t</*simd-complex-value-type*/<V>, V> real(const V&) noexcept;

 template</*simd-complex*/ V>
 constexpr rebind_t</*simd-complex-value-type*/<V>, V> imag(const V&) noexcept;

 template</*simd-complex*/ V>
 constexpr rebind_t</*simd-complex-value-type*/<V>, V> abs(const V&);

 template</*simd-complex*/ V>
 constexpr rebind_t</*simd-complex-value-type*/<V>, V> arg(const V&);

 template</*simd-complex*/ V>
 constexpr rebind_t</*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);

 // plantilla de clase basic_mask
 template<size_t Bytes, class Abi> class basic_mask;
 template<class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
 using mask = vec<T, N>::mask_type;

 // reducciones
 template<size_t Bytes, class Abi>
 constexpr bool all_of(const basic_mask<Bytes, Abi>&) noexcept;
 template<size_t Bytes, class Abi>
 constexpr bool any_of(const basic_mask<Bytes, Abi>&) noexcept;
 template<size_t Bytes, class Abi>
 constexpr bool none_of(const basic_mask<Bytes, Abi>&) noexcept;
 template<size_t Bytes, class Abi>
 constexpr /*simd-size-type*/ reduce_count(const basic_mask<Bytes, Abi>&) noexcept;
 template<size_t Bytes, class Abi>
 constexpr /*simd-size-type*/ reduce_min_index(const basic_mask<Bytes, Abi>&);
 template<size_t Bytes, class Abi>
 constexpr /*simd-size-type*/ reduce_max_index(const basic_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);

}

namespace std {

 // algoritmos
 using simd::min;
 using simd::max;
 using simd::minmax;
 using simd::clamp;

 // funciones matemáticas
 using simd::acos;
 using simd::asin;
 using simd::atan;
 using simd::atan2;
 using simd::cos;
 using simd::sin;
 using simd::tan;
 using simd::acosh;
 using simd::asinh;
 using simd::atanh;
 using simd::cosh;
 using simd::sinh;
 using simd::tanh;
 using simd::exp;
 using simd::exp2;
 using simd::expm1;
 using simd::frexp;
 using simd::ilogb;
 using simd::ldexp;
 using simd::log;
 using simd::log10;
 using simd::log1p;
 using simd::log2;
 using simd::logb;
 using simd::modf;
 using simd::scalbn;
 using simd::scalbln;
 using simd::cbrt;
 using simd::abs;
 using simd::fabs;
 using simd::hypot;
 using simd::pow;
 using simd::sqrt;
 using simd::erf;
 using simd::erfc;
 using simd::lgamma;
 using simd::tgamma;
 using simd::ceil;
 using simd::floor;
 using simd::nearbyint;
 using simd::rint;
 using simd::lrint;
 using simd::llrint;
 using simd::round;
 using simd::lround;
 using simd::llround;
 using simd::trunc;
 using simd::fmod;
 using simd::remainder;
 using simd::remquo;
 using simd::copysign;
 using simd::nextafter;
 using simd::fdim;
 using simd::fmax;
 using simd::fmin;
 using simd::fma;
 using simd::lerp;
 using simd::fpclassify;
 using simd::isfinite;
 using simd::isinf;
 using simd::isnan;
 using simd::isnormal;
 using simd::signbit;
 using simd::isgreater;
 using simd::isgreaterequal;
 using simd::isless;
 using simd::islessequal;
 using simd::islessgreater;
 using simd::isunordered;
 using simd::assoc_laguerre;
 using simd::assoc_legendre;
 using simd::beta;
 using simd::comp_ellint_1;
 using simd::comp_ellint_2;
 using simd::comp_ellint_3;
 using simd::cyl_bessel_i;
 using simd::cyl_bessel_j;
 using simd::cyl_bessel_k;
 using simd::cyl_neumann;
 using simd::ellint_1;
 using simd::ellint_2;
 using simd::ellint_3;
 using simd::expint;
 using simd::hermite;
 using simd::laguerre;
 using simd::legendre;
 using simd::riemann_zeta;
 using simd::sph_bessel;
 using simd::sph_legendre;
 using simd::sph_neumann;

 // manipulación de bits
 using simd::byteswap;
 using simd::bit_ceil;
 using simd::bit_floor;
 using simd::has_single_bit;
 using simd::rotl;
 using simd::rotr;
 using simd::bit_width;
 using simd::countl_zero;
 using simd::countl_one;
 using simd::countr_zero;
 using simd::countr_one;
 using simd::popcount;

 // matemáticas complejas de vectores
 using simd::real;
 using simd::imag;
 using simd::arg;
 using simd::norm;
 using simd::conj;
 using simd::proj;
 using simd::polar;

} }}

Plantilla de clase std::simd::flags

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

Plantilla de clase std::simd::simd-iterator

namespace std::simd {
  template<class V> class /*simd-iterator*/
  {                                                                     // solo para exposición
    V* /*data_*/ = nullptr;                                             // solo para exposición
    /*simd-size-type*/ /*offset_*/ = 0;                                 // solo para exposición

    constexpr /*simd-iterator*/(V& d, /*simd-size-type*/ off) noexcept; // solo para exposición

  public:
    using value_type = V::value_type;
    using iterator_category = input_iterator_tag;
    using iterator_concept = random_access_iterator_tag;
    using difference_type = /*simd-size-type*/;

    constexpr /*simd-iterator*/() = default;

    constexpr /*simd-iterator*/(const /*simd-iterator*/&) = default;
    constexpr /*simd-iterator*/& operator=(const /*simd-iterator*/&) = default;

    constexpr /*simd-iterator*/(const /*simd-iterator*/<remove_const_t<V>>&)
      requires is_const_v<V>;

    constexpr value_type operator*() const;

    constexpr /*simd-iterator*/& operator++();
    constexpr /*simd-iterator*/ operator++(int);
    constexpr /*simd-iterator*/& operator--();
    constexpr /*simd-iterator*/ operator--(int);

    constexpr /*simd-iterator*/& operator+=(difference_type n);
    constexpr /*simd-iterator*/& operator-=(difference_type n);

    constexpr value_type operator[](difference_type n) const;

    friend constexpr bool operator==(/*simd-iterator*/ a, /*simd-iterator*/ b) = default;
    friend constexpr bool operator==(/*simd-iterator*/ a, default_sentinel_t) noexcept;
    friend constexpr auto operator<=>(/*simd-iterator*/ a, /*simd-iterator*/ b);

    friend constexpr /*simd-iterator*/ operator+(/*simd-iterator*/ i, difference_type n);
    friend constexpr /*simd-iterator*/ operator+(difference_type n, /*simd-iterator*/ i);
    friend constexpr /*simd-iterator*/ operator-(/*simd-iterator*/ i, difference_type n);

    friend constexpr difference_type operator-(/*simd-iterator*/ a, /*simd-iterator*/ b);
    friend constexpr difference_type operator-(/*simd-iterator*/ i,
                                               default_sentinel_t) noexcept;
    friend constexpr difference_type operator-(default_sentinel_t,
                                               /*simd-iterator*/ i) noexcept;
  };
}

Plantilla de clase std::simd::basic_vec

namespace std::simd {
  template<class T, class Abi> class basic_vec
  {
    using /*real-type*/ = /* véase descripción */; // solo para exposición
  public:
    using value_type = T;
    using mask_type = basic_mask<sizeof(T), Abi>;
    using abi_type = Abi;
    using iterator = /*simd-iterator*/<basic_vec>;
    using const_iterator = /*simd-iterator*/<const basic_vec>;

    constexpr iterator begin() noexcept { return { *this, 0 }; }
    constexpr const_iterator begin() const noexcept { return { *this, 0 }; }
    constexpr const_iterator cbegin() const noexcept { return { *this, 0 }; }
    constexpr default_sentinel_t end() const noexcept { return {}; }
    constexpr default_sentinel_t cend() const noexcept { return {}; }

    static constexpr integral_constant</*simd-size-type*/, /*simd-size-v*/<T, Abi>>
      size{};

    constexpr basic_vec() noexcept = default;

    // simd.ctor, constructores de basic_vec
    template<class U> constexpr basic_vec(U&& value) noexcept;
    template<class U, class UAbi>
    constexpr explicit(/* véase descripción */)
      basic_vec(const basic_vec<U, UAbi>&) noexcept;
    template<class G> constexpr explicit basic_vec(G&& gen);
    template<class R, class... Flags>
    constexpr basic_vec(R&& range, flags<Flags...> = {});
    template<class R, class... Flags>
    constexpr basic_vec(R&& range, const mask_type& mask, flags<Flags...> = {});
    constexpr basic_vec(const /*real-type*/& reals,
                        const /*real-type*/& imags = {}) noexcept;

    // simd.subscr, operadores de subíndice de basic_vec
    constexpr value_type operator[](/*simd-size-type*/) const;
    template</*simd-integral*/ I>
    constexpr resize_t<I::size(), basic_vec> operator[](const I& indices) const;

    // simd.complex.access, accesores complejos de basic_vec
    constexpr /*real-type*/ real() const noexcept;
    constexpr /*real-type*/ imag() const noexcept;
    constexpr void real(const /*real-type*/& v) noexcept;
    constexpr void imag(const /*real-type*/& v) noexcept;

    // simd.unary, operadores unarios de basic_vec
    constexpr basic_vec& operator++() noexcept;
    constexpr basic_vec operator++(int) noexcept;
    constexpr basic_vec& operator--() noexcept;
    constexpr basic_vec operator--(int) noexcept;
    constexpr mask_type operator!() const noexcept;
    constexpr basic_vec operator~() const noexcept;
    constexpr basic_vec operator+() const noexcept;
    constexpr basic_vec operator-() const noexcept;

    // simd.binary, operadores binarios de basic_vec
    friend constexpr basic_vec operator+(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator-(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator*(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator/(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator%(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator&(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator|(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator^(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator<<(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator>>(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec operator<<(const basic_vec&, /*simd-size-type*/) noexcept;
    friend constexpr basic_vec operator>>(const basic_vec&, /*simd-size-type*/) noexcept;

    // simd.cassign, asignación compuesta de basic_vec
    friend constexpr basic_vec& operator+=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator-=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator*=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator/=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator%=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator&=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator|=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator^=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator<<=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator>>=(basic_vec&, const basic_vec&) noexcept;
    friend constexpr basic_vec& operator<<=(basic_vec&, /*simd-size-type*/) noexcept;
    friend constexpr basic_vec& operator>>=(basic_vec&, /*simd-size-type*/) noexcept;

    // simd.comparison, operadores de comparación de basic_vec
    friend constexpr mask_type operator==(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator!=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator>=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator<=(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator>(const basic_vec&, const basic_vec&) noexcept;
    friend constexpr mask_type operator<(const basic_vec&, const basic_vec&) noexcept;

    // simd.cond, operadores condicionales de basic_vec solo para exposición
    friend constexpr basic_vec /*simd-select-impl*/( // solo para exposición
      const mask_type&,
      const basic_vec&,
      const basic_vec&) noexcept;
  };

  template<class R, class... Ts> basic_vec(R&& r, Ts...)->/* véase descripción */;

  template<size_t Bytes, class Abi>
  basic_vec(basic_mask<Bytes, Abi>)->/* véase descripción */;
}

Plantilla de clase std::simd::basic_mask

namespace std::simd {
  template<size_t Bytes, class Abi> class basic_mask
  {
  public:
    using value_type = bool;
    using abi_type = Abi;
    using iterator = /*simd-iterator*/<basic_mask>;
    using const_iterator = /*simd-iterator*/<const basic_mask>;

    constexpr iterator begin() noexcept { return { *this, 0 }; }
    constexpr const_iterator begin() const noexcept { return { *this, 0 }; }
    constexpr const_iterator cbegin() const noexcept { return { *this, 0 }; }
    constexpr default_sentinel_t end() const noexcept { return {}; }
    constexpr default_sentinel_t cend() const noexcept { return {}; }

    static constexpr integral_constant</*simd-size-type*/, /*mask-size-v*/<Bytes, Abi>>
      size{};

    constexpr basic_mask() noexcept = default;

    // simd.mask.ctor, constructores de basic_mask
    constexpr explicit basic_mask(same_as<value_type> auto) noexcept;
    template<size_t UBytes, class UAbi>
    constexpr explicit basic_mask(const basic_mask<UBytes, UAbi>&) noexcept;
    template<class G> constexpr explicit basic_mask(G&& gen);
    template<same_as<bitset<size()>> T> constexpr basic_mask(const T& b) noexcept;
    template<unsigned_integral T>
      requires(!same_as<T, value_type>)
    constexpr explicit basic_mask(T val) noexcept;

    // simd.mask.subscr, operadores de subíndice de basic_mask
    constexpr value_type operator[](/*simd-size-type*/) const;
    template</*simd-integral*/ I>
    constexpr resize_t<I::size(), basic_mask> operator[](const I& indices) const;

    // simd.mask.unary, operadores unarios de basic_mask
    constexpr basic_mask operator!() const noexcept;
    constexpr /* véase descripción */ operator+() const noexcept;
    constexpr /* véase descripción */ operator-() const noexcept;
    constexpr /* véase descripción */ operator~() const noexcept;

    // simd.mask.conv, conversiones de basic_mask
    template<class U, class A>
    constexpr explicit(sizeof(U) != Bytes) operator basic_vec<U, A>() const noexcept;
    constexpr bitset<size()> to_bitset() const noexcept;
    constexpr unsigned long long to_ullong() const;

    // simd.mask.binary, operadores binarios de basic_mask
    friend constexpr basic_mask operator&&(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator||(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator&(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator|(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator^(const basic_mask&, const basic_mask&) noexcept;

    // simd.mask.cassign, asignación compuesta de basic_mask
    friend constexpr basic_mask& operator&=(basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask& operator|=(basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask& operator^=(basic_mask&, const basic_mask&) noexcept;

    // simd.mask.comparison, comparaciones de basic_mask
    friend constexpr basic_mask operator==(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator!=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator>=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator<=(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator>(const basic_mask&, const basic_mask&) noexcept;
    friend constexpr basic_mask operator<(const basic_mask&, const basic_mask&) noexcept;

    // simd.mask.cond, operadores condicionales de basic_mask solo para exposición
    friend constexpr basic_mask /*simd-select-impl*/(    // solo para exposición
      const basic_mask&,
      const basic_mask&,
      const basic_mask&) noexcept;
    friend constexpr basic_mask /*simd-select-impl*/(    // solo para exposición
      const basic_mask&,
      same_as<bool> auto,
      same_as<bool> auto) noexcept;
    template<class T0, class T1>
    friend constexpr vec</* véase descripción */, size()> /*simd-select-impl*/(
      const basic_mask&, const T0&, const T1&) noexcept; // solo para exposición
  };
}