Array Operations (vDSP / vForce)

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.

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.

Negate each element: result[i] = -X[i]. Wraps vDSP_vneg.

Negative absolute value: result[i] = -|X[i]|. Wraps vDSP_vnabs.

Absolute value: result[i] = |X[i]|. Wraps vDSP_vabs.

Square each element: result[i] = X[i]^2. Wraps vDSP_vsq.

Signed square: result[i] = X[i] * |X[i]|. Wraps vDSP_vssq.

Fractional part: result[i] = X[i] - trunc(X[i]). Wraps vDSP_vfrac.

Reverse X in-place. Wraps vDSP_vrvrs.

Return a reversed copy of X. Wraps vDSP_vrvrs.

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.

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.

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.

mean(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the arithmetic mean of elements in X via vDSP. Wraps vDSP_meanv.

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.

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.

meanmag(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the mean of absolute values: sum(abs.(X)) / length(X). Wraps vDSP_meamgv.

meansqr(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the mean of squares: sum(X.^2) / length(X). Wraps vDSP_measqv.

meanssqr(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the mean of signed squares: sum(X .* abs.(X)) / length(X). Wraps vDSP_mvessq.

summag(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the sum of absolute values: sum(abs.(X)). Wraps vDSP_svemg.

sumsqr(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the sum of squares: sum(X.^2). Wraps vDSP_svesq.

sumssqr(X::StridedVector{T}) where T <: Union{Float32, Float64}

Return the sum of signed squares: sum(X .* abs.(X)). Wraps vDSP_svs.

Dot product: sum(X .* Y). Wraps vDSP_dotpr.

Dual dot product: (sum(A0 .* B), sum(A1 .* B)) — one vector B dotted against both A0 and A1. Wraps vDSP_dotpr2.

Squared Euclidean distance: sum((X .- Y).^2). Wraps vDSP_distancesq.

Root mean square: sqrt(sum(X.^2) / length(X)). Wraps vDSP_rmsqv.

Simultaneous sum and sum-of-squares: returns (sum(X), sum(X.^2)). Wraps vDSP_sve_svesq.

Maximum magnitude: maximum(abs.(X)). Wraps vDSP_maxmgv.

Minimum magnitude: minimum(abs.(X)). Wraps vDSP_minmgv.

Maximum magnitude with index: returns (maximum(abs.(X)), index). Wraps vDSP_maxmgvi.

Minimum magnitude with index: returns (minimum(abs.(X)), index). Wraps vDSP_minmgvi.

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}

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

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}

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

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.

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

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.

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

Element-wise maximum: result[i] = max(X[i], Y[i]). Wraps vDSP_vmax.

Element-wise minimum: result[i] = min(X[i], Y[i]). Wraps vDSP_vmin.

Element-wise maximum magnitude: result[i] = max(|X[i]|, |Y[i]|). Wraps vDSP_vmaxmg.

Element-wise minimum magnitude: result[i] = min(|X[i]|, |Y[i]|). Wraps vDSP_vminmg.

Element-wise Euclidean distance: result[i] = hypot(X[i], Y[i]). Wraps vDSP_vdist.

Tapered merge of two vectors. Wraps vDSP_vtmerg.

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}

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

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}

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

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}

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

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.

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

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}

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

Scalar divided by vector: result[i] = c / X[i]. Wraps vDSP_svdiv.

Vector add and multiply: result[i] = (A[i] + B[i]) * C[i]. Wraps vDSP_vam.

Vector subtract and multiply: result[i] = (A[i] - B[i]) * C[i]. Wraps vDSP_vsbm.

Vector multiply and add: result[i] = A[i]*B[i] + C[i]. Wraps vDSP_vma.

Vector multiply and subtract: result[i] = A[i]*B[i] - C[i]. Wraps vDSP_vmsb.

Signal envelope. Wraps vDSP_venvlp.

Vector add, add, and multiply: result[i] = (A[i] + B[i]) * (C[i] + D[i]). Wraps vDSP_vaam.

Vector subtract, subtract, and multiply: result[i] = (A[i] - B[i]) * (C[i] - D[i]). Wraps vDSP_vsbsbm.

Vector add, subtract, and multiply: result[i] = (A[i] + B[i]) * (C[i] - D[i]). Wraps vDSP_vasbm.

Vector multiply, multiply, and add: result[i] = A[i]*B[i] + C[i]*D[i]. Wraps vDSP_vmma.

Vector multiply, multiply, and subtract: result[i] = A[i]*B[i] - C[i]*D[i]. Wraps vDSP_vmmsb.

Pythagorean distance: result[i] = sqrt((A[i]-C[i])^2 + (B[i]-D[i])^2). Wraps vDSP_vpythg.

Vector add and scalar multiply: result[i] = (A[i] + B[i]) * c. Wraps vDSP_vasm.

Vector subtract and scalar multiply: result[i] = (A[i] - B[i]) * c. Wraps vDSP_vsbsm.

Vector scalar multiply and add: result[i] = A[i] * b + C[i]. Wraps vDSP_vsma.

Vector scalar multiply and scalar add: result[i] = A[i] * b + c. Wraps vDSP_vsmsa.

Vector multiply and scalar add: result[i] = A[i]*B[i] + c. Wraps vDSP_vmsa.

Vector scalar multiply and subtract: result[i] = A[i]*b - C[i]. Wraps vDSP_vsmsb.

Vector scalar multiply and scalar multiply add: result[i] = A[i]*b + C[i]*d. Wraps vDSP_vsmsma.

Simultaneous add and subtract: returns (A .+ B, B .- A). Wraps vDSP_vaddsub.

Clip values to [low, high]: clamp.(X, low, high). Wraps vDSP_vclip.

Clip with count: returns (clipped, nlow, nhigh). Wraps vDSP_vclipc.

Inverted clip: pass through values outside [low, high], zero inside. Wraps vDSP_viclip.

Threshold: result[i] = X[i] >= threshold ? X[i] : threshold. Wraps vDSP_vthr.

Threshold to zero: result[i] = X[i] >= threshold ? X[i] : 0. Wraps vDSP_vthres.

Test limit: result[i] = (b <= A[i]) ? c : -c. Wraps vDSP_vlim.

Threshold with signed constant. Wraps vDSP_vthrsc.

Compress: gather elements of X where gate is nonzero. Wraps vDSP_vcmprs.

vdouble(X::StridedVector{Float32}) -> Vector{Float64}

Convert single-precision to double-precision. Wraps vDSP_vspdp.

vsingle(X::StridedVector{Float64}) -> Vector{Float32}

Convert double-precision to single-precision. Wraps vDSP_vdpsp.

Generate a ramp: result[i] = start + i * step for i = 0, ..., n-1. Wraps vDSP_vramp.

Multiply vector by a generated ramp. Wraps vDSP_vrampmul.

Stereo ramp multiply: multiply two vectors by the same ramp. Wraps vDSP_vrampmul2.

Ramp-multiply then accumulate: result[i] = C[i] + X[i] * (start + i*step) for i = 0, ..., length(X)-1. The mutating vrampmuladd!(result, X, start, step) reads/writes result in place as the accumulator (i.e. result[i] += X[i] * ramp[i]). Wraps vDSP_vrampmuladd.

Stereo ramp-multiply then accumulate: multiplies I0/I1 by the same generated ramp and accumulates into C0/C1. Wraps vDSP_vrampmuladd2.

Vector linear average: C[n] = (C[n] * weight + A[n]) / (weight + 1). Wraps vDSP_vavlin.

Running sum scaled by scale. Wraps vDSP_vrsum.

Simpson's rule integration with step size step. Wraps vDSP_vsimps.

Trapezoidal integration with step size step. Wraps vDSP_vtrapz.

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.

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.

Vector interpolation: result[i] = A[i] + t * (B[i] - A[i]). Wraps vDSP_vintb.

Linear interpolation from a lookup table using fractional indices. Wraps vDSP_vlint.

Quadratic interpolation from a lookup table using fractional indices. Wraps vDSP_vqint.

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.

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.

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.

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.

Fill vector with zeros: C[i] = 0. Wraps vDSP_vclr.

Fill vector with scalar value: C[i] = a. Wraps vDSP_vfill.

Swap elements of two vectors in-place. Wraps vDSP_vswap.

Sort vector in-place. ascending=true for ascending order. Wraps vDSP_vsort.

Return sort permutation (1-based indices). Wraps vDSP_vsorti.

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.

vgathra(A::AbstractVector{<:StridedVector{T}}, ptrstride::Integer=1) -> Vector{T}

Gather the first element of each source vector in A into a contiguous result: C[i] = A[1 + (i-1)*ptrstride][1]. A is a caller-owned array of unit-stride vectors; internally an array of their pointers is built and passed to vDSP (GC.@preserved for the duration of the call). ptrstride selects every ptrstride-th pointer from that array (must be positive); the allocating form derives the output length from length(A) and ptrstride, while vgathra! derives the requested output count N from length(C) and requires A to hold at least (N-1)*ptrstride + 1 entries. Wraps vDSP_vgathra / vDSP_vgathraD.

Index with float indices: C[i] = A[trunc(B[i])] where B contains 0-based float indices. Wraps vDSP_vindex.

Generate linear ramp between two scalars: C[i] = a + (b-a)*i/(N-1). Wraps vDSP_vgen.

Piecewise linear interpolation from breakpoints. Wraps vDSP_vgenp.

Table lookup with interpolation: D[i] = C[clamp(s1*A[i]+s2, 0, M-1)]. Wraps vDSP_vtabi.

Matrix multiply: C = A * B. Wraps vDSP_mmul.

Matrix transpose: C = Aᵀ. Wraps vDSP_mtrans.

Matrix copy (submatrix move). Wraps vDSP_mmov.

Int32 vector addition: C[i] = A[i] + B[i]. Wraps vDSP_vaddi.

Int32 absolute value: C[i] = |A[i]|. Wraps vDSP_vabsi.

Fill Int32 vector with scalar value. Wraps vDSP_vfilli.

Int32 bitwise XNOR: C[i] = ~(A[i] ^ B[i]). Wraps vDSP_veqvi.

Integer vector divide: C[i] = div(A[i], B[i]) (truncating). Wraps vDSP_vdivi.

Integer scalar add: C[i] = A[i] + b. Wraps vDSP_vsaddi.

Integer scalar divide: C[i] = div(A[i], b) (truncating). Wraps vDSP_vsdivi.

Fixed-point (s115) dot product: sum(A .* B) computed and stored in Q-format. Wraps [`vDSPdotprs115`](https://developer.apple.com/documentation/accelerate/vdspdotprs1_15).

Fixed-point (s824) dot product: sum(A .* B) computed and stored in Q-format. Wraps [`vDSPdotprs824`](https://developer.apple.com/documentation/accelerate/vdspdotprs8_24).

Fixed-point (s115) dual dot product: B dotted against both A0 and A1. Wraps [`vDSPdotpr2s115`](https://developer.apple.com/documentation/accelerate/vdspdotpr2s1_15).

Fixed-point (s824) dual dot product: B dotted against both A0 and A1. Wraps [`vDSPdotpr2s824`](https://developer.apple.com/documentation/accelerate/vdspdotpr2s8_24).

Fixed-point (s115) ramp multiply. Wraps [`vDSPvrampmuls115`](https://developer.apple.com/documentation/accelerate/vdspvrampmuls1_15).

Fixed-point (s824) ramp multiply. Wraps [`vDSPvrampmuls824`](https://developer.apple.com/documentation/accelerate/vdspvrampmuls8_24).

Fixed-point (s115) stereo ramp multiply. Wraps [`vDSPvrampmul2s115`](https://developer.apple.com/documentation/accelerate/vdspvrampmul2s1_15).

Fixed-point (s824) stereo ramp multiply. Wraps [`vDSPvrampmul2s824`](https://developer.apple.com/documentation/accelerate/vdspvrampmul2s8_24).

Fixed-point (s115) ramp-multiply then accumulate. Wraps [`vDSPvrampmuladds115`](https://developer.apple.com/documentation/accelerate/vdspvrampmuladds1_15).

Fixed-point (s824) ramp-multiply then accumulate. Wraps [`vDSPvrampmuladds824`](https://developer.apple.com/documentation/accelerate/vdspvrampmuladds8_24).

Fixed-point (s115) stereo ramp-multiply then accumulate. Wraps [`vDSPvrampmuladd2s115`](https://developer.apple.com/documentation/accelerate/vdspvrampmuladd2s1_15).

Fixed-point (s824) stereo ramp-multiply then accumulate. Wraps [`vDSPvrampmuladd2s824`](https://developer.apple.com/documentation/accelerate/vdspvrampmuladd2s8_24).

Convert packed 24-bit signed integers (given as Int32 values in -8388608:8388607) to Float32. Wraps vDSP_vflt24.

Convert packed 24-bit unsigned integers (given as UInt32/Integer values in 0:16777215) to Float32. Wraps vDSP_vfltu24.

Convert packed 24-bit signed integers to Float32, then scale by b: C[i] = Float32(A[i]) * b. Wraps vDSP_vfltsm24.

Convert packed 24-bit unsigned integers to Float32, then scale by b: C[i] = Float32(A[i]) * b. Wraps vDSP_vfltsmu24.

Scale A by b and truncate to packed 24-bit signed integers (returned as Int32): C[i] = trunc(Int32, A[i] * b). Wraps vDSP_vsmfix24.

Scale A by b and truncate to packed 24-bit unsigned integers (returned as UInt32): C[i] = trunc(UInt32, A[i] * b). Wraps vDSP_vsmfixu24.

Packed 24-bit signed integer element (Apple's 3-byte vDSP_int24). Build a vector with pack24; decode with unpack24.

Packed 24-bit unsigned integer element (Apple's 3-byte vDSP_uint24). Build a vector with packu24; decode with unpack24.

pack24(A::AbstractVector{<:Integer}) -> Vector{PackedInt24}

Pack integer values in -8388608:8388607 into Apple's 3-byte signed 24-bit layout, ready to pass to vflt24 / vfltsm24 with no further copying. See also unpack24, packu24.

packu24(A::AbstractVector{<:Integer}) -> Vector{PackedUInt24}

Pack integer values in 0:16777215 into Apple's 3-byte unsigned 24-bit layout. See also unpack24, pack24.

unpack24(A::AbstractVector{PackedInt24})  -> Vector{Int32}
unpack24(A::AbstractVector{PackedUInt24}) -> Vector{UInt32}

Decode packed 24-bit integers back to Int32 / UInt32 values. Inverse of pack24 / packu24.

2D convolution with a 3×3 filter. Border elements are set to zero. Wraps vDSP_f3x3.

2D convolution with a 5×5 filter. Border elements are set to zero. Wraps vDSP_f5x5.

General 2D image convolution with a P×Q filter. Border elements are set to zero. Wraps vDSP_imgfir.