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.
648 lines
25 KiB
Swift
648 lines
25 KiB
Swift
// RUN: %target-run-simple-swift
|
|
// REQUIRES: executable_test
|
|
|
|
// REQUIRES: rdar50301438
|
|
// REQUIRES: objc_interop
|
|
// UNSUPPORTED: OS=watchos
|
|
|
|
import StdlibUnittest
|
|
import Accelerate
|
|
|
|
var Accelerate_vDSPFillClearGenerateTests = TestSuite("Accelerate_vDSPFillClearGenerate")
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vDSP vector fill, clear, and generation tests
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(iOS 9999, OSX 9999, tvOS 9999, watchOS 9999, *) {
|
|
|
|
let count = 256
|
|
let n = vDSP_Length(256)
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionFill") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.fill(&result,
|
|
with: 999)
|
|
|
|
vDSP_vfill([999],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionClear") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.clear(&result)
|
|
|
|
vDSP_vclr(&legacyResult, 1,
|
|
n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionFill") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.fill(&result,
|
|
with: 999)
|
|
|
|
vDSP_vfillD([999],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionClear") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.clear(&result)
|
|
|
|
vDSP_vclrD(&legacyResult, 1,
|
|
n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHanningNormalized") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningNormalized,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hann_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_NORM))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hanningNormalized,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHanningNormalizedHalf") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningNormalized,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hann_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_NORM | vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hanningNormalized,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHanningDenormalized") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningDenormalized,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hann_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_DENORM))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hanningDenormalized,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHanningDenormalizedHalf") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningDenormalized,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hann_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_DENORM | vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hanningDenormalized,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHamming") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hamming,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hamm_window(&legacyResult,
|
|
n,
|
|
0)
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hamming,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionHammingHalf") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hamming,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hamm_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .hamming,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionBlackman") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .blackman,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_blkman_window(&legacyResult,
|
|
n,
|
|
0)
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .blackman,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionBlackmanHalf") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .blackman,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_blkman_window(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Float.self,
|
|
usingSequence: .blackman,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHanningNormalized") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningNormalized,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hann_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_NORM))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hanningNormalized,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHanningNormalizedHalf") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningNormalized,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hann_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_NORM | vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hanningNormalized,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHanningDenormalized") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningDenormalized,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hann_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_DENORM))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hanningDenormalized,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHanningDenormalizedHalf") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hanningDenormalized,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hann_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HANN_DENORM | vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hanningDenormalized,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHamming") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hamming,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_hamm_windowD(&legacyResult,
|
|
n,
|
|
0)
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hamming,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionHammingHalf") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .hamming,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_hamm_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .hamming,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionBlackman") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .blackman,
|
|
result: &result,
|
|
isHalfWindow: false)
|
|
|
|
vDSP_blkman_windowD(&legacyResult,
|
|
n,
|
|
0)
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .blackman,
|
|
count: count,
|
|
isHalfWindow: false)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionBlackmanHalf") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formWindow(usingSequence: .blackman,
|
|
result: &result,
|
|
isHalfWindow: true)
|
|
|
|
vDSP_blkman_windowD(&legacyResult,
|
|
n,
|
|
Int32(vDSP_HALF_WINDOW))
|
|
|
|
let returnedResult = vDSP.window(ofType: Double.self,
|
|
usingSequence: .blackman,
|
|
count: count,
|
|
isHalfWindow: true)
|
|
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(legacyResult[0 ..< count / 2]))
|
|
expectTrue(result[0 ..< count / 2].elementsEqual(returnedResult[0 ..< count / 2]))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionWithRange") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formRamp(in: 0 ... 100,
|
|
result: &result)
|
|
|
|
vDSP_vgen([0],
|
|
[100],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.ramp(in: Float(0) ... Float(100),
|
|
count: count)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionRampWithIncrement") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vDSP.formRamp(withInitialValue: 0,
|
|
increment: 0.1,
|
|
result: &result)
|
|
|
|
vDSP_vramp([0],
|
|
[0.1],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.ramp(withInitialValue: Float(0),
|
|
increment: Float(0.1),
|
|
count: count)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/SinglePrecisionRampWithMultiplier") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
let multiplier = (0 ..< n).map{ i in
|
|
return sin(Float(i) * 0.05)
|
|
}
|
|
|
|
var start = Float(10)
|
|
|
|
vDSP.formRamp(withInitialValue: &start,
|
|
multiplyingBy: multiplier,
|
|
increment: 1,
|
|
result: &result)
|
|
|
|
var legacyStart = Float(10)
|
|
|
|
vDSP_vrampmul(multiplier, 1,
|
|
&legacyStart,
|
|
[1],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
var start2 = Float(10)
|
|
let returnedResult = vDSP.ramp(withInitialValue: &start2,
|
|
multiplyingBy: multiplier,
|
|
increment: 1)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
|
|
expectEqual(start, legacyStart)
|
|
expectEqual(start, start2)
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/StereoSinglePrecisionRampWithMultiplier") {
|
|
var result = [Float](repeating: 1, count: count)
|
|
var legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
let multiplierOne = (0 ..< n).map{ i in
|
|
return sin(Float(i) * 0.05)
|
|
}
|
|
let multiplierTwo = (0 ..< n).map{ i in
|
|
return sin(Float(i) * 0.0125)
|
|
}
|
|
|
|
var start = Float(10)
|
|
var resultTwo = [Float](repeating: 2, count: result.count)
|
|
|
|
vDSP.formStereoRamp(withInitialValue: &start,
|
|
multiplyingBy: multiplierOne, multiplierTwo,
|
|
increment: 1,
|
|
results: &result, &resultTwo)
|
|
|
|
var legacyStart = Float(10)
|
|
var legacyResultTwo = [Float](repeating: -2, count: legacyResult.count)
|
|
|
|
vDSP_vrampmul2(multiplierOne, multiplierTwo, 1,
|
|
&legacyStart,
|
|
[1],
|
|
&legacyResult, &legacyResultTwo, 1,
|
|
n)
|
|
|
|
var start2 = Float(10)
|
|
let returnedResult = vDSP.stereoRamp(withInitialValue: &start2,
|
|
multiplyingBy: multiplierOne, multiplierTwo,
|
|
increment: 1)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(resultTwo.elementsEqual(legacyResultTwo))
|
|
expectEqual(start, legacyStart)
|
|
|
|
expectTrue(result.elementsEqual(returnedResult.firstOutput))
|
|
expectTrue(resultTwo.elementsEqual(returnedResult.secondOutput))
|
|
expectEqual(start, start2)
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionRampWithRange") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formRamp(in: 0 ... 100,
|
|
result: &result)
|
|
|
|
vDSP_vgenD([0],
|
|
[100],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.ramp(in: Double(0) ... Double(100),
|
|
count: count)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionRampWithRange") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vDSP.formRamp(withInitialValue: 0,
|
|
increment: 0.1,
|
|
result: &result)
|
|
|
|
vDSP_vrampD([0],
|
|
[0.1],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
let returnedResult = vDSP.ramp(withInitialValue: 0,
|
|
increment: 0.1,
|
|
count: count)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/DoublePrecisionRampWithMultiplier") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
let multiplier = (0 ..< n).map{ i in
|
|
return sin(Double(i) * 0.05)
|
|
}
|
|
|
|
var start = Double(10)
|
|
|
|
vDSP.formRamp(withInitialValue: &start,
|
|
multiplyingBy: multiplier,
|
|
increment: 1,
|
|
result: &result)
|
|
|
|
var legacyStart = Double(10)
|
|
|
|
vDSP_vrampmulD(multiplier, 1,
|
|
&legacyStart,
|
|
[1],
|
|
&legacyResult, 1,
|
|
n)
|
|
|
|
var start2 = Double(10)
|
|
let returnedResult = vDSP.ramp(withInitialValue: &start2,
|
|
multiplyingBy: multiplier,
|
|
increment: 1)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
|
|
expectEqual(start, legacyStart)
|
|
expectEqual(start, start2)
|
|
}
|
|
|
|
Accelerate_vDSPFillClearGenerateTests.test("vDSP/StereoDoublePrecisionRampWithMultiplier") {
|
|
var result = [Double](repeating: 1, count: count)
|
|
var legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
let multiplierOne = (0 ..< n).map{ i in
|
|
return sin(Double(i) * 0.05)
|
|
}
|
|
let multiplierTwo = (0 ..< n).map{ i in
|
|
return sin(Double(i) * 0.0125)
|
|
}
|
|
|
|
var start = Double(10)
|
|
var resultTwo = [Double](repeating: 2, count: result.count)
|
|
|
|
vDSP.formStereoRamp(withInitialValue: &start,
|
|
multiplyingBy: multiplierOne, multiplierTwo,
|
|
increment: 1,
|
|
results: &result, &resultTwo)
|
|
|
|
var legacyStart = Double(10)
|
|
var legacyResultTwo = [Double](repeating: -2, count: legacyResult.count)
|
|
|
|
vDSP_vrampmul2D(multiplierOne, multiplierTwo, 1,
|
|
&legacyStart,
|
|
[1],
|
|
&legacyResult, &legacyResultTwo, 1,
|
|
n)
|
|
|
|
var start2 = Double(10)
|
|
let returnedResult = vDSP.stereoRamp(withInitialValue: &start2,
|
|
multiplyingBy: multiplierOne, multiplierTwo,
|
|
increment: 1)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(resultTwo.elementsEqual(legacyResultTwo))
|
|
expectEqual(start, legacyStart)
|
|
|
|
expectTrue(result.elementsEqual(returnedResult.firstOutput))
|
|
expectTrue(resultTwo.elementsEqual(returnedResult.secondOutput))
|
|
expectEqual(start, start2)
|
|
}
|
|
}
|
|
|
|
runAllTests()
|