mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
d4b90f4837
These are testing for bitwise identical results, but don't guarantee that the buffers being used always have identical alignment. This will result in small rounding differences when vector codepaths are used for different elements of some results. This is partially an underlying bug in Accelerate (which is outside the scope of this project to fix), and partly a test bug (which we can address by adopting approximate comparisons here). In the short term, though, I'm going to disable these.
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(iOS 9999, macOS 9999, tvOS 9999, watchOS 9999, *) {
|
|
|
|
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(iOS 9999, OSX 9999, tvOS 9999, watchOS 9999, *) {
|
|
|
|
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(iOS 9999, macOS 9999, tvOS 9999, watchOS 9999, *) {
|
|
|
|
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(iOS 9999, macOS 9999, tvOS 9999, watchOS 9999, *) {
|
|
|
|
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()
|