mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1270 lines
39 KiB
Swift
1270 lines
39 KiB
Swift
// RUN: %target-run-simple-swift
|
|
// REQUIRES: executable_test
|
|
|
|
// REQUIRES: rdar50301438
|
|
// REQUIRES: objc_interop
|
|
// UNSUPPORTED: OS=watchos
|
|
|
|
import StdlibUnittest
|
|
import Accelerate
|
|
|
|
var Accelerate_vForceTests = TestSuite("Accelerate_vForce")
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vForce single-precision tests
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
var result = [Float]()
|
|
var legacyResult = [Float]()
|
|
let x: [Float] = [2, 4, -6.876, 10.9, -100.3, 100]
|
|
let y: [Float] = [-10, -20, 40, 60, -80, -300]
|
|
let z: [Float] = [-0.6, 0.2, -0.1, 0.9, -0.1, 0.1]
|
|
let count = 6
|
|
var n: Int32 = 6
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionCeiling") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.ceil(x,
|
|
result: &result)
|
|
|
|
vvceilf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.ceil(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionFloor") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.floor(x,
|
|
result: &result)
|
|
|
|
vvfloorf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.floor(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionCopySign") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.copysign(magnitudes: x,
|
|
signs: y,
|
|
result: &result)
|
|
|
|
vvcopysignf(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.copysign(magnitudes: x,
|
|
signs: y)
|
|
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionModulus") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.truncatingRemainder(dividends: x,
|
|
divisors: y,
|
|
result: &result)
|
|
|
|
vvfmodf(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.truncatingRemainder(dividends: x,
|
|
divisors: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionModulusParameters") {
|
|
var scalarResult = [Float.nan]
|
|
let scalarNumerator = [Float(20)]
|
|
let scalarDenominator = [Float(6)]
|
|
|
|
vForce.truncatingRemainder(dividends: scalarNumerator,
|
|
divisors: scalarDenominator,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 2)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionRemainder") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.remainder(dividends: x,
|
|
divisors: y,
|
|
result: &result)
|
|
|
|
vvremainderf(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.remainder(dividends: x,
|
|
divisors: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionRemainderParameters") {
|
|
var scalarResult = [Float.nan]
|
|
let scalarNumerator = [Float(20)]
|
|
let scalarDenominator = [Float(6)]
|
|
|
|
vForce.remainder(dividends: scalarNumerator,
|
|
divisors: scalarDenominator,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 2)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionIntegerTruncation") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.trunc(x,
|
|
result: &result)
|
|
|
|
vvintf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.trunc(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionNearestInteger") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.nearestInteger(x,
|
|
result: &result)
|
|
|
|
vvnintf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.nearestInteger(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionrsqrt") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.rsqrt(x,
|
|
result: &result)
|
|
|
|
vvrsqrtf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.rsqrt(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionsqrt") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.sqrt(x,
|
|
result: &result)
|
|
|
|
vvsqrtf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sqrt(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionReciprocal") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.reciprocal(x,
|
|
result: &result)
|
|
|
|
vvrecf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.reciprocal(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionExp") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.exp(x,
|
|
result: &result)
|
|
|
|
vvexpf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.exp(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionExpm1") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.expm1(x,
|
|
result: &result)
|
|
|
|
vvexpm1f(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.expm1(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionExp2") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.exp2(x,
|
|
result: &result)
|
|
|
|
vvexp2f(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.exp2(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionLog2") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.log2(x,
|
|
result: &result)
|
|
|
|
vvlog2f(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.log2(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionLog10") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.log10(x,
|
|
result: &result)
|
|
|
|
vvlog10f(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.log10(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionUnbiasedExponent") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.logb(x,
|
|
result: &result)
|
|
|
|
vvlogbf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.logb(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionPower") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.pow(bases: x,
|
|
exponents: y,
|
|
result: &result)
|
|
|
|
vvpowf(&legacyResult,
|
|
y,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.pow(bases: x,
|
|
exponents: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionPower") {
|
|
var scalarResult = [Float.nan]
|
|
let scalarBase = [Float(10)]
|
|
let scalarExponent = [Float(2)]
|
|
|
|
vForce.pow(bases: scalarBase,
|
|
exponents: scalarExponent,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 100)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionSine") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.sin(x,
|
|
result: &result)
|
|
|
|
vvsinf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sin(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionSinPi") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.sinPi(x,
|
|
result: &result)
|
|
|
|
vvsinpif(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sinPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionCosine") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.cos(x,
|
|
result: &result)
|
|
|
|
vvcosf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cos(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionCosPi") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.cosPi(x,
|
|
result: &result)
|
|
|
|
vvcospif(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cosPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionSinCos") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
var cosResult = [Float](repeating: .nan, count: result.count)
|
|
var legacyCosResult = [Float](repeating: .nan, count: result.count)
|
|
|
|
vForce.sincos(x,
|
|
sinResult: &result,
|
|
cosResult: &cosResult)
|
|
|
|
vvsincosf(&legacyResult,
|
|
&legacyCosResult,
|
|
x,
|
|
&n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(cosResult.elementsEqual(legacyCosResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionTangent") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.tan(x,
|
|
result: &result)
|
|
|
|
vvtanf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tan(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionTanPi") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.tanPi(x,
|
|
result: &result)
|
|
|
|
vvtanpif(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tanPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionArcsin") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.asin(z,
|
|
result: &result)
|
|
|
|
vvasinf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.asin(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionArccos") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.acos(z,
|
|
result: &result)
|
|
|
|
vvacosf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.acos(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionArctan") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.atan(z,
|
|
result: &result)
|
|
|
|
vvatanf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.atan(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionSinh") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.sinh(x,
|
|
result: &result)
|
|
|
|
vvsinhf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sinh(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionCosh") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.cosh(x,
|
|
result: &result)
|
|
|
|
vvcoshf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cosh(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionTanh") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.tanh(z,
|
|
result: &result)
|
|
|
|
vvtanhf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tanh(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionAsinh") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.asinh(z,
|
|
result: &result)
|
|
|
|
vvasinhf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.asinh(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionAcosh") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.acosh(x,
|
|
result: &result)
|
|
|
|
vvacoshf(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.acosh(x)
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/SinglePrecisionAtan") {
|
|
result = [Float](repeating: 0, count: count)
|
|
legacyResult = [Float](repeating: -1, count: count)
|
|
|
|
vForce.atanh(z,
|
|
result: &result)
|
|
|
|
vvatanhf(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.atanh(z)
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// vForce double precision tests
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
|
|
|
|
var result = [Double]()
|
|
var legacyResult = [Double]()
|
|
let x: [Double] = [2, 4, -6.876, 10.9, -100.3, 100]
|
|
let y: [Double] = [-10, -20, 40, 60, -80, -300]
|
|
let z: [Double] = [-0.6, 0.2, -0.1, 0.9, -0.1, 0.1]
|
|
let count = 6
|
|
var n: Int32 = 6
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionCeiling") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.ceil(x,
|
|
result: &result)
|
|
|
|
vvceil(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.ceil(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionFloor") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.floor(x,
|
|
result: &result)
|
|
|
|
vvfloor(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.floor(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionCopySign") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.copysign(magnitudes: x,
|
|
signs: y,
|
|
result: &result)
|
|
|
|
vvcopysign(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.copysign(magnitudes: x,
|
|
signs: y)
|
|
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionModulus") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.truncatingRemainder(dividends: x,
|
|
divisors: y,
|
|
result: &result)
|
|
|
|
vvfmod(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.truncatingRemainder(dividends: x,
|
|
divisors: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionModulusParameters") {
|
|
var scalarResult = [Double.nan]
|
|
let scalarNumerator = [Double(20)]
|
|
let scalarDenominator = [Double(6)]
|
|
|
|
vForce.truncatingRemainder(dividends: scalarNumerator,
|
|
divisors: scalarDenominator,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 2)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionRemainder") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.remainder(dividends: x,
|
|
divisors: y,
|
|
result: &result)
|
|
|
|
vvremainder(&legacyResult,
|
|
x,
|
|
y,
|
|
&n)
|
|
|
|
let returnedResult = vForce.remainder(dividends: x,
|
|
divisors: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionRemainderParameters") {
|
|
var scalarResult = [Double.nan]
|
|
let scalarNumerator = [Double(20)]
|
|
let scalarDenominator = [Double(6)]
|
|
|
|
vForce.remainder(dividends: scalarNumerator,
|
|
divisors: scalarDenominator,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 2)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionIntegerTruncation") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.trunc(x,
|
|
result: &result)
|
|
|
|
vvint(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.trunc(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionNearestInteger") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.nearestInteger(x,
|
|
result: &result)
|
|
|
|
vvnint(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.nearestInteger(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionrsqrt") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.rsqrt(x,
|
|
result: &result)
|
|
|
|
vvrsqrt(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.rsqrt(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionsqrt") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.sqrt(x,
|
|
result: &result)
|
|
|
|
vvsqrt(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sqrt(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionReciprocal") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.reciprocal(x,
|
|
result: &result)
|
|
|
|
vvrec(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.reciprocal(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionExp") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.exp(x,
|
|
result: &result)
|
|
|
|
vvexp(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.exp(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionExpm1") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.expm1(x,
|
|
result: &result)
|
|
|
|
vvexpm1(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.expm1(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionExp2") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.exp2(x,
|
|
result: &result)
|
|
|
|
vvexp2(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.exp2(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionLog2") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.log2(x,
|
|
result: &result)
|
|
|
|
vvlog2(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.log2(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionLog10") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.log10(x,
|
|
result: &result)
|
|
|
|
vvlog10(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.log10(x)
|
|
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionUnbiasedExponent") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.logb(x,
|
|
result: &result)
|
|
|
|
vvlogb(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.logb(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionPower") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.pow(bases: x,
|
|
exponents: y,
|
|
result: &result)
|
|
|
|
vvpow(&legacyResult,
|
|
y,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.pow(bases: x,
|
|
exponents: y)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionPower") {
|
|
var scalarResult = [Double.nan]
|
|
let scalarBase = [Double(10)]
|
|
let scalarExponent = [Double(2)]
|
|
|
|
vForce.pow(bases: scalarBase,
|
|
exponents: scalarExponent,
|
|
result: &scalarResult)
|
|
|
|
expectEqual(Int(scalarResult.first!), 100)
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionSine") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.sin(x,
|
|
result: &result)
|
|
|
|
vvsin(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sin(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionSinPi") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.sinPi(x,
|
|
result: &result)
|
|
|
|
vvsinpi(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sinPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionCosine") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.cos(x,
|
|
result: &result)
|
|
|
|
vvcos(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cos(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionCosPi") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.cosPi(x,
|
|
result: &result)
|
|
|
|
vvcospi(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cosPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionSinCos") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
var cosResult = [Double](repeating: .nan, count: result.count)
|
|
var legacyCosResult = [Double](repeating: .nan, count: result.count)
|
|
|
|
vForce.sincos(x,
|
|
sinResult: &result,
|
|
cosResult: &cosResult)
|
|
|
|
vvsincos(&legacyResult,
|
|
&legacyCosResult,
|
|
x,
|
|
&n)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(cosResult.elementsEqual(legacyCosResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionTangent") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.tan(x,
|
|
result: &result)
|
|
|
|
vvtan(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tan(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionTanPi") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.tanPi(x,
|
|
result: &result)
|
|
|
|
vvtanpi(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tanPi(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionArcsin") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.asin(z,
|
|
result: &result)
|
|
|
|
vvasin(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.asin(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionArccos") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.acos(z,
|
|
result: &result)
|
|
|
|
vvacos(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.acos(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionArctan") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.atan(z,
|
|
result: &result)
|
|
|
|
vvatan(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.atan(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionSinh") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.sinh(x,
|
|
result: &result)
|
|
|
|
vvsinh(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.sinh(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionCosh") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.cosh(x,
|
|
result: &result)
|
|
|
|
vvcosh(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.cosh(x)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionTanh") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.tanh(z,
|
|
result: &result)
|
|
|
|
vvtanh(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.tanh(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionAsinh") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.asinh(z,
|
|
result: &result)
|
|
|
|
vvasinh(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.asinh(z)
|
|
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionAcosh") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.acosh(x,
|
|
result: &result)
|
|
|
|
vvacosh(&legacyResult,
|
|
x,
|
|
&n)
|
|
|
|
let returnedResult = vForce.acosh(x)
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(legacyResult.filter{!$0.isNaN}))
|
|
expectTrue(result.filter{!$0.isNaN}.elementsEqual(returnedResult.filter{!$0.isNaN}))
|
|
}
|
|
|
|
Accelerate_vForceTests.test("vForce/DoublePrecisionAtan") {
|
|
result = [Double](repeating: 0, count: count)
|
|
legacyResult = [Double](repeating: -1, count: count)
|
|
|
|
vForce.atanh(z,
|
|
result: &result)
|
|
|
|
vvatanh(&legacyResult,
|
|
z,
|
|
&n)
|
|
|
|
let returnedResult = vForce.atanh(z)
|
|
expectTrue(result.elementsEqual(legacyResult))
|
|
expectTrue(result.elementsEqual(returnedResult))
|
|
}
|
|
}
|
|
|
|
runAllTests()
|