Function

vDSP_fft_zipt

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

Declaration

void vDSP_fft_zipt(FFTSetup __Setup, const DSPSplitComplex *__C, vDSP_Stride __IC, const DSPSplitComplex *__Buffer, vDSP_Length __Log2N, FFTDirection __Direction);

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

A complex input/output vector.

__IC

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

__Buffer

A temporary vector used for storing interim results. The minimum size of temporary memory for each part (real and imaginary) is the lesser of the size of N elements or 16,384 bytes. For best performance, the buffer addresses should be 16-byte aligned or better.

__Log2N

The base 2 exponent of the number of elements to process. For example, to process 1024 elements, specify 10 for parameter Log2N.

__Direction

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

Discussion

This performs the following operation:

This performs the following operation:

        N = 1 << Log2N;
 
        scale = 0 < Direction ? 1 : 1./N;
 
        // Define a complex vector, h:
        for (j = 0; j < N; ++j)
            h[j] = C->realp[j*IC] + i * C->imagp[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[k*IC] = Re(H[k]);
            C->imagp[k*IC] = Im(H[k]);
        }

See also functions vDSP_create_fftsetup and vDSP_destroy_fftsetup.

See Also

1D Fast Fourier Transforms (In-Place Complex)

vDSP_fft_zip

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.

vDSP_fft_zipD

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.

vDSP_fft_ziptD

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

vDSP_fftm_zip

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

vDSP_fftm_zipD

Performs the same operation as vDSP_fft_zipD, but on multiple signals with a single call.

vDSP_fftm_zipt

Performs the same operation as vDSP_fft_zipt, but on multiple signals with a single call.

vDSP_fftm_ziptD

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.