Functions¶

sin(X)¶

Computes the element-wise sine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

sin!(result, X)¶

Computes the element-wise sine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

cos(X)¶

Computes the element-wise cosine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

cos!(result, X)¶

Computes the element-wise cosine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

tan(X)¶

Computes the element-wise tangent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

tan!(result, X)¶

Computes the element-wise tangent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

asin(X)¶

Computes the element-wise inverse sine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

asin!(result, X)¶

Computes the element-wise inverse sine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

acos(X)¶

Computes the element-wise inverse cosine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

acos!(result, X)¶

Computes the element-wise inverse cosine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

atan(X)¶

Computes the element-wise inverse tangent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

atan!(result, X)¶

Computes the element-wise inverse tangent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

sinh(X)¶

Computes the element-wise hyperbolic sine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

sinh!(result, X)¶

Computes the element-wise hyperbolic sine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

cosh(X)¶

Computes the element-wise hyperbolic cosine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

cosh!(result, X)¶

Computes the element-wise cosine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

tanh(X)¶

Computes the element-wise hyperbolic tangent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

tanh!(result, X)¶

Computes the element-wise hyperbolic tangent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

asinh(X)¶

Computes the element-wise inverse hyperbolic sine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

asinh!(result, X)¶

Computes the element-wise inverse hyperbolic sine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

acosh(X)¶

Computes the element-wise inverse hyperbolic cosine of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

acosh!(result, X)¶

Computes the element-wise inverse hyperbolic cosine of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

atanh(X)¶

Computes the element-wise inverse hyperbolic tangent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float64)

atanh!(result, X)¶

Computes the element-wise inverse hyperbolic tangent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

sinpi(X)¶

Computes the element-wise sine of pi times a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

sinpi!(result, X)¶

Computes the element-wise sine of pi times a vector and stores it in result:

Accelerate(X::Float32)
Accelerate(X::Float64)

cospi(X)¶

Computes the element-wise cosine of pi times a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

cospi!(result, X)¶

Computes the element-wise cosine of pi times a vector and stores it in result:

Accelerate(X::Float32)
Accelerate(X::Float64)

tanpi(X)¶

Computes the element-wise tangent of pi times a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

tanpi!(result, X)¶

Computes the element-wise tangent of pi times a vector and stores it in result:

Accelerate(X::Float32)
Accelerate(X::Float64)

atan2(X, Y)¶

Computes the element-wise arctangent two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)

atan2!(result, X, Y)¶

Computes the element-wise arctangent two vectors and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)

log(X)¶

Computes the element-wise logarithm of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

log!(result, X)¶

Computes the element-wise logarithm of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

log10(X)¶

Computes the element-wise logarithm to base-10 of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

log10!(result, X)¶

Computes the element-wise logarithm to base-10 of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

log1p(X)¶

Computes the element-wise natural logarithm to one plus a vector:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

log1p!(result, X)¶

Computes the element-wise natural logarithm of one plus a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

log2(X)¶

Computes the element-wise logarithm to base-2 of a vector:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

log2!(result, X)¶

Computes the element-wise logarithm to base-2 of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

exp(X)¶

Computes the element-wise base-e exponent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

exp!(result, X)¶

Computes the element-wise base-e exponent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

exp2(X)¶

Computes the element-wise base-2 exponent of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

exp2!(result, X)¶

Computes the element-wise base-2 exponent of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

expm1(X)¶

Computes the element-wise natural exponent of a vector minus one:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

expm1!(result, X)¶

Computes the element-wise natural exponent of a vector minus one and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

pow(X, Y)¶

Calculates a vector raised element-wise to the power of another vector:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)

pow!(result, X, Y)¶

Calculates a vector raised element-wise to the power of another vector and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)

pow2o3(X)¶

Raises each element of a vector to the 2/3 power:

VML(X::Float32)
VML(X::Float64)

pow2o3!(result, X)¶

Raises each element of a vector to the 2/3 power stores it in result:

VML(X::Float32)
VML(X::Float64)

pow3o2(X)¶

Raises each element of a vector to the 3/3 power:

VML(X::Float32)
VML(X::Float64)

pow3o2!(result, X)¶

Raises each element of a vector to the 3/2 power stores it in result:

VML(X::Float32)
VML(X::Float64)

exponent(X)¶

Computes the element-wise exponent of a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

exponent!(result, X)¶

Computes element-wise exponent of a vector and stores it in result:

Accelerate(X::Float32)
Accelerate(X::Float64)

sqrt(X)¶

Computes the element-wise square root of a vector minus one:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

sqrt!(result, X)¶

Computes the element-wise square root of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Yeppp(X::Float64)
Accelerate(X::Float32)
Accelerate(X::Float64)

invsqrt(X)¶

Computes the element-wise square root of a vector minus one:

VML(X::Float32)
VML(X::Float64)

invsqrt!(result, X)¶

Computes the element-wise square root of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)

invsqrt(X)

Computes the element-wise square root of a vector minus one:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

invsqrt!(result, X)

Computes the element-wise square root of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

add(X, Y)¶

Computes the element-wise addition two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

add!(result, X, Y)¶

Computes the element-wise addition of two vectors and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

sub(X, Y)¶

Computes the element-wise subtraction two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

sub!(result, X, Y)¶

Computes the element-wise subtraction of two vectors and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

mul(X, Y)¶

Computes the element-wise multiplication two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

mul!(result, X, Y)¶

Computes the element-wise multiplication of two vectors and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Yeppp(X::Int8, Y::Int8)
Yeppp(X::UInt8, Y::UInt8)
Yeppp(X::Int16, Y::Int16)
Yeppp(X::UInt16, Y::UInt16)
Yeppp(X::Int32, Y::Int32)
Yeppp(X::UInt32, Y::UInt32)
Yeppp(X::Int64, Y::Int64)
Yeppp(X::Float32, Y::Float32)
Yeppp(X::Float64, Y::Float64)
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

div(X, Y)¶

Computes the element-wise division two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

div!(result, X, Y)¶

Computes the element-wise division of two vectors and stores it in result:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)
VML(X::Complex{Float32}, Y::Complex{Float32})
VML(X::Complex{Float64}, Y::Complex{Float64})
Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)

abs(X)¶

Computes the element-wise absolute value of a vector:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

abs!(result, X)¶

Computes the element-wise absolute value of a vector and stores it in result:

VML(X::Float32)
VML(X::Float64)
VML(X::Complex{Float32})
VML(X::Complex{Float64})
Accelerate(X::Float32)
Accelerate(X::Float64)

max(X, Y)¶

Computes the element-wise maximum value of two vectors:

Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)
Yeppp(X::Float64, Y::Float64)

max!(result, X, Y)¶

Computes the element-wise maximum value of two vectors and stores it in result:

Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)
Yeppp(X::Float64, Y::Float64)

min(X, Y)¶

Computes the element-wise minimum value of two vectors:

Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)
Yeppp(X::Float64, Y::Float64)

min!(result, X, Y)¶

Computes the element-wise minimum value of two vectors and stores it in result:

Accelerate(X::Float32, Y::Float32)
Accelerate(X::Float64, Y::Float64)
Yeppp(X::Float64, Y::Float64)

maximum(X)¶

Returns the maximum value contained within a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

mininum(X)¶

Returns the minimum value contained within a vector:

Accelerate(X::Float32)
Accelerate(X::Float64)

hypot(X, Y)¶

Computes the element-wise hypotenuse of a triangle with sides given by two vectors:

VML(X::Float32, Y::Float32)
VML(X::Float64, Y::Float64)

hypot!(result, X, Y)¶

Computes the element-wise hypotenuse of a triangle with sides given by two vectors and stores it in result::

VML(X::Float32, Y::Float32) VML(X::Float64, Y::Float64)