Skip to content

Commit e74feb6

Browse files
lorenteylorentey
authored
Merge pull request #24432 from FlexMonkey/accelerate-vDSP-interpolation-tests
[Accelerate] [vDSP] Resolve Interpolation Test Failures on tvOS Simulator
2 parents ec70b62 + 71f5cee commit e74feb6

File tree

1 file changed

+72
-28
lines changed

1 file changed

+72
-28
lines changed

‎test/stdlib/Accelerate.swift

Lines changed: 72 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -77,8 +77,9 @@ if #available(iOS 10.0, OSX 10.12, tvOS 10.0, watchOS 4.0, *) {
7777

7878
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
7979

80+
let n = 1024
81+
8082
AccelerateTests.test("vDSP/DiscreteCosineTransform") {
81-
let n = 1024
8283

8384
let source = (0 ..< n).map{ i in
8485
return sin(Float(i) * 0.05) + sin(Float(i) * 0.025)
@@ -110,18 +111,17 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
110111
source,
111112
&legacyDestination)
112113

113-
expectTrue(destination.elementsEqual(legacyDestination))
114-
expectTrue(destination.elementsEqual(returnedResult))
114+
expectTrue(elementsAlmostEqual(destination, legacyDestination))
115+
expectTrue(elementsAlmostEqual(destination, returnedResult))
115116
}
116117
}
117118
}
118-
119+
119120
//===----------------------------------------------------------------------===//
120121
//
121122
// Sliding window summation
122123
//
123124
//===----------------------------------------------------------------------===//
124-
125125
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
126126

127127
AccelerateTests.test("vDSP/SinglePrecisionSlidingWindowSum") {
@@ -135,7 +135,7 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
135135
let returnedResult = vDSP.slidingWindowSum(source,
136136
usingWindowLength: 3)
137137

138-
expectTrue(destination.elementsEqual(returnedResult))
138+
expectTrue(elementsAlmostEqual(destination, returnedResult))
139139
expectTrue(destination.map{ Int($0) }.elementsEqual([23, 31, 24, 19, 12, 15]))
140140
}
141141

@@ -150,8 +150,7 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
150150
let returnedResult = vDSP.slidingWindowSum(source,
151151
usingWindowLength: 3)
152152

153-
expectTrue(destination.elementsEqual(returnedResult))
154-
153+
expectTrue(elementsAlmostEqual(destination, returnedResult))
155154
expectTrue(destination.map{ Int($0) }.elementsEqual([23, 31, 24, 19, 12, 15]))
156155
}
157156

@@ -194,8 +193,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
194193
let returnedResult = vDSP.linearInterpolate(a, b,
195194
using: interpolationConstant)
196195

197-
expectTrue(result.elementsEqual(legacyResult))
198-
expectTrue(result.elementsEqual(returnedResult))
196+
expectTrue(elementsAlmostEqual(result, legacyResult))
197+
expectTrue(elementsAlmostEqual(result, returnedResult))
199198
}
200199

201200
AccelerateTests.test("vDSP/SinglePrecisionInterpolateBetweenNeighbours") {
@@ -230,8 +229,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
230229
let returnedResult = vDSP.linearInterpolate(elementsOf: shortSignal,
231230
using: controlVector)
232231

233-
expectTrue(result.elementsEqual(legacyResult))
234-
expectTrue(result.elementsEqual(returnedResult))
232+
expectTrue(elementsAlmostEqual(result, legacyResult))
233+
expectTrue(elementsAlmostEqual(result, returnedResult))
235234
}
236235

237236
AccelerateTests.test("vDSP/DoublePrecisionInterpolateBetweenVectors") {
@@ -261,8 +260,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
261260
let returnedResult = vDSP.linearInterpolate(a, b,
262261
using: interpolationConstant)
263262

264-
expectTrue(result.elementsEqual(legacyResult))
265-
expectTrue(result.elementsEqual(returnedResult))
263+
expectTrue(elementsAlmostEqual(result, legacyResult))
264+
expectTrue(elementsAlmostEqual(result, returnedResult))
266265
}
267266

268267
AccelerateTests.test("vDSP/DoublePrecisionInterpolateBetweenNeighbours") {
@@ -297,8 +296,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
297296
let returnedResult = vDSP.linearInterpolate(elementsOf: shortSignal,
298297
using: controlVector)
299298

300-
expectTrue(result.elementsEqual(legacyResult))
301-
expectTrue(result.elementsEqual(returnedResult))
299+
expectTrue(elementsAlmostEqual(result, legacyResult))
300+
expectTrue(elementsAlmostEqual(result, returnedResult))
302301
}
303302
}
304303

@@ -344,8 +343,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
344343
coefficients[3],
345344
coefficients[4]))
346345

347-
expectTrue(result.elementsEqual(legacyResult))
348-
expectTrue(result.elementsEqual(returnedResult))
346+
expectTrue(elementsAlmostEqual(result, legacyResult))
347+
expectTrue(elementsAlmostEqual(result, returnedResult))
349348
}
350349

351350
AccelerateTests.test("vDSP/DifferenceEquationDoublePrecision") {
@@ -382,8 +381,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
382381
coefficients[3],
383382
coefficients[4]))
384383

385-
expectTrue(result.elementsEqual(legacyResult))
386-
expectTrue(result.elementsEqual(returnedResult))
384+
expectTrue(elementsAlmostEqual(result, legacyResult))
385+
expectTrue(elementsAlmostEqual(result, returnedResult))
387386
}
388387
}
389388

@@ -430,8 +429,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
430429
decimationFactor: decimationFactor,
431430
filter: filter)
432431

433-
expectTrue(result.elementsEqual(legacyResult))
434-
expectTrue(result.elementsEqual(returnedResult))
432+
expectTrue(elementsAlmostEqual(result, legacyResult))
433+
expectTrue(elementsAlmostEqual(result, returnedResult))
435434
}
436435

437436
AccelerateTests.test("vDSP/DownsampleDoublePrecision") {
@@ -470,8 +469,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
470469
decimationFactor: decimationFactor,
471470
filter: filter)
472471

473-
expectTrue(result.elementsEqual(legacyResult))
474-
expectTrue(result.elementsEqual(returnedResult))
472+
expectTrue(elementsAlmostEqual(result, legacyResult))
473+
expectTrue(elementsAlmostEqual(result, returnedResult))
475474
}
476475
}
477476

@@ -503,8 +502,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
503502
let returnedResult = vDSP.evaluatePolynomial(usingCoefficients: coefficients,
504503
withVariables: variables)
505504

506-
expectTrue(result.elementsEqual(legacyResult))
507-
expectTrue(result.elementsEqual(returnedResult))
505+
expectTrue(elementsAlmostEqual(result, legacyResult))
506+
expectTrue(elementsAlmostEqual(result, returnedResult))
508507
}
509508

510509
AccelerateTests.test("vDSP/PolynomialEvaluationDoublePrecision") {
@@ -527,8 +526,53 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
527526
let returnedResult = vDSP.evaluatePolynomial(usingCoefficients: coefficients,
528527
withVariables: variables)
529528

530-
expectTrue(result.elementsEqual(legacyResult))
531-
expectTrue(result.elementsEqual(returnedResult))
529+
expectTrue(elementsAlmostEqual(result, legacyResult))
530+
expectTrue(elementsAlmostEqual(result, returnedResult))
531+
}
532+
533+
//===----------------------------------------------------------------------===//
534+
//
535+
// Array almost equal.
536+
//
537+
//===----------------------------------------------------------------------===//
538+
539+
func elementsAlmostEqual<T: FloatingPoint>(_ lhs: [T], _ rhs: [T]) -> Bool {
540+
var returnValue = true
541+
zip(lhs, rhs).forEach {
542+
if !isAlmostEqual($0.0, $0.1) {
543+
returnValue = false
544+
return
545+
}
546+
}
547+
return returnValue
548+
}
549+
550+
func isAlmostEqual<T: FloatingPoint>(_ lhs: T,
551+
_ rhs: T,
552+
tolerance: T = T.ulpOfOne.squareRoot()) -> Bool {
553+
assert(tolerance >= .ulpOfOne && tolerance < 1, "tolerance should be in [.ulpOfOne, 1).")
554+
guard lhs.isFinite && rhs.isFinite else {
555+
return rescaledAlmostEqual(lhs, rhs, tolerance: tolerance)
556+
}
557+
let scale = max(abs(lhs), abs(rhs), .leastNormalMagnitude)
558+
return abs(lhs - rhs) < scale*tolerance
559+
}
560+
561+
func rescaledAlmostEqual<T: FloatingPoint>(_ lhs: T,
562+
_ rhs: T,
563+
tolerance: T) -> Bool {
564+
if lhs.isNaN || rhs.isNaN { return false }
565+
if lhs.isInfinite {
566+
if rhs.isInfinite { return lhs == rhs }
567+
let scaledLhs = T(sign: lhs.sign,
568+
exponent: T.greatestFiniteMagnitude.exponent,
569+
significand: 1)
570+
let scaledRhs = T(sign: .plus,
571+
exponent: -1,
572+
significand: rhs)
573+
return isAlmostEqual(scaledLhs, scaledRhs, tolerance: tolerance)
574+
}
575+
return rescaledAlmostEqual(rhs, lhs, tolerance: tolerance)
532576
}
533577
}
534578

0 commit comments

Comments
 (0)