# Arithmetic Operations

No overview available.

## Topics

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

### Subtraction

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

### Multiplication

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

### Division

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