Complex Array Operations

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

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, θ)

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.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.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.