mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1019 lines
40 KiB
Swift
1019 lines
40 KiB
Swift
// RUN: %target-run-simple-swift
|
|
// REQUIRES: executable_test
|
|
|
|
// REQUIRES: rdar50301438
|
|
// REQUIRES: objc_interop
|
|
// UNSUPPORTED: OS=watchos
|
|
|
|
import StdlibUnittest
|
|
import Accelerate
|
|
|
|
var AccelerateTests_vDSPConversion = TestSuite("Accelerate_vDSPConversion")
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vDSP polar / rectangular conversion
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/SinglePrecisionRectToPolar") {
|
|
let source: [Float] = [2, 4,
|
|
-10, -20,
|
|
100, -300]
|
|
|
|
let n = vDSP_Length(source.count)
|
|
|
|
var result = [Float](repeating: 0,
|
|
count: source.count)
|
|
|
|
vDSP.convert(rectangularCoordinates: source,
|
|
toPolarCoordinates: &result)
|
|
|
|
var legacyResult = [Float](repeating: -1,
|
|
count: source.count)
|
|
|
|
vDSP_polar(source, 2,
|
|
&legacyResult, 2,
|
|
n / 2)
|
|
|
|
let returnedResult = vDSP.rectangularToPolar(source)
|
|
|
|
expectTrue(returnedResult.elementsEqual(legacyResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/SinglePrecisionPolarToRect") {
|
|
let source: [Float] = [2, 4,
|
|
-10, -20,
|
|
100, -300]
|
|
|
|
let n = vDSP_Length(source.count)
|
|
|
|
var result = [Float](repeating: 0,
|
|
count: source.count)
|
|
|
|
vDSP.convert(polarCoordinates: source,
|
|
toRectangularCoordinates: &result)
|
|
|
|
var legacyResult = [Float](repeating: -1,
|
|
count: source.count)
|
|
|
|
vDSP_rect(source, 2,
|
|
&legacyResult, 2,
|
|
n / 2)
|
|
|
|
let returnedResult = vDSP.polarToRectangular(source)
|
|
|
|
expectTrue(returnedResult.elementsEqual(legacyResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoublePrecisionRectToPolar") {
|
|
let source: [Double] = [2, 4,
|
|
-10, -20,
|
|
100, -300]
|
|
|
|
let n = vDSP_Length(source.count)
|
|
|
|
var result = [Double](repeating: 0,
|
|
count: source.count)
|
|
|
|
vDSP.convert(rectangularCoordinates: source,
|
|
toPolarCoordinates: &result)
|
|
|
|
var legacyResult = [Double](repeating: -1,
|
|
count: source.count)
|
|
|
|
vDSP_polarD(source, 2,
|
|
&legacyResult, 2,
|
|
n / 2)
|
|
|
|
let returnedResult = vDSP.rectangularToPolar(source)
|
|
|
|
expectTrue(returnedResult.elementsEqual(legacyResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoublePrecisionRectToPolar") {
|
|
let source: [Double] = [2, 4,
|
|
-10, -20,
|
|
100, -300]
|
|
|
|
let n = vDSP_Length(source.count)
|
|
|
|
var result = [Double](repeating: 0,
|
|
count: source.count)
|
|
|
|
vDSP.convert(polarCoordinates: source,
|
|
toRectangularCoordinates: &result)
|
|
|
|
var legacyResult = [Double](repeating: -1,
|
|
count: source.count)
|
|
|
|
vDSP_rectD(source, 2,
|
|
&legacyResult, 2,
|
|
n / 2)
|
|
|
|
let returnedResult = vDSP.polarToRectangular(source)
|
|
|
|
expectTrue(returnedResult.elementsEqual(legacyResult))
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vDSP type-conversion tests
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
let n = vDSP_Length(10)
|
|
|
|
let floatingPointValues: [Float] = [-10.9, -20.1, 32.99, 14.001, -16.5,
|
|
90.5, 0, -0, -0.00001, 0.000001]
|
|
|
|
let floatingPointValuesD: [Double] = [-10.9, -20.1, 32.99, 14.001, -16.5,
|
|
90.5, 0, -0, -0.00001, 0.000001]
|
|
|
|
let unsignedIntValues = [5, 250, 0, 99, 127, 65, 78, 1, 33, 10]
|
|
let signedIntValues = [5, -126, 0, -99, 125, -65, 78, -1, 33, -10]
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToDouble") {
|
|
let source = floatingPointValues
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vspdp(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatToDouble(source)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToFloat") {
|
|
let source = floatingPointValuesD
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vdpsp(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.doubleToFloat(source)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt8_to_Float") {
|
|
let source = unsignedIntValues.map{ return UInt8($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt8_to_Double") {
|
|
let source = unsignedIntValues.map{ return UInt8($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt16_to_Float") {
|
|
let source = unsignedIntValues.map{ return UInt16($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt16_to_Double") {
|
|
let source = unsignedIntValues.map{ return UInt16($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt32_to_Float") {
|
|
let source = unsignedIntValues.map{ return UInt32($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/UInt32_to_Double") {
|
|
let source = unsignedIntValues.map{ return UInt32($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vfltu32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int8_to_Float") {
|
|
let source = signedIntValues.map{ return Int8($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int8_to_Double") {
|
|
let source = signedIntValues.map{ return Int8($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int16_to_Float") {
|
|
let source = signedIntValues.map{ return Int16($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int16_to_Double") {
|
|
let source = signedIntValues.map{ return Int16($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int32_to_Float") {
|
|
let source = signedIntValues.map{ return Int32($0) }
|
|
var result = [Float](repeating: 0, count: source.count)
|
|
var legacyResult = [Float](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Float.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/Int32_to_Double") {
|
|
let source = signedIntValues.map{ return Int32($0) }
|
|
var result = [Double](repeating: 0, count: source.count)
|
|
var legacyResult = [Double](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result)
|
|
|
|
vDSP_vflt32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.integerToFloatingPoint(source,
|
|
floatingPointType: Double.self)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt32towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [Int32](repeating: 0, count: source.count)
|
|
var legacyResult = [Int32](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int32.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt32towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [Int32](repeating: 0, count: source.count)
|
|
var legacyResult = [Int32](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int32.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt32towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int32](repeating: 0, count: source.count)
|
|
var legacyResult = [Int32](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int32.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt32towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int32](repeating: 0, count: source.count)
|
|
var legacyResult = [Int32](repeating: -1, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int32.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt16towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [UInt16](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt16.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt16towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [UInt16](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt16.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt16towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt16](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt16.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt16towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt16](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt16.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt32towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [UInt32](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt32](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt32.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt32towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [UInt32](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt32](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru32(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt32.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt32towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt32](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt32](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt32.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt32towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt32](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt32](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru32D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt32.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt16towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [Int16](repeating: 0, count: source.count)
|
|
var legacyResult = [Int16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int16.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt16towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [Int16](repeating: 0, count: source.count)
|
|
var legacyResult = [Int16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr16(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int16.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt16towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int16](repeating: 0, count: source.count)
|
|
var legacyResult = [Int16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int16.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt16towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int16](repeating: 0, count: source.count)
|
|
var legacyResult = [Int16](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr16D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int16.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt8towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [Int8](repeating: 0, count: source.count)
|
|
var legacyResult = [Int8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int8.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToInt8towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [Int8](repeating: 0, count: source.count)
|
|
var legacyResult = [Int8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int8.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt8towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int8](repeating: 0, count: source.count)
|
|
var legacyResult = [Int8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfix8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int8.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt8towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [Int8](repeating: 0, count: source.count)
|
|
var legacyResult = [Int8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixr8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: Int8.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt8towardZero") {
|
|
let source = floatingPointValues
|
|
var result = [UInt8](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt8.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt8towardNearest") {
|
|
let source = floatingPointValues
|
|
var result = [UInt8](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru8(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt8.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt8towardZero") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt8](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
|
|
|
|
vDSP_vfixu8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt8.self,
|
|
rounding: .towardZero)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/DoubletoUInt8towardNearest") {
|
|
let source = floatingPointValuesD
|
|
var result = [UInt8](repeating: 0, count: source.count)
|
|
var legacyResult = [UInt8](repeating: 99, count: source.count)
|
|
|
|
vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
|
|
|
|
vDSP_vfixru8D(source, 1,
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.floatingPointToInteger(source,
|
|
integerType: UInt8.self,
|
|
rounding: .towardNearestInteger)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vDSP decibel conversion
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/PowerToDecibelsSinglePrecision") {
|
|
let source: [Float] = [1, 10, 100, 2, 4, 8, 16, 101,
|
|
27, 13, 11, 44, 0.5, 99, 0.125]
|
|
let zeroReference = Float(7)
|
|
let n = source.count
|
|
|
|
var result = [Float](repeating: 0,
|
|
count: n)
|
|
|
|
vDSP.convert(power: source,
|
|
toDecibels: &result,
|
|
zeroReference: zeroReference)
|
|
|
|
var legacyResult = [Float](repeating: -1,
|
|
count: n)
|
|
|
|
vDSP_vdbcon(source, 1,
|
|
[zeroReference],
|
|
&legacyResult, 1,
|
|
vDSP_Length(n),
|
|
0)
|
|
|
|
let returnedResult = vDSP.powerToDecibels(source,
|
|
zeroReference: zeroReference)
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/AmplitudeToDecibelsSinglePrecision") {
|
|
let source: [Float] = [1, 10, 100, 2, 4, 8, 16, 101,
|
|
27, 13, 11, 44, 0.5, 99, 0.125]
|
|
let zeroReference = Float(7)
|
|
let n = source.count
|
|
|
|
var result = [Float](repeating: 0,
|
|
count: n)
|
|
|
|
vDSP.convert(amplitude: source,
|
|
toDecibels: &result,
|
|
zeroReference: zeroReference)
|
|
|
|
var legacyResult = [Float](repeating: -1,
|
|
count: n)
|
|
|
|
vDSP_vdbcon(source, 1,
|
|
[zeroReference],
|
|
&legacyResult, 1,
|
|
vDSP_Length(n),
|
|
1)
|
|
|
|
let returnedResult = vDSP.amplitudeToDecibels(source,
|
|
zeroReference: zeroReference)
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/PowerToDecibelsDoublePrecision") {
|
|
let source: [Double] = [1, 10, 100, 2, 4, 8, 16, 101,
|
|
27, 13, 11, 44, 0.5, 99, 0.125]
|
|
let zeroReference = Double(7)
|
|
let n = source.count
|
|
|
|
var result = [Double](repeating: 0,
|
|
count: n)
|
|
|
|
vDSP.convert(power: source,
|
|
toDecibels: &result,
|
|
zeroReference: zeroReference)
|
|
|
|
var legacyResult = [Double](repeating: -1,
|
|
count: n)
|
|
|
|
vDSP_vdbconD(source, 1,
|
|
[zeroReference],
|
|
&legacyResult, 1,
|
|
vDSP_Length(n),
|
|
0)
|
|
|
|
let returnedResult = vDSP.powerToDecibels(source,
|
|
zeroReference: zeroReference)
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/AmplitudeToDecibelsDoublePrecision") {
|
|
let source: [Double] = [1, 10, 100, 2, 4, 8, 16, 101,
|
|
27, 13, 11, 44, 0.5, 99, 0.125]
|
|
let zeroReference = Double(7)
|
|
let n = source.count
|
|
|
|
var result = [Double](repeating: 0,
|
|
count: n)
|
|
|
|
vDSP.convert(amplitude: source,
|
|
toDecibels: &result,
|
|
zeroReference: zeroReference)
|
|
|
|
var legacyResult = [Double](repeating: -1,
|
|
count: n)
|
|
|
|
vDSP_vdbconD(source, 1,
|
|
[zeroReference],
|
|
&legacyResult, 1,
|
|
vDSP_Length(n),
|
|
1)
|
|
|
|
let returnedResult = vDSP.amplitudeToDecibels(source,
|
|
zeroReference: zeroReference)
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vDSP complex format conversion
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/ComplexFormatConversionSinglePrecision") {
|
|
var real: [Float] = [4, 5, 6]
|
|
var imag: [Float] = [1, 2, 3]
|
|
let src = DSPSplitComplex(realp: &real,
|
|
imagp: &imag)
|
|
|
|
var dest = [DSPComplex](repeating: DSPComplex(),
|
|
count: 3)
|
|
|
|
vDSP.convert(splitComplexVector: src,
|
|
toInterleavedComplexVector: &dest)
|
|
|
|
var realResult: [Float] = [0, 0, 0]
|
|
var imagResult: [Float] = [0, 0, 0]
|
|
var result = DSPSplitComplex(realp: &realResult,
|
|
imagp: &imagResult)
|
|
|
|
vDSP.convert(interleavedComplexVector: dest,
|
|
toSplitComplexVector: &result)
|
|
|
|
expectTrue(real.elementsEqual(realResult))
|
|
expectTrue(imag.elementsEqual(imagResult))
|
|
}
|
|
|
|
AccelerateTests_vDSPConversion.test("vDSP/ComplexFormatConversionDoublePrecision") {
|
|
var real: [Double] = [4, 5, 6]
|
|
var imag: [Double] = [1, 2, 3]
|
|
let src = DSPDoubleSplitComplex(realp: &real,
|
|
imagp: &imag)
|
|
|
|
var dest = [DSPDoubleComplex](repeating: DSPDoubleComplex(),
|
|
count: 3)
|
|
|
|
vDSP.convert(splitComplexVector: src,
|
|
toInterleavedComplexVector: &dest)
|
|
|
|
var realResult: [Double] = [0, 0, 0]
|
|
var imagResult: [Double] = [0, 0, 0]
|
|
var result = DSPDoubleSplitComplex(realp: &realResult,
|
|
imagp: &imagResult)
|
|
|
|
vDSP.convert(interleavedComplexVector: dest,
|
|
toSplitComplexVector: &result)
|
|
|
|
expectTrue(real.elementsEqual(realResult))
|
|
expectTrue(imag.elementsEqual(imagResult))
|
|
}
|
|
}
|
|
|
|
runAllTests()
|