Array Operations
AppleAccelerate wraps Apple's vecLib (vv*) and vDSP (vDSP_*) functions to provide accelerated element-wise operations on Array{Float32} and Array{Float64}.
These functions are not exported to avoid conflicts with Base. Access them via the AppleAccelerate. prefix.
Element-wise Math Functions
These functions wrap Apple's vecLib vv* routines.
One-argument functions
Each function f has an allocating variant f(X) and a mutating variant f!(out, X):
| Function | Description |
|---|---|
ceil, floor, trunc, round | Rounding |
sqrt, rsqrt, rec | Square root, reciprocal square root, reciprocal |
exp, exp2, expm1 | Exponentials |
log, log1p, log2, log10 | Logarithms |
sin, sinpi, cos, cospi, tan, tanpi | Trigonometric |
asin, acos, atan | Inverse trigonometric |
sinh, cosh, tanh, asinh, acosh, atanh | Hyperbolic |
abs, exponent | Miscellaneous |
Two-argument functions
| Function | Description |
|---|---|
copysign(X, Y) | Copy sign of Y to X |
rem(X, Y) | Element-wise remainder |
div_float(X, Y) | Element-wise division (via vecLib) |
atan(X, Y) | Two-argument arctangent |
pow(X, Y) | Element-wise power |
Special return types
| Function | Description |
|---|---|
sincos(X) | Returns (sin(X), cos(X)) tuple |
cis(X) | Returns Complex array cos(X) + im*sin(X) |
X = randn(Float64, 1000)
# Element-wise math — 3–19× faster than Base
Y_exp = AppleAccelerate.exp(X)
Y_sin = AppleAccelerate.sin(X)
Y_log = AppleAccelerate.log(X .+ 10) # shift to positive domain
# Mutating variant (pre-allocate output)
out = similar(X)
AppleAccelerate.exp!(out, X)
# Broadcasting works automatically
Y_broadcast = AppleAccelerate.sin.(X)AppleAccelerate.sincos — Function
sincos(X::Array{T}) where T <: Union{Float32, Float64}Compute the sine and cosine of each element simultaneously via vecLib vvsincos. Returns a tuple (sin(X), cos(X)) of arrays. Faster than computing sin and cos separately since both are produced in a single pass.
The mutating variant sincos!(out_sin, out_cos, X) stores results in preallocated arrays.
AppleAccelerate.cis — Function
cis(X::Array{T}) where T <: Union{Float32, Float64}Compute cos(x) + im*sin(x) for each element via vecLib vvcosisin. Returns a Complex{T} array. Equivalent to exp.(im .* X) but faster.
The mutating variant cis!(out, X) stores results in a preallocated complex array.
Unary vDSP Operations
Wraps vDSP unary vector operations.
| Function | Description |
|---|---|
vneg | Negate each element: result[i] = -X[i] |
vnabs | Negative absolute value: `result[i] = - |
vabs | Absolute value: result[i] = |X[i]| |
vsq | Square each element: result[i] = X[i]^2 |
vssq | Signed square: result[i] = X[i] * |X[i]| |
vfrac | Fractional part: result[i] = X[i] - trunc(X[i]) |
vreverse! | Reverse vector in-place |
vreverse | Return a reversed copy |
AppleAccelerate.vneg — Function
Negate each element: result[i] = -X[i]. Wraps vDSP_vneg.
AppleAccelerate.vnabs — Function
Negative absolute value: result[i] = -|X[i]|. Wraps vDSP_vnabs.
AppleAccelerate.vabs — Function
Absolute value: result[i] = |X[i]|. Wraps vDSP_vabs.
AppleAccelerate.vsq — Function
Square each element: result[i] = X[i]^2. Wraps vDSP_vsq.
AppleAccelerate.vssq — Function
Signed square: result[i] = X[i] * |X[i]|. Wraps vDSP_vssq.
AppleAccelerate.vfrac — Function
Fractional part: result[i] = X[i] - trunc(X[i]). Wraps vDSP_vfrac.
AppleAccelerate.vreverse! — Function
Reverse X in-place. Wraps vDSP_vrvrs.
AppleAccelerate.vreverse — Function
Return a reversed copy of X. Wraps vDSP_vrvrs.
Vector Reductions
Wraps vDSP reduction functions.
| Function | Description | Apple function |
|---|---|---|
maximum(X), minimum(X) | Max/min value | vDSP_maxv, vDSP_minv |
findmax(X), findmin(X) | Max/min value and index | vDSP_maxvi, vDSP_minvi |
sum(X), mean(X) | Sum and mean | vDSP_sve, vDSP_meanv |
meanmag(X) | Mean of absolute values | vDSP_meamgv |
meansqr(X) | Mean of squares | vDSP_measqv |
meanssqr(X) | Mean of signed squares | vDSP_mvessq |
summag(X) | Sum of absolute values | vDSP_svemg |
sumsqr(X) | Sum of squares | vDSP_svesq |
sumssqr(X) | Sum of signed squares | vDSP_svs |
dot | Dot product: sum(X .* Y) | vDSP_dotpr |
distancesq | Squared Euclidean distance: sum((X .- Y).^2) | vDSP_distancesq |
rmsqv | Root mean square: sqrt(sum(X.^2)/N) | |
sve_svesq | Simultaneous sum and sum-of-squares | |
maxmgv | Maximum magnitude: max(|X|) | |
minmgv | Minimum magnitude: min(|X|) | |
maxmgvi | Maximum magnitude with index | |
minmgvi | Minimum magnitude with index |
X = randn(Float64, 10_000)
# Reductions
s = AppleAccelerate.sum(X)
mx = AppleAccelerate.maximum(X)
val, idx = AppleAccelerate.findmax(X)
avg = AppleAccelerate.mean(X)AppleAccelerate.maximum — Function
maximum(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the maximum value in X via vDSP. Equivalent to Base.maximum(X). Wraps vDSP_maxv.
AppleAccelerate.minimum — Function
minimum(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the minimum value in X via vDSP. Equivalent to Base.minimum(X). Wraps vDSP_minv.
AppleAccelerate.sum — Function
sum(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the sum of elements in X via vDSP. Equivalent to Base.sum(X). Wraps vDSP_sve.
AppleAccelerate.mean — Function
mean(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the arithmetic mean of elements in X via vDSP. Wraps vDSP_meanv.
AppleAccelerate.findmax — Function
findmax(X::StridedVector{T}) where T <: Union{Float32, Float64}Return (value, index) of the maximum element in X via vDSP. Equivalent to Base.findmax(X). Wraps vDSP_maxvi.
AppleAccelerate.findmin — Function
findmin(X::StridedVector{T}) where T <: Union{Float32, Float64}Return (value, index) of the minimum element in X via vDSP. Equivalent to Base.findmin(X). Wraps vDSP_minvi.
AppleAccelerate.meanmag — Function
meanmag(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the mean of absolute values: sum(abs.(X)) / length(X). Wraps vDSP_meamgv.
AppleAccelerate.meansqr — Function
meansqr(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the mean of squares: sum(X.^2) / length(X). Wraps vDSP_measqv.
AppleAccelerate.meanssqr — Function
meanssqr(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the mean of signed squares: sum(X .* abs.(X)) / length(X). Wraps vDSP_mvessq.
AppleAccelerate.summag — Function
summag(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the sum of absolute values: sum(abs.(X)). Wraps vDSP_svemg.
AppleAccelerate.sumsqr — Function
sumsqr(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the sum of squares: sum(X.^2). Wraps vDSP_svesq.
AppleAccelerate.sumssqr — Function
sumssqr(X::StridedVector{T}) where T <: Union{Float32, Float64}Return the sum of signed squares: sum(X .* abs.(X)). Wraps vDSP_svs.
AppleAccelerate.dot — Function
Dot product: sum(X .* Y). Wraps vDSP_dotpr.
AppleAccelerate.distancesq — Function
Squared Euclidean distance: sum((X .- Y).^2). Wraps vDSP_distancesq.
AppleAccelerate.rmsqv — Function
Root mean square: sqrt(sum(X.^2) / length(X)). Wraps vDSP_rmsqv.
AppleAccelerate.sve_svesq — Function
Simultaneous sum and sum-of-squares: returns (sum(X), sum(X.^2)). Wraps vDSP_sve_svesq.
AppleAccelerate.maxmgv — Function
Maximum magnitude: maximum(abs.(X)). Wraps vDSP_maxmgv.
AppleAccelerate.minmgv — Function
Minimum magnitude: minimum(abs.(X)). Wraps vDSP_minmgv.
AppleAccelerate.maxmgvi — Function
Maximum magnitude with index: returns (maximum(abs.(X)), index). Wraps vDSP_maxmgvi.
AppleAccelerate.minmgvi — Function
Minimum magnitude with index: returns (minimum(abs.(X)), index). Wraps vDSP_minmgvi.
Vector-Vector Arithmetic
| Function | Description | Apple function |
|---|---|---|
vadd / vadd! | Element-wise addition | vDSP_vadd |
vsub / vsub! | Element-wise subtraction | vDSP_vsub |
vmul / vmul! | Element-wise multiplication | vDSP_vmul |
vdiv / vdiv! | Element-wise division | vDSP_vdiv |
A = randn(Float64, 1000)
B = randn(Float64, 1000)
# Vector arithmetic
C = AppleAccelerate.vadd(A, B) # A .+ B
D = AppleAccelerate.vmul(A, B) # A .* B
# Compound operation: A * scalar + B
E = AppleAccelerate.vsma(A, 2.5, B) # A .* 2.5 .+ BAppleAccelerate.vadd — Function
vadd(X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise addition over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vadd(X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise addition over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vadd! — Function
vadd!(result::StridedVector{Float32}, X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise addition over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vadd!(result::StridedVector{Float64}, X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise addition over two Vector{Float64} and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vsub — Function
vsub(X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise subtraction over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vsub(X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise subtraction over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vsub! — Function
vsub!(result::StridedVector{Float32}, X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise subtraction over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vsub!(result::StridedVector{Float64}, X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise subtraction over two Vector{Float64} and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vmul — Function
vmul(X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise multiplication over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vmul(X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise multiplication over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
vmul(X::Vector{Complex{Float32}}, Y::Vector{Complex{Float32}}) -> Vector{Complex{Float32}}
vmul!(result, X, Y)Element-wise complex multiplication: result[i] = X[i] * Y[i]. Wraps vDSP_zvmul.
vmul(X::Vector{Complex{Float64}}, Y::Vector{Complex{Float64}}) -> Vector{Complex{Float64}}
vmul!(result, X, Y)Element-wise complex multiplication: result[i] = X[i] * Y[i]. Wraps vDSP_zvmul.
AppleAccelerate.vmul! — Function
vmul!(result::StridedVector{Float32}, X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise multiplication over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vmul!(result::StridedVector{Float64}, X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise multiplication over two Vector{Float64} and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vdiv — Function
vdiv(X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise division over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vdiv(X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise division over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
vdiv(X::Vector{Complex{Float32}}, Y::Vector{Complex{Float32}}) -> Vector{Complex{Float32}}
vdiv!(result, X, Y)Element-wise complex division: result[i] = X[i] / Y[i]. Wraps vDSP_zvdiv.
vdiv(X::Vector{Complex{Float64}}, Y::Vector{Complex{Float64}}) -> Vector{Complex{Float64}}
vdiv!(result, X, Y)Element-wise complex division: result[i] = X[i] / Y[i]. Wraps vDSP_zvdiv.
AppleAccelerate.vdiv! — Function
vdiv!(result::StridedVector{Float32}, X::StridedVector{Float32}, Y::StridedVector{Float32})
Implements element-wise division over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vdiv!(result::StridedVector{Float64}, X::StridedVector{Float64}, Y::StridedVector{Float64})
Implements element-wise division over two Vector{Float64} and overwrites the result vector with computed value. Returns: Vector{Float64} result
Two-Vector Comparison & Distance
| Function | Description |
|---|---|
vmax | Element-wise maximum |
vmin | Element-wise minimum |
vmaxmg | Element-wise maximum magnitude |
vminmg | Element-wise minimum magnitude |
vdist | Element-wise Euclidean distance |
vtmerg | Tapered merge of two vectors |
AppleAccelerate.vmax — Function
Element-wise maximum: result[i] = max(X[i], Y[i]). Wraps vDSP_vmax.
AppleAccelerate.vmin — Function
Element-wise minimum: result[i] = min(X[i], Y[i]). Wraps vDSP_vmin.
AppleAccelerate.vmaxmg — Function
Element-wise maximum magnitude: result[i] = max(|X[i]|, |Y[i]|). Wraps vDSP_vmaxmg.
AppleAccelerate.vminmg — Function
Element-wise minimum magnitude: result[i] = min(|X[i]|, |Y[i]|). Wraps vDSP_vminmg.
AppleAccelerate.vdist — Function
Element-wise Euclidean distance: result[i] = hypot(X[i], Y[i]). Wraps vDSP_vdist.
AppleAccelerate.vtmerg — Function
Tapered merge of two vectors. Wraps vDSP_vtmerg.
Vector-Scalar Operations
| Function | Description | Apple function |
|---|---|---|
vsadd / vsadd! | Vector + scalar | vDSP_vsadd |
vssub / vssub! | Vector - scalar | vDSP_vsadd |
svsub / svsub! | Scalar - vector | vDSP_vsadd |
vsmul / vsmul! | Vector * scalar | vDSP_vsmul |
vsdiv / vsdiv! | Vector / scalar | vDSP_vsdiv |
svdiv | Scalar / vector | vDSP_svdiv |
AppleAccelerate.vsadd — Function
vsadd(X::StridedVector{Float32}, c::Float32)
Implements vector-scalar addition over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsadd(X::StridedVector{Float64}, c::Float64)
Implements vector-scalar addition over Vector{Float64} and Float64. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vsadd! — Function
vsadd!(result::StridedVector{Float32}, X::StridedVector{Float32}, c::Float32)
Implements vector-scalar addition over Vector{Float32} and Float32 and overwrites the result vector with computed value. Returns: Vector{Float32} result
vsadd!(result::StridedVector{Float64}, X::StridedVector{Float64}, c::Float64)
Implements vector-scalar addition over Vector{Float64} and Float64 and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vssub — Function
vssub(X::StridedVector{Float32}, c::Float32)
Implements vector-scalar subtraction over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vssub(X::StridedVector{Float64}, c::Float64)
Implements vector-scalar subtraction over Vector{Float64} and Float64. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vssub! — Function
vssub!(result::StridedVector{Float32}, X::StridedVector{Float32}, c::Float32)
Implements vector-scalar subtraction over Vector{Float32} and Float32 and overwrites the result vector with computed value. Returns: Vector{Float32} result
vssub!(result::StridedVector{Float64}, X::StridedVector{Float64}, c::Float64)
Implements vector-scalar subtraction over Vector{Float64} and Float64 and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.svsub — Function
svsub(X::StridedVector{Float32, c::Float32})
Implements vector-scalar subtraction over Float32 and Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
svsub(X::StridedVector{Float64, c::Float64})
Implements vector-scalar subtraction over Float64 and Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.svsub! — Function
svsub!(result::StridedVector{Float32}, X::StridedVector{Float32}, c::Float32)
Implements vector-scalar subtraction over Float32 and Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
svsub!(result::StridedVector{Float64}, X::StridedVector{Float64}, c::Float64)
Implements vector-scalar subtraction over Float64 and Vector{Float64} and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vsmul — Function
vsmul(X::StridedVector{Float32}, c::Float32)
Implements vector-scalar multiplication over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsmul(X::StridedVector{Float64}, c::Float64)
Implements vector-scalar multiplication over Vector{Float64} and Float64. Allocates memory to store result. Returns: Vector{Float64}
vsmul(X::Vector{Complex{Float32}}, c::Complex{Float32}) -> Vector{Complex{Float32}}
vsmul!(result, X, c)Complex vector-scalar multiplication: result[i] = X[i] * c. Wraps vDSP_zvzsml.
vsmul(X::Vector{Complex{Float64}}, c::Complex{Float64}) -> Vector{Complex{Float64}}
vsmul!(result, X, c)Complex vector-scalar multiplication: result[i] = X[i] * c. Wraps vDSP_zvzsml.
AppleAccelerate.vsmul! — Function
vsmul!(result::StridedVector{Float32}, X::StridedVector{Float32}, c::Float32)
Implements vector-scalar multiplication over Vector{Float32} and Float32 and overwrites the result vector with computed value. Returns: Vector{Float32} result
vsmul!(result::StridedVector{Float64}, X::StridedVector{Float64}, c::Float64)
Implements vector-scalar multiplication over Vector{Float64} and Float64 and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.vsdiv — Function
vsdiv(X::StridedVector{Float32}, c::Float32)
Implements vector-scalar division over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsdiv(X::StridedVector{Float64}, c::Float64)
Implements vector-scalar division over Vector{Float64} and Float64. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vsdiv! — Function
vsdiv!(result::StridedVector{Float32}, X::StridedVector{Float32}, c::Float32)
Implements vector-scalar division over Vector{Float32} and Float32 and overwrites the result vector with computed value. Returns: Vector{Float32} result
vsdiv!(result::StridedVector{Float64}, X::StridedVector{Float64}, c::Float64)
Implements vector-scalar division over Vector{Float64} and Float64 and overwrites the result vector with computed value. Returns: Vector{Float64} result
AppleAccelerate.svdiv — Function
Scalar divided by vector: result[i] = c / X[i]. Wraps vDSP_svdiv.
Compound Arithmetic
These operations fuse multiple arithmetic steps into a single vDSP call for better performance.
Three-vector operations
| Function | Description |
|---|---|
vam | (A + B) * C |
vsbm | (A - B) * C |
vma | A * B + C |
vmsb | A * B - C |
venvlp | Signal envelope |
Four-vector operations
| Function | Description |
|---|---|
vaam | (A + B) * (C + D) |
vsbsbm | (A - B) * (C - D) |
vasbm | (A + B) * (C - D) |
vmma | A * B + C * D |
vmmsb | A * B - C * D |
vpythg | Pythagorean distance |
Vector-vector-scalar operations
| Function | Description |
|---|---|
vasm | (A + B) * c |
vsbsm | (A - B) * c |
vsma | A * b + C |
vsmsa | A * b + c |
vmsa | A * B + c |
vsmsb | A * b - C |
vsmsma | A * b + C * d |
Dual output
| Function | Description |
|---|---|
vaddsub | Simultaneous add and subtract: returns (A .+ B, A .- B) |
AppleAccelerate.vam — Function
Vector add and multiply: result[i] = (A[i] + B[i]) * C[i]. Wraps vDSP_vam.
AppleAccelerate.vsbm — Function
Vector subtract and multiply: result[i] = (A[i] - B[i]) * C[i]. Wraps vDSP_vsbm.
AppleAccelerate.vma — Function
Vector multiply and add: result[i] = A[i]*B[i] + C[i]. Wraps vDSP_vma.
AppleAccelerate.vmsb — Function
Vector multiply and subtract: result[i] = A[i]*B[i] - C[i]. Wraps vDSP_vmsb.
AppleAccelerate.venvlp — Function
Signal envelope. Wraps vDSP_venvlp.
AppleAccelerate.vaam — Function
Vector add, add, and multiply: result[i] = (A[i] + B[i]) * (C[i] + D[i]). Wraps vDSP_vaam.
AppleAccelerate.vsbsbm — Function
Vector subtract, subtract, and multiply: result[i] = (A[i] - B[i]) * (C[i] - D[i]). Wraps vDSP_vsbsbm.
AppleAccelerate.vasbm — Function
Vector add, subtract, and multiply: result[i] = (A[i] + B[i]) * (C[i] - D[i]). Wraps vDSP_vasbm.
AppleAccelerate.vmma — Function
Vector multiply, multiply, and add: result[i] = A[i]*B[i] + C[i]*D[i]. Wraps vDSP_vmma.
AppleAccelerate.vmmsb — Function
Vector multiply, multiply, and subtract: result[i] = A[i]*B[i] - C[i]*D[i]. Wraps vDSP_vmmsb.
AppleAccelerate.vpythg — Function
Pythagorean distance: result[i] = sqrt((A[i]-C[i])^2 + (B[i]-D[i])^2). Wraps vDSP_vpythg.
AppleAccelerate.vasm — Function
Vector add and scalar multiply: result[i] = (A[i] + B[i]) * c. Wraps vDSP_vasm.
AppleAccelerate.vsbsm — Function
Vector subtract and scalar multiply: result[i] = (A[i] - B[i]) * c. Wraps vDSP_vsbsm.
AppleAccelerate.vsma — Function
Vector scalar multiply and add: result[i] = A[i] * b + C[i]. Wraps vDSP_vsma.
AppleAccelerate.vsmsa — Function
Vector scalar multiply and scalar add: result[i] = A[i] * b + c. Wraps vDSP_vsmsa.
AppleAccelerate.vmsa — Function
Vector multiply and scalar add: result[i] = A[i]*B[i] + c. Wraps vDSP_vmsa.
AppleAccelerate.vsmsb — Function
Vector scalar multiply and subtract: result[i] = A[i]*b - C[i]. Wraps vDSP_vsmsb.
AppleAccelerate.vsmsma — Function
Vector scalar multiply and scalar multiply add: result[i] = A[i]*b + C[i]*d. Wraps vDSP_vsmsma.
AppleAccelerate.vaddsub — Function
Simultaneous add and subtract: returns (A .+ B, B .- A). Wraps vDSP_vaddsub.
Clipping & Thresholding
| Function | Description |
|---|---|
vclip | Clip values to [low, high] |
vclipc | Clip with count: returns (clipped, nlow, nhigh) |
viclip | Inverted clip: pass values outside [low, high] |
vthr | Threshold: keep or clamp to threshold |
vthres | Threshold to zero |
vlim | Test limit: (b <= A[i]) ? c : -c |
vthrsc | Threshold with signed constant |
vcmprs | Compress: gather elements where gate is nonzero |
AppleAccelerate.vclip — Function
Clip values to [low, high]: clamp.(X, low, high). Wraps vDSP_vclip.
AppleAccelerate.vclipc — Function
Clip with count: returns (clipped, nlow, nhigh). Wraps vDSP_vclipc.
AppleAccelerate.viclip — Function
Inverted clip: pass through values outside [low, high], zero inside. Wraps vDSP_viclip.
AppleAccelerate.vthr — Function
Threshold: result[i] = X[i] >= threshold ? X[i] : threshold. Wraps vDSP_vthr.
AppleAccelerate.vthres — Function
Threshold to zero: result[i] = X[i] >= threshold ? X[i] : 0. Wraps vDSP_vthres.
AppleAccelerate.vlim — Function
Test limit: result[i] = (b <= A[i]) ? c : -c. Wraps vDSP_vlim.
AppleAccelerate.vthrsc — Function
Threshold with signed constant. Wraps vDSP_vthrsc.
AppleAccelerate.vcmprs — Function
Compress: gather elements of X where gate is nonzero. Wraps vDSP_vcmprs.
Type Conversion
| Function | Description |
|---|---|
vdouble | Convert Float32 to Float64 |
vsingle | Convert Float64 to Float32 |
AppleAccelerate.vdouble — Function
vdouble(X::StridedVector{Float32}) -> Vector{Float64}Convert single-precision to double-precision. Wraps vDSP_vspdp.
AppleAccelerate.vsingle — Function
vsingle(X::StridedVector{Float64}) -> Vector{Float32}Convert double-precision to single-precision. Wraps vDSP_vdpsp.
Ramp Generation
| Function | Description |
|---|---|
vramp | Generate a ramp: start + i * step |
vrampmul | Multiply vector by a generated ramp |
vrampmul2 | Stereo ramp multiply (two outputs) |
AppleAccelerate.vramp — Function
Generate a ramp: result[i] = start + i * step for i = 0, ..., n-1. Wraps vDSP_vramp.
AppleAccelerate.vrampmul — Function
Multiply vector by a generated ramp. Wraps vDSP_vrampmul.
AppleAccelerate.vrampmul2 — Function
Stereo ramp multiply: multiply two vectors by the same ramp. Wraps vDSP_vrampmul2.
Linear Average
| Function | Description |
|---|---|
vavlin | Weighted linear average of two vectors |
AppleAccelerate.vavlin — Function
Vector linear average: C[n] = (C[n] * weight + A[n]) / (weight + 1). Wraps vDSP_vavlin.
Integration & Running Operations
| Function | Description |
|---|---|
vrsum | Running sum scaled by scale |
vsimps | Simpson's rule integration |
vtrapz | Trapezoidal integration |
vswsum | Sliding window sum |
vswmax | Sliding window maximum |
AppleAccelerate.vrsum — Function
Running sum scaled by scale. Wraps vDSP_vrsum.
AppleAccelerate.vsimps — Function
Simpson's rule integration with step size step. Wraps vDSP_vsimps.
AppleAccelerate.vtrapz — Function
Trapezoidal integration with step size step. Wraps vDSP_vtrapz.
AppleAccelerate.vswsum — Function
Sliding window sum with window size window. Returns a vector of length length(X) - window + 1. window must satisfy 1 ≤ window ≤ length(X); for vswsum!, result must have length ≥ length(X) - window + 1. Wraps vDSP_vswsum.
AppleAccelerate.vswmax — Function
Sliding window maximum with window size window. Returns a vector of length length(X) - window + 1. window must satisfy 1 ≤ window ≤ length(X); for vswmax!, result must have length ≥ length(X) - window + 1. Wraps vDSP_vswmax.
Interpolation
| Function | Description |
|---|---|
vintb | Linear interpolation: A + t * (B - A) |
vlint | Linear interpolation from lookup table |
vqint | Quadratic interpolation from lookup table |
AppleAccelerate.vintb — Function
Vector interpolation: result[i] = A[i] + t * (B[i] - A[i]). Wraps vDSP_vintb.
AppleAccelerate.vlint — Function
Linear interpolation from a lookup table using fractional indices. Wraps vDSP_vlint.
AppleAccelerate.vqint — Function
Quadratic interpolation from a lookup table using fractional indices. Wraps vDSP_vqint.
Polynomial Evaluation
| Function | Description |
|---|---|
vpoly | Evaluate polynomial at each point |
AppleAccelerate.vpoly — Function
vpoly(coeffs, X)Evaluate polynomial at each point in X. Coefficients are highest degree first: [a_P, a_{P-1}, ..., a_1, a_0]. Wraps vDSP_vpoly.
Normalization
| Function | Description |
|---|---|
vnormalize | Normalize to zero mean and unit standard deviation |
AppleAccelerate.vnormalize — Function
vnormalize(X) -> (normalized, mean, stddev)Normalize vector to zero mean and unit standard deviation: (X .- mean) ./ stddev. Returns a tuple of (normalized_vector, mean, stddev). Wraps vDSP_normalize.
Zero Crossings
| Function | Description |
|---|---|
nzcros | Find zero crossings |
AppleAccelerate.nzcros — Function
nzcros(X, max_crossings=0) -> (indices, count)Find zero crossings in X. Returns a tuple of (crossing_indices, count). If max_crossings <= 0, searches for up to length(X) crossings. Wraps vDSP_nzcros.
Decibel Conversion
| Function | Description |
|---|---|
vdbcon | Convert to decibels relative to a reference |
AppleAccelerate.vdbcon — Function
vdbcon(X, ref, power=true)Convert to decibels relative to ref. If power=true, computes 10*log10(X/ref); if power=false, computes 20*log10(X/ref). Wraps vDSP_vdbcon.
Vector Fill, Swap & Sort
| Function | Description |
|---|---|
vclr! | Fill vector with zeros |
vfill! | Fill vector with scalar value |
vswap! | Swap two vectors in-place |
vsort! | Sort vector in-place |
vsorti | Return sort permutation (indices) |
AppleAccelerate.vclr! — Function
Fill vector with zeros: C[i] = 0. Wraps vDSP_vclr.
AppleAccelerate.vfill! — Function
Fill vector with scalar value: C[i] = a. Wraps vDSP_vfill.
AppleAccelerate.vswap! — Function
Swap elements of two vectors in-place. Wraps vDSP_vswap.
AppleAccelerate.vsort! — Function
Sort vector in-place. ascending=true for ascending order. Wraps vDSP_vsort.
AppleAccelerate.vsorti — Function
Return sort permutation (1-based indices). Wraps vDSP_vsorti.
Gathering & Indexing
| Function | Description |
|---|---|
vgathr | Gather by index: C[i] = A[B[i]] |
vindex | Index with float indices |
vgen | Generate linear ramp between two values |
vgenp | Piecewise linear interpolation from breakpoints |
vtabi | Table lookup with interpolation |
AppleAccelerate.vgathr — Function
Gather elements by index: C[i] = A[B[i]] where B contains 1-based UInt indices in 1:length(A) (a BoundsError is thrown otherwise). Wraps vDSP_vgathr.
AppleAccelerate.vindex — Function
Index with float indices: C[i] = A[trunc(B[i])] where B contains 0-based float indices. Wraps vDSP_vindex.
AppleAccelerate.vgen — Function
Generate linear ramp between two scalars: C[i] = a + (b-a)*i/(N-1). Wraps vDSP_vgen.
AppleAccelerate.vgenp — Function
Piecewise linear interpolation from breakpoints. Wraps vDSP_vgenp.
AppleAccelerate.vtabi — Function
Table lookup with interpolation: D[i] = C[clamp(s1*A[i]+s2, 0, M-1)]. Wraps vDSP_vtabi.
Matrix Operations
| Function | Description |
|---|---|
mmul | Matrix multiply: C = A * B |
mtrans | Matrix transpose: C = Aᵀ |
mmov | Matrix copy (submatrix move) |
AppleAccelerate.mmul — Function
Matrix multiply: C = A * B. Wraps vDSP_mmul.
AppleAccelerate.mtrans — Function
Matrix transpose: C = Aᵀ. Wraps vDSP_mtrans.
AppleAccelerate.mmov — Function
Matrix copy (submatrix move). Wraps vDSP_mmov.
Integer Operations (Int32)
| Function | Description |
|---|---|
vaddi | Int32 vector addition |
vabsi | Int32 absolute value |
vfilli! | Fill Int32 vector with scalar |
veqvi | Int32 bitwise XNOR |
AppleAccelerate.vaddi — Function
Int32 vector addition: C[i] = A[i] + B[i]. Wraps vDSP_vaddi.
AppleAccelerate.vabsi — Function
Int32 absolute value: C[i] = |A[i]|. Wraps vDSP_vabsi.
AppleAccelerate.vfilli! — Function
Fill Int32 vector with scalar value. Wraps vDSP_vfilli.
AppleAccelerate.veqvi — Function
Int32 bitwise XNOR: C[i] = ~(A[i] ^ B[i]). Wraps vDSP_veqvi.
Type Conversion (int ↔ float)
| Direction | Functions | Description |
|---|---|---|
| float → signed int (truncate) | vfix8, vfix16, vfix32 | Truncating conversion |
| float → unsigned int (truncate) | vfixu8, vfixu16, vfixu32 | Truncating conversion |
| float → signed int (round) | vfixr8, vfixr16, vfixr32 | Rounding conversion |
| float → unsigned int (round) | vfixru8, vfixru16, vfixru32 | Rounding conversion |
| signed int → float | vflt8, vflt16, vflt32 | Signed integer to float |
| unsigned int → float | vfltu8, vfltu16, vfltu32 | Unsigned integer to float |
Every function in this family has an allocating variant and a mutating variant f!(C, A) that writes into a preallocated C. The number in the name is the integer bit width (8, 16, 32), so vfix32 truncates to Int32, vfltu16 converts UInt16 to float, and so on. Both Float32 and Float64 are supported.
For the mutating f!(C, A) forms, C must satisfy length(C) ≥ length(A); otherwise a DimensionMismatch is thrown before any elements are written.
The two directions differ in how the output type is chosen. For float → int the integer type is fixed by the function name, so the allocating form is f(A). For int → float the float width is ambiguous, so the allocating form takes it explicitly as f(A, Float64) (or Float32).
X = Float64[-1.7, 0.4, 2.9]
I32 = AppleAccelerate.vfix32(X) # truncate toward zero → Int32[-1, 0, 2]
R32 = AppleAccelerate.vfixr32(X) # round to nearest → Int32[-2, 0, 3]
Xf = AppleAccelerate.vflt32(I32, Float64) # back to Float64 (target type required)
# Mutating variant writes into a preallocated output
out = Vector{Int32}(undef, length(X))
AppleAccelerate.vfix32!(out, X)Image Convolution
| Function | Description |
|---|---|
f3x3 | 2D convolution with 3×3 filter |
f5x5 | 2D convolution with 5×5 filter |
imgfir | General 2D image convolution |
AppleAccelerate.f3x3 — Function
2D convolution with a 3×3 filter. Border elements are set to zero. Wraps vDSP_f3x3.
AppleAccelerate.f5x5 — Function
2D convolution with a 5×5 filter. Border elements are set to zero. Wraps vDSP_f5x5.
AppleAccelerate.imgfir — Function
General 2D image convolution with a P×Q filter. Border elements are set to zero. Wraps vDSP_imgfir.
Broadcasting
AppleAccelerate overrides Base.copy and Base.copyto! for Broadcasted objects, so that broadcasting syntax like f.(X) automatically uses the accelerated implementation.