Arithmetic operators

template<class T, class A>
inline auto add(batch<T> const &x, batch<T, A> const &y) noexcept -> decltype(x + y)

Computes the sum of the batches x and y.

Parameters:
  • x – batch or scalar involved in the addition.

  • y – batch or scalar involved in the addition.

Returns:

the sum of x and y

template<class T, class A>
inline auto div(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x / y)

Computes the division of the batch x by the batch y.

Parameters:
  • x – scalar or batch of scalars

  • y – scalar or batch of scalars

Returns:

the result of the division.

template<class T, class A>
inline batch<T, A> fma(batch<T, A> const &x, batch<T, A> const &y, batch<T, A> const &z) noexcept

Computes (x*y) + z in a single instruction when possible.

Parameters:
  • x – a batch of integer or floating point values.

  • y – a batch of integer or floating point values.

  • z – a batch of integer or floating point values.

Returns:

the result of the fused multiply-add operation.

template<class T, class A>
inline batch<T, A> fms(batch<T, A> const &x, batch<T, A> const &y, batch<T, A> const &z) noexcept

Computes (x*y) - z in a single instruction when possible.

Parameters:
  • x – a batch of integer or floating point values.

  • y – a batch of integer or floating point values.

  • z – a batch of integer or floating point values.

Returns:

the result of the fused multiply-sub operation.

template<class T, class A>
inline batch<T, A> fnma(batch<T, A> const &x, batch<T, A> const &y, batch<T, A> const &z) noexcept

Computes -(x*y) + z in a single instruction when possible.

Parameters:
  • x – a batch of integer or floating point values.

  • y – a batch of integer or floating point values.

  • z – a batch of integer or floating point values.

Returns:

the result of the fused negated multiply-add operation.

template<class T, class A>
inline batch<T, A> fnms(batch<T, A> const &x, batch<T, A> const &y, batch<T, A> const &z) noexcept

Computes -(x*y) - z in a single instruction when possible.

Parameters:
  • x – a batch of integer or floating point values.

  • y – a batch of integer or floating point values.

  • z – a batch of integer or floating point values.

Returns:

the result of the fused negated multiply-sub operation.

template<class T, class A>
inline auto mod(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x % y)

Computes the integer modulo of the batch x by the batch y.

Parameters:
  • x – batch involved in the modulo.

  • y – batch involved in the modulo.

Returns:

the result of the modulo.

template<class T, class A>
inline auto mul(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x * y)

Computes the product of the batches x and y.

Template Parameters:

X – the actual type of batch.

Parameters:
  • x – batch involved in the product.

  • y – batch involved in the product.

Returns:

the result of the product.

template<class T, class A>
inline batch<T, A> neg(batch<T, A> const &x) noexcept

Computes the opposite of the batch x.

Parameters:

x – batch involved in the operation.

Returns:

the opposite of x.

template<class T, class A>
inline batch<T, A> pos(batch<T, A> const &x) noexcept

No-op on x.

Parameters:

x – batch involved in the operation.

Returns:

x.

template<class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value, void>::type>
inline batch<T, A> reciprocal(batch<T, A> const &x) noexcept

Computes the approximate reciprocal of the batch x.

The maximum relative error for this approximation is less than 1.5*2^-12.

Parameters:

x – batch of floating point numbers.

Returns:

the reciprocal.

template<class T, class A>
inline auto sadd(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x + y)

Computes the saturate sum of the batch x and the batch y.

Template Parameters:

X – the actual type of batch.

Parameters:
  • x – batch involved in the saturated addition.

  • y – batch involved in the saturated addition.

Returns:

the result of the saturated addition.

template<class T, class A>
inline auto ssub(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x - y)

Computes the saturate difference of the batch x and the batch y.

Template Parameters:

X – the actual type of batch.

Parameters:
  • x – batch involved in the saturated difference.

  • y – batch involved in the saturated difference.

Returns:

the result of the saturated difference.

template<class T, class A>
inline auto sub(batch<T, A> const &x, batch<T, A> const &y) noexcept -> decltype(x - y)

Computes the difference between x and y.

Template Parameters:

X – the actual type of batch.

Parameters:
  • x – scalar or batch of scalars

  • y – scalar or batch of scalars

Returns:

the difference between x and y