// RUN: %target-run-simple-swift
// REQUIRES: executable_test

// REQUIRES: rdar50301438
// REQUIRES: objc_interop
// UNSUPPORTED: OS=watchos

import StdlibUnittest
import Accelerate

var AccelerateTests_vDSPConversion = TestSuite("Accelerate_vDSPConversion")

//===----------------------------------------------------------------------===//
//
//  vDSP polar / rectangular conversion
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    AccelerateTests_vDSPConversion.test("vDSP/SinglePrecisionRectToPolar") {
        let source: [Float] = [2, 4,
                               -10, -20,
                               100, -300]
        
        let n = vDSP_Length(source.count)
        
        var result = [Float](repeating: 0,
                             count: source.count)
        
        vDSP.convert(rectangularCoordinates: source,
                     toPolarCoordinates: &result)
        
        var legacyResult = [Float](repeating: -1,
                                   count: source.count)
        
        vDSP_polar(source, 2,
                   &legacyResult, 2,
                   n / 2)
        
        let returnedResult = vDSP.rectangularToPolar(source)
        
        expectTrue(returnedResult.elementsEqual(legacyResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/SinglePrecisionPolarToRect") {
        let source: [Float] = [2, 4,
                               -10, -20,
                               100, -300]
        
        let n = vDSP_Length(source.count)
        
        var result = [Float](repeating: 0,
                             count: source.count)
        
        vDSP.convert(polarCoordinates: source,
                     toRectangularCoordinates: &result)
        
        var legacyResult = [Float](repeating: -1,
                                   count: source.count)
        
        vDSP_rect(source, 2,
                  &legacyResult, 2,
                  n / 2)
        
        let returnedResult = vDSP.polarToRectangular(source)
        
        expectTrue(returnedResult.elementsEqual(legacyResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoublePrecisionRectToPolar") {
        let source: [Double] = [2, 4,
                                -10, -20,
                                100, -300]
        
        let n = vDSP_Length(source.count)
        
        var result = [Double](repeating: 0,
                              count: source.count)
        
        vDSP.convert(rectangularCoordinates: source,
                     toPolarCoordinates: &result)
        
        var legacyResult = [Double](repeating: -1,
                                    count: source.count)
        
        vDSP_polarD(source, 2,
                    &legacyResult, 2,
                    n / 2)
        
        let returnedResult = vDSP.rectangularToPolar(source)
        
        expectTrue(returnedResult.elementsEqual(legacyResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoublePrecisionRectToPolar") {
        let source: [Double] = [2, 4,
                                -10, -20,
                                100, -300]
        
        let n = vDSP_Length(source.count)
        
        var result = [Double](repeating: 0,
                              count: source.count)
        
        vDSP.convert(polarCoordinates: source,
                     toRectangularCoordinates: &result)
        
        var legacyResult = [Double](repeating: -1,
                                    count: source.count)
        
        vDSP_rectD(source, 2,
                   &legacyResult, 2,
                   n / 2)
        
        let returnedResult = vDSP.polarToRectangular(source)
        
        expectTrue(returnedResult.elementsEqual(legacyResult))
    }
}

//===----------------------------------------------------------------------===//
//
//  vDSP type-conversion tests
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    let n = vDSP_Length(10)
    
    let floatingPointValues: [Float] = [-10.9, -20.1, 32.99, 14.001, -16.5,
                                        90.5, 0, -0, -0.00001, 0.000001]
    
    let floatingPointValuesD: [Double] = [-10.9, -20.1, 32.99, 14.001, -16.5,
                                          90.5, 0, -0, -0.00001, 0.000001]
    
    let unsignedIntValues = [5, 250, 0, 99, 127, 65, 78, 1, 33, 10]
    let signedIntValues = [5, -126, 0, -99, 125, -65, 78, -1, 33, -10]
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToDouble") {
        let source = floatingPointValues
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vspdp(source, 1,
                   &legacyResult, 1,
                   n)
        
        let returnedResult = vDSP.floatToDouble(source)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToFloat") {
        let source = floatingPointValuesD
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vdpsp(source, 1,
                   &legacyResult, 1,
                   n)
        
        let returnedResult = vDSP.doubleToFloat(source)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/UInt8_to_Float") {
        let source = unsignedIntValues.map{ return UInt8($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu8(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/UInt8_to_Double") {
        let source = unsignedIntValues.map{ return UInt8($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu8D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)

        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/UInt16_to_Float") {
        let source = unsignedIntValues.map{ return UInt16($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu16(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/UInt16_to_Double") {
        let source = unsignedIntValues.map{ return UInt16($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu16D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)

        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }

    AccelerateTests_vDSPConversion.test("vDSP/UInt32_to_Float") {
        let source = unsignedIntValues.map{ return UInt32($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu32(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/UInt32_to_Double") {
        let source = unsignedIntValues.map{ return UInt32($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vfltu32D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)

        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int8_to_Float") {
        let source = signedIntValues.map{ return Int8($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt8(source, 1,
                   &legacyResult, 1,
                   n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int8_to_Double") {
        let source = signedIntValues.map{ return Int8($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt8D(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int16_to_Float") {
        let source = signedIntValues.map{ return Int16($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt16(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int16_to_Double") {
        let source = signedIntValues.map{ return Int16($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt16D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int32_to_Float") {
        let source = signedIntValues.map{ return Int32($0) }
        var result = [Float](repeating: 0, count: source.count)
        var legacyResult = [Float](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt32(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Float.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/Int32_to_Double") {
        let source = signedIntValues.map{ return Int32($0) }
        var result = [Double](repeating: 0, count: source.count)
        var legacyResult = [Double](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result)
        
        vDSP_vflt32D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.integerToFloatingPoint(source,
                                                         floatingPointType: Double.self)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt32towardZero") {
        let source = floatingPointValues
        var result = [Int32](repeating: 0, count: source.count)
        var legacyResult = [Int32](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix32(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int32.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt32towardNearest") {
        let source = floatingPointValues
        var result = [Int32](repeating: 0, count: source.count)
        var legacyResult = [Int32](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr32(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int32.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt32towardZero") {
        let source = floatingPointValuesD
        var result = [Int32](repeating: 0, count: source.count)
        var legacyResult = [Int32](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix32D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int32.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt32towardNearest") {
        let source = floatingPointValuesD
        var result = [Int32](repeating: 0, count: source.count)
        var legacyResult = [Int32](repeating: -1, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr32D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int32.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt16towardZero") {
        let source = floatingPointValues
        var result = [UInt16](repeating: 0, count: source.count)
        var legacyResult = [UInt16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu16(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt16.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt16towardNearest") {
        let source = floatingPointValues
        var result = [UInt16](repeating: 0, count: source.count)
        var legacyResult = [UInt16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru16(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt16.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt16towardZero") {
        let source = floatingPointValuesD
        var result = [UInt16](repeating: 0, count: source.count)
        var legacyResult = [UInt16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu16D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt16.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt16towardNearest") {
        let source = floatingPointValuesD
        var result = [UInt16](repeating: 0, count: source.count)
        var legacyResult = [UInt16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru16D(source, 1,
                       &legacyResult, 1,
                       n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt16.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt32towardZero") {
        let source = floatingPointValues
        var result = [UInt32](repeating: 0, count: source.count)
        var legacyResult = [UInt32](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu32(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt32.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt32towardNearest") {
        let source = floatingPointValues
        var result = [UInt32](repeating: 0, count: source.count)
        var legacyResult = [UInt32](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru32(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt32.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt32towardZero") {
        let source = floatingPointValuesD
        var result = [UInt32](repeating: 0, count: source.count)
        var legacyResult = [UInt32](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu32D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt32.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt32towardNearest") {
        let source = floatingPointValuesD
        var result = [UInt32](repeating: 0, count: source.count)
        var legacyResult = [UInt32](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru32D(source, 1,
                       &legacyResult, 1,
                       n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt32.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt16towardZero") {
        let source = floatingPointValues
        var result = [Int16](repeating: 0, count: source.count)
        var legacyResult = [Int16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix16(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int16.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt16towardNearest") {
        let source = floatingPointValues
        var result = [Int16](repeating: 0, count: source.count)
        var legacyResult = [Int16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr16(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int16.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt16towardZero") {
        let source = floatingPointValuesD
        var result = [Int16](repeating: 0, count: source.count)
        var legacyResult = [Int16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix16D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int16.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt16towardNearest") {
        let source = floatingPointValuesD
        var result = [Int16](repeating: 0, count: source.count)
        var legacyResult = [Int16](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr16D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int16.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt8towardZero") {
        let source = floatingPointValues
        var result = [Int8](repeating: 0, count: source.count)
        var legacyResult = [Int8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix8(source, 1,
                   &legacyResult, 1,
                   n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int8.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToInt8towardNearest") {
        let source = floatingPointValues
        var result = [Int8](repeating: 0, count: source.count)
        var legacyResult = [Int8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr8(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int8.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt8towardZero") {
        let source = floatingPointValuesD
        var result = [Int8](repeating: 0, count: source.count)
        var legacyResult = [Int8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfix8D(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int8.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToInt8towardNearest") {
        let source = floatingPointValuesD
        var result = [Int8](repeating: 0, count: source.count)
        var legacyResult = [Int8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixr8D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: Int8.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt8towardZero") {
        let source = floatingPointValues
        var result = [UInt8](repeating: 0, count: source.count)
        var legacyResult = [UInt8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu8(source, 1,
                    &legacyResult, 1,
                    n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt8.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/FloatToUInt8towardNearest") {
        let source = floatingPointValues
        var result = [UInt8](repeating: 0, count: source.count)
        var legacyResult = [UInt8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru8(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt8.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubleToUInt8towardZero") {
        let source = floatingPointValuesD
        var result = [UInt8](repeating: 0, count: source.count)
        var legacyResult = [UInt8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardZero)
        
        vDSP_vfixu8D(source, 1,
                     &legacyResult, 1,
                     n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt8.self,
                                                         rounding: .towardZero)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/DoubletoUInt8towardNearest") {
        let source = floatingPointValuesD
        var result = [UInt8](repeating: 0, count: source.count)
        var legacyResult = [UInt8](repeating: 99, count: source.count)
        
        vDSP.convertElements(of: source, to: &result, rounding: .towardNearestInteger)
        
        vDSP_vfixru8D(source, 1,
                      &legacyResult, 1,
                      n)
        
        let returnedResult = vDSP.floatingPointToInteger(source,
                                                         integerType: UInt8.self,
                                                         rounding: .towardNearestInteger)
        
        expectTrue(result.elementsEqual(legacyResult))
        expectTrue(result.elementsEqual(returnedResult))
    }
}

//===----------------------------------------------------------------------===//
//
//  vDSP decibel conversion
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    AccelerateTests_vDSPConversion.test("vDSP/PowerToDecibelsSinglePrecision") {
        let source: [Float] = [1, 10, 100, 2, 4, 8, 16, 101,
                               27, 13, 11, 44, 0.5, 99, 0.125]
        let zeroReference = Float(7)
        let n = source.count
        
        var result = [Float](repeating: 0,
                             count: n)
        
        vDSP.convert(power: source,
                     toDecibels: &result,
                     zeroReference: zeroReference)
        
        var legacyResult = [Float](repeating: -1,
                                   count: n)
        
        vDSP_vdbcon(source, 1,
                    [zeroReference],
                    &legacyResult, 1,
                    vDSP_Length(n),
                    0)
        
        let returnedResult = vDSP.powerToDecibels(source,
                                                  zeroReference: zeroReference)
    }

    AccelerateTests_vDSPConversion.test("vDSP/AmplitudeToDecibelsSinglePrecision") {
        let source: [Float] = [1, 10, 100, 2, 4, 8, 16, 101,
                               27, 13, 11, 44, 0.5, 99, 0.125]
        let zeroReference = Float(7)
        let n = source.count
        
        var result = [Float](repeating: 0,
                             count: n)
        
        vDSP.convert(amplitude: source,
                     toDecibels: &result,
                     zeroReference: zeroReference)
        
        var legacyResult = [Float](repeating: -1,
                                   count: n)
        
        vDSP_vdbcon(source, 1,
                    [zeroReference],
                    &legacyResult, 1,
                    vDSP_Length(n),
                    1)
        
        let returnedResult = vDSP.amplitudeToDecibels(source,
                                                      zeroReference: zeroReference)
    }

    AccelerateTests_vDSPConversion.test("vDSP/PowerToDecibelsDoublePrecision") {
        let source: [Double] = [1, 10, 100, 2, 4, 8, 16, 101,
                                27, 13, 11, 44, 0.5, 99, 0.125]
        let zeroReference = Double(7)
        let n = source.count
        
        var result = [Double](repeating: 0,
                              count: n)
        
        vDSP.convert(power: source,
                     toDecibels: &result,
                     zeroReference: zeroReference)
        
        var legacyResult = [Double](repeating: -1,
                                    count: n)
        
        vDSP_vdbconD(source, 1,
                     [zeroReference],
                     &legacyResult, 1,
                     vDSP_Length(n),
                     0)
        
        let returnedResult = vDSP.powerToDecibels(source,
                                                  zeroReference: zeroReference)
    }

    AccelerateTests_vDSPConversion.test("vDSP/AmplitudeToDecibelsDoublePrecision") {
        let source: [Double] = [1, 10, 100, 2, 4, 8, 16, 101,
                                27, 13, 11, 44, 0.5, 99, 0.125]
        let zeroReference = Double(7)
        let n = source.count
        
        var result = [Double](repeating: 0,
                              count: n)
        
        vDSP.convert(amplitude: source,
                     toDecibels: &result,
                     zeroReference: zeroReference)
        
        var legacyResult = [Double](repeating: -1,
                                    count: n)
        
        vDSP_vdbconD(source, 1,
                     [zeroReference],
                     &legacyResult, 1,
                     vDSP_Length(n),
                     1)
        
        let returnedResult = vDSP.amplitudeToDecibels(source,
                                                      zeroReference: zeroReference)
    }
}

//===----------------------------------------------------------------------===//
//
//  vDSP complex format conversion
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    AccelerateTests_vDSPConversion.test("vDSP/ComplexFormatConversionSinglePrecision") {
        var real: [Float] = [4, 5, 6]
        var imag: [Float] = [1, 2, 3]
        let src = DSPSplitComplex(realp: &real,
                                  imagp: &imag)
        
        var dest = [DSPComplex](repeating: DSPComplex(),
                                count: 3)
        
        vDSP.convert(splitComplexVector: src,
                     toInterleavedComplexVector: &dest)
        
        var realResult: [Float] = [0, 0, 0]
        var imagResult: [Float] = [0, 0, 0]
        var result = DSPSplitComplex(realp: &realResult,
                                     imagp: &imagResult)
        
        vDSP.convert(interleavedComplexVector: dest,
                     toSplitComplexVector: &result)
        
        expectTrue(real.elementsEqual(realResult))
        expectTrue(imag.elementsEqual(imagResult))
    }
    
    AccelerateTests_vDSPConversion.test("vDSP/ComplexFormatConversionDoublePrecision") {
        var real: [Double] = [4, 5, 6]
        var imag: [Double] = [1, 2, 3]
        let src = DSPDoubleSplitComplex(realp: &real,
                                        imagp: &imag)
        
        var dest = [DSPDoubleComplex](repeating: DSPDoubleComplex(),
                                      count: 3)
        
        vDSP.convert(splitComplexVector: src,
                     toInterleavedComplexVector: &dest)
        
        var realResult: [Double] = [0, 0, 0]
        var imagResult: [Double] = [0, 0, 0]
        var result = DSPDoubleSplitComplex(realp: &realResult,
                                           imagp: &imagResult)
        
        vDSP.convert(interleavedComplexVector: dest,
                     toSplitComplexVector: &result)
        
        expectTrue(real.elementsEqual(realResult))
        expectTrue(imag.elementsEqual(imagResult))
    }
}

runAllTests()