simd_complex_batch

template<class X>
class xsimd::simd_complex_batch : public xsimd::simd_base<X>

Base class for batch complex numbers.

The simd_complex_batch class is the base class for all classes representing a batch of complex numbers. Each type of batch (i.e. a class inheriting from simd_complex_batch) has its dedicated type of boolean batch (i.e. a class inheriting from simd_complex_batch_bool) for logical operations.

Internally, a batch of complex numbers holds two batches of real numbers, one for the real part and one for the imaginary part.

See

simd_complex_batch_bool

tparam X

The derived type

Arithmetic computed assignment

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

Adds the batch rhs to this.

Parameters

rhs – the batch to add.

Returns

a reference to this.

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

Adds the scalar rhs to each value contained in this.

Parameters

rhs – the scalar to add.

Returns

a reference to this.

inline X &operator+=(const real_batch &rhs)

Adds the real batch rhs to this.

Parameters

rhs – the real batch to add.

Returns

a reference to this.

inline X &operator+=(const real_value_type &rhs)

Adds the real scalar rhs to each value contained in this.

Parameters

rhs – the real scalar to add.

Returns

a reference to this.

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

Substracts the batch rhs to this.

Parameters

rhs – the batch to substract.

Returns

a reference to this.

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

Substracts the scalar rhs to each value contained in this.

Parameters

rhs – the scalar to substract.

Returns

a reference to this.

inline X &operator-=(const real_batch &rhs)

Substracts the real batch rhs to this.

Parameters

rhs – the batch to substract.

Returns

a reference to this.

inline X &operator-=(const real_value_type &rhs)

Substracts the real scalar rhs to each value contained in this.

Parameters

rhs – the real scalar to substract.

Returns

a reference to this.

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

Multiplies this with the batch rhs.

Parameters

rhs – the batch involved in the multiplication.

Returns

a reference to this.

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

Multiplies each scalar contained in this with the scalar rhs.

Parameters

rhs – the scalar involved in the multiplication.

Returns

a reference to this.

inline X &operator*=(const real_batch &rhs)

Multiplies this with the real batch rhs.

Parameters

rhs – the real batch involved in the multiplication.

Returns

a reference to this.

inline X &operator*=(const real_value_type &rhs)

Multiplies each scalar contained in this with the real scalar rhs.

Parameters

rhs – the real scalar involved in the multiplication.

Returns

a reference to this.

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

Divides this by the batch rhs.

Parameters

rhs – the batch involved in the division.

Returns

a reference to this.

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

Divides each scalar contained in this by the scalar rhs.

Parameters

rhs – the scalar involved in the division.

Returns

a reference to this.

inline X &operator/=(const real_batch &rhs)

Divides this by the real batch rhs.

Parameters

rhs – the real batch involved in the division.

Returns

a reference to this.

inline X &operator/=(const real_value_type &rhs)

Divides each scalar contained in this by the real scalar rhs.

Parameters

rhs – the real scalar involved in the division.

Returns

a reference to this.

Load and store methods

template<class T>
inline X &load_aligned(const T *real_src, const T *imag_src)

Loads the N contiguous values pointed by real_src into the batch holding the real values, and N contiguous values pointed by imag_src into the batch holding the imaginary values.

real_src and imag_src must be aligned.

template<class T>
inline X &load_unaligned(const T *real_src, const T *imag_src)

Loads the N contiguous values pointed by real_src into the batch holding the real values, and N contiguous values pointed by imag_src into the batch holding the imaginary values.

real_src and imag_src are not required to be aligned.

template<class T>
inline void store_aligned(T *real_dst, T *imag_dst) const

Stores the N values of the batch holding the real values into a contiguous array pointed by real_dst., and the N values of the batch holding the imaginary values into a contiguous array pointer by imag_dst.

real_dst and imag_dst must be aligned.

template<class T>
inline void store_unaligned(T *real_dst, T *imag_dst) const

Stores the N values of the batch holding the real values into a contiguous array pointed by real_dst., and the N values of the batch holding the imaginary values into a contiguous array pointer by imag_dst.

real_dst and imag_dst are not required to be aligned.

template<class T>
inline std::enable_if<detail::is_complex<T>::value, X&>::type load_aligned(const T *src)

Loads the N contiguous values pointed by src into the batch.

src must be aligned.

template<class T>
inline std::enable_if<detail::is_complex<T>::value, X&>::type load_unaligned(const T *src)

Loads the N contiguous values pointed by src into the batch.

src is not required to be aligned.

template<class T>
inline std::enable_if<detail::is_complex<T>::value, void>::type store_aligned(T *dst) const

Stores the N values of the batch into a contiguous array of complex pointed by dst.

Stores the N values of the batch into a contiguous array of reals pointed by dst.

dst must be aligned.

template<class T>
inline std::enable_if<detail::is_complex<T>::value, void>::type store_unaligned(T *dst) const

Stores the N values of the batch into a contiguous array of complex pointed by dst.

Stores the N values of the batch into a contiguous array of reals pointed by dst.

dst is not required to be aligned.

Public Functions

inline explicit simd_complex_batch(const value_type &v)

Initializes all the values of the batch to the complex value v.

inline explicit simd_complex_batch(const real_value_type &v)

Initializes all the values of the batch to the real value v.

inline explicit simd_complex_batch(const real_batch &re)

Initializes the values of the batch whith those of the real batch re.

Imaginary parts are set to 0.

inline simd_complex_batch(const real_batch &re, const real_batch &im)

Initializes the batch with two real batch, one for the real part and one for the inamginary part.

inline real_batch &real()

Returns a batch for the real part.

inline real_batch &imag()

Returns a batch for the imaginary part.

inline const real_batch &real() const

Returns a const batch for the real part.

inline const real_batch &imag() const

Returns a const batch for the imaginary part.

Arithmetic operators

template<class X>
inline X operator+(const simd_complex_batch<X> &rhs)

No-op on rhs.

Template Parameters

X – the actual type of batch.

Parameters

rhs – batch involved in the operation.

Returns

the opposite of rhs.

template<class X>
inline X operator-(const simd_complex_batch<X> &rhs)

Computes the opposite of the batch rhs.

Template Parameters

X – the actual type of batch.

Parameters

rhs – batch involved in the operation.

Returns

the opposite of rhs.

template<class X>
inline X operator+(const simd_complex_batch<X> &lhs, const simd_complex_batch<X> &rhs)

Computes the sum of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the addition.

  • rhs – batch involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the addition.

  • rhs – scalar involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const typename simd_batch_traits<X>::value_type &lhs, const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – scalar involved in the addition.

  • rhs – batch involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_batch &rhs)

Computes the sum of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the addition.

  • rhs – real batch involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const typename simd_batch_traits<X>::real_batch &lhs, const simd_complex_batch<X> &rhs)

Computes the sum of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real batch involved in the addition.

  • rhs – batch involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_value_type &rhs)

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

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the addition.

  • rhs – real scalar involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator+(const typename simd_batch_traits<X>::real_value_type &lhs, const simd_complex_batch<X> &rhs)

Computes the sum of the real 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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real scalar involved in the addition.

  • rhs – batch involved in the addition.

Returns

the result of the addition.

template<class X>
inline X operator-(const simd_complex_batch<X> &lhs, const simd_complex_batch<X> &rhs)

Computes the difference of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the difference.

  • rhs – batch involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the difference.

  • rhs – scalar involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const typename simd_batch_traits<X>::value_type &lhs, const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – scalar involved in the difference.

  • rhs – batch involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_batch &rhs)

Computes the difference of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the difference.

  • rhs – real batch involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const typename simd_batch_traits<X>::real_batch &lhs, const simd_complex_batch<X> &rhs)

Computes the difference of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real batch involved in the difference.

  • rhs – batch involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_value_type &rhs)

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

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the difference.

  • rhs – real scalar involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator-(const typename simd_batch_traits<X>::real_value_type &lhs, const simd_complex_batch<X> &rhs)

Computes the difference of the real 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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real scalar involved in the difference.

  • rhs – batch involved in the difference.

Returns

the result of the difference.

template<class X>
inline X operator*(const simd_complex_batch<X> &lhs, const simd_complex_batch<X> &rhs)

Computes the product of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the product.

  • rhs – batch involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the product.

  • rhs – scalar involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const typename simd_batch_traits<X>::value_type &lhs, const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – scalar involved in the product.

  • rhs – batch involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_batch &rhs)

Computes the product of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the product.

  • rhs – real batch involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const typename simd_batch_traits<X>::real_batch &lhs, const simd_complex_batch<X> &rhs)

Computes the product of the batches lhs and rhs.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real batch involved in the product.

  • rhs – batch involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_value_type &rhs)

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

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the product.

  • rhs – real scalar involved in the product.

Returns

the result of the product.

template<class X>
inline X operator*(const typename simd_batch_traits<X>::real_value_type &lhs, const simd_complex_batch<X> &rhs)

Computes the product of the real 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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real scalar involved in the product.

  • rhs – batch involved in the product.

Returns

the result of the product.

template<class X>
inline X operator/(const simd_complex_batch<X> &lhs, const simd_complex_batch<X> &rhs)

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the division.

  • rhs – batch involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the division.

  • rhs – scalar involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const typename simd_batch_traits<X>::value_type &lhs, const simd_complex_batch<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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – scalar involved in the division.

  • rhs – batch involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_batch &rhs)

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the division.

  • rhs – real batch involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const typename simd_batch_traits<X>::real_batch &lhs, const simd_complex_batch<X> &rhs)

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real batch involved in the division.

  • rhs – batch involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const simd_complex_batch<X> &lhs, const typename simd_batch_traits<X>::real_value_type &rhs)

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

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

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – batch involved in the division.

  • rhs – real scalar involved in the division.

Returns

the result of the division.

template<class X>
inline X operator/(const typename simd_batch_traits<X>::real_value_type &lhs, const simd_complex_batch<X> &rhs)

Computes the division of the real 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.

Template Parameters

X – the actual type of batch.

Parameters
  • lhs – real scalar involved in the division.

  • rhs – batch involved in the division.

Returns

the result of the division.

template<class X>
inline simd_batch_traits<X>::value_type hadd(const simd_complex_batch<X> &rhs)

Adds all the scalars of the batch rhs.

Parameters

rhs – batch involved in the reduction

Returns

the result of the reduction.

template<class X>
inline X select(const typename simd_batch_traits<X>::batch_bool_type &cond, const simd_complex_batch<X> &a, const simd_complex_batch<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];

Parameters
  • cond – batch condition.

  • a – batch values for truthy condition.

  • b – batch value for falsy condition.

Returns

the result of the selection.

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

Element-wise equality comparison of batches lhs and rhs.

Parameters
  • lhs – batch involved in the comparison.

  • rhs – batch involved in the comparison.

Returns

a boolean batch.

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

Element-wise inequality comparison of batches lhs and rhs.

Parameters
  • lhs – batch involved in the comparison.

  • rhs – batch involved in the comparison.

Returns

a boolean batch.

template<class X>
inline std::ostream &operator<<(std::ostream &out, const simd_complex_batch<X> &rhs)

Insert the batch rhs into the stream out.

Template Parameters

X – the actual type of batch.

Parameters
  • out – the output stream.

  • rhs – the batch to output.

Returns

the output stream.

Comparison operators

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

Element-wise equality comparison of batches lhs and rhs.

Parameters
  • lhs – batch involved in the comparison.

  • rhs – batch involved in the comparison.

Returns

a boolean batch.

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

Element-wise inequality comparison of batches lhs and rhs.

Parameters
  • lhs – batch involved in the comparison.

  • rhs – batch involved in the comparison.

Returns

a boolean batch.

Reducers

template<class X>
inline simd_batch_traits<X>::value_type hadd(const simd_complex_batch<X> &rhs)

Adds all the scalars of the batch rhs.

Parameters

rhs – batch involved in the reduction

Returns

the result of the reduction.

Miscellaneous

template<class X>
inline X select(const typename simd_batch_traits<X>::batch_bool_type &cond, const simd_complex_batch<X> &a, const simd_complex_batch<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];

Parameters
  • cond – batch condition.

  • a – batch values for truthy condition.

  • b – batch value for falsy condition.

Returns

the result of the selection.

Other operators

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

Insert the batch rhs into the stream out.

Template Parameters

X – the actual type of batch.

Parameters
  • out – the output stream.

  • rhs – the batch to output.

Returns

the output stream.