Namespaces
Variants

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

From cppreference.net
C++
Standard library headers

このヘッダは numeric ライブラリの一部です。

目次

クラス

(C++26)
データ並列ベクトル型
(クラステンプレート)
(C++26)
その幅を指定できる basic_simd の便利なエイリアステンプレート
(エイリアステンプレート)
(C++26)
要素型が bool のデータ並列型
(クラステンプレート)
(C++26)
その幅を指定できる basic_simd_mask の便利なエイリアステンプレート
(エイリアステンプレート)
(C++26)
データ並列型のためのロード・ストアフラグ
(クラステンプレート)
(C++26)
datapar::flag_aligned に適切なアライメントを取得する
(クラステンプレート)
(C++26)
データ並列型の要素型を変更する
(クラステンプレート)
(C++26)
データ並列型の幅を変更する
(クラステンプレート)

関数

(C++26)
連続範囲から要素を basic_simd にロードする
(関数テンプレート)
(C++26)
basic_simd の要素を連続範囲に格納
(関数テンプレート)
(C++26)
単一のデータ並列オブジェクトを複数のオブジェクトに分割する
(関数テンプレート)
(C++26)
複数のデータ並列オブジェクトを単一のオブジェクトに連結する
(関数テンプレート)
(C++26)
basic_simd_mask の bool への縮約
(関数テンプレート)
(C++26)
basic_simd_mask の true 値の個数への縮約
(関数テンプレート)
(C++26)
basic_simd_mask の最初または最後の true 値のインデックスへの縮約
(関数テンプレート)
(C++26)
basic_simd 内のすべての値を指定された二項演算で単一の値に縮約する
(関数テンプレート)
(C++26)
basic_simd に対する要素単位の最小/最大演算
(関数テンプレート)
(C++26)
basic_simd に対する要素ごとのクランプ操作
(関数テンプレート)
(C++26)
条件演算子を使用した要素ごとの選択
(関数テンプレート)

定数

(C++26)
ロードおよびストア操作で使用されるデフォルトフラグ
(定数)
(C++26)
ロードおよびストア操作において値保存的でない変換を有効にするフラグ
(定数)
(C++26)
ロード・ストアアドレスのアライメントが datapar::alignment の値に指定されたストレージに合っていることを示すフラグ
(定数)
(C++26)
指定されたストレージのロード・ストアアドレスのアライメントが指定されたアライメントに合っていることを示すフラグ
(variable template)

概要 

namespace std::datapar {
// SIMD 型特性
template <class T, class U = typename T::value_type> struct alignment;
template <class T, class U = typename T::value_type>
constexpr size_t alignment_v = alignment<T, U>::value;
template <class T, class V> struct rebind {
  using type = /* 説明を参照 */;
};
template <class T, class V> using rebind_t = typename rebind<T, V>::type;
template </*simd-size-type*/ N, class V> struct resize {
  using type = /* 説明を参照 */;
};
template </*simd-size-type*/ N, class V>
using resize_t = typename resize<N, V>::type;
// ロードおよびストアフラグ
template <class... フラグ> struct flags;
inline constexpr flags<> flag_default{};
inline constexpr flags</*変換フラグ*/> 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{};
// クラステンプレート basic_simd
template <class T, class Abi = /*native-abi*/<T>> class basic_simd;
template <class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
using simd = basic_simd<T, /*deduce-abi-t*/<T, N>>;
// クラステンプレート basic_simd_mask
template <size_t Bytes, class Abi = /*native-abi*/</*整数から*/<Bytes>>>
class basic_simd_mask;
template <class T, /*simd-size-type*/ N = /*simd-size-v*/<T, /*native-abi*/<T>>>
using simd_mask = basic_simd_mask<sizeof(T), /*deduce-abi-t*/<T, N>>;
// 基本的なSIMDロードおよびストア関数
template <class V = /* 説明を参照 */, ranges::contiguous_range R,
          class... フラグ>
  requires ranges::sized_range<R>
constexpr V unchecked_load(R &&r, flags<Flags...> f = {});
template <class V = /* 説明を参照 */, ranges::contiguous_range R,
          class... フラグ>
  requires ranges::sized_range<R>
constexpr V unchecked_load(R &&r, const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* 詳細は説明を参照 */, contiguous_iterator I,
          class... フラグ>
constexpr V unchecked_load(I first, iter_difference_t<I> n,
                           flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          class... フラグ>
constexpr V unchecked_load(I first, iter_difference_t<I> n,
                           const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... フラグ>
constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... フラグ>
constexpr V unchecked_load(I first, S last, const typename V::mask_type &k,
                           flags<Flags...> f = {});
template <class V = /* 説明を参照 */, ranges::contiguous_range R,
          class... フラグ>
  requires ranges::sized_range<R>
constexpr V partial_load(R &&r, flags<Flags...> f = {});
template <class V = /* 説明を参照 */, ranges::contiguous_range R,
          class... フラグ>
  requires ranges::sized_range
（注：指定された条件により、HTMLタグ・属性は保持され、C++固有用語である「ranges::sized_range」は翻訳対象外のため、元のテキストをそのまま保持しています）<R>
constexpr V partial_load(R &&r, const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class V = /* 詳細は説明を参照 */, contiguous_iterator I,
          class... フラグ>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          class... フラグ>
constexpr V partial_load(I first, iter_difference_t<I> n,
                         const typename V::mask_type &k,
                         flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... フラグ>
constexpr V partial_load(I first, S last, flags<Flags...> f = {});
template <class V = /* 説明を参照 */, contiguous_iterator I,
          sized_sentinel_for<I> S, class... フラグ>
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... フラグ>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t<R>, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, R &&r,
                               flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... フラグ>
  requires ranges::sized_range
（注：指定された条件に基づき、HTMLタグ・属性は翻訳せず、C++固有用語も保持しました。表示されるテキスト部分「ranges::sized_range」はC++の専門用語であるため、原文のまま維持しています）<R> &&
           indirectly_writable<ranges::iterator_t
（注：指定された条件により、HTMLタグ・属性は翻訳せず、C++固有用語も翻訳していません。テキスト部分が既に英語の専門用語のみであるため、翻訳対象となる自然言語テキストが存在しません）<R>, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, R &&r,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... フラグ>
  requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, I first,
                               iter_difference_t<I> n, flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... フラグ>
  requires indirectly_writable<I, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, I first, iter_difference_t<I> n,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... フラグ>
  requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_simd<T, Abi> &v, I first, S last,
                               flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... フラグ>
  requires indirectly_writable<I, T>
constexpr void
unchecked_store(const basic_simd<T, Abi> &v, I first, S last,
                const typename basic_simd<T, Abi>::mask_type &mask,
                flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... フラグ>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t
（注：指定された条件により、HTMLタグ・属性は翻訳せず、C++固有用語も翻訳していません。表示されるテキスト「ranges::iterator_t」はC++の専門用語であるため、原文のまま保持しています）<R>, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, R &&r,
                             flags<Flags...> f = {});
template <class T, class Abi, ranges::contiguous_range R, class... フラグ>
  requires ranges::sized_range<R> &&
           indirectly_writable<ranges::iterator_t
（注：指定された条件により、HTMLタグ・属性は翻訳せず、C++固有用語も翻訳していません。表示されるテキスト「ranges::iterator_t」はC++の専門用語であるため、原文のまま保持しています）<R>, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, R &&r,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... フラグ>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first,
                             iter_difference_t<I> n, flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, class... フラグ>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first,
                             iter_difference_t<I> n,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... フラグ>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first, S last,
                             flags<Flags...> f = {});
template <class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S,
          class... フラグ>
  requires indirectly_writable<I, T>
constexpr void partial_store(const basic_simd<T, Abi> &v, I first, S last,
                             const typename basic_simd<T, Abi>::mask_type &mask,
                             flags<Flags...> f = {});
// basic_simdとbasic_simd_maskの作成
template <class T, class Abi>
constexpr auto chunk(const basic_simd<typename T::value_type, Abi> &x) noexcept;
template <class T, class Abi>
constexpr auto
chunk(const basic_simd_mask</*mask-element-size*/<T>, Abi> &x) noexcept;
template <size_t N, class T, class Abi>
constexpr auto chunk(const basic_simd<T, Abi> &x) noexcept;
template <size_t N, size_t Bytes, class Abi>
constexpr auto chunk(const basic_simd_mask<Bytes, Abi> &x) noexcept;
template <class T, class... Abis>
constexpr basic_simd<T,
                     /*deduce-abi-t*/<T, (basic_simd<T, Abis>::size() + ...)>>
cat(const basic_simd<T, Abis> &...) noexcept;
template <size_t Bytes, class... Abis>
constexpr basic_simd_mask<
    Bytes, /*deduce-abi-t*/</*整数から*/<Bytes>,
                            (basic_simd_mask<Bytes, Abis>::size() + ...)>>
cat(const basic_simd_mask<Bytes, Abis> &...) noexcept;
// basic_simd_mask リダクション
template <size_t Bytes, class Abi>
constexpr bool all_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr bool any_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr bool none_of(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_count(const basic_simd_mask<Bytes, Abi> &) noexcept;
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_min_index(const basic_simd_mask<Bytes, Abi> &);
template <size_t Bytes, class Abi>
constexpr /*simd-size-type*/
reduce_max_index(const basic_simd_mask<Bytes, Abi> &);
constexpr bool all_of(same_as<bool> auto) noexcept;
constexpr bool any_of(same_as<bool> auto) noexcept;
constexpr bool none_of(same_as<bool> auto) noexcept;
constexpr /*simd-size-type*/ reduce_count(same_as<bool> auto) noexcept;
constexpr /*simd-size-type*/ reduce_min_index(same_as<bool> auto);
constexpr /*simd-size-type*/ reduce_max_index(same_as<bool> auto);
// 基本的なSIMDリダクション
template <class T, class Abi, class BinaryOperation = plus<>>
constexpr T reduce(const basic_simd<T, Abi> &, BinaryOperation = {});
template <class T, class Abi, class BinaryOperation = plus<>>
constexpr T reduce(const basic_simd<T, Abi> &x,
                   const typename basic_simd<T, Abi>::mask_type &mask,
                   BinaryOperation binary_op = {},
                   type_identity_t<T> identity_element = /* 説明を参照 */);
template <class T, class Abi>
constexpr T reduce_min(const basic_simd<T, Abi> &) noexcept;
template <class T, class Abi>
constexpr T reduce_min(const basic_simd<T, Abi> &,
                       const typename basic_simd<T, Abi>::mask_type &) noexcept;
template <class T, class Abi>
constexpr T reduce_max(const basic_simd<T, Abi> &) noexcept;
template <class T, class Abi>
constexpr T reduce_max(const basic_simd<T, Abi> &,
                       const typename basic_simd<T, Abi>::mask_type &) noexcept;
// アルゴリズム
template <class T, class Abi>
constexpr basic_simd<T, Abi> min(const basic_simd<T, Abi> &a,
                                 const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr basic_simd<T, Abi> max(const basic_simd<T, Abi> &a,
                                 const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr pair<basic_simd<T, Abi>, basic_simd<T, Abi>>
minmax(const basic_simd<T, Abi> &a, const basic_simd<T, Abi> &b) noexcept;
template <class T, class Abi>
constexpr basic_simd<T, Abi> clamp(const basic_simd<T, Abi> &v,
                                   const basic_simd<T, Abi> &lo,
                                   const basic_simd<T, Abi> &hi);
template <class T, class U>
constexpr auto select(bool c, const T &a, const U &b)
    -> remove_cvref_t<decltype(c ? a : b)>;
template <size_t Bytes, class Abi, class T, class U>
constexpr auto select(const basic_simd_mask<Bytes, Abi> &c, const T &a,
                      const U &b) noexcept
    -> decltype(/*simd-select-impl*/(c, a, b));
// 数学関数
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> acos(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> asin(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> atan(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> atan2(const V0 &y, const V1 &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cos(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sin(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tan(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> acosh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> asinh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> atanh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cosh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sinh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tanh(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> exp(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> exp2(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> expm1(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
frexp(const V &value, rebind_t<int, /*deduced-simd-t*/<V>> *exp);
template </*math-floating-point*/ V>
constexpr rebind_t<int, /*deduced-simd-t*/<V>> ilogb(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
ldexp(const V &x, const rebind_t<int, /*deduced-simd-t*/<V>> &exp);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log10(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log1p(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> log2(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> logb(const V &x);
template <class T, class Abi>
constexpr basic_simd<T, Abi>
modf(const type_identity_t<basic_simd<T, Abi>> &value,
     basic_simd<T, Abi> *iptr);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
scalbn(const V &x, const rebind_t<int, /*deduced-simd-t*/<V>> &n);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V>
scalbln(const V &x, const rebind_t<long int, /*deduced-simd-t*/<V>> &n);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> cbrt(const V &x);
template <signed_integral T, class Abi>
constexpr basic_simd<T, Abi> abs(const basic_simd<T, Abi> &j);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> abs(const V &j);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> fabs(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> hypot(const V0 &x, const V1 &y);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> hypot(const V0 &x, const V1 &y,
                                                   const V2 &z);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> pow(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> sqrt(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> erf(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> erfc(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> lgamma(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> tgamma(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> ceil(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> floor(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> nearbyint(const V &x);
template </*math-floating-point*/ V> /*deduced-simd-t*/<V> rint(const V &x);
template </*math-floating-point*/ V>
rebind_t<long int, /*deduced-simd-t*/<V>> lrint(const V &x);
template </*math-floating-point*/ V>
rebind_t<long long int, V> llrint(const /*deduced-simd-t*/<V> &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> round(const V &x);
template </*math-floating-point*/ V>
constexpr rebind_t<long int, /*deduced-simd-t*/<V>> lround(const V &x);
template </*math-floating-point*/ V>
constexpr rebind_t<long long int, /*deduced-simd-t*/<V>> llround(const V &x);
template </*math-floating-point*/ V>
constexpr /*deduced-simd-t*/<V> trunc(const V &x);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmod(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> remainder(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1>
remquo(const V0 &x, const V1 &y,
       rebind_t<int, /*math-common-simd-t*/<V0, V1>> *quo);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> copysign(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> nextafter(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fdim(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmax(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr /*math-common-simd-t*/<V0, V1> fmin(const V0 &x, const V1 &y);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> fma(const V0 &x, const V1 &y,
                                                 const V2 &z);
template <class V0, class V1, class V2>
constexpr /*math-common-simd-t*/<V0, V1, V2> lerp(const V0 &a, const V1 &b,
                                                  const V2 &t) noexcept;
template </*math-floating-point*/ V>
constexpr rebind_t<int, /*deduced-simd-t*/<V>> fpclassify(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isfinite(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isinf(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isnan(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type isnormal(const V &x);
template </*math-floating-point*/ V>
constexpr typename /*deduced-simd-t*/<V>::mask_type signbit(const V &x);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isgreater(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isgreaterequal(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isless(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
islessequal(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
islessgreater(const V0 &x, const V1 &y);
template <class V0, class V1>
constexpr typename /*math-common-simd-t*/<V0, V1>::mask_type
isunordered(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
assoc_laguerre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n,
               const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
assoc_legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l,
               const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m, const V &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> beta(const V0 &x, const V1 &y);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> comp_ellint_1(const V &k);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> comp_ellint_2(const V &k);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> comp_ellint_3(const V0 &k, const V1 &nu);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_i(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_j(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_bessel_k(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> cyl_neumann(const V0 &nu, const V1 &x);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> ellint_1(const V0 &k, const V1 &phi);
template <class V0, class V1>
/*math-common-simd-t*/<V0, V1> ellint_2(const V0 &k, const V1 &phi);
template <class V0, class V1, class V2>
/*math-common-simd-t*/<V0, V1, V2> ellint_3(const V0 &k, const V1 &nu,
                                            const V2 &phi);
template </*math-floating-point*/ V> /*deduced-simd-t*/<V> expint(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
hermite(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
laguerre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V> riemann_zeta(const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_bessel(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_legendre(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &l,
             const rebind_t<unsigned, /*deduced-simd-t*/<V>> &m,
             const V &theta);
template </*math-floating-point*/ V>
/*deduced-simd-t*/<V>
sph_neumann(const rebind_t<unsigned, /*deduced-simd-t*/<V>> &n, const V &x);
// ビット操作
template </*simd-type*/ V> constexpr V byteswap(const V &v) noexcept;
template </*simd-type*/ V> constexpr V bit_ceil(const V &v) noexcept;
template </*simd-type*/ V> constexpr V bit_floor(const V &v) noexcept;
template </*simd-type*/ V>
constexpr typename V::mask_type has_single_bit(const V &v) noexcept;
template </*simd-type*/ V0, /*simd-type*/ V1>
constexpr V0 rotl(const V0 &v, const V1 &s) noexcept;
template </*simd-type*/ V> constexpr V rotl(const V &v, int s) noexcept;
template </*simd-type*/ V0, /*simd-type*/ V1>
constexpr V0 rotr(const V0 &v, const V1 &s) noexcept;
template </*simd-type*/ V> constexpr V rotr(const V &v, int s) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
bit_width(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countl_zero(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countl_one(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countr_zero(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
countr_one(const V &v) noexcept;
template </*simd-type*/ V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V>
popcount(const V &v) noexcept;
// SIMD 複素数演算
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> real(const V &) noexcept;
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> imag(const V &) noexcept;
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> abs(const V &);
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> arg(const V &);
template </*simd-complex*/ V>
constexpr </*simd-complex-value-type*/<V>, V> norm(const V &);
template </*simd-complex*/ V> constexpr V conj(const V &);
template </*simd-complex*/ V> constexpr V proj(const V &);
template </*simd-complex*/ V> constexpr V exp(const V &v);
template </*simd-complex*/ V> constexpr V log(const V &v);
template </*simd-complex*/ V> constexpr V log10(const V &v);
template </*simd-complex*/ V> constexpr V sqrt(const V &v);
template </*simd-complex*/ V> constexpr V sin(const V &v);
template </*simd-complex*/ V> constexpr V asin(const V &v);
template </*simd-complex*/ V> constexpr V cos(const V &v);
template </*simd-complex*/ V> constexpr V acos(const V &v);
template </*simd-complex*/ V> constexpr V tan(const V &v);
template </*simd-complex*/ V> constexpr V atan(const V &v);
template </*simd-complex*/ V> constexpr V sinh(const V &v);
template </*simd-complex*/ V> constexpr V asinh(const V &v);
template </*simd-complex*/ V> constexpr V cosh(const V &v);
template </*simd-complex*/ V> constexpr V acosh(const V &v);
template </*simd-complex*/ V> constexpr V tanh(const V &v);
template </*simd-complex*/ V> constexpr V atanh(const V &v);
template </*SIMD浮動小数点*/ V>
rebind_t<complex<typename V::value_type>, V> polar(const V &x, const V &y = {});
template </*simd-complex*/ V> constexpr V pow(const V &x, const V &y);
}
namespace std {
// アルゴリズムを参照
using datapar::clamp;
using datapar::max;
using datapar::min;
using datapar::minmax;
// 数学関数を参照
using datapar::abs;
using datapar::acos;
using datapar::acosh;
using datapar::asin;
using datapar::asinh;
using datapar::assoc_laguerre;
using datapar::assoc_legendre;
using datapar::atan;
using datapar::atan2;
using datapar::atanh;
using datapar::ベータ;
using datapar::cbrt;
using datapar::ceil;
using datapar::comp_ellint_1;
using datapar::comp_ellint_2;
using datapar::comp_ellint_3;
using datapar::copysign;
using datapar::cos;
using datapar::cosh;
using datapar::cyl_bessel_i;
using datapar::cyl_bessel_j;
using datapar::cyl_bessel_k;
using datapar::cyl_neumann;
using datapar::ellint_1;
using datapar::ellint_2;
using datapar::ellint_3;
using datapar::erf;
using datapar::erfc;
using datapar::exp;
using datapar::exp2;
using datapar::expint;
using datapar::expm1;
using datapar::fabs;
using datapar::fdim;
using datapar::floor;
using datapar::fma;
using datapar::fmax;
using datapar::fmin;
using datapar::fmod;
using datapar::fpclassify;
using datapar::frexp;
using datapar::エルミート;
using datapar::hypot;
using datapar::ilogb;
using datapar::isfinite;
using datapar::isgreater;
using datapar::isgreaterequal;
using datapar::isinf;
using datapar::isless;
using datapar::islessequal;
using datapar::islessgreater;
using datapar::isnan;
using datapar::isnormal;
using datapar::isunordered;
using datapar::ラゲール;
using datapar::ldexp;
using datapar::ルジャンドル;
using datapar::lerp;
using datapar::lgamma;
using datapar::llrint;
using datapar::llround;
using datapar::log;
using datapar::log10;
using datapar::log1p;
using datapar::log2;
using datapar::logb;
using datapar::lrint;
using datapar::lround;
using datapar::modf;
using datapar::nearbyint;
using datapar::nextafter;
using datapar::pow;
using datapar::remainder;
using datapar::remquo;
using datapar::リーマンゼータ関数;
using datapar::rint;
using datapar::round;
using datapar::scalbln;
using datapar::scalbn;
using datapar::signbit;
using datapar::sin;
using datapar::sinh;
using datapar::sph_bessel;
using datapar::sph_legendre;
using datapar::sph_neumann;
using datapar::sqrt;
using datapar::tan;
using datapar::tanh;
using datapar::tgamma;
using datapar::trunc;
// ビット操作を参照
using datapar::bit_ceil;
using datapar::bit_floor;
using datapar::bit_width;
using datapar::byteswap;
using datapar::countl_one;
using datapar::countl_zero;
using datapar::countr_one;
using datapar::countr_zero;
using datapar::has_single_bit;
using datapar::popcount;
using datapar::rotl;
using datapar::rotr;
// SIMD 複素数数学を参照
using datapar::arg;
using datapar::conj;
using datapar::imag;
using datapar::norm;
using datapar::polar;
using datapar::proj;
using datapar::real;
}

クラステンプレート std::datapar::flags 

namespace std::datapar {
template <class... Flags> struct flags {
  // フラグ演算子
  template <class... Other>
  friend consteval auto operator|(flags, flags<Other...>);
};
}

クラステンプレート std::datapar::basic_simd 

namespace std::datapar {
template <class T, class Abi> class basic_simd {
public:
  using value_type = T;
  using mask_type = basic_simd_mask<sizeof(T), Abi>;
  using abi_type = Abi;
  static constexpr integral_constant</*simd-size-type*/,
                                     /*simd-size-v*/<T, Abi>>
      size{};
  constexpr basic_simd() noexcept = default;
  // basic_simd コンストラクタ
  template <class U>
  constexpr explicit(/* 詳細は説明を参照 */) basic_simd(U &&value) noexcept;
  template <class U, class UAbi>
  constexpr explicit(/* 詳細を参照 */)
      basic_simd(const basic_simd<U, UAbi> &) noexcept;
  template <class G> constexpr explicit basic_simd(G &&gen) noexcept;
  template <class R, class... フラグ>
  constexpr basic_simd(R &&range, flags<Flags...> = {});
  template <class R, class... フラグ>
  constexpr basic_simd(R &&range, const mask_type &mask, flags<Flags...> = {});
  template </*SIMD浮動小数点*/ V>
  constexpr explicit(/* 詳細は説明を参照 */)
      basic_simd(const V &reals, const V &imags = {}) noexcept;
  // basic_simd 添字演算子
  constexpr value_type operator[](/*simd-size-type*/) const;
  // basic_simd 単項演算子
  constexpr basic_simd &operator++() noexcept;
  constexpr basic_simd operator++(int) noexcept;
  constexpr basic_simd &operator--() noexcept;
  constexpr basic_simd operator--(int) noexcept;
  constexpr mask_type operator!() const noexcept;
  constexpr basic_simd operator~() const noexcept;
  constexpr basic_simd operator+() const noexcept;
  constexpr basic_simd operator-() const noexcept;
  // basic_simd 二項演算子
  friend constexpr basic_simd operator+(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator-(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator*(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator/(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator%(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator&(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator|(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator^(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr basic_simd operator<<(const basic_simd &,
                                         const basic_simd &) noexcept;
  friend constexpr basic_simd operator>>(const basic_simd &,
                                         const basic_simd &) noexcept;
  friend constexpr basic_simd operator<<(const basic_simd &,
                                         /*simd-size-type*/) noexcept;
  friend constexpr basic_simd operator>>(const basic_simd &,
                                         /*simd-size-type*/) noexcept;
  // basic_simd 複合代入
  friend constexpr basic_simd &operator+=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator-=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator*=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator/=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator%=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator&=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator|=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator^=(basic_simd &,
                                          const basic_simd &) noexcept;
  friend constexpr basic_simd &operator<<=(basic_simd &,
                                           const basic_simd &) noexcept;
  friend constexpr basic_simd &operator>>=(basic_simd &,
                                           const basic_simd &) noexcept;
  friend constexpr basic_simd &operator<<=(basic_simd &,
                                           /*simd-size-type*/) noexcept;
  friend constexpr basic_simd &operator>>=(basic_simd &,
                                           /*simd-size-type*/) noexcept;
  // basic_simd 比較演算子
  friend constexpr mask_type operator==(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator!=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator>=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator<=(const basic_simd &,
                                        const basic_simd &) noexcept;
  friend constexpr mask_type operator>(const basic_simd &,
                                       const basic_simd &) noexcept;
  friend constexpr mask_type operator<(const basic_simd &,
                                       const basic_simd &) noexcept;
  // basic_simd 複素数値アクセサ
  constexpr auto real() const noexcept;
  constexpr auto imag() const noexcept;
  template </*SIMD浮動小数点*/ V> constexpr void real(const V &v) noexcept;
  template </*SIMD浮動小数点*/ V> constexpr void imag(const V &v) noexcept;
  // basic_simd 説明専用条件演算子
  friend constexpr basic_simd /*simd-select-impl*/( // 説明専用
      const mask_type &, const basic_simd &, const basic_simd &) noexcept;
};
template <class R, class... Ts> basic_simd(R &&r, Ts...)->/* 説明を参照 */;
}

クラステンプレート std::datapar::basic_simd_mask 

namespace std::datapar {
template <size_t Bytes, class Abi> class basic_simd_mask {
public:
  using value_type = bool;
  using abi_type = Abi;
  static constexpr integral_constant<
      /*simd-size-type*/, /*simd-size-v*/</*整数から*/<Bytes>, Abi>>
      size{};
  constexpr basic_simd_mask() noexcept = default;
  // basic_simd_mask コンストラクタ
  constexpr explicit basic_simd_mask(value_type) noexcept;
  template <size_t UBytes, class UAbi>
  constexpr explicit basic_simd_mask(
      const basic_simd_mask<UBytes, UAbi> &) noexcept;
  template <class G> constexpr explicit basic_simd_mask(G &&gen) noexcept;
  // basic_simd_mask 添字演算子
  constexpr value_type operator[]
（注：元のテキストが単一の閉じ角括弧のみであるため、HTMLタグを保持したまま、内容を日本語に翻訳する必要はありません。指定された条件に従い、この記号はそのまま維持されます。）(/*simd-size-type*/) const;
  // basic_simd_mask 単項演算子
  constexpr basic_simd_mask operator!() const noexcept;
  constexpr basic_simd</*整数から*/<Bytes>, Abi> operator+() const noexcept;
  constexpr basic_simd</*整数から*/<Bytes>, Abi> operator-() const noexcept;
  constexpr basic_simd</*整数から*/<Bytes>, Abi> operator~() const noexcept;
  // basic_simd_mask 変換演算子
  template <class U, class A>
  constexpr explicit(sizeof(U) != Bytes)
  operator basic_simd<U, A>() const noexcept;
  // basic_simd_mask 二項演算子
  friend constexpr basic_simd_mask operator&&(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator||(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator&(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator|(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator^(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  // basic_simd_mask 複合代入
  friend constexpr basic_simd_mask &
  operator&=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask &
  operator|=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask &
  operator^=(basic_simd_mask &, const basic_simd_mask &) noexcept;
  // basic_simd_mask 比較
  friend constexpr basic_simd_mask operator==(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator!=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator>=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator<=(const basic_simd_mask &,
                                              const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator>(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask operator<(const basic_simd_mask &,
                                             const basic_simd_mask &) noexcept;
  // basic_simd_mask 説明専用 条件演算子
  friend constexpr basic_simd_mask /*simd-select-impl*/( // 説明専用
      const basic_simd_mask &, const basic_simd_mask &,
      const basic_simd_mask &) noexcept;
  friend constexpr basic_simd_mask /*simd-select-impl*/( // 説明専用
      const basic_simd_mask &, same_as<bool> auto, same_as<bool> auto) noexcept;
  template <class T0, class T1>
  friend constexpr simd</* 説明を参照 */, size()>
  /*simd-select-impl*/(const basic_simd_mask &, const T0 &,
                       const T1 &) noexcept; // 説明専用
};
}