Mathematical Functions

Basic functions:

abs()	absolute value
fabs()	absolute value of floating point values
fmod()	remainder of the floating point division operation
remainder()	signed remainder of the division operation
min()	smaller of two batches
max()	larger of two batches
fmin()	smaller of two batches of floating point values
fmax()	larger of two batches of floating point values
fdim()	positive difference
clip()	clipping operation

Exponential functions:

exp()	natural exponential function
exp2()	base 2 exponential function
exp10()	base 10 exponential function
expm1()	natural exponential function, minus one
log()	natural logarithm function
log2()	base 2 logarithm function
log10()	base 10 logarithm function
log1p()	natural logarithm of one plus function

Power functions:

pow()	power function
rsqrt()	reciprocal square root function
sqrt()	square root function
cbrt()	cubic root function
hypot()	hypotenuse function

Trigonometric functions:

sin()	sine function
cos()	cosine function
sincos()	sine and cosine function
tan()	tangent function
asin()	arc sine function
acos()	arc cosine function
atan()	arc tangent function
atan2()	arc tangent function, determining quadrants

Hyperbolic functions:

sinh()	hyperbolic sine function
cosh()	hyperbolic cosine function
tanh()	hyperbolic tangent function
asinh()	inverse hyperbolic sine function
acosh()	inverse hyperbolic cosine function
atanh()	inverse hyperbolic tangent function

Error functions:

erf()	error function
erfc()	complementary error function
tgamma()	gamma function
lgamma()	natural logarithm of the gamma function

Nearint operations:

ceil()	nearest integers not less
floor()	nearest integers not greater
trunc()	nearest integers not greater in magnitude
round()	nearest integers, rounding away from zero
nearbyint()	nearest integers using current rounding mode
rint()	nearest integers using current rounding mode

---

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

Computes the absolute values of each scalar in the batch x.

Parameters:

x – batch of integer or floating point values.

Returns:

the absolute values of x.

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

Computes the average of batches x and y.

Parameters:

• x – batch of T

• y – batch of T

Returns:

the average of elements between x and y.

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

Computes the rounded average of batches x and y.

Parameters:

• x – batch of T

• y – batch of T

Returns:

the rounded average of elements between x and y.

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

Computes the cubic root of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the cubic root of x.

template<class T, class A>
inline batch<T, A> clip(batch<T, A> const &x, batch<T, A> const &lo, batch<T, A> const &hi) noexcept

Clips the values of the batch x between those of the batches lo and hi.

Parameters:

• x – batch of scalar values.

• lo – batch of scalar values.

• hi – batch of scalar values.

Returns:

the result of the clipping.

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

Computes the natural exponential of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the natural exponential of x.

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

Computes the base 10 exponential of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the base 10 exponential of x.

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

Computes the base 2 exponential of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the base 2 exponential of x.

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

Computes the natural exponential of the batch x, minus one.

Parameters:

x – batch of floating point values.

Returns:

the natural exponential of x, minus one.

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

Computes the absolute values of each scalar in the batch x.

Parameters:

x – batch floating point values.

Returns:

the absolute values of x.

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

Computes the positive difference between x and y, that is, max(0, x-y).

Parameters:

• x – batch of floating point values.

• y – batch of floating point values.

Returns:

the positive difference.

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

Computes the larger values of the batches x and y.

Parameters:

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

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

Returns:

a batch of the larger values.

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

Computes the smaller values of the batches x and y.

Parameters:

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

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

Returns:

a batch of the smaller values.

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

Computes the 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 batch<T, A> hypot(batch<T, A> const &x, batch<T, A> const &y) noexcept

Computes the square root of the sum of the squares of the batches x, and y.

Parameters:

• x – batch of floating point values.

• y – batch of floating point values.

Returns:

the square root of the sum of the squares of x and y.

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

Computes the natural logarithm of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the natural logarithm of x.

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

Computes the base 2 logarithm of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the base 2 logarithm of x.

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

Computes the base 10 logarithm of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the base 10 logarithm of x.

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

Computes the natural logarithm of one plus the batch x.

Parameters:

x – batch of floating point values.

Returns:

the natural logarithm of one plus x.

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

Computes the larger values of the batches x and y.

Parameters:

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

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

Returns:

a batch of the larger values.

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

Computes the smaller values of the batches x and y.

Parameters:

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

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

Returns:

a batch of the smaller values.

template<class T, class A>
inline complex_batch_type_t<batch<T, A>> polar(batch<T, A> const &r, batch<T, A> const &theta = batch<T, A>{}) noexcept

Returns a complex batch with magnitude r and phase angle theta.

Parameters:

• r – The magnitude of the desired complex result.

• theta – The phase angle of the desired complex result.

Returns:

r exp(i * theta).

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

Computes the value of the batch x raised to the power y.

Parameters:

• x – batch of floating point values.

• y – batch of floating point values.

Returns:

x raised to the power y.

template<class T, class A>
inline batch<std::complex<T>, A> pow(batch<std::complex<T>, A> const &x, batch<T, A> const &y) noexcept

Computes the value of the batch x raised to the power y.

Parameters:

• x – batch of complex floating point values.

• y – batch of floating point values.

Returns:

x raised to the power y.

template<class T, class A>
inline batch<std::complex<T>, A> pow(batch<T, A> const &x, batch<std::complex<T>, A> const &y) noexcept

Computes the value of the batch x raised to the power y.

Parameters:

• x – batch of complex floating point values.

• y – batch of floating point values.

Returns:

x raised to the power y.

template<class T, class ITy, class A, class = typename std::enable_if<std::is_integral<ITy>::value>::type>
inline batch<T, A> pow(batch<T, A> const &x, ITy y) noexcept

Computes the value of the batch x raised to the power y.

Parameters:

• x – batch of integral values.

• y – batch of integral values.

Returns:

x raised to the power y.

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

Computes the remainder of dividing x by y.

Parameters:

• x – batch of scalar values

• y – batch of scalar values

Returns:

the result of the addition.

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

Computes an estimate of the inverse square root of the batch x.

Warning

Unlike most xsimd function, this does not return the same result as the equivalent scalar operation, trading accuracy for speed.

Parameters:

x – batch of floating point values.

Returns:

the inverse square root of x.

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

Computes the square root of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the square root of x.

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

Computes the arc cosine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the arc cosine of x.

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

Computes the inverse hyperbolic cosine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the inverse hyperbolic cosine of x.

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

Computes the arc sine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the arc sine of x.

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

Computes the inverse hyperbolic sine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the inverse hyperbolic sine of x.

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

Computes the arc tangent of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the arc tangent of x.

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

Computes the arc tangent of the batch x/y, using the signs of the arguments to determine the correct quadrant.

Parameters:

• x – batch of floating point values.

• y – batch of floating point values.

Returns:

the arc tangent of x/y.

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

Computes the inverse hyperbolic tangent of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the inverse hyperbolic tangent of x.

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

Computes the cosine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the cosine of x.

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

computes the hyperbolic cosine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the hyperbolic cosine of x.

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

Computes the sine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the sine of x.

template<class T, class A>
inline std::pair<batch<T, A>, batch<T, A>> sincos(batch<T, A> const &x) noexcept

Computes the sine and the cosine of the batch x.

This method is faster than calling sine and cosine independently.

Parameters:

x – batch of floating point values.

Returns:

a pair containing the sine then the cosine of batch x

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

Computes the hyperbolic sine of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the hyperbolic sine of x.

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

Computes the tangent of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the tangent of x.

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

Computes the hyperbolic tangent of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the hyperbolic tangent of x.

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

Computes the batch of smallest integer values not less than scalars in x.

Parameters:

x – batch of floating point values.

Returns:

the batch of smallest integer values not less than x.

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

Computes the batch of largest integer values not greater than scalars in x.

Parameters:

x – batch of floating point values.

Returns:

the batch of largest integer values not greater than x.

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

Rounds the scalars in x to integer values (in floating point format), using the current rounding mode.

Parameters:

x – batch of floating point values.

Returns:

the batch of nearest integer values.

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

Rounds the scalars in x to integer values (in integer format) using the current rounding mode.

Warning

For very large values the conversion to int silently overflows.

Parameters:

x – batch of floating point values.

Returns:

the batch of nearest integer values.

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

Rounds the scalars in x to integer values (in floating point format), using the current rounding mode.

Parameters:

x – batch of floating point values.

Returns:

the batch of rounded values.

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

Computes the batch of nearest integer values to scalars in x (in floating point format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters:

x – batch of flaoting point values.

Returns:

the batch of nearest integer values.

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

Computes the batch of nearest integer values not greater in magnitude than scalars in x.

Parameters:

x – batch of floating point values.

Returns:

the batch of nearest integer values not greater in magnitude than x.

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

Computes the error function of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the error function of x.

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

Computes the complementary error function of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the error function of x.

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

Computes the multiplication of the floating point number x by 2 raised to the power y.

Parameters:

• x – batch of floating point values.

• y – batch of integer values.

Returns:

a batch of floating point values.

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

Computes the natural logarithm of the gamma function of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the natural logarithm of the gamma function of x.

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

Computes the next representable floating-point value following x in the direction of y.

Parameters:

• x – batch of floating point values.

• y – batch of floating point values.

Returns:

x raised to the power y.

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

Computes the gamma function of the batch x.

Parameters:

x – batch of floating point values.

Returns:

the gamma function of x.