Complex Array Operations (vDSP)
AppleAccelerate wraps vDSP's split-complex (vDSP_z*) 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 on the Array Operations page.
Julia's interleaved complex storage is passed to the split-complex vDSP routines directly (using a stride-2 split-complex view of the same memory), so the mutating (!) variants are in-place and allocation-free.
These functions are not exported. Access them via the AppleAccelerate. prefix.
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 |
The complex-valued docstrings for vneg and vabs are rendered alongside the real-valued ones on the Array Operations page.
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) | Conjugated dot product matching LinearAlgebra.dot: sum(conj(X) .* Y) |
dotu(X, Y) | Unconjugated (bilinear) 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: A * B |
zmma | Complex matrix multiply-add: A * B + C |
zmms | Complex matrix multiply-subtract: A * B - C |
zmsm | Complex matrix multiply and reverse-subtract: C - A*B |
zvmmaa | Elementwise multiply-multiply-add-add: A*B + C*D + E |
zrdesamp | Complex-real decimating resample/correlation |
Coordinate conversion
| Function | Description |
|---|---|
polar | Cartesian to polar coordinates |
rect | Polar to Cartesian coordinates |
Format conversion
| Function | Description |
|---|---|
ctoz | Interleaved complex → split (real, imag) vectors |
ztoc | Split (real, imag) vectors → interleaved complex |
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, θ)
# Complex matrix multiply-add: D = A*B + C
A = rand(ComplexF64, 4, 3); B = rand(ComplexF64, 3, 5); C = rand(ComplexF64, 4, 5)
D = AppleAccelerate.zmma(A, B, C) # ≈ A*B + CAppleAccelerate.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.dotu — Function
dotu(X::Vector{Complex{Float32}}, Y::Vector{Complex{Float32}})Un-conjugated complex dot product sum(X .* Y) (the "bilinear" dot, without conjugating X). Wraps vDSP_zdotpr. For the conjugated product matching LinearAlgebra.dot use dot.
dotu(X::Vector{Complex{Float64}}, Y::Vector{Complex{Float64}})Un-conjugated complex dot product sum(X .* Y) (the "bilinear" dot, without conjugating X). Wraps vDSP_zdotpr. For the conjugated product matching LinearAlgebra.dot use dot.
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.
AppleAccelerate.zmma — Function
Complex matrix multiply-add: D = A * B + C. C and D are size(A,1)×size(B,2). The zmma!(D, A, B, C) form writes into D. Wraps vDSP_zmma.
AppleAccelerate.zmms — Function
Complex matrix multiply-subtract: D = A * B - C. C and D are size(A,1)×size(B,2). The zmms!(D, A, B, C) form writes into D. Wraps vDSP_zmms.
AppleAccelerate.zmsm — Function
zmsm(A::Matrix{Complex{Float32}}, B::Matrix{Complex{Float32}}, C::Matrix{Complex{Float32}}) -> Matrix{Complex{Float32}}
zmsm!(D, A, B, C)Complex matrix multiply and reverse-subtract: D = C - A*B. Wraps vDSP_zmsm (the vDSP.h header labels this "matrix multiply and reverse subtract"; confirmed empirically to compute C - A*B, not (A-B)*C).
zmsm(A::Matrix{Complex{Float64}}, B::Matrix{Complex{Float64}}, C::Matrix{Complex{Float64}}) -> Matrix{Complex{Float64}}
zmsm!(D, A, B, C)Complex matrix multiply and reverse-subtract: D = C - A*B. Wraps vDSP_zmsm (the vDSP.h header labels this "matrix multiply and reverse subtract"; confirmed empirically to compute C - A*B, not (A-B)*C).
AppleAccelerate.zvmmaa — Function
zvmmaa(A::Vector{Complex{Float32}}, B::Vector{Complex{Float32}}, C::Vector{Complex{Float32}}, D::Vector{Complex{Float32}}, E::Vector{Complex{Float32}}) -> Vector{Complex{Float32}}
zvmmaa!(F, A, B, C, D, E)Elementwise vector multiply-multiply-add-add: F[i] = A[i]*B[i] + C[i]*D[i] + E[i]. Wraps vDSP_zvmmaa.
zvmmaa(A::Vector{Complex{Float64}}, B::Vector{Complex{Float64}}, C::Vector{Complex{Float64}}, D::Vector{Complex{Float64}}, E::Vector{Complex{Float64}}) -> Vector{Complex{Float64}}
zvmmaa!(F, A, B, C, D, E)Elementwise vector multiply-multiply-add-add: F[i] = A[i]*B[i] + C[i]*D[i] + E[i]. Wraps vDSP_zvmmaa.
AppleAccelerate.zrdesamp — Function
zrdesamp(A::Vector{Complex{Float32}}, DF::Int, F::Vector{Float32}) -> Vector{Complex{Float32}}
zrdesamp!(C, A, DF, F)Complex-real decimating resample/correlation using vDSP_zrdesamp. Filters complex input A with real FIR coefficients F (P taps) and decimation factor DF. C must have at least div(length(A) - P, DF) + 1 elements. Computes: C[n] = sum(A[n*DF+p] * F[p] for p in 0:P-1) (0-indexed). Wraps vDSP_zrdesamp.
zrdesamp(A::Vector{Complex{Float64}}, DF::Int, F::Vector{Float64}) -> Vector{Complex{Float64}}
zrdesamp!(C, A, DF, F)Complex-real decimating resample/correlation using vDSP_zrdesamp. Filters complex input A with real FIR coefficients F (P taps) and decimation factor DF. C must have at least div(length(A) - P, DF) + 1 elements. Computes: C[n] = sum(A[n*DF+p] * F[p] for p in 0:P-1) (0-indexed). Wraps vDSP_zrdesamp.
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.