Accelerate_vForce.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()