simd_batch¶

template<class X> class xsimd::simd_batch : public xsimd::simd_base<X>¶

Base class for batch of integer or floating point values.

The simd_batch class is the base class for all classes representing a batch of integer or floating point values. Each type of batch (i.e. a class inheriting from simd_batch) has its dedicated type of boolean batch (i.e. a class inheriting from simd_batch_bool) for logical operations.

See

simd_batch_bool

Template Parameters

X: The derived type

Subclassed by xsimd::avx512_int_batch< uint8_t, 64 >, xsimd::avx512_int_batch< uint32_t, 16 >, xsimd::avx512_int_batch< uint16_t, 32 >, xsimd::avx512_int_batch< int64_t, 8 >, xsimd::avx512_int_batch< uint64_t, 8 >, xsimd::avx512_int_batch< int8_t, 64 >, xsimd::avx512_int_batch< int32_t, 16 >, xsimd::avx512_int_batch< int16_t, 32 >, xsimd::avx_int_batch< int64_t, 4 >, xsimd::avx_int_batch< uint32_t, 8 >, xsimd::avx_int_batch< int32_t, 8 >, xsimd::avx_int_batch< int16_t, 16 >, xsimd::avx_int_batch< int8_t, 32 >, xsimd::avx_int_batch< uint64_t, 4 >, xsimd::avx_int_batch< uint8_t, 32 >, xsimd::avx_int_batch< uint16_t, 16 >, xsimd::sse_int_batch< uint32_t, 4 >, xsimd::sse_int_batch< int8_t, 16 >, xsimd::sse_int_batch< int64_t, 2 >, xsimd::sse_int_batch< int16_t, 8 >, xsimd::sse_int_batch< uint16_t, 8 >, xsimd::sse_int_batch< uint8_t, 16 >, xsimd::sse_int_batch< int32_t, 4 >, xsimd::sse_int_batch< uint64_t, 2 >

Static builders

X broadcast(value_type v)¶

Creates a batch from the single value v.

Return

a new batch instance

Parameters

v: the value used to initialize the batch

template<class T> X from_unaligned(T *src)¶

Creates a batch from the buffer src.

The memory does not need to be aligned.

Return

a new batch instance

Parameters

src: the memory buffer to read

template<class T> X from_aligned(T *src)¶

Creates a batch from the buffer src.

The memory needs to be aligned.

Return

a new batch instance

Parameters

src: the memory buffer to read

Arithmetic computed assignment

X &operator+=(const X &rhs)¶

Adds the batch rhs to this.

Return

a reference to this.

Parameters

rhs: the batch to add.

X &operator+=(const value_type &rhs)¶

Adds the scalar rhs to each value contained in this.

Return

a reference to this.

Parameters

rhs: the scalar to add.

X &operator-=(const X &rhs)¶

Substracts the batch rhs to this.

Return

a reference to this.

Parameters

rhs: the batch to substract.

X &operator-=(const value_type &rhs)¶

Substracts the scalar rhs to each value contained in this.

Return

a reference to this.

Parameters

rhs: the scalar to substract.

X &operator*=(const X &rhs)¶

Multiplies this with the batch rhs.

Return

a reference to this.

Parameters

rhs: the batch involved in the multiplication.

X &operator*=(const value_type &rhs)¶

Multiplies each scalar contained in this with the scalar rhs.

Return

a reference to this.

Parameters

rhs: the scalar involved in the multiplication.

X &operator/=(const X &rhs)¶

Divides this by the batch rhs.

Return

a reference to this.

Parameters

rhs: the batch involved in the division.

X &operator/=(const value_type &rhs)¶

Divides each scalar contained in this by the scalar rhs.

Return

a reference to this.

Parameters

rhs: the scalar involved in the division.

Bitwise computed assignment

X &operator&=(const X &rhs)¶

Assigns the bitwise and of rhs and this.

Return

a reference to this.

Parameters

rhs: the batch involved in the operation.

X &operator|=(const X &rhs)¶

Assigns the bitwise or of rhs and this.

Return

a reference to this.

Parameters

rhs: the batch involved in the operation.

X &operator^=(const X &rhs)¶

Assigns the bitwise xor of rhs and this.

Return

a reference to this.

Parameters

rhs: the batch involved in the operation.

Increment and decrement operators

X &operator++()¶

Pre-increment operator.

Return: a reference to this.

X &operator++(int)¶

Post-increment operator.

Return: a reference to this.

X &operator--()¶

Pre-decrement operator.

Return: a reference to this.

X &operator--(int)¶

Post-decrement operator.

Return: a reference to this.

Arithmetic operators¶

template<class X> batch_type_t<X> operator-(const simd_base<X> &rhs)¶

Computes the opposite of the batch rhs.

Return

the opposite of rhs.

Template Parameters

X: the actual type of batch.

Parameters

rhs: batch involved in the operation.

template<class X> X operator+(const simd_batch<X> &rhs)¶

No-op on rhs.

Return

rhs.

Template Parameters

X: the actual type of batch.

Parameters

rhs: batch involved in the operation.

template<class X, class Y> batch_type_t<X> operator+(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the sum of the batches lhs and rhs.

Return

the result of the addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the addition.
rhs: batch involved in the addition.

template<class X> batch_type_t<X> operator+(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the sum of the batch lhs and the scalar rhs.

Equivalent to the sum of two batches where all the values of the second one are initialized to rhs.

Return

the result of the addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the addition.
rhs: scalar involved in the addition.

template<class X> batch_type_t<X> operator+(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the sum of the scalar lhs and the batch rhs.

Equivalent to the sum of two batches where all the values of the first one are initialized to rhs.

Return

the result of the addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the addition.
rhs: batch involved in the addition.

template<class X> batch_type_t<X> sadd(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Computes the saturate sum of the batch lhs and the batch rhs.

lhs.

Return

the result of the saturated addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the saturated addition.
rhs: batch involved in the saturated addition.

template<class X> batch_type_t<X> sadd(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the saturate sum of the scalar lhs and the batch rhs.

Equivalent to the saturated sum of two batches where all the values of the first one are initialized to lhs.

Return

the result of the saturated addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the saturated addition.
rhs: batch involved in the saturated addition.

template<class X> batch_type_t<X> sadd(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the saturate sum of the batch lhs and the scalar rhs.

Equivalent to the saturated sum of two batches where all the values of the second one are initialized to rhs.

Return

the result of the saturated addition.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the saturated addition.
rhs: scalar involved in the saturated addition.

template<class X, class Y> batch_type_t<X> operator-(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the difference of the batches lhs and rhs.

Return

the result of the difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the difference.
rhs: batch involved in the difference.

template<class X> batch_type_t<X> operator-(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the difference of the batch lhs and the scalar rhs.

Equivalent to the difference of two batches where all the values of the second one are initialized to rhs.

Return

the result of the difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the difference.
rhs: scalar involved in the difference.

template<class X> batch_type_t<X> operator-(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the difference of the scalar lhs and the batch rhs.

Equivalent to the difference of two batches where all the values of the first one are initialized to rhs.

Return

the result of the difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the difference.
rhs: batch involved in the difference.

template<class X> batch_type_t<X> ssub(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Computes the saturate difference of the batch lhs and the batch rhs.

lhs.

Return

the result of the saturated difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the saturated difference.
rhs: batch involved in the saturated difference.

template<class X> batch_type_t<X> ssub(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the saturate difference of the scalar lhs and the batch rhs.

Equivalent to the saturated sum of two batches where all the values of the first one are initialized to lhs.

Return

the result of the saturated difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the saturated difference.
rhs: batch involved in the saturated difference.

template<class X> batch_type_t<X> ssub(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the saturate difference of the batch lhs and the scalar rhs.

Equivalent to the saturated difference of two batches where all the values of the second one are initialized to rhs.

Return

the result of the saturated difference.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the saturated difference.
rhs: scalar involved in the saturated difference.

template<class X, class Y> batch_type_t<X> operator*(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the product of the batches lhs and rhs.

Return

the result of the product.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the product.
rhs: batch involved in the product.

template<class X> batch_type_t<X> operator*(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the product of the batch lhs and the scalar rhs.

Equivalent to the product of two batches where all the values of the second one are initialized to rhs.

Return

the result of the product.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the product.
rhs: scalar involved in the product.

template<class X> batch_type_t<X> operator*(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the product of the scalar lhs and the batch rhs.

Equivalent to the difference of two batches where all the values of the first one are initialized to rhs.

Return

the result of the product.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the product.
rhs: batch involved in the product.

template<class X, class Y> batch_type_t<X> operator/(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the division of the batch lhs by the batch rhs.

Return

the result of the division.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the division.
rhs: batch involved in the division.

template<class X> batch_type_t<X> operator/(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the division of the batch lhs by the scalar rhs.

Equivalent to the division of two batches where all the values of the second one are initialized to rhs.

Return

the result of the division.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the division.
rhs: scalar involved in the division.

template<class X> batch_type_t<X> operator/(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the division of the scalar lhs and the batch rhs.

Equivalent to the difference of two batches where all the values of the first one are initialized to rhs.

Return

the result of the division.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the division.
rhs: batch involved in the division.

template<class X, class Y> batch_type_t<X> operator%(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the integer modulo of the batch lhs by the batch rhs.

Return

the result of the modulo.

Parameters

lhs: batch involved in the modulo.
rhs: batch involved in the modulo.

template<class X> batch_type_t<X> operator%(const simd_base<X> &lhs, const typename simd_batch_traits<X>::value_type &rhs)¶

Computes the integer modulo of the batch lhs by the scalar rhs.

Equivalent to the modulo of two batches where all the values of the second one are initialized to rhs.

Return

the result of the modulo.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the modulo.
rhs: scalar involved in the modulo.

template<class X> batch_type_t<X> operator%(const typename simd_batch_traits<X>::value_type &lhs, const simd_base<X> &rhs)¶

Computes the integer modulo of the scalar lhs and the batch rhs.

Equivalent to the difference of two batches where all the values of the first one are initialized to rhs.

Return

the result of the modulo.

Template Parameters

X: the actual type of batch.

Parameters

lhs: scalar involved in the modulo.
rhs: batch involved in the modulo.

Comparison operators¶

template<class X> simd_batch_traits<X>::batch_bool_type operator==(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise equality comparison of batches lhs and rhs.

Return

a boolean batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

template<class X> simd_batch_traits<X>::batch_bool_type operator!=(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise inequality comparison of batches lhs and rhs.

Return

a boolean batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

template<class X> simd_batch_traits<X>::batch_bool_type operator<(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise lesser than comparison of batches lhs and rhs.

Return

a boolean batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

template<class X> simd_batch_traits<X>::batch_bool_type operator<=(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise lesser or equal to comparison of batches lhs and rhs.

Return

a boolean batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

template<class X> simd_batch_traits<X>::batch_bool_type operator>(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise greater than comparison of batches lhs and rhs.

Return

a boolean batch.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

template<class X> simd_batch_traits<X>::batch_bool_type operator>=(const simd_base<X> &lhs, const simd_base<X> &rhs)¶

Element-wise greater or equal comparison of batches lhs and rhs.

Return

a boolean batch.

Template Parameters

X: the actual type of batch.

Parameters

lhs: batch involved in the comparison.
rhs: batch involved in the comparison.

Bitwise operators¶

template<class X, class Y> batch_type_t<X> operator&(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the bitwise and of the batches lhs and rhs.

Return

the result of the bitwise and.

Parameters

lhs: batch involved in the operation.
rhs: batch involved in the operation.

template<class X, class Y> batch_type_t<X> operator|(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the bitwise or of the batches lhs and rhs.

Return

the result of the bitwise or.

Parameters

lhs: batch involved in the operation.
rhs: batch involved in the operation.

template<class X, class Y> batch_type_t<X> operator^(const simd_base<X> &lhs, const simd_base<Y> &rhs)¶

Computes the bitwise xor of the batches lhs and rhs.

Return

the result of the bitwise xor.

Parameters

lhs: batch involved in the operation.
rhs: batch involved in the operation.

template<class X> batch_type_t<X> operator~(const simd_base<X> &rhs)¶

Computes the bitwise not of the batches lhs and rhs.

Return

the result of the bitwise not.

Parameters

rhs: batch involved in the operation.

template<class X> batch_type_t<X> bitwise_andnot(const simd_batch<X> &lhs, const simd_batch<X> &rhs)¶

Computes the bitwise andnot of the batches lhs and rhs.

Return

the result of the bitwise andnot.

Parameters

lhs: batch involved in the operation.
rhs: batch involved in the operation.

Reducers¶

template<class X> simd_batch_traits<X>::value_type hadd(const simd_base<X> &rhs)¶

Adds all the scalars of the batch rhs.

Return

the result of the reduction.

Parameters

rhs: batch involved in the reduction

template<class X> enable_if_simd_t<X> haddp(const X *row)¶

Parallel horizontal addition: adds the scalars of each batch in the array pointed by row and store them in a returned batch.

Return

the result of the reduction.

Parameters

row: an array of N batches

Miscellaneous¶

template<class X> batch_type_t<X> select(const typename simd_batch_traits<X>::batch_bool_type &cond, const simd_base<X> &a, const simd_base<X> &b)¶

Ternary operator for batches: selects values from the batches a or b depending on the boolean values in cond.

Equivalent to

for(std::size_t i = 0; i < N; ++i)
    res[i] = cond[i] ? a[i] : b[i];

Return

the result of the selection.

Parameters

cond: batch condition.
a: batch values for truthy condition.
b: batch value for falsy condition.

template<class X, bool... Masks> batch_type_t<X> select(const batch_bool_constant<typename simd_batch_traits<X>::value_type, Masks...> &cond, const simd_base<X> &a, const simd_base<X> &b)¶

Ternary operator for batches: selects values from the batches a or b depending on the boolean values in the constant batch cond.

Equivalent to

for(std::size_t i = 0; i < N; ++i)
    res[i] = cond[i] ? a[i] : b[i];

Return

the result of the selection.

Parameters

cond: constant batch condition.
a: batch values for truthy condition.
b: batch value for falsy condition.

Other operators¶

Warning

doxygenfunction: Unable to resolve multiple matches for function “xsimd::operator!” with arguments ((const simd_batch<X>&)) in doxygen xml output for project “xsimd” from directory: ../xml. Potential matches:

- template<class X> X operator!(const simd_batch_bool<X> &rhs)
- template<class X> simd_batch_traits<X>::batch_bool_type operator!(const simd_base<X> &rhs)

template<class X> std::ostream &xsimd::operator<<(std::ostream &out, const simd_batch<X> &rhs)¶

Insert the batch rhs into the stream out.

Return

the output stream.

Template Parameters

X: the actual type of batch.

Parameters

out: the output stream.
rhs: the batch to output.