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_vec 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_vec 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_vec(n));

Let op be the operator.

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

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

Constraints: simd-complex<basic_vec> is modeled.

Returns: An object of type rebind_t<typename T​::​value_type, basic_vec> where the $i^{\text{th}}$ element is initialized to the result of cmplx-func(operator[](i)) for all i in the range [0, size()), where cmplx-func is the corresponding function from <complex>.

Constraints:

• (3.1)
  simd-complex<basic_vec> is modeled,
• (3.2)
  same_as<typename V​::​value_type, typename T​::​value_type> is modeled, and
• (3.3)
  V​::​size() == size() is true.

Effects: Replaces each element of the basic_vec object such that the $i^{\text{th}}$ element is replaced with value_type(v[i], operator[](i).imag()) or value_type(operator[](i).real(), v[i]) for real and imag respectively, for all i in the range [0, size()).

Returns: A basic_vec 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, vec<T, 1>(x[0]), …, vec<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(vec<T, 1>(identity_element), vec<T, 1>(y))[0] and y == binary_op(vec<T, 1>(y), vec<T, 1>(identity_element))[0] are true.

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

Otherwise, returns GENERALIZED_SUM(binary_op, vec<T, 1>(x[$k_0$]), …, vec<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_vec<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_vec<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 partial_load<V>(r, mask, f);

Remarks: The default argument for template parameter V is basic_vec<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_vec, 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 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_vec<ranges​::​range_value_t<R>>.

Let

• (11.1)
  mask be basic_vec<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: partial_store(v, r, mask, f).

Let

• (15.1)
  mask be basic_vec<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 alignment_v<basic_vec<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_vec<T, Abi>​::​size()), if mask[i] && i < ranges​::​​size(r) is true, evaluates ranges​::​data(r)[i] = v[i].

Let:

• (1.1)
  gen-fn(i) be idxmap(i, V​::​size()) if that expression is well-formed, and idxmap(i) otherwise.
• (1.2)
  perm-fn be the following exposition-only function template: template<simd-size-type I> typename V::value_type perm-fn() { constexpr auto src_index = gen-fn(I); if constexpr (src_index == zero_element) { return typename V::value_type(); } else if constexpr (src_index == uninit_element) { return unspecified-value; } else { return v[src_index]; } }

Constraints: integral<invoke_result_t<IdxMap&, simd-size-type>> || integral<invoke_result_t<IdxMap&, simd-size-type, simd-size-type>> is true.

Mandates: gen-fn(i) is a constant expression whose value is zero_element, uninit_element, or in the range [0, V​::​size()), for all i in the range [0, N).

Returns: A data-parallel object where the $i^{\text{th}}$ element is initialized to the result of perm-fn<i>() for all i in the range [0, N).

Remarks: The default argument for template parameter N is V​::​size().

Preconditions: All values in indices are in the range [0, V​::​size()).

Returns: A data-parallel object where the $i^{\text{th}}$ element is initialized to the result of v[indices[i]] for all i in the range [0, I​::​size()).

Let:

• (1.1)
  bit-index(i) be a function which returns the index of the $i^{\text{th}}$ element of selector that is true.
• (1.2)
  select-value(i) be a function which returns v[bit-index(i)] for i in the range [0, reduce_count(selector)) and a valid but unspecified value otherwise.

  [Note 1: 

  Different calls to select-value can return different unspecified values.

  — end note]

Returns: A data-parallel object where the $i^{\text{th}}$ element is initialized to the result of select-value(i) for all i in the range [0, V​::​size()).

Let:

• (3.1)
  bit-index(i) be a function which returns the index of the $i^{\text{th}}$ element of selector that is true.
• (3.2)
  select-value(i) be a function which returns v[bit-index(i)] for i in the range [0, reduce_count(selector)) and fill_value otherwise.

Returns: A data-parallel object where the $i^{\text{th}}$ element is initialized to the result of select-value(i) for all i in the range [0, V​::​size()).

Let:

• (5.1)
  set-indices be a list of the index positions of true elements in selector.
• (5.2)
  bit-lookup(b) be a function which returns the index where b appears in set-indices.
• (5.3)
  select-value(i) be a function which returns v[bit-lookup(i)] if selector[i] is true, otherwise returns original[i].

Returns: A data-parallel object where the $i^{\text{th}}$ element is initialized to the result of select-value(i) for all i in the range [0, V​::​size()).

Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.

Preconditions: All values in select(mask, indices, typename I​::​value_type()) are in the range [0, ranges​::​size(in)).

Effects: Equivalent to: return partial_gather_from<V>(in, mask, indices, f);

Remarks: The default argument for template parameter V is vec<ranges​::​range_value_t<R>, I​::​​size()>.

Let:

• (5.1)
  mask be typename I​::​mask_type(true) for the overload with no mask parameter;
• (5.2)
  T be typename V​::​value_type.

Mandates:

• (6.1)
  ranges​::​range_value_t<R> is a vectorizable type,
• (6.2)
  same_as<remove_cvref_t<V>, V> is true,
• (6.3)
  V is an enabled specialization of basic_vec,
• (6.4)
  V​::​size() == I​::​size() is true, and
• (6.5)
  if the template parameter pack Flags does not contain convert-flag, then the conversion from ranges​::​range_value_t<R> to T is value-preserving.

Preconditions:

• (7.1)
  If the template parameter pack Flags contains aligned-flag, ranges​::​data(in) points to storage aligned by alignment_v<V, ranges​::​range_value_t<R>>.
• (7.2)
  If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(in) points to storage aligned by N.

Returns: A basic_vec object where the $i^{\text{th}}$ element is initialized to the result of mask[i] && indices[i] < ranges::size(in) ? static_cast<T>(ranges::data(in)[indices[i]]) : T() for all i in the range [0, I​::​size()).

Remarks: The default argument for template parameter V is vec<ranges​::​range_value_t<R>, I​::​​size()>.

Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.

Preconditions: All values in select(mask, indices, typename I​::​value_type()) are in the range [0, ranges​::​size(out)).

Effects: Equivalent to: partial_scatter_to(v, out, mask, indices, f);

Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.

Constraints: V​::​size() == I​::​size() is true.

Mandates:

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

Preconditions:

• (16.1)
  For all selected indices i the values indices[i] are unique.
• (16.2)
  If the template parameter pack Flags contains aligned-flag, ranges​::​data(out) points to storage aligned by alignment_v<V, ranges​::​range_value_t<R>>.
• (16.3)
  If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(out) points to storage aligned by N.

Effects: For all i in the range [0, I​::​size()), if mask[i] && (indices[i] < ranges​::​size(out)) is true, evaluates ranges​::​data(out)[indices[i]] = v[i].

Constraints:

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

  If basic_vec<​typename T​::​​value_type, Abi>​::​size() % T​::​size() is not 0, then resize_t<basic_vec<​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_mask.

  If basic_mask<mask-element-size<T>, Abi>​::​size() % T​::​size() is not 0, then resize_t<​basic_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_vec or basic_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_t<x.size() % T​::​size(), T>.

  The $i^{\text{th}}$ basic_vec or basic_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_vec or basic_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().

Effects: Equivalent to: return chunk<resize_t<N, basic_vec<T, Abi>>>(x);

Effects: Equivalent to: return chunk<resize_t<N, basic_mask<Bytes, Abi>>>(x);

Constraints:

• (6.1)
  For the first overload vec<T, (basic_vec<T, Abis>​::​size() + ...)> is enabled.
• (6.2)
  For the second overload basic_mask<Bytes, deduce-abi-t<integer-from<Bytes>, (basic_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_vec/basic_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_vec<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_vec<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_vec<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-vec denote: template<class... Args> Ret math-func-vec(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-vec with the arguments of the above functions.

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

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