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

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

import StdlibUnittest
import Accelerate

var Accelerate_vDSPFourierTransformTests = TestSuite("Accelerate_vDSPFourierTransform")


//===----------------------------------------------------------------------===//
//
//  vDSP discrete Fourier transform tests; single-precision
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    let n = 2048
    let tau: Float = .pi * 2
    
    let frequencies: [Float] = [1, 5, 25, 30, 75, 100,
                                300, 500, 512, 1023]
    
    let inputReal: [Float] = (0 ..< n).map { index in
        frequencies.reduce(0) { accumulator, frequency in
            let normalizedIndex = Float(index) / Float(n)
            return accumulator + sin(normalizedIndex * frequency * tau)
        }
    }
    
    let inputImag: [Float] = (0 ..< n).map { index in
        frequencies.reduce(0) { accumulator, frequency in
            let normalizedIndex = Float(index) / Float(n)
            return accumulator + sin(normalizedIndex * 1/frequency * tau)
        }
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionForwardComplexComplex") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .forward,
                              transformType: .complexComplex,
                              ofType: Float.self)!
        
        var outputReal = [Float](repeating: 0, count: n)
        var outputImag = [Float](repeating: 0, count: n)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zop_CreateSetup(nil,
                                                   vDSP_Length(n),
                                                   .FORWARD)!
        
        var legacyOutputReal = [Float](repeating: -1, count: n)
        var legacyOutputImag = [Float](repeating: -1, count: n)
        
        vDSP_DFT_Execute(legacySetup,
                         inputReal,
                         inputImag,
                         &legacyOutputReal,
                         &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionInverseComplexComplex") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .inverse,
                              transformType: .complexComplex,
                              ofType: Float.self)!
        
        var outputReal = [Float](repeating: 0, count: n)
        var outputImag = [Float](repeating: 0, count: n)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zop_CreateSetup(nil,
                                                   vDSP_Length(n),
                                                   .INVERSE)!
        
        var legacyOutputReal = [Float](repeating: -1, count: n)
        var legacyOutputImag = [Float](repeating: -1, count: n)
        
        vDSP_DFT_Execute(legacySetup,
                         inputReal,
                         inputImag,
                         &legacyOutputReal,
                         &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionForwardComplexReal") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .forward,
                              transformType: .complexReal,
                              ofType: Float.self)!
        
        var outputReal = [Float](repeating: 0, count: n / 2)
        var outputImag = [Float](repeating: 0, count: n / 2)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zrop_CreateSetup(nil,
                                                    vDSP_Length(n),
                                                    .FORWARD)!
        
        var legacyOutputReal = [Float](repeating: -1, count: n / 2)
        var legacyOutputImag = [Float](repeating: -1, count: n / 2)
        
        vDSP_DFT_Execute(legacySetup,
                         inputReal,
                         inputImag,
                         &legacyOutputReal,
                         &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionInverseComplexReal") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .inverse,
                              transformType: .complexReal,
                              ofType: Float.self)!
        
        var outputReal = [Float](repeating: 0, count: n / 2)
        var outputImag = [Float](repeating: 0, count: n / 2)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zrop_CreateSetup(nil,
                                                    vDSP_Length(n),
                                                    .INVERSE)!
        
        var legacyOutputReal = [Float](repeating: -1, count: n / 2)
        var legacyOutputImag = [Float](repeating: -1, count: n / 2)
        
        vDSP_DFT_Execute(legacySetup,
                         inputReal,
                         inputImag,
                         &legacyOutputReal,
                         &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
}


//===----------------------------------------------------------------------===//
//
//  vDSP discrete Fourier transform tests; double-precision
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    let n = 2048
    let tau: Double = .pi * 2
    
    let frequencies: [Double] = [1, 5, 25, 30, 75, 100,
                                 300, 500, 512, 1023]
    
    let inputReal: [Double] = (0 ..< n).map { index in
        frequencies.reduce(0) { accumulator, frequency in
            let normalizedIndex = Double(index) / Double(n)
            return accumulator + sin(normalizedIndex * frequency * tau)
        }
    }
    
    let inputImag: [Double] = (0 ..< n).map { index in
        frequencies.reduce(0) { accumulator, frequency in
            let normalizedIndex = Double(index) / Double(n)
            return accumulator + sin(normalizedIndex * 1/frequency * tau)
        }
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionForwardComplexComplex") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .forward,
                              transformType: .complexComplex,
                              ofType: Double.self)!
        
        var outputReal = [Double](repeating: 0, count: n)
        var outputImag = [Double](repeating: 0, count: n)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zop_CreateSetupD(nil,
                                                    vDSP_Length(n),
                                                    .FORWARD)!
        
        var legacyOutputReal = [Double](repeating: -1, count: n)
        var legacyOutputImag = [Double](repeating: -1, count: n)
        
        vDSP_DFT_ExecuteD(legacySetup,
                          inputReal,
                          inputImag,
                          &legacyOutputReal,
                          &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionInverseComplexComplex") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .inverse,
                              transformType: .complexComplex,
                              ofType: Double.self)!
        
        var outputReal = [Double](repeating: 0, count: n)
        var outputImag = [Double](repeating: 0, count: n)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zop_CreateSetupD(nil,
                                                    vDSP_Length(n),
                                                    .INVERSE)!
        
        var legacyOutputReal = [Double](repeating: -1, count: n)
        var legacyOutputImag = [Double](repeating: -1, count: n)
        
        vDSP_DFT_ExecuteD(legacySetup,
                          inputReal,
                          inputImag,
                          &legacyOutputReal,
                          &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionForwardComplexReal") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .forward,
                              transformType: .complexReal,
                              ofType: Double.self)!
        
        var outputReal = [Double](repeating: 0, count: n / 2)
        var outputImag = [Double](repeating: 0, count: n / 2)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zrop_CreateSetupD(nil,
                                                     vDSP_Length(n),
                                                     .FORWARD)!
        
        var legacyOutputReal = [Double](repeating: -1, count: n / 2)
        var legacyOutputImag = [Double](repeating: -1, count: n / 2)
        
        vDSP_DFT_ExecuteD(legacySetup,
                          inputReal,
                          inputImag,
                          &legacyOutputReal,
                          &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionInverseComplexReal") {
        let fwdDFT = vDSP.DFT(count: n,
                              direction: .inverse,
                              transformType: .complexReal,
                              ofType: Double.self)!
        
        var outputReal = [Double](repeating: 0, count: n / 2)
        var outputImag = [Double](repeating: 0, count: n / 2)
        
        fwdDFT.transform(inputReal: inputReal,
                         inputImaginary: inputImag,
                         outputReal: &outputReal,
                         outputImaginary: &outputImag)
        
        // legacy...
        
        let legacySetup = vDSP_DFT_zrop_CreateSetupD(nil,
                                                     vDSP_Length(n),
                                                     .INVERSE)!
        
        var legacyOutputReal = [Double](repeating: -1, count: n / 2)
        var legacyOutputImag = [Double](repeating: -1, count: n / 2)
        
        vDSP_DFT_ExecuteD(legacySetup,
                          inputReal,
                          inputImag,
                          &legacyOutputReal,
                          &legacyOutputImag)
        
        expectTrue(outputReal.elementsEqual(legacyOutputReal))
        expectTrue(outputImag.elementsEqual(legacyOutputImag))
        
        let returnedResult = fwdDFT.transform(inputReal: inputReal,
                                              inputImaginary: inputImag)
        
        expectTrue(outputReal.elementsEqual(returnedResult.real))
        expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
    }
}

//===----------------------------------------------------------------------===//
//
//  vDSP Fast Fourier Transform Tests
//
//===----------------------------------------------------------------------===//

if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionComplexConversions") {
        func convert(splitComplexVector: DSPSplitComplex,
                     toInterleavedComplexVector interleavedComplexVector: inout [DSPComplex]) {
            
            withUnsafePointer(to: splitComplexVector) {
                vDSP_ztoc($0, 1,
                          &interleavedComplexVector, 2,
                          vDSP_Length(interleavedComplexVector.count))
            }
        }
        
        func convert(interleavedComplexVector: [DSPComplex],
                     toSplitComplexVector splitComplexVector: inout DSPSplitComplex) {
            
            vDSP_ctoz(interleavedComplexVector, 2,
                      &splitComplexVector, 1,
                      vDSP_Length(interleavedComplexVector.count))
        }
        
        var realSrc: [Float] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var imagSrc: [Float] = realSrc.reversed()
        
        let splitSrc = DSPSplitComplex(realp: &realSrc,
                                       imagp: &imagSrc)
        
        var interleavedDest = [DSPComplex](repeating: DSPComplex(),
                                           count:  realSrc.count)
        
        convert(splitComplexVector: splitSrc,
                toInterleavedComplexVector: &interleavedDest)
        
        var realDest = [Float](repeating: .nan, count: realSrc.count)
        var imagDest = [Float](repeating: .nan, count: realSrc.count)
        
        var splitDest = DSPSplitComplex(realp: &realDest,
                                        imagp: &imagDest)
        
        convert(interleavedComplexVector: interleavedDest,
                toSplitComplexVector: &splitDest)
        
        expectTrue(realSrc.elementsEqual(realDest))
        expectTrue(imagSrc.elementsEqual(imagDest))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionComplexConversions") {
        func convert(splitComplexVector: DSPDoubleSplitComplex,
                     toInterleavedComplexVector interleavedComplexVector: inout [DSPDoubleComplex]) {
            
            withUnsafePointer(to: splitComplexVector) {
                vDSP_ztocD($0, 1,
                           &interleavedComplexVector, 2,
                           vDSP_Length(interleavedComplexVector.count))
            }
        }
        
        func convert(interleavedComplexVector: [DSPDoubleComplex],
                     toSplitComplexVector splitComplexVector: inout DSPDoubleSplitComplex) {
            
            vDSP_ctozD(interleavedComplexVector, 2,
                       &splitComplexVector, 1,
                       vDSP_Length(interleavedComplexVector.count))
        }
        
        var realSrc: [Double] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var imagSrc: [Double] = realSrc.reversed()
        
        let splitSrc = DSPDoubleSplitComplex(realp: &realSrc,
                                             imagp: &imagSrc)
        
        var interleavedDest = [DSPDoubleComplex](repeating: DSPDoubleComplex(),
                                                 count:  realSrc.count)
        
        convert(splitComplexVector: splitSrc,
                toInterleavedComplexVector: &interleavedDest)
        
        var realDest = [Double](repeating: .nan, count: realSrc.count)
        var imagDest = [Double](repeating: .nan, count: realSrc.count)
        
        var splitDest = DSPDoubleSplitComplex(realp: &realDest,
                                              imagp: &imagDest)
        
        convert(interleavedComplexVector: interleavedDest,
                toSplitComplexVector: &splitDest)
        
        expectTrue(realSrc.elementsEqual(realDest))
        expectTrue(imagSrc.elementsEqual(imagDest))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/2DSinglePrecision") {
        let width = 256
        let height = 256
        let pixelCount = width * height
        let n = pixelCount / 2
        
        let pixels: [Float] = (0 ..< pixelCount).map { i in
            return abs(sin(Float(i) * 0.001 * 2))
        }
        
        var sourceImageReal = [Float](repeating: 0, count: n)
        var sourceImageImaginary = [Float](repeating: 0, count: n)
        
        var sourceImage = DSPSplitComplex(fromInputArray: pixels,
                                          realParts: &sourceImageReal,
                                          imaginaryParts: &sourceImageImaginary)
        
        let pixelsRecreated = [Float](fromSplitComplex: sourceImage,
                                      scale: 1, count: pixelCount)
        
        expectTrue(pixelsRecreated.elementsEqual(pixels))
        
        // Create FFT2D object
        let fft2D = vDSP.FFT2D(width: 256,
                               height: 256,
                               ofType: DSPSplitComplex.self)!
        
        // New style transform
        var transformedImageReal = [Float](repeating: 0,
                                           count: n)
        var transformedImageImaginary = [Float](repeating: 0,
                                                count: n)
        var transformedImage = DSPSplitComplex(
            realp: &transformedImageReal,
            imagp: &transformedImageImaginary)
        
        fft2D.transform(input: sourceImage,
                        output: &transformedImage,
                        direction: .forward)
        
        // Legacy 2D FFT
        
        let log2n = vDSP_Length(log2(Float(width * height)))
        let legacySetup = vDSP_create_fftsetup(
            log2n,
            FFTRadix(kFFTRadix2))!
        
        var legacyTransformedImageReal = [Float](repeating: -1,
                                                 count: n)
        var legacyTransformedImageImaginary = [Float](repeating: -1,
                                                      count: n)
        var legacyTransformedImage = DSPSplitComplex(
            realp: &legacyTransformedImageReal,
            imagp: &legacyTransformedImageImaginary)
        
        vDSP_fft2d_zrop(legacySetup,
                        &sourceImage, 1, 0,
                        &legacyTransformedImage, 1, 0,
                        vDSP_Length(log2(Float(width))),
                        vDSP_Length(log2(Float(height))),
                        FFTDirection(kFFTDirection_Forward))
        
        expectTrue(transformedImageReal.elementsEqual(legacyTransformedImageReal))
        expectTrue(transformedImageImaginary.elementsEqual(legacyTransformedImageImaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/2DDoublePrecision") {
        let width = 256
        let height = 256
        let pixelCount = width * height
        let n = pixelCount / 2
        
        let pixels: [Double] = (0 ..< pixelCount).map { i in
            return abs(sin(Double(i) * 0.001 * 2))
        }
        
        var sourceImageReal = [Double](repeating: 0, count: n)
        var sourceImageImaginary = [Double](repeating: 0, count: n)
        
        var sourceImage = DSPDoubleSplitComplex(fromInputArray: pixels,
                                                realParts: &sourceImageReal,
                                                imaginaryParts: &sourceImageImaginary)
        
        let pixelsRecreated = [Double](fromSplitComplex: sourceImage,
                                       scale: 1, count: pixelCount)
        expectTrue(pixelsRecreated.elementsEqual(pixels))
        
        // Create FFT2D object
        let fft2D = vDSP.FFT2D(width: width,
                               height: height,
                               ofType: DSPDoubleSplitComplex.self)!
        
        // New style transform
        var transformedImageReal = [Double](repeating: 0,
                                            count: n)
        var transformedImageImaginary = [Double](repeating: 0,
                                                 count: n)
        var transformedImage = DSPDoubleSplitComplex(
            realp: &transformedImageReal,
            imagp: &transformedImageImaginary)
        
        fft2D.transform(input: sourceImage,
                        output: &transformedImage,
                        direction: .forward)
        
        // Legacy 2D FFT
        
        let log2n = vDSP_Length(log2(Float(width * height)))
        let legacySetup = vDSP_create_fftsetupD(
            log2n,
            FFTRadix(kFFTRadix2))!
        
        var legacyTransformedImageReal = [Double](repeating: -1,
                                                  count: n)
        var legacyTransformedImageImaginary = [Double](repeating: -1,
                                                       count: n)
        var legacyTransformedImage = DSPDoubleSplitComplex(
            realp: &legacyTransformedImageReal,
            imagp: &legacyTransformedImageImaginary)
        
        vDSP_fft2d_zropD(legacySetup,
                         &sourceImage, 1, 0,
                         &legacyTransformedImage, 1, 0,
                         vDSP_Length(log2(Float(width))),
                         vDSP_Length(log2(Float(height))),
                         FFTDirection(kFFTDirection_Forward))
        
        expectTrue(transformedImageReal.elementsEqual(legacyTransformedImageReal))
        expectTrue(transformedImageImaginary.elementsEqual(legacyTransformedImageImaginary))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/1DSinglePrecision") {
        let n = vDSP_Length(2048)
        
        let frequencies: [Float] = [1, 5, 25, 30, 75, 100,
                                    300, 500, 512, 1023]
        
        let tau: Float = .pi * 2
        let signal: [Float] = (0 ... n).map { index in
            frequencies.reduce(0) { accumulator, frequency in
                let normalizedIndex = Float(index) / Float(n)
                return accumulator + sin(normalizedIndex * frequency * tau)
            }
        }
        
        let halfN = Int(n / 2)
        
        var forwardInputReal = [Float](repeating: 0, count: halfN)
        var forwardInputImag = [Float](repeating: 0, count: halfN)
        
        var forwardInput = DSPSplitComplex(fromInputArray: signal,
                                           realParts: &forwardInputReal,
                                           imaginaryParts: &forwardInputImag)
        
        let log2n = vDSP_Length(log2(Float(n)))
        
        // New API
        
        guard let fft = vDSP.FFT(log2n: log2n,
                                 radix: .radix2,
                                 ofType: DSPSplitComplex.self) else {
                                    fatalError("Can't create FFT.")
        }
        
        var outputReal = [Float](repeating: 0, count: halfN)
        var outputImag = [Float](repeating: 0, count: halfN)
        var forwardOutput = DSPSplitComplex(realp: &outputReal,
                                            imagp: &outputImag)
        
        fft.transform(input: forwardInput,
                      output: &forwardOutput,
                      direction: .forward)
        
        // Legacy Style
        
        let legacySetup = vDSP_create_fftsetup(log2n,
                                               FFTRadix(kFFTRadix2))!
        
        var legacyoutputReal = [Float](repeating: -1, count: halfN)
        var legacyoutputImag = [Float](repeating: -1, count: halfN)
        var legacyForwardOutput = DSPSplitComplex(realp: &legacyoutputReal,
                                                  imagp: &legacyoutputImag)
        
        
        vDSP_fft_zrop(legacySetup,
                      &forwardInput, 1,
                      &legacyForwardOutput, 1,
                      log2n,
                      FFTDirection(kFFTDirection_Forward))
        
        expectTrue(outputReal.elementsEqual(legacyoutputReal))
        expectTrue(outputImag.elementsEqual(legacyoutputImag))
    }
    
    Accelerate_vDSPFourierTransformTests.test("vDSP/1DDoublePrecision") {
        let n = vDSP_Length(2048)
        
        let frequencies: [Double] = [1, 5, 25, 30, 75, 100,
                                     300, 500, 512, 1023]
        
        let tau: Double = .pi * 2
        let signal: [Double] = (0 ... n).map { index in
            frequencies.reduce(0) { accumulator, frequency in
                let normalizedIndex = Double(index) / Double(n)
                return accumulator + sin(normalizedIndex * frequency * tau)
            }
        }
        
        let halfN = Int(n / 2)
        
        var forwardInputReal = [Double](repeating: 0, count: halfN)
        var forwardInputImag = [Double](repeating: 0, count: halfN)
        
        var forwardInput = DSPDoubleSplitComplex(fromInputArray: signal,
                                                 realParts: &forwardInputReal,
                                                 imaginaryParts: &forwardInputImag)
        
        let log2n = vDSP_Length(log2(Double(n)))
        
        // New API
        
        guard let fft = vDSP.FFT(log2n: log2n,
                                 radix: .radix2,
                                 ofType: DSPDoubleSplitComplex.self) else {
                                    fatalError("Can't create FFT.")
        }
        
        var outputReal = [Double](repeating: 0, count: halfN)
        var outputImag = [Double](repeating: 0, count: halfN)
        var forwardOutput = DSPDoubleSplitComplex(realp: &outputReal,
                                                  imagp: &outputImag)
        
        fft.transform(input: forwardInput,
                      output: &forwardOutput,
                      direction: .forward)
        
        // Legacy Style
        
        let legacySetup = vDSP_create_fftsetupD(log2n,
                                                FFTRadix(kFFTRadix2))!
        
        var legacyoutputReal = [Double](repeating: 0, count: halfN)
        var legacyoutputImag = [Double](repeating: 0, count: halfN)
        var legacyForwardOutput = DSPDoubleSplitComplex(realp: &legacyoutputReal,
                                                        imagp: &legacyoutputImag)
        
        
        vDSP_fft_zropD(legacySetup,
                       &forwardInput, 1,
                       &legacyForwardOutput, 1,
                       log2n,
                       FFTDirection(kFFTDirection_Forward))
        
        expectTrue(outputReal.elementsEqual(legacyoutputReal))
        expectTrue(outputImag.elementsEqual(legacyoutputImag))
    }
}

runAllTests()