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::Vector{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::Vector{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::Vector{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::Vector{T}) where T <: Union{Float32, Float64}Return the arithmetic mean of elements in X via vDSP. Wraps vDSP_meanv.
AppleAccelerate.findmax — Function
findmax(X::Vector{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::Vector{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::Vector{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::Vector{T}) where T <: Union{Float32, Float64}Return the mean of squares: sum(X.^2) / length(X). Wraps vDSP_measqv.
AppleAccelerate.meanssqr — Function
meanssqr(X::Vector{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::Vector{T}) where T <: Union{Float32, Float64}Return the sum of absolute values: sum(abs.(X)). Wraps vDSP_svemg.
AppleAccelerate.sumsqr — Function
sumsqr(X::Vector{T}) where T <: Union{Float32, Float64}Return the sum of squares: sum(X.^2). Wraps vDSP_svesq.
AppleAccelerate.sumssqr — Function
sumssqr(X::Vector{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::Vector{Float32}, Y::Vector{Float32})
Implements element-wise addition over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vadd(X::Vector{Float64}, Y::Vector{Float64})
Implements element-wise addition over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vadd! — Function
vadd!(result::Vector{Float32}, X::Vector{Float32}, Y::Vector{Float32})
Implements element-wise addition over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vadd!(result::Vector{Float64}, X::Vector{Float64}, Y::Vector{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::Vector{Float32}, Y::Vector{Float32})
Implements element-wise subtraction over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vsub(X::Vector{Float64}, Y::Vector{Float64})
Implements element-wise subtraction over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vsub! — Function
vsub!(result::Vector{Float32}, X::Vector{Float32}, Y::Vector{Float32})
Implements element-wise subtraction over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vsub!(result::Vector{Float64}, X::Vector{Float64}, Y::Vector{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::Vector{Float32}, Y::Vector{Float32})
Implements element-wise multiplication over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vmul(X::Vector{Float64}, Y::Vector{Float64})
Implements element-wise multiplication over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vmul! — Function
vmul!(result::Vector{Float32}, X::Vector{Float32}, Y::Vector{Float32})
Implements element-wise multiplication over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vmul!(result::Vector{Float64}, X::Vector{Float64}, Y::Vector{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::Vector{Float32}, Y::Vector{Float32})
Implements element-wise division over two Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
vdiv(X::Vector{Float64}, Y::Vector{Float64})
Implements element-wise division over two Vector{Float64}. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vdiv! — Function
vdiv!(result::Vector{Float32}, X::Vector{Float32}, Y::Vector{Float32})
Implements element-wise division over two Vector{Float32} and overwrites the result vector with computed value. Returns: Vector{Float32} result
vdiv!(result::Vector{Float64}, X::Vector{Float64}, Y::Vector{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::Vector{Float32}, c::Float32)
Implements vector-scalar addition over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsadd(X::Vector{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::Vector{Float32}, X::Vector{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::Vector{Float64}, X::Vector{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::Vector{Float32}, c::Float32)
Implements vector-scalar subtraction over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vssub(X::Vector{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::Vector{Float32}, X::Vector{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::Vector{Float64}, X::Vector{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::Vector{Float32, c::Float32})
Implements vector-scalar subtraction over Float32 and Vector{Float32}. Allocates memory to store result. Returns: Vector{Float32}
svsub(X::Vector{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::Vector{Float32}, X::Vector{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::Vector{Float64}, X::Vector{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::Vector{Float32}, c::Float32)
Implements vector-scalar multiplication over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsmul(X::Vector{Float64}, c::Float64)
Implements vector-scalar multiplication over Vector{Float64} and Float64. Allocates memory to store result. Returns: Vector{Float64}
AppleAccelerate.vsmul! — Function
vsmul!(result::Vector{Float32}, X::Vector{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::Vector{Float64}, X::Vector{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::Vector{Float32}, c::Float32)
Implements vector-scalar division over Vector{Float32} and Float32. Allocates memory to store result. Returns: Vector{Float32}
vsdiv(X::Vector{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::Vector{Float32}, X::Vector{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::Vector{Float64}, X::Vector{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::Vector{Float32}) -> Vector{Float64}Convert single-precision to double-precision. Wraps vDSP_vspdp.
AppleAccelerate.vsingle — Function
vsingle(X::Vector{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. Wraps vDSP_vswsum.
AppleAccelerate.vswmax — Function
Sliding window maximum with window size window. Returns a vector of 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. 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 |
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.
Format Conversion
| Function | Description |
|---|---|
ctoz | Interleaved complex → split (real, imag) vectors |
ztoc | Split (real, imag) vectors → interleaved complex |
AppleAccelerate.ctoz — Function
Convert interleaved complex to split-complex (real, imag) vectors. Wraps vDSP_ctoz.
AppleAccelerate.ztoc — Function
Convert split-complex (real, imag) vectors to interleaved complex. Wraps vDSP_ztoc.
Complex Array Operations
AppleAccelerate also wraps vDSP's split-complex functions for Vector{Complex{Float32}} and Vector{Complex{Float64}}. These extend existing function names (e.g., vneg, vabs, vmul) with methods that dispatch on complex element types — no naming conflicts with the real-valued versions above.
Complex unary operations
| Function | Description |
|---|---|
vneg(X) / vneg!(result, X) | Negate: -X |
vabs(X) / vabs!(result, X) | Modulus: abs.(X) |
vconj | Complex conjugate |
vcopy | Copy via split-complex move |
Complex → real operations
| Function | Description |
|---|---|
vphase | Complex phase (angle) |
vmags | Squared magnitude (abs2) |
vmagsa | Squared magnitude + accumulate |
Complex binary operations
| Function | Description |
|---|---|
vmul(X, Y) / vmul!(result, X, Y) | Element-wise multiply: X .* Y |
vdiv(X, Y) / vdiv!(result, X, Y) | Element-wise divide: X ./ Y |
vsmul(X, c) / vsmul!(result, X, c) | Scalar multiply (complex scalar) |
dot(X, Y) | Unconjugated dot product: sum(X .* Y) |
zvadd | Complex addition: A + B |
zvsub | Complex subtraction: A - B |
zvcmul | Conjugate multiply: conj(A) * B |
Complex-real operations
| Function | Description |
|---|---|
zrvmul | Complex × real |
zrvdiv | Complex / real |
zrvadd | Complex + real (adds to real part) |
zrvsub | Complex − real |
Complex compound operations
| Function | Description |
|---|---|
zvcma | conj(A)*B + C |
zvma | A*B + C |
zvsma | A*b + C (b is complex scalar) |
Complex dot products
| Function | Description |
|---|---|
zidotpr | Conjugate dot: sum(conj(A) .* B) |
zrdotpr | Complex-real dot: sum(A .* B) |
Complex fill & convolution
| Function | Description |
|---|---|
zvfill! | Fill complex vector with scalar |
zconv | Complex convolution |
zmmul | Complex matrix multiply |
Coordinate conversion
| Function | Description |
|---|---|
polar | Cartesian to polar coordinates |
rect | Polar to Cartesian coordinates |
Z = AppleAccelerate.cis(randn(Float64, 100)) # complex array
# Complex operations
conj_Z = AppleAccelerate.vconj(Z)
phases = AppleAccelerate.vphase(Z)
mags = AppleAccelerate.vmags(Z)
# Coordinate conversion
r, θ = AppleAccelerate.polar(Z)
Z_back = AppleAccelerate.rect(r, θ)AppleAccelerate.vconj — Function
vconj(X::Vector{Complex{T}}) -> Vector{Complex{T}}
vconj!(result, X)Complex conjugate: result[i] = conj(X[i]). Wraps vDSP_zvconj.
AppleAccelerate.vcopy — Function
vcopy(X::Vector{Complex{T}}) -> Vector{Complex{T}}Copy complex vector via split-complex move. Wraps vDSP_zvmov.
AppleAccelerate.vphase — Function
vphase(X::Vector{Complex{T}}) -> Vector{T}
vphase!(result, X)Complex phase (angle): result[i] = atan(imag(X[i]), real(X[i])). Wraps vDSP_zvphas.
AppleAccelerate.vmags — Function
vmags(X::Vector{Complex{T}}) -> Vector{T}
vmags!(result, X)Squared magnitude: result[i] = abs2(X[i]) = real(X[i])^2 + imag(X[i])^2. Wraps vDSP_zvmags.
AppleAccelerate.vmagsa — Function
vmagsa(X::Vector{Complex{T}}, B::Vector{T}) -> Vector{T}
vmagsa!(result, X, B)Squared magnitude and accumulate: result[i] = abs2(X[i]) + B[i]. Wraps vDSP_zvmgsa.
AppleAccelerate.polar — Function
polar(X::Vector{Complex{T}}) -> (magnitudes::Vector{T}, angles::Vector{T})Convert complex Cartesian coordinates to polar form. Wraps vDSP_polar.
AppleAccelerate.rect — Function
rect(magnitudes::Vector{T}, angles::Vector{T}) -> Vector{Complex{T}}Convert polar coordinates to complex Cartesian form. Wraps vDSP_rect.
AppleAccelerate.zvadd — Function
Complex vector addition: C = A + B. Wraps vDSP_zvadd.
AppleAccelerate.zvsub — Function
Complex vector subtraction: C = A - B. Wraps vDSP_zvsub.
AppleAccelerate.zvcmul — Function
Complex conjugate multiply: C = conj(A) * B. Wraps vDSP_zvcmul.
AppleAccelerate.zrvmul — Function
Complex-real multiply: C = A * B (complex * real). Wraps vDSP_zrvmul.
AppleAccelerate.zrvdiv — Function
Complex-real divide: C = A / B (complex / real). Wraps vDSP_zrvdiv.
AppleAccelerate.zrvadd — Function
Complex-real add: adds real vector to real part of complex. Wraps vDSP_zrvadd.
AppleAccelerate.zrvsub — Function
Complex-real subtract: subtracts real from complex. Wraps vDSP_zrvsub.
AppleAccelerate.zvcma — Function
Complex conjugate multiply and add: D = conj(A)*B + C. Wraps vDSP_zvcma.
AppleAccelerate.zvma — Function
Complex multiply and add: D = A*B + C. Wraps vDSP_zvma.
AppleAccelerate.zvsma — Function
Complex scalar multiply and add: D = A*b + C. Wraps vDSP_zvsma.
AppleAccelerate.zidotpr — Function
Conjugate dot product: sum(conj(A) .* B). Wraps vDSP_zidotpr.
AppleAccelerate.zrdotpr — Function
Complex-real dot product: sum(A .* B) where B is real. Wraps vDSP_zrdotpr.
AppleAccelerate.zvfill! — Function
Fill complex vector with complex scalar. Wraps vDSP_zvfill.
AppleAccelerate.zconv — Function
Complex convolution. Wraps vDSP_zconv.
AppleAccelerate.zmmul — Function
Complex matrix multiply: C = A * B. Wraps vDSP_zmmul.
Broadcasting
AppleAccelerate overrides Base.copy and Base.copyto! for Broadcasted objects, so that broadcasting syntax like f.(X) automatically uses the accelerated implementation.