Enumeration

# vDSP

An enumeration that acts as a namespace for Swift overlays to vDSP.

## Topics

### Type Methods

`static func absolute<U>(U) -> [Double]`

Returns the absolute value of each element in the supplied double-precision vector.

`static func absolute<U>(U) -> [Float]`

Returns the absolute value of each element in the supplied single-precision vector.

`static func absolute<V>(DSPSplitComplex, result: inout V)`

Calculates the absolute value of each element in the supplied single-precision complex vector.

`static func absolute<V>(DSPDoubleSplitComplex, result: inout V)`

Calculates the absolute value of each element in the supplied double-precision complex vector.

`static func absolute<U, V>(U, result: inout V)`

Calculates the absolute value of each element in the supplied double-precision vector.

`static func absolute<U, V>(U, result: inout V)`

Calculates the absolute value of each element in the supplied single-precision vector.

`static func add<U>(Double, U) -> [Double]`

Returns the double-precision elementwise sum of a vector and a scalar value.

`static func add<T, U>(T, U) -> [Double]`

Returns the double-precision elementwise sum of the supplied vectors.

`static func add<U>(Float, U) -> [Float]`

Returns the single-precision elementwise sum of a vector and a scalar value.

`static func add<T, U>(T, U) -> [Float]`

Returns the single-precision elementwise sum of the supplied vectors.

`static func add<U, V>(Double, U, result: inout V)`

Calculates the double-precision elementwise sum of a vector and a scalar value.

`static func add<U, V>(Float, U, result: inout V)`

Calculates the single-precision elementwise sum of a vector and a scalar value.

`static func add<T, U, V>(T, U, result: inout V)`

Calculates the double-precision elementwise sum of the supplied vectors.

`static func add<T, U, V>(T, U, result: inout V)`

Calculates the single-precision elementwise sum of the supplied vectors.

`static func add(DSPSplitComplex, to: DSPSplitComplex, count: Int, result: inout DSPSplitComplex)`

Calculates the single-precision elementwise sum of the supplied complex vectors.

`static func add<U>(multiplication: (a: U, b: Double), Double) -> [Double]`

Returns the double-precision elementwise product of a scalar and a vector, added to a scalar.

`static func add<T, U>(multiplication: (a: T, b: Double), U) -> [Double]`

Returns the double-precision elementwise product of a scalar and a vector, added to a vector.

`static func add<T, U>(multiplication: (a: T, b: U), Double) -> [Double]`

Returns the double-precision elementwise product of a vector and a vector, added to a scalar.

`static func add<S, T, U>(multiplication: (a: S, b: T), U) -> [Double]`

Returns the double-precision elementwise product of a vector and a vector, added to a vector.

`static func add<U>(multiplication: (a: U, b: Float), Float) -> [Float]`

Returns the single-precision elementwise product of a scalar and a vector, added to a scalar.

`static func add<T, U>(multiplication: (a: T, b: Float), U) -> [Float]`

Returns the single-precision elementwise product of a scalar and a vector, added to a vector.

`static func add<T, U>(multiplication: (a: T, b: U), Float) -> [Float]`

Returns the single-precision elementwise product of a vector and a vector, added to a scalar.

`static func add<S, T, U>(multiplication: (a: S, b: T), U) -> [Float]`

Returns the single-precision elementwise product of a vector and a vector, added to a vector.

`static func add<U, V>(multiplication: (a: U, b: Double), Double, result: inout V)`

Calculates the double-precision elementwise product of a scalar and a vector, added to a scalar.

`static func add<T, U, V>(multiplication: (a: T, b: Double), U, result: inout V)`

Calculates the double-precision elementwise product of a scalar and a vector, added to a vector.

`static func add<U, V>(multiplication: (a: U, b: Float), Float, result: inout V)`

Calculates the single-precision elementwise product of a scalar and a vector, added to a scalar.

`static func add<T, U, V>(multiplication: (a: T, b: Float), U, result: inout V)`

Calculates the single-precision elementwise product of a scalar and a vector, added to a vector.

`static func add<T, U, V>(multiplication: (a: T, b: U), Double, result: inout V)`

Calculates the double-precision elementwise product of a vector and a vector, added to a scalar.

`static func add<T, U, V>(multiplication: (a: T, b: U), Float, result: inout V)`

Calculates the single-precision elementwise product of a vector and a vector, added to a scalar.

`static func add<S, T, U, V>(multiplication: (a: S, b: T), U, result: inout V)`

Calculates the double-precision elementwise product of a vector and a vector, added to a vector.

`static func add<S, T, U, V>(multiplication: (a: S, b: T), U, result: inout V)`

Calculates the single-precision elementwise product of a vector and a vector, added to a vector.

`static func add<T, U>(multiplication: (a: T, b: Double), multiplication: (c: U, d: Double)) -> [Double]`

Returns the double-precision elementwise product of a scalar and a vector, added to a second product of a scalar and a vector.

`static func add<R, S, T, U>(multiplication: (a: R, b: S), multiplication: (c: T, d: U)) -> [Double]`

Returns the double-precision elementwise product of a vector and a vector, added to a second product of a vector and a vector.

`static func add<T, U>(multiplication: (a: T, b: Float), multiplication: (c: U, d: Float)) -> [Float]`

Returns the single-precision elementwise product of a scalar and a vector, added to a second product of a scalar and a vector.

`static func add<R, S, T, U>(multiplication: (a: R, b: S), multiplication: (c: T, d: U)) -> [Float]`

Returns the single-precision elementwise product of a vector and a vector, added to a second product of a vector and a vector.

`static func add<T, U, V>(multiplication: (a: T, b: Double), multiplication: (c: U, d: Double), result: inout V)`

Calculates the double-precision elementwise product of a scalar and a vector, added to a second product of a scalar and a vector.

`static func add<T, U, V>(multiplication: (a: T, b: Float), multiplication: (c: U, d: Float), result: inout V)`

Calculates the single-precision elementwise product of a scalar and a vector, added to a second product of a scalar and a vector.

`static func add<R, S, T, U, V>(multiplication: (a: R, b: S), multiplication: (c: T, d: U), result: inout V)`

Calculates the double-precision elementwise product of a vector and a vector, added to a second product of a vector and a vector.

`static func add<R, S, T, U, V>(multiplication: (a: R, b: S), multiplication: (c: T, d: U), result: inout V)`

Calculates the single-precision elementwise product of a vector and a vector, added to a second product of a vector and a vector.

`static func addSubtract<S, T, U, V>(S, T, addResult: inout U, subtractResult: inout V)`

Calculates the double-precision elementwise sum and difference of the supplied vectors.

`static func addSubtract<S, T, U, V>(S, T, addResult: inout U, subtractResult: inout V)`

Calculates the single-precision elementwise sum and difference of the supplied vectors.

`static func amplitudeToDecibels<U>(U, zeroReference: Double) -> [Double]`

Returns double-precision amplitude values converted to decibel values.

`static func amplitudeToDecibels<U>(U, zeroReference: Float) -> [Float]`

Returns single-precision amplitude values converted to decibels.

`static func clear<V>(inout V)`

Populates a double-precision vector with zeros.

`static func clear<V>(inout V)`

Populates a single-precision vector with zeros.

`static func clip<U>(U, to: ClosedRange<Double>) -> [Double]`

Returns the elements of a double-precision vector clipped to the specified range.

`static func clip<U>(U, to: ClosedRange<Float>) -> [Float]`

Returns the elements of a single-precision vector clipped to the specified range.

`static func clip<U, V>(U, to: ClosedRange<Double>, result: inout V)`

Calculates the elements of a double-precision vector clipped to the specified range.

`static func clip<U, V>(U, to: ClosedRange<Float>, result: inout V)`

Calculates the elements of a single-precision vector clipped to the specified range.

`static func conjugate(DSPSplitComplex, count: Int, result: inout DSPSplitComplex)`

Calculates the complex conjugate of the values in a single-precision vector.

`static func conjugate(DSPDoubleSplitComplex, count: Int, result: inout DSPDoubleSplitComplex)`

Calculates the complex conjugate of the values in a double-precision vector.

`static func convert(interleavedComplexVector: [DSPDoubleComplex], toSplitComplexVector: inout DSPDoubleSplitComplex)`

Converts the contents of an interleaved double-precision complex vector to a split complex vector.

`static func convert(interleavedComplexVector: [DSPComplex], toSplitComplexVector: inout DSPSplitComplex)`

Converts the contents of an interleaved single-precision complex vector to a split complex vector.

`static func convert<U, V>(polarCoordinates: U, toRectangularCoordinates: inout V)`

Converts double-precision polar coordinates to rectangular coordinates.

`static func convert<U, V>(polarCoordinates: U, toRectangularCoordinates: inout V)`

Converts single-precision polar coordinates to rectangular coordinates.

`static func convert<U, V>(rectangularCoordinates: U, toPolarCoordinates: inout V)`

Converts double-precision rectangular coordinates to polar coordinates.

`static func convert<U, V>(rectangularCoordinates: U, toPolarCoordinates: inout V)`

Converts single-precision rectangular coordinates to polar coordinates.

`static func convert(splitComplexVector: DSPDoubleSplitComplex, toInterleavedComplexVector: inout [DSPDoubleComplex])`

Converts the contents of a split double-precision complex vector to an interleaved vector.

`static func convert(splitComplexVector: DSPSplitComplex, toInterleavedComplexVector: inout [DSPComplex])`

Converts the contents of a split single-precision complex vector to an interleaved vector.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts double-precision values to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts single-precision values to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 8-bit signed integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 8-bit signed integers to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 16-bit signed integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 16-bit signed integers to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 32-bit signed integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 32-bit signed integers to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 8-bit unsigned integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 8-bit unsigned integers to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 16-bit unsigned integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 16-bit unsigned integers to single-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 32-bit unsigned integers to double-precision values.

`static func convertElements<U, V>(of: U, to: inout V)`

Converts 32-bit unsigned integers to single-precision values.

`static func convolve<T, U>(T, rowCount: Int, columnCount: Int, with3x3Kernel: U) -> [Double]`

Returns the 2D convolution of a double-precision vector with a 3 x 3 kernel.

`static func convolve<T, U>(T, rowCount: Int, columnCount: Int, with3x3Kernel: U) -> [Float]`

Returns the 2D convolution of a single-precision vector with a 3 x 3 kernel.

`static func convolve<T, U, V>(T, rowCount: Int, columnCount: Int, with3x3Kernel: U, result: inout V)`

Calculates the 2D convolution of a double-precision vector with a 3 x 3 kernel.

`static func convolve<T, U, V>(T, rowCount: Int, columnCount: Int, with3x3Kernel: U, result: inout V)`

Calculates the 2D convolution of a single-precision vector with a 3 x 3 kernel.

`static func convolve<T, U>(T, rowCount: Int, columnCount: Int, with5x5Kernel: U) -> [Double]`

Returns the 2D convolution of a double-precision vector with a 5 x 5 kernel.

`static func convolve<T, U>(T, rowCount: Int, columnCount: Int, with5x5Kernel: U) -> [Float]`

Returns the 2D convolution of a single-precision vector with a 5 x 5 kernel.

`static func convolve<T, U, V>(T, rowCount: Int, columnCount: Int, with5x5Kernel: U, result: inout V)`

Calculates the 2D convolution of a double-precision vector with a 5 x 5 kernel.

`static func convolve<T, U, V>(T, rowCount: Int, columnCount: Int, with5x5Kernel: U, result: inout V)`

Calculates the 2D convolution of a single-precision vector with a 5 x 5 kernel.

`static func convolve<T, U>(T, withKernel: U) -> [Double]`

Returns the 1D convolution of a double-precision vector.

`static func convolve<T, U>(T, withKernel: U) -> [Float]`

Returns the 1D convolution of a single-precision vector.

`static func convolve<T, U, V>(T, withKernel: U, result: inout V)`

Calculates the 1D convolution of a double-precision vector.

`static func convolve<T, U, V>(T, withKernel: U, result: inout V)`

Calculates the 1D convolution of a single-precision vector.

`static func correlate<T, U>(T, withKernel: U) -> [Double]`

Returns the correlation of a double-precision signal vector and a filter vector.

`static func correlate<T, U>(T, withKernel: U) -> [Float]`

Returns the correlation of a single-precision signal vector and a filter vector.

`static func correlate<T, U, V>(T, withKernel: U, result: inout V)`

Calculates the correlation of a double-precision signal vector and a filter vector.

`static func correlate<T, U, V>(T, withKernel: U, result: inout V)`

Calculates the correlation of a single-precision signal vector and a filter vector.

`static func countZeroCrossings<U>(U) -> UInt`

Returns the number of zero crossings in a double-precision vector.

`static func countZeroCrossings<U>(U) -> UInt`

Returns the number of zero crossings in a single-precision vector.

`static func distanceSquared<U, V>(U, V) -> Double`

Returns the double-precision distance squared between two points in n-dimensional space.

`static func distanceSquared<U, V>(U, V) -> Float`

Returns the single-precision distance squared between two points in n-dimensional space.

`static func divide<U>(Double, U) -> [Double]`

Returns the double-precision elementwise division of a scalar by a vector.

`static func divide<U>(U, Double) -> [Double]`

Returns the double-precision elementwise division of a vector by a scalar.

`static func divide<T, U>(T, U) -> [Double]`

Returns the double-precision elementwise division of a vector by a vector.

`static func divide<U>(Float, U) -> [Float]`

Returns the single-precision elementwise division of a scalar by a vector.

`static func divide<U>(U, Float) -> [Float]`

Returns the single-precision elementwise division of a vector by a scalar.

`static func divide<T, U>(T, U) -> [Float]`

Returns the single-precision elementwise division of a vector by a vector.

`static func divide<U, V>(Double, U, result: inout V)`

Calculates the double-precision elementwise division of a scalar by a vector.

`static func divide<U, V>(Float, U, result: inout V)`

Calculates the single-precision elementwise division of a scalar by a vector.

`static func divide<U, V>(U, Double, result: inout V)`

Calculates the double-precision elementwise division of a vector by a scalar.

`static func divide<U, V>(U, Float, result: inout V)`

Calculates the single-precision elementwise division of a vector by a scalar.

`static func divide<T, U, V>(T, U, result: inout V)`

Calculates the double-precision elementwise division of a vector by a vector.

`static func divide<T, U, V>(T, U, result: inout V)`

Calculates the single-precision elementwise division of a vector by a vector.

`static func divide(DSPSplitComplex, by: DSPSplitComplex, count: Int, result: inout DSPSplitComplex)`

Calculates the single-precision elementwise division of a complex vector by a complex vector.

`static func divide(DSPDoubleSplitComplex, by: DSPDoubleSplitComplex, count: Int, result: inout DSPDoubleSplitComplex)`

Calculates the double-precision elementwise division of a complex vector by a complex vector.

`static func divide<U>(DSPSplitComplex, by: U, result: inout DSPSplitComplex)`

Calculates the single-precision elementwise division of a complex vector by a real vector.

`static func divide<U>(DSPDoubleSplitComplex, by: U, result: inout DSPDoubleSplitComplex)`

Calculates the double-precision elementwise division of a complex vector by a complex vector.

`static func dot<U>(U, U) -> Double`

Returns the double-precision dot product of two vectors.

`static func dot<U>(U, U) -> Float`

Returns the single-precision dot product of two vectors.

`static func doubleToFloat<U>(U) -> [Float]`

Returns double-precision values converted to single-precision values.

`static func evaluatePolynomial<U>(usingCoefficients: [Double], withVariables: U) -> [Double]`

Returns a double-precision evaluated polynomial using specified coefficients and independent variables.

`static func evaluatePolynomial<U>(usingCoefficients: [Float], withVariables: U) -> [Float]`

Returns a single-precision evaluated polynomial using specified coefficients and independent variables.

`static func evaluatePolynomial<U, V>(usingCoefficients: [Double], withVariables: U, result: inout V)`

Evaluates a double-precision polynomial using specified coefficients and independent variables.

`static func evaluatePolynomial<U, V>(usingCoefficients: [Float], withVariables: U, result: inout V)`

Evaluates a single-precision polynomial using specified coefficients and independent variables.

`static func fill<V>(inout V, with: Double)`

Populates a double-precision vector with a specified scalar value.

`static func fill<V>(inout V, with: Float)`

Populates a single-precision vector with a specified scalar value.

`static func floatToDouble<U>(U) -> [Double]`

Returns single-precision values converted to double-precision values.

`static func formRamp<V>(in: ClosedRange<Double>, result: inout V)`

Populates a double-precision vector with monotonically incrementing or decrementing values within a specified range.

`static func formRamp<V>(in: ClosedRange<Float>, result: inout V)`

Populates a single-precision vector with monotonically incrementing or decrementing values within a specified range.

`static func formRamp<V>(withInitialValue: Double, increment: Double, result: inout V)`

Populates a double-precision vector with monotonically incrementing or decrementing values.

`static func formRamp<V>(withInitialValue: Float, increment: Float, result: inout V)`

Populates a single-precision vector with monotonically incrementing or decrementing values.

`static func formRamp<U, V>(withInitialValue: inout Double, multiplyingBy: U, increment: Double, result: inout V)`

Populates a double-precision vector with monotonically incrementing or decrementing values, multiplied by a source vector.

`static func formRamp<U, V>(withInitialValue: inout Float, multiplyingBy: U, increment: Float, result: inout V)`

Populates a single-precision vector with monotonically incrementing or decrementing values, multiplied by a source vector.

`static func formStereoRamp<U, V>(withInitialValue: inout Double, multiplyingBy: U, U, increment: Double, results: inout V, inout V)`

Populates a double-precision vector with stereo monotonically incrementing or decrementing values, multiplied by a source vector.

`static func formStereoRamp<U, V>(withInitialValue: inout Float, multiplyingBy: U, U, increment: Float, results: inout V, inout V)`

Populates a single-precision vector with stereo monotonically incrementing or decrementing values, multiplied by a source vector.

`static func hypot<U, V>(U, V) -> [Double]`

Returns the double-precision hypotenuse of right-angled triangles with sides that are the lengths of corresponding elements of vectors `x` and `y`.

`static func hypot<U, V>(U, V) -> [Float]`

Returns the single-precision hypotenuse of right-angled triangles with sides that are the lengths of corresponding elements of vectors `x` and `y`.

`static func hypot<T, U, V>(T, U, result: inout V)`

Calculates the double-precision hypotenuse of right-angled triangles with sides that are the lengths of corresponding elements of vectors `x` and `y`.

`static func hypot<T, U, V>(T, U, result: inout V)`

Calculates the single-precision hypotenuse of right-angled triangles with sides that are the lengths of corresponding elements of vectors `x` and `y`.

`static func hypot<R, S, T, U>(x0: R, x1: S, y0: T, y1: U) -> [Double]`

Returns the double-precision hypotenuse of right-angled triangles with sides that are the differences of corresponding elements of vectors `x0`, `x1`, and `y0`, `y1`.

`static func hypot<R, S, T, U>(x0: R, x1: S, y0: T, y1: U) -> [Float]`

Returns the single-precision hypotenuse of right-angled triangles with sides that are the differences of corresponding elements of vectors `x0`, `x1`, and `y0`, `y1`.

`static func hypot<R, S, T, U, V>(x0: R, x1: S, y0: T, y1: U, result: inout V)`

Calculates the double-precision hypotenuse of right-angled triangles with sides that are the differences of corresponding elements of vectors `x0`, `x1`, and `y0`, `y1`.

`static func hypot<R, S, T, U, V>(x0: R, x1: S, y0: T, y1: U, result: inout V)`

Calculates the single-precision hypotenuse of right-angled triangles with sides that are the differences of corresponding elements of vectors `x0`, `x1`, and `y0`, `y1`.

`static func indexOfMaximum<U>(U) -> (UInt, Double)`

Returns the maximum element, and its index, of a double-precision vector.

`static func indexOfMaximum<U>(U) -> (UInt, Float)`

Returns the maximum element, and its index, of a signal-precision vector.

`static func indexOfMaximumMagnitude<U>(U) -> (UInt, Double)`

Returns the maximum magnitude element, and its index, of a double-precision vector.

`static func indexOfMaximumMagnitude<U>(U) -> (UInt, Float)`

Returns the maximum magnitude element, and its index, of a single-precision vector.

`static func indexOfMinimum<U>(U) -> (UInt, Double)`

Returns the minimum element, and its index, of a double-precision vector.

`static func indexOfMinimum<U>(U) -> (UInt, Float)`

Returns the minimum element, and its index, of a single-precision vector.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of signed 8-bit integers converted to floating-point values.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of signed 16-bit integers converted to floating-point values.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of signed 32-bit integers converted to floating-point values.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of unsigned 8-bit integers converted to floating-point values.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of unsigned 16-bit integers converted to floating-point values.

`static func integerToFloatingPoint<T, U>(T, floatingPointType: U.Type) -> [U]`

Returns a vector of unsigned 32-bit integers converted floating-point values.

`static func integrate<U>(U, using: vDSP.IntegrationRule, stepSize: Double) -> [Double]`

Returns the integration of a double-precision vector using the specified rule.

`static func integrate<U>(U, using: vDSP.IntegrationRule, stepSize: Float) -> [Float]`

Returns the integration of a single-precision vector using the specified rule.

`static func integrate<U, V>(U, using: vDSP.IntegrationRule, stepSize: Double, result: inout V)`

Performs the integration of a double-precision using the specified rule.

`static func integrate<U, V>(U, using: vDSP.IntegrationRule, stepSize: Float, result: inout V)`

Performs the integration of a single-precision using the specified rule.

`static func invertedClip<U>(U, to: ClosedRange<Double>) -> [Double]`

Returns a double-precision vector that’s inverted-clipped to the specified range.

`static func invertedClip<U>(U, to: ClosedRange<Float>) -> [Float]`

Returns a single-precision vector that’s inverted-clipped to the specified range.

`static func invertedClip<U, V>(U, to: ClosedRange<Double>, result: inout V)`

Calculates a double-precision vector that’s inverted-clipped to the specified range.

`static func invertedClip<U, V>(U, to: ClosedRange<Float>, result: inout V)`

Calculates a single-precision vector that’s inverted-clipped to the specified range.

`static func linearInterpolate<T, U>(T, U, using: Double) -> [Double]`

Returns the linear interpolation between the supplied double-precision vectors.

`static func linearInterpolate<T, U>(T, U, using: Float) -> [Float]`

Returns the linear interpolation between the supplied single-precision vectors.

`static func linearInterpolate<T, U, V>(T, U, using: Double, result: inout V)`

Calculates the linear interpolation between the supplied double-precision vectors.

`static func linearInterpolate<T, U, V>(T, U, using: Float, result: inout V)`

Calculates the linear interpolation between the supplied single-precision vectors.

`static func linearInterpolate<T, U>(elementsOf: T, using: U) -> [Double]`

Returns the interpolation between the neighboring elements of a double-precision vector.

`static func linearInterpolate<T, U>(elementsOf: T, using: U) -> [Float]`

Returns the interpolation between the neighboring elements of a single-precision vector.

`static func linearInterpolate<T, U, V>(elementsOf: T, using: U, result: inout V)`

Calculates the interpolation between the neighboring elements of a double-precision vector.

`static func linearInterpolate<T, U, V>(elementsOf: T, using: U, result: inout V)`

Calculates the interpolation between the neighboring elements of a single-precision vector.

`static func maximum<U>(U) -> Double`

Returns the maximum element of a double-precision vector.

`static func maximum<U>(U) -> Float`

Returns the maximum element of a single-precision vector.

`static func maximum<U>(U, U) -> [Double]`

Returns a double-precision array containing the maximum of the corresponding values of two vectors.

`static func maximum<U>(U, U) -> [Float]`

Returns a single-precision array containing the maximum of the corresponding values of two vectors.

`static func maximum<U, V>(U, U, result: inout V)`

Calculates the maximum of the corresponding double-precision values of two vectors.

`static func maximum<U, V>(U, U, result: inout V)`

Calculates the maximum of the corresponding single-precision values of two vectors.

`static func maximumMagnitude<U>(U) -> Double`

Returns the maximum magnitude element of a double-precision vector.

`static func maximumMagnitude<U>(U) -> Float`

Returns the maximum magnitude element of a single-precision vector.

`static func mean<U>(U) -> Double`

Returns the double-precision vector mean.

`static func mean<U>(U) -> Float`

Returns the single-precision vector mean.

`static func meanMagnitude<U>(U) -> Double`

Returns the double-precision vector mean magnitude.

`static func meanMagnitude<U>(U) -> Float`

Returns the single-precision vector mean magnitude.

`static func meanSquare<U>(U) -> Double`

Returns the double-precision vector mean square.

`static func meanSquare<U>(U) -> Float`

Returns the single-precision vector mean square.

`static func minimum<U>(U) -> Double`

Returns the minimum element of a double-precision vector.

`static func minimum<U>(U) -> Float`

Returns the minimum element of a single-precision vector.

`static func minimum<U>(U, U) -> [Double]`

Returns a double-precision array containing the minimum of the corresponding values of two vectors.

`static func minimum<U>(U, U) -> [Float]`

Returns a single-precision array containing the minimum of the corresponding values of two vectors.

`static func minimum<U, V>(U, U, result: inout V)`

Calculates the double-precision minimum of the corresponding values of two vectors.

`static func minimum<U, V>(U, U, result: inout V)`

Calculates the single-precision minimum of the corresponding values of two vectors.

`static func multiply<U>(Double, U) -> [Double]`

Returns the double-precision elementwise product of a vector and a scalar value.

`static func multiply<T, U>(T, U) -> [Double]`

Returns the double-precision elementwise product of a vector and a vector.

`static func multiply<U>(Float, U) -> [Float]`

Returns the single-precision elementwise product of a vector and a scalar value.

`static func multiply<T, U>(T, U) -> [Float]`

Returns the single-precision elementwise product of a vector and a vector.

`static func multiply<U, V>(Double, U, result: inout V)`

Calculates the double-precision elementwise product of a vector and a vector.

`static func multiply<U, V>(Float, U, result: inout V)`

Calculates the single-precision elementwise product of a vector and a vector.

`static func multiply<T, U, V>(T, U, result: inout V)`

Calculates the double-precision elementwise product of a vector and a vector.

`static func multiply<T, U, V>(T, U, result: inout V)`

Calculates the single-precision elementwise product of a vector and a vector.

`static func multiply(DSPSplitComplex, by: DSPSplitComplex, count: Int, useConjugate: Bool, result: inout DSPSplitComplex)`

Calculates the product of two complex single-precision vectors, optionally conjugating one of them.

`static func multiply(DSPDoubleSplitComplex, by: DSPDoubleSplitComplex, count: Int, useConjugate: Bool, result: inout DSPDoubleSplitComplex)`

Calculates the elementwise product of two complex double-precision vectors, optionally conjugating one of them.

`static func multiply<U>(DSPSplitComplex, by: U, result: inout DSPSplitComplex)`

Calculates the double-precision elementwise product of a complex vector and a real vector.

`static func multiply<U>(DSPDoubleSplitComplex, by: U, result: inout DSPDoubleSplitComplex)`

Calculates the single-precision elementwise product of a complex vector and a real vector.

`static func multiply<T, U>(addition: (a: T, b: U), Double) -> [Double]`

Returns the double-precision elementwise product of the sum of two vectors and a scalar value.

`static func multiply<S, T, U>(addition: (a: S, b: T), U) -> [Double]`

Returns the double-precision elementwise product of the sum of two vectors and a vector.

`static func multiply<T, U>(addition: (a: T, b: U), Float) -> [Float]`

Returns the single-precision elementwise product of the sum of two vectors and a scalar value.

`static func multiply<S, T, U>(addition: (a: S, b: T), U) -> [Float]`

Returns the single-precision elementwise product of the sum of two vectors and a vector.

`static func multiply<T, U, V>(addition: (a: T, b: U), Double, result: inout V)`

Calculates the double-precision elementwise product of the sum of two vectors and a scalar value.

`static func multiply<T, U, V>(addition: (a: T, b: U), Float, result: inout V)`

Calculates the single-precision elementwise product of the sum of two vectors and a scalar value.

`static func multiply<S, T, U, V>(addition: (a: S, b: T), U, result: inout V)`

Calculates the double-precision elementwise product of the sum of two vectors and a vector.

`static func multiply<S, T, U, V>(addition: (a: S, b: T), U, result: inout V)`

Calculates the single-precision elementwise product of the sum of two vectors and a vector.

`static func multiply<S, T, U>(addition: (a: S, b: T), addition: (c: U, d: U)) -> [Double]`

Returns the double-precision elementwise product of two elementwise vector-vector sums.

`static func multiply<S, T, U>(addition: (a: S, b: T), addition: (c: U, d: U)) -> [Float]`

Returns the single-precision elementwise product of two elementwise vector-vector sums.

`static func multiply<S, T, U, V>(addition: (a: S, b: T), addition: (c: U, d: U), result: inout V)`

Calculates the double-precision elementwise product of two elementwise vector-vector sums.

`static func multiply<S, T, U, V>(addition: (a: S, b: T), addition: (c: U, d: U), result: inout V)`

Returns the single-precision elementwise product of two elementwise vector-vector sums.

`static func multiply<R, S, T, U>(addition: (a: R, b: S), subtraction: (c: T, d: U)) -> [Double]`

Returns the double-precision elementwise product of an elementwise vector-vector sum and an elementwise vector-vector difference.

`static func multiply<R, S, T, U>(addition: (a: R, b: S), subtraction: (c: T, d: U)) -> [Float]`

Returns the single-precision elementwise product of an elementwise vector-vector sum and an elementwise vector-vector difference.

`static func multiply<R, S, T, U, V>(addition: (a: R, b: S), subtraction: (c: T, d: U), result: inout V)`

Calculates the double-precision elementwise product of an elementwise vector-vector sum and an elementwise vector-vector difference.

`static func multiply<R, S, T, U, V>(addition: (a: R, b: S), subtraction: (c: T, d: U), result: inout V)`

Calculates the single-precision elementwise product of an elementwise vector-vector sum and an elementwise vector-vector difference.

`static func multiply<T, U>(subtraction: (a: T, b: U), Double) -> [Double]`

Returns the double-precision elementwise product of the difference of two vectors and a scalar value.

`static func multiply<S, T, U>(subtraction: (a: S, b: T), U) -> [Double]`

Returns the double-precision elementwise product of the difference of two vectors and a vector.

`static func multiply<T, U>(subtraction: (a: T, b: U), Float) -> [Float]`

Returns the single-precision elementwise product of the difference of two vectors and a scalar value.

`static func multiply<S, T, U>(subtraction: (a: S, b: T), U) -> [Float]`

Returns the single-precision elementwise product of the difference of two vectors and a vector.

`static func multiply<T, U, V>(subtraction: (a: T, b: U), Double, result: inout V)`

Calculates the double-precision elementwise product of the difference of two vectors and a scalar value.

`static func multiply<T, U, V>(subtraction: (a: T, b: U), Float, result: inout V)`

Calculates the single-precision elementwise product of the difference of two vectors and a scalar value.

`static func multiply<S, T, U, V>(subtraction: (a: S, b: T), U, result: inout V)`

Calculates the double-precision elementwise product of the difference of two vectors and a vector.

`static func multiply<S, T, U, V>(subtraction: (a: S, b: T), U, result: inout V)`

Calculates the single-precision elementwise product of the difference of two vectors and a vector.

`static func multiply<R, S, T, U>(subtraction: (a: R, b: S), subtraction: (c: T, d: U)) -> [Double]`

Returns the double-precision elementwise product of two elementwise vector-vector differences.

`static func multiply<R, S, T, U>(subtraction: (a: R, b: S), subtraction: (c: T, d: U)) -> [Float]`

Returns the single-precision elementwise product of two elementwise vector-vector differences.

`static func multiply<R, S, T, U, V>(subtraction: (a: R, b: S), subtraction: (c: T, d: U), result: inout V)`

Calculates the double-precision elementwise product of two elementwise vector-vector differences.

`static func multiply<R, S, T, U, V>(subtraction: (a: R, b: S), subtraction: (c: T, d: U), result: inout V)`

Calculates the single-precision elementwise product of two elementwise vector-vector differences.

`static func negative<U>(U) -> [Double]`

Returns a double-precision array containing the negative values of the supplied vector.

`static func negative<U>(U) -> [Float]`

Returns a single-precision array containing the negative values of the supplied vector.

`static func negative<U, V>(U, result: inout V)`

Calculates the negative values of the supplied double-precision vector.

`static func negative<U, V>(U, result: inout V)`

Calculates the negative values of the supplied single-precision vector.

`static func negativeAbsolute<U>(U) -> [Double]`

Returns a double-precision array containing the negative absolute values of the supplied vector.

`static func negativeAbsolute<U>(U) -> [Float]`

Returns a single-precision array containing the negative absolute values of the supplied vector.

`static func negativeAbsolute<U, V>(U, result: inout V)`

Calculates the negative absolute values of the supplied double-precision vector.

`static func negativeAbsolute<U, V>(U, result: inout V)`

Calculates the negative absolute values of the supplied single-precision vector.

`static func phase<V>(DSPSplitComplex, result: inout V)`

Calculates the single-precision elementwise phase values, in radians, of the supplied complex vector.

`static func phase<V>(DSPDoubleSplitComplex, result: inout V)`

Calculates the double-precision elementwise phase values, in radians, of the supplied complex vector.

`static func polarToRectangular<U>(U) -> [Double]`

Returns double-precision polar coordinates converted to rectangular coordinates.

`static func polarToRectangular<U>(U) -> [Float]`

Returns single-precision polar coordinates converted to rectangular coordinates.

`static func powerToDecibels<U>(U, zeroReference: Double) -> [Double]`

Returns double-precision power values converted to decibel values.

`static func powerToDecibels<U>(U, zeroReference: Float) -> [Float]`

Returns single-precision power values converted to decibel values.

`static func ramp(in: ClosedRange<Double>, count: Int) -> [Double]`

Returns a double-precision vector that contains monotonically incrementing or decrementing values within a specified range.

`static func ramp(in: ClosedRange<Float>, count: Int) -> [Float]`

Returns a single-precision vector that contains monotonically incrementing or decrementing values within a specified range.

`static func ramp(withInitialValue: Double, increment: Double, count: Int) -> [Double]`

Returns a double-precision vector that contains monotonically incrementing or decrementing values.

`static func ramp(withInitialValue: Float, increment: Float, count: Int) -> [Float]`

Returns a single-precision vector that contains monotonically incrementing or decrementing values.

`static func ramp<U>(withInitialValue: inout Double, multiplyingBy: U, increment: Double) -> [Double]`

Returns a double-precision vector that contains monotonically incrementing or decrementing values, multiplied by a source vector.

`static func ramp<U>(withInitialValue: inout Float, multiplyingBy: U, increment: Float) -> [Float]`

Returns a single-precision vector that contains monotonically incrementing or decrementing values, multiplied by a source vector.

`static func rectangularToPolar<U>(U) -> [Double]`

Returns double-precision rectangular coordinates converted to polar coordinates.

`static func rectangularToPolar<U>(U) -> [Float]`

Returns single-precision rectangular coordinates converted to polar coordinates.

`static func reverse<V>(inout V)`

Reverses a vector of double-precision values in place.

`static func reverse<V>(inout V)`

Reverses a vector of single-precision values in place.

`static func rootMeanSquare<U>(U) -> Double`

Returns double-precision vector root mean square.

`static func rootMeanSquare<U>(U) -> Float`

Returns single-precision vector root mean square.

`static func signedSquare<U>(U) -> [Double]`

Returns a double-precision array containing the signed square of each element in the supplied vector.

`static func signedSquare<U>(U) -> [Float]`

Returns a single-precision array containing the signed square of each element in the supplied vector.

`static func signedSquare<U, V>(U, result: inout V)`

Calculates the signed square of each element in the supplied double-precision vector.

`static func signedSquare<U, V>(U, result: inout V)`

Calculates the signed square of each element in the supplied single-precision vector.

`static func slidingWindowSum<U>(U, usingWindowLength: Int) -> [Double]`

Returns the double-precision sliding window sum of a vector.

`static func slidingWindowSum<U>(U, usingWindowLength: Int) -> [Float]`

Returns the single-precision sliding window sum of a vector.

`static func slidingWindowSum<U, V>(U, usingWindowLength: Int, result: inout V)`

Calculates the double-precision sliding window sum of a vector.

`static func slidingWindowSum<U, V>(U, usingWindowLength: Int, result: inout V)`

Calculates the single-precision sliding window sum of a vector.

`static func sort<V>(inout V, sortOrder: vDSP.SortOrder)`

Sorts a vector of double-precision values in place.

`static func sort<V>(inout V, sortOrder: vDSP.SortOrder)`

Sorts a vector of single-precision values in place.

`static func square<U>(U) -> [Double]`

Returns a double-precision array containing the square of each element in the supplied vector.

`static func square<U>(U) -> [Float]`

Returns a single-precision array containing the square of each element in the supplied vector.

`static func square<U, V>(U, result: inout V)`

Calculates the square of each element in the supplied double-precision vector.

`static func square<U, V>(U, result: inout V)`

Calculates the square of each element in the supplied single-precision vector.

`static func squareMagnitudes<V>(DSPSplitComplex, result: inout V)`

Calculates the square magnitude of each element in the supplied single-precision complex vector.

`static func squareMagnitudes<V>(DSPDoubleSplitComplex, result: inout V)`

Calculates the square magnitude of each element in the supplied double-precision complex vector.

`static func stereoRamp<U>(withInitialValue: inout Double, multiplyingBy: U, U, increment: Double) -> (firstOutput: [Double], secondOutput: [Double])`

Returns a double-precision vector that contains stereo monotonically incrementing or decrementing values, multiplied by a source vector.

`static func stereoRamp<U>(withInitialValue: inout Float, multiplyingBy: U, U, increment: Float) -> (firstOutput: [Float], secondOutput: [Float])`

Returns a single-precision vector that contains stereo monotonically incrementing or decrementing values, multiplied by a source vector.

`static func subtract<T, U>(U, T) -> [Double]`

Returns the double-precision elementwise subtraction of a vector from a vector.

`static func subtract<T, U>(U, T) -> [Float]`

Returns the single-precision elementwise subtraction of a vector from a vector.

`static func subtract<T, U, V>(U, T, result: inout V)`

Calculates the double-precision elementwise subtraction of a vector from a vector.

`static func subtract<T, U, V>(U, T, result: inout V)`

Calculates the single-precision elementwise subtraction of a vector from a vector.

`static func subtract(DSPSplitComplex, from: DSPSplitComplex, count: Int, result: inout DSPSplitComplex)`

Calculates the single-precision elementwise subtraction of a complex vector from a complex vector.

`static func subtract(DSPDoubleSplitComplex, from: DSPDoubleSplitComplex, count: Int, result: inout DSPDoubleSplitComplex)`

Calculates the double-precision elementwise subtraction of a complex vector from a complex vector.

`static func subtract<T, U>(multiplication: (a: U, b: Double), T) -> [Double]`

Returns the double-precision elementwise subtraction of a vector from the elementwise product of a vector and a scalar value.

`static func subtract<S, T, U>(multiplication: (a: T, b: U), S) -> [Double]`

Returns the double-precision elementwise subtraction of a vector from the elementwise product of a vector and a vector.

`static func subtract<T, U>(multiplication: (a: U, b: Float), T) -> [Float]`

Returns the single-precision elementwise subtraction of a vector from the elementwise product of a vector and a scalar value.

`static func subtract<S, T, U>(multiplication: (a: T, b: U), S) -> [Float]`

Returns the single-precision elementwise subtraction of a vector from the elementwise product of a vector and a vector.

`static func subtract<T, U, V>(multiplication: (a: U, b: Double), T, result: inout V)`

Calculates the double-precision elementwise subtraction of a vector from the elementwise product of a vector and a scalar value.

`static func subtract<T, U, V>(multiplication: (a: U, b: Float), T, result: inout V)`

Calculates the single-precision elementwise subtraction of a vector from the elementwise product of a vector and a scalar value.

`static func subtract<S, T, U, V>(multiplication: (a: T, b: U), S, result: inout V)`

Calculates the double-precision elementwise subtraction of a vector from the elementwise product of a vector and a vector.

`static func subtract<S, T, U, V>(multiplication: (a: T, b: U), S, result: inout V)`

Calculates the single-precision elementwise subtraction of a vector from the elementwise product of a vector and a vector.

`static func subtract<R, S, T, U>(multiplication: (a: T, b: U), multiplication: (c: R, d: S)) -> [Double]`

Returns the double-precision elementwise subtraction of an elementwise vector-vector product from a second elementwise vector-vector product.

`static func subtract<R, S, T, U>(multiplication: (a: T, b: U), multiplication: (c: R, d: S)) -> [Float]`

Returns the single-precision elementwise subtraction of an elementwise vector-vector product from a second elementwise vector-vector product.

`static func subtract<R, S, T, U, V>(multiplication: (a: T, b: U), multiplication: (c: R, d: S), result: inout V)`

Calculates the double-precision elementwise subtraction of an elementwise vector-vector product from a second elementwise vector-vector product.

`static func subtract<R, S, T, U, V>(multiplication: (a: T, b: U), multiplication: (c: R, d: S), result: inout V)`

Calculates the single-precision elementwise subtraction of an elementwise vector-vector product from a second elementwise vector-vector product.

`static func sum<U>(U) -> Double`

Returns the double-precision vector sum.

`static func sum<U>(U) -> Float`

Returns the single-precision vector sum.

`static func sumOfMagnitudes<U>(U) -> Double`

Returns the double-precision vector sum of magnitudes.

`static func sumOfMagnitudes<U>(U) -> Float`

Returns the single-precision vector sum of magnitudes.

`static func sumOfSquares<U>(U) -> Double`

Returns the double-precision vector sum of squares.

`static func sumOfSquares<U>(U) -> Float`

Returns the single-precision vector sum of squares.

`static func threshold<U>(U, to: Double, with: vDSP.ThresholdRule<Double>) -> [Double]`

Returns the elements of the supplied double-precision vector after applying a specified thresholding rule.

`static func threshold<U>(U, to: Float, with: vDSP.ThresholdRule<Float>) -> [Float]`

Returns the elements of the supplied single-precision vector after applying a specified thresholding rule.

`static func threshold<U, V>(U, to: Double, with: vDSP.ThresholdRule<Double>, result: inout V)`

Calculates the elements of the supplied double-precision vector after applying a specified thresholding rule.

`static func threshold<U, V>(U, to: Float, with: vDSP.ThresholdRule<Float>, result: inout V)`

Calculates the elements of the supplied single-precision vector after applying a specified thresholding rule.

`static func trunc<U>(U) -> [Double]`

Returns a double-precision array containing each element in the supplied vector truncated to a fraction.

`static func trunc<U>(U) -> [Float]`

Returns a single-precision array containing each element in the supplied vector truncated to a fraction.

`static func trunc<U, V>(U, result: inout V)`

Calculates each element in the supplied double-precision vector truncated to a fraction.

`static func trunc<U, V>(U, result: inout V)`

Calculates each element in the supplied single-precision vector truncated to a fraction.

`static func twoPoleTwoZeroFilter<U>(U, coefficients: (Float, Float, Float, Float, Float)) -> [Float]`

Returns the result of single-precision, two-pole, two-zero recursive filtering.

### Classes

`class vDSP.DCT`

A single-precision discrete cosine transform.

`class vDSP.DFT`

A single- and double-precision discrete Fourier transform.

`class vDSP.FFT`

A 1D single- and double-precision fast Fourier transform.

`class vDSP.FFT2D`

A 2D single- and double-precision fast Fourier transform.

### Structures

`struct vDSP.Biquad`

A structure that applies biquadratic filters to single- and double-precision signals.

`struct vDSP.VectorizableDouble`

A structure that represents a double-precision real value for biquadratic filtering and discrete Fourier transforms.

`struct vDSP.VectorizableFloat`

A structure that represents a single-precision real value for biquadratic filtering and discrete Fourier transforms.

### Enumerations

`enum vDSP.DCTTransformType`

Discrete cosine transform types.

`enum vDSP.DFTTransformType`

Discrete Fourier transform types.

`enum vDSP.FourierTransformDirection`

Fast Fourier transform directions.

`enum vDSP.Radix`

`enum vDSP.RoundingMode`

Floating point to integer conversion rounding modes.

`enum vDSP.SortOrder`

Vector sorting orders.

`enum vDSP.WindowSequence`

Constants specifying window sequence functions.