Function

vDSP_fftm_zip(_:_:_:_:_:_:_:)

Performs the same operation as vDSP_fft_zip(_:_:_:_:_:), but on multiple signals with a single call.

Declaration

func vDSP_fftm_zip(_ __Setup: FFTSetup, _ __C: UnsafePointer<DSPSplitComplex>, _ __IC: vDSP_Stride, _ __IM: vDSP_Stride, _ __Log2N: vDSP_Length, _ __M: vDSP_Length, _ __Direction: FFTDirection)

Parameters

__Setup

Points to a structure initialized by a prior call to the FFT setup data function, vDSP_create_fftsetup. The value supplied as parameter Log2n of the earlier call to the setup function must equal or exceed the value supplied as parameter Log2N of this transform function.

__C

Complex input/output vector where multiple signals are concatenated.

__IC

Stride between elements in C. The value of IC should be 1 for best performance.

__IM

The number of elements between the first element of one input signal and the first element of the next (which is also the length of each input signal, measured in elements).

__Log2N

The base 2 exponent of the number of elements to process in a single input signal. For example, to process 512 elements, specify 9 for parameter Log2N.

__M

The number of signals.

__Direction

A forward/inverse directional flag, which must specify kFFTDirection_Forward (+1) or kFFTDirection_Inverse (-1).

Discussion

This function performs discrete Fourier transforms on multiple input signals using a single call. This function works for input signals of 4 points or greater. Each of the input signals processed by a given call must have the same length and address stride.

This function computes the in-place complex discrete Fourier transforms of the input signals, either from the time domain to the frequency domain (forward) or from the frequency domain to the time domain (inverse).

This function performs the following operation:g

N = 1 << Log2N;
 
scale = 0 < Direction ? 1 : 1./N;
 
// Repeat M times:
for (m = 0; m < M; ++m)
{
    // Define a complex vector, h:
    for (j = 0; j < N; ++j) {
        h[j] = C->realp[m*IM + j*IC] + i * C->imagp[m*IM + j*IC];
 
        // Perform discrete Fourier transform
        for (k = 0; k < N; ++k) {
            H[k] = scale * sum(h[j] *
                     e**(-Direction*2*pi*i*j*k/N), 0 <= j < N);
 
            // Store result
        }
    }
    for (k = 0; k < N; ++k)
    {
           C->realp[m*IM + k*IC] = Re(H[k]);
           C->imagp[m*IM + k*IC] = Im(H[k]);
    }
}

See also functions vDSP_create_fftsetup, vDSP_destroy_fftsetup, and vDSP Programming Guide.

See Also

1D Fast Fourier Transforms (In-Place Complex)

func vDSP_fft_zip(FFTSetup, UnsafePointer<DSPSplitComplex>, vDSP_Stride, vDSP_Length, FFTDirection)

Computes an in-place single-precision complex discrete Fourier transform of the input/output vector signal, either from the time domain to the frequency domain (forward) or from the frequency domain to the time domain (inverse). Does not use temporary memory.

func vDSP_fft_zipD(FFTSetupD, UnsafePointer<DSPDoubleSplitComplex>, vDSP_Stride, vDSP_Length, FFTDirection)

Computes an in-place double-precision complex discrete Fourier transform of the input/output vector signal, either from the time domain to the frequency domain (forward) or from the frequency domain to the time domain (inverse). Does not use temporary memory.

func vDSP_fft_zipt(FFTSetup, UnsafePointer<DSPSplitComplex>, vDSP_Stride, UnsafePointer<DSPSplitComplex>, vDSP_Length, FFTDirection)

Performs the same operation as the vDSP_fft_zip(_:_:_:_:_:) function but uses a temporary buffer to hold intermediate results for improved performance. Computes an in-place single-precision complex discrete Fourier transform of the input/output vector signal, either from the time domain to the frequency domain (forward) or from the frequency domain to the time domain (inverse).

func vDSP_fft_ziptD(FFTSetupD, UnsafePointer<DSPDoubleSplitComplex>, vDSP_Stride, UnsafePointer<DSPDoubleSplitComplex>, vDSP_Length, FFTDirection)

Performs the same operation as the vDSP_fft_zipD(_:_:_:_:_:) function but uses A temporary buffer for improved performance. Computes an in-place double-precision complex discrete Fourier transform of the input/output vector signal, either from the time domain to the frequency domain (forward) or from the frequency domain to the time domain (inverse).

func vDSP_fftm_ziptD(FFTSetupD, UnsafePointer<DSPDoubleSplitComplex>, vDSP_Stride, vDSP_Stride, UnsafePointer<DSPDoubleSplitComplex>, vDSP_Length, vDSP_Length, FFTDirection)

Performs the same operation as vDSP_fft_ziptD(_:_:_:_:_:_:), but on multiple signals with a single call. Performs the same operation as the vDSP_fftm_zipD(_:_:_:_:_:_:_:) function but uses a temporary buffer for improved performance.

Beta Software

This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software.

Learn more about using Apple's beta software