29 Numerics library [numerics]

Let op be the operator.

Constraints: requires (value_type a, value_type b) { a op b; } is true.

Returns: A basic_simd object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.

Let op be the operator.

Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.

Returns: A basic_simd object where the $i^{\text{th}}$ element is initialized to the result of applying op to v[i] and n for all i in the range of [0, size()).

Let op be the operator.

Constraints: requires (value_type a, value_type b) { a op b; } is true.

Effects: These operators apply the indicated operator to lhs and rhs as an element-wise operation.

Returns: lhs.

Let op be the operator.

Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.

Effects: Equivalent to: return operator op (lhs, basic_simd(n));

Let op be the operator.

Constraints: requires (value_type a, value_type b) { a op b; } is true.

Returns: A basic_simd_mask object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.

Returns: A basic_simd object where the $i^{\text{th}}$ element equals mask[i] ? a[i] : b[i] for all i in the range of [0, size()).

Constraints: BinaryOperation models reduction-binary-operation<T>.

Preconditions: binary_op does not modify x.

Returns: GENERALIZED_SUM(binary_op, simd<T, 1>(x[0]), …, simd<T, 1>(x[x.size() - 1])​)[0] ([numerics.defns]).

Throws: Any exception thrown from binary_op.

Constraints:

• (5.1)
  BinaryOperation models reduction-binary-operation<T>.
• (5.2)
  An argument for identity_element is provided for the invocation, unless BinaryOperation is one of plus<>, multiplies<>, bit_and<>, bit_or<>, or bit_xor<>.

Preconditions:

• (6.1)
  binary_op does not modify x.
• (6.2)
  For all finite values y representable by T, the results of y == binary_op(simd<T, 1>(identity_element), simd<T, 1>(y))[0] and y == binary_op(simd<T, 1>(y), simd<T, 1>(identity_element))[0] are true.

Returns: If none_of(mask) is true, returns identity_element.

Otherwise, returns GENERALIZED_SUM(binary_op, simd<T, 1>(x[$k_0$]), …, simd<T, 1>(x[$k_n$]))[0] where $k_0,\dots ,k_n$ are the selected indices of mask.

Throws: Any exception thrown from binary_op.

Remarks: The default argument for identity_element is equal to

• (9.1)
  T() if BinaryOperation is plus<>,
• (9.2)
  T(1) if BinaryOperation is multiplies<>,
• (9.3)
  T(~T()) if BinaryOperation is bit_and<>,
• (9.4)
  T() if BinaryOperation is bit_or<>, or
• (9.5)
  T() if BinaryOperation is bit_xor<>.

Constraints: T models totally_ordered.

Returns: The value of an element x[j] for which x[i] < x[j] is false for all i in the range of [0, basic_simd<T, Abi>​::​size()).

Constraints: T models totally_ordered.

Returns: If none_of(mask) is true, returns numeric_limits<T>​::​max().

Otherwise, returns the value of a selected element x[j] for which x[i] < x[j] is false for all selected indices i of mask.

Constraints: T models totally_ordered.

Returns: The value of an element x[j] for which x[j] < x[i] is false for all i in the range of [0, basic_simd<T, Abi>​::​size()).

Constraints: T models totally_ordered.

Returns: If none_of(mask) is true, returns numeric_limits<V​::​value_type>​::​lowest().

Otherwise, returns the value of a selected element x[j] for which x[j] < x[i] is false for all selected indices i of mask.

Let

• (1.1)
  mask be V​::​mask_type(true) for the overloads with no mask parameter;
• (1.2)
  R be span<const iter_value_t<I>> for the overloads with no template parameter R;
• (1.3)
  r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.

Mandates: If ranges​::​size(r) is a constant expression then ranges​::​size(r)  ≥  V​::​size().

Preconditions:

• (3.1)
  [first, first + n) is a valid range for the overloads with an n parameter.
• (3.2)
  [first, last) is a valid range for the overloads with a last parameter.
• (3.3)
  ranges​::​size(r)  ≥  V​::​size()

Effects: Equivalent to: return simd_partial_load<V>(r, mask, f);

Remarks: The default argument for template parameter V is basic_simd<ranges​::​range_value_t<R>>.

Let

• (6.1)
  mask be V​::​mask_type(true) for the overloads with no mask parameter;
• (6.2)
  R be span<const iter_value_t<I>> for the overloads with no template parameter R;
• (6.3)
  r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.

Mandates:

• (7.1)
  ranges​::​range_value_t<R> is a vectorizable type,
• (7.2)
  same_as<remove_cvref_t<V>, V> is true,
• (7.3)
  V is an enabled specialization of basic_simd, and
• (7.4)
  if the template parameter pack Flags does not contain convert-flag, then the conversion from ranges​::​range_value_t<R> to V​::​value_type is value-preserving.

Preconditions:

• (8.1)
  [first, first + n) is a valid range for the overloads with an n parameter.
• (8.2)
  [first, last) is a valid range for the overloads with a last parameter.
• (8.3)
  If the template parameter pack Flags contains aligned-flag, ranges​::​data(r) points to storage aligned by simd_alignment_v<V, ranges​::​range_value_t<R>>.
• (8.4)
  If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(r) points to storage aligned by N.

Effects: Initializes the $i^{\text{th}}$ element with

mask[i] && i < ranges​::​size(r) ? static_cast<T>(​ranges​::​data(r)[i]) : T() for all i in the range of [0, V​::​size()).

Remarks: The default argument for template parameter V is basic_simd<ranges​::​range_value_t<R>>.

Let

• (11.1)
  mask be basic_simd<T, Abi>​::​mask_type(true) for the overloads with no mask parameter;
• (11.2)
  R be span<iter_value_t<I>> for the overloads with no template parameter R;
• (11.3)
  r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.

Mandates: If ranges​::​size(r) is a constant expression then ranges​::​size(r)  ≥  simd-size-v<T, Abi>.

Preconditions:

• (13.1)
  [first, first + n) is a valid range for the overloads with an n parameter.
• (13.2)
  [first, last) is a valid range for the overloads with a last parameter.
• (13.3)
  ranges​::​size(r)  ≥  simd-size-v<T, Abi>

Effects: Equivalent to: simd_partial_store(v, r, mask, f).

Let

• (15.1)
  mask be basic_simd<T, Abi>​::​mask_type(true) for the overloads with no mask parameter;
• (15.2)
  R be span<iter_value_t<I>> for the overloads with no template parameter R;
• (15.3)
  r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.

Mandates:

• (16.1)
  ranges​::​range_value_t<R> is a vectorizable type, and
• (16.2)
  if the template parameter pack Flags does not contain convert-flag, then the conversion from T to ranges​::​range_value_t<R> is value-preserving.

Preconditions:

• (17.1)
  [first, first + n) is a valid range for the overloads with an n parameter.
• (17.2)
  [first, last) is a valid range for the overloads with a last parameter.
• (17.3)
  If the template parameter pack Flags contains aligned-flag, ranges​::​data(r) points to storage aligned by simd_alignment_v<basic_simd<T, Abi>, ranges​::​range_value_t<R>>.
• (17.4)
  If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(r) points to storage aligned by N.

Effects: For all i in the range of [0, basic_simd<T, Abi>​::​size()), if mask[i] && i < ranges​::​​size(r) is true, evaluates ranges​::​data(r)[i] = v[i].

Constraints:

• (1.1)
  For the first overload T is an enabled specialization of basic_simd.

  If basic_simd<​typename T​::​​value_type, Abi>​::​size() % T​::​size() is not 0 then resize_simd_t<basic_simd<​typename T​::​​value_type, Abi>​::​size() % T​::​size(), T> is valid and denotes a type.
• (1.2)
  For the second overload T is an enabled specialization of basic_simd_mask.

  If basic_simd_mask<mask-element-size<T>, Abi>​::​size() % T​::​size() is not 0 then resize_simd_t<​basic_simd_mask<​mask-element-size<T>, Abi>​::​size() % T​::​size(), T> is valid and denotes a type.

Let N be x.size() / T​::​size().

Returns:

• (3.1)
  If x.size() % T​::​size() == 0 is true, an array<T, N> with the $i^{\text{th}}$ basic_simd or basic_simd_mask element of the $j^{\text{th}}$ array element initialized to the value of the element in x with index i + j * T​::​size().
• (3.2)
  Otherwise, a tuple of N objects of type T and one object of type resize_simd_t<x.size() % T​::​size(), T>.

  The $i^{\text{th}}$ basic_simd or basic_simd_mask element of the $j^{\text{th}}$ tuple element of type T is initialized to the value of the element in x with index i + j * T​::​size().

  The $i^{\text{th}}$ basic_simd or basic_simd_mask element of the $N^{\text{th}}$ tuple element is initialized to the value of the element in x with index i + N * T​::​size().

Constraints:

• (4.1)
  For the first overload simd<T, (basic_simd<T, Abis>​::​size() + ...)> is enabled.
• (4.2)
  For the second overload basic_simd_mask<Bytes, deduce-abi-t<integer-from<Bytes>, (basic_simd_mask<Bytes, Abis>​::​size() + ...)>> is enabled.

Returns: A data-parallel object initialized with the concatenated values in the xs pack of data-parallel objects: The $i^{\text{th}}$ basic_simd/basic_simd_mask element of the $j^{\text{th}}$ parameter in the xs pack is copied to the return value's element with index i + the sum of the width of the first j parameters in the xs pack.

Constraints: T models totally_ordered.

Returns: The result of the element-wise application of min(a[i], b[i]) for all i in the range of [0, basic_simd<T, Abi>​::​size()).

Constraints: T models totally_ordered.

Returns: The result of the element-wise application of max(a[i], b[i]) for all i in the range of [0, basic_simd<T, Abi>​::​size()).

Effects: Equivalent to: return pair{min(a, b), max(a, b)};

Constraints: T models totally_ordered.

Preconditions: No element in lo shall be greater than the corresponding element in hi.

Returns: The result of element-wise application of clamp(v[i], lo[i], hi[i]) for all i in the range of [0, basic_simd<T, Abi>​::​size()).

Effects: Equivalent to: return c ? a : b;

Effects: Equivalent to: return simd-select-impl(c, a, b); where simd-select-impl is found by argument-dependent lookup ([basic.lookup.argdep]) contrary to [contents].

Let Ret denote the return type of the specialization of a function template with the name math-func.

Let math-func-simd denote: template<class... Args> Ret math-func-simd(Args... args) { return Ret([&](simd-size-type i) { math-func(make-compatible-simd-t<Ret, Args>(args)[i]...); }); }

Returns: A value ret of type Ret, that is element-wise equal to the result of calling math-func-simd with the arguments of the above functions.

If in an invocation of a scalar overload of math-func for index i in math-func-simd a domain, pole, or range error would occur, the value of ret[i] is unspecified.

Remarks: It is unspecified whether errno ([errno]) is accessed.

Let Ret denote the return type of the specialization of a function template with the name math-func.

Let math-func-simd denote: template<class... Args> Ret math-func-simd(Args... args) { return Ret([&](simd-size-type i) { math-func(make-compatible-simd-t<Ret, Args>(args)[i]...); }); }

Returns: A value ret of type Ret, that is element-wise approximately equal to the result of calling math-func-simd with the arguments of the above functions.

If in an invocation of a scalar overload of math-func for index i in math-func-simd a domain, pole, or range error would occur, the value of ret[i] is unspecified.

Remarks: It is unspecified whether errno ([errno]) is accessed.

Let Ret be deduced-simd-t<V>.

Let frexp-simd denote: template<class V> pair<Ret, rebind_simd_t<int, Ret>> frexp-simd(const V& x) { int r1[Ret::size()]; Ret r0([&](simd-size-type i) { frexp(make-compatible-simd-t<Ret, V>(x)[i], &r1[i]); }); return {r0, rebind_simd_t<int, Ret>(r1)}; }

Let ret be a value of type pair<Ret, rebind_simd_t<int, Ret>> that is the same value as the result of calling frexp-simd(x).

Effects: Sets *exp to ret.second.

Returns: ret.first.

Let Ret be math-common-simd-t<V0, V1>.

Let remquo-simd denote: template<class V0, class V1> pair<Ret, rebind_simd_t<int, Ret>> remquo-simd(const V0& x, const V1& y) { int r1[Ret::size()]; Ret r0([&](simd-size-type i) { remquo(make-compatible-simd-t<Ret, V0>(x)[i], make-compatible-simd-t<Ret, V1>(y)[i], &r1[i]); }); return {r0, rebind_simd_t<int, Ret>(r1)}; }

Let ret be a value of type pair<Ret, rebind_simd_t<int, Ret>> that is the same value as the result of calling remquo-simd(x, y).

If in an invocation of a scalar overload of remquo for index i in remquo-simd a domain, pole, or range error would occur, the value of ret[i] is unspecified.

Effects: Sets *quo to ret.second.

Returns: ret.first.

Remarks: It is unspecified whether errno ([errno]) is accessed.

Let V be basic_simd<T, Abi>.

Let modf-simd denote: pair<V, V> modf-simd(const V& x) { T r1[Ret::size()]; V r0([&](simd-size-type i) { modf(V(x)[i], &r1[i]); }); return {r0, V(r1)}; }

Let ret be a value of type pair<V, V> that is the same value as the result of calling modf-simd(value).

Effects: Sets *iptr to ret.second.

Returns: ret.first.