This section describes mixed-radix FFT algorithms for real data. The mixed-radix functions work for FFTs of any length. They are a reimplementation of the real-FFT routines in the Fortran FFTPACK library by Paul Swarztrauber. The theory behind the algorithm is explained in the article Fast Mixed-Radix Real Fourier Transforms by Clive Temperton. The routines here use the same indexing scheme and basic algorithms as FFTPACK.

The functions use the FFTPACK storage convention for half-complex sequences. In this convention the half-complex transform of a real sequence is stored with frequencies in increasing order, starting at zero, with the real and imaginary parts of each frequency in neighboring locations. When a value is known to be real the imaginary part is not stored. The imaginary part of the zero-frequency component is never stored. It is known to be zero (since the zero frequency component is simply the sum of the input data (all real)). For a sequence of even length the imaginary part of the frequency @math{n/2} is not stored either, since the symmetry @math{z_k = z_{N-k}^*} implies that this is purely real too.

The storage scheme is best shown by some examples. The table below
shows the output for an odd-length sequence, @math{n=5}. The two columns
give the correspondence between the 5 values in the half-complex
sequence returned by `gsl_fft_real_transform`

, `halfcomplex`[] and the
values `complex`[] that would be returned if the same real input
sequence were passed to `gsl_fft_complex_backward`

as a complex
sequence (with imaginary parts set to `0`

),

complex[0].real = halfcomplex[0] complex[0].imag = 0 complex[1].real = halfcomplex[1] complex[1].imag = halfcomplex[2] complex[2].real = halfcomplex[3] complex[2].imag = halfcomplex[4] complex[3].real = halfcomplex[3] complex[3].imag = -halfcomplex[4] complex[4].real = halfcomplex[1] complex[4].imag = -halfcomplex[2]

The upper elements of the `complex` array, `complex[3]`

and
`complex[4]`

are filled in using the symmetry condition. The
imaginary part of the zero-frequency term `complex[0].imag`

is
known to be zero by the symmetry.

The next table shows the output for an even-length sequence, @math{n=5} In the even case both the there are two values which are purely real,

complex[0].real = halfcomplex[0] complex[0].imag = 0 complex[1].real = halfcomplex[1] complex[1].imag = halfcomplex[2] complex[2].real = halfcomplex[3] complex[2].imag = halfcomplex[4] complex[3].real = halfcomplex[5] complex[3].imag = 0 complex[4].real = halfcomplex[3] complex[4].imag = -halfcomplex[4] complex[5].real = halfcomplex[1] complex[5].imag = -halfcomplex[2]

The upper elements of the `complex` array, `complex[4]`

and
`complex[5]`

are filled in using the symmetry condition. Both
`complex[0].imag`

and `complex[3].imag`

are known to be zero.

All these functions are declared in the header files
``gsl_fft_real.h'` and ``gsl_fft_halfcomplex.h'`.

__Function:__gsl_fft_real_wavetable ***gsl_fft_real_wavetable_alloc***(size_t*`n`)__Function:__gsl_fft_halfcomplex_wavetable ***gsl_fft_halfcomplex_wavetable_alloc***(size_t*`n`)-
These functions prepare trigonometric lookup tables for an FFT of size
@math{n} real elements. The functions return a pointer to the newly
allocated struct if no errors were detected, and a null pointer in the
case of error. The length
`n`is factorized into a product of subtransforms, and the factors and their trigonometric coefficients are stored in the wavetable. The trigonometric coefficients are computed using direct calls to`sin`

and`cos`

, for accuracy. Recursion relations could be used to compute the lookup table faster, but if an application performs many FFTs of the same length then computing the wavetable is a one-off overhead which does not affect the final throughput.The wavetable structure can be used repeatedly for any transform of the same length. The table is not modified by calls to any of the other FFT functions. The appropriate type of wavetable must be used for forward real or inverse half-complex transforms.

__Function:__void**gsl_fft_real_wavetable_free***(gsl_fft_real_wavetable **`wavetable`)__Function:__void**gsl_fft_halfcomplex_wavetable_free***(gsl_fft_halfcomplex_wavetable **`wavetable`)-
These functions free the memory associated with the wavetable
`wavetable`. The wavetable can be freed if no further FFTs of the same length will be needed.

__Function:__gsl_fft_real_workspace ***gsl_fft_real_workspace_alloc***(size_t*`n`)-
This function allocates a workspace for a real transform of length
`n`. The same workspace is used for both forward real and inverse halfcomplex transforms.

__Function:__void**gsl_fft_real_workspace_free***(gsl_fft_real_workspace **`workspace`)-
This function frees the memory associated with the workspace
`workspace`. The workspace can be freed if no further FFTs of the same length will be needed.

__Function:__int**gsl_fft_real_transform***(double*`data`[], size_t`stride`, size_t`n`, const gsl_fft_real_wavetable *`wavetable`, gsl_fft_real_workspace *`work`)__Function:__int**gsl_fft_halfcomplex_transform***(double*`data`[], size_t`stride`, size_t`n`, const gsl_fft_halfcomplex_wavetable *`wavetable`, gsl_fft_real_workspace *`work`)-
These functions compute the FFT of
`data`, a real or half-complex array of length`n`, using a mixed radix decimation-in-frequency algorithm. For`gsl_fft_real_transform`

`data`is an array of time-ordered real data. For`gsl_fft_halfcomplex_transform`

`data`contains fourier coefficients in the half-complex ordering described above. There is no restriction on the length`n`. Efficient modules are provided for subtransforms of length 2, 3, 4 and 5. Any remaining factors are computed with a slow, @math{O(n^2)}, general-n module. The caller must supply a`wavetable`containing trigonometric lookup tables and a workspace`work`.

__Function:__int**gsl_fft_real_unpack***(const double*`real_coefficient`[], gsl_complex_packed_array`complex_coefficient`[], size_t`stride`, size_t`n`)-
This function converts a single real array,

`real_coefficient`into an equivalent complex array,`complex_coefficient`, (with imaginary part set to zero), suitable for`gsl_fft_complex`

routines. The algorithm for the conversion is simply,for (i = 0; i < n; i++) { complex_coefficient[i].real = real_coefficient[i]; complex_coefficient[i].imag = 0.0; }

__Function:__int**gsl_fft_halfcomplex_unpack***(const double*`halfcomplex_coefficient`[], gsl_complex_packed_array`complex_coefficient`[], size_t`stride`, size_t`n`)-
This function converts

`halfcomplex_coefficient`, an array of half-complex coefficients as returned by`gsl_fft_real_transform`

, into an ordinary complex array,`complex_coefficient`. It fills in the complex array using the symmetry @math{z_k = z_{N-k}^*} to reconstruct the redundant elements. The algorithm for the conversion is,complex_coefficient[0].real = halfcomplex_coefficient[0]; complex_coefficient[0].imag = 0.0; for (i = 1; i < n - i; i++) { double hc_real = halfcomplex_coefficient[2 * i - 1]; double hc_imag = halfcomplex_coefficient[2 * i]; complex_coefficient[i].real = hc_real; complex_coefficient[i].imag = hc_imag; complex_coefficient[n - i].real = hc_real; complex_coefficient[n - i].imag = -hc_imag; } if (i == n - i) { complex_coefficient[i].real = halfcomplex_coefficient[n - 1]; complex_coefficient[i].imag = 0.0; }

Here is an example program using `gsl_fft_real_transform`

and
`gsl_fft_halfcomplex_inverse`

. It generates a real signal in the
shape of a square pulse. The pulse is fourier transformed to frequency
space, and all but the lowest ten frequency components are removed from
the array of fourier coefficients returned by
`gsl_fft_real_transform`

.

The remaining fourier coefficients are transformed back to the time-domain, to give a filtered version of the square pulse. Since fourier coefficients are stored using the half-complex symmetry both positive and negative frequencies are removed and the final filtered signal is also real.

#include <stdio.h> #include <math.h> #include <gsl/gsl_errno.h> #include <gsl/gsl_fft_real.h> #include <gsl/gsl_fft_halfcomplex.h> int main (void) { int i, n = 100; double data[n]; gsl_fft_real_wavetable * real; gsl_fft_halfcomplex_wavetable * hc; gsl_fft_real_workspace * work; for (i = 0; i < n; i++) { data[i] = 0.0; } for (i = n / 3; i < 2 * n / 3; i++) { data[i] = 1.0; } for (i = 0; i < n; i++) { printf ("%d: %e\n", i, data[i]); } printf ("\n"); work = gsl_fft_real_workspace_alloc (n); real = gsl_fft_real_wavetable_alloc (n); gsl_fft_real_transform (data, 1, n, real, work); gsl_fft_real_wavetable_free (real); for (i = 11; i < n; i++) { data[i] = 0; } hc = gsl_fft_halfcomplex_wavetable_alloc (n); gsl_fft_halfcomplex_inverse (data, 1, n, hc, work); gsl_fft_halfcomplex_wavetable_free (hc); for (i = 0; i < n; i++) { printf ("%d: %e\n", i, data[i]); } gsl_fft_real_workspace_free (work); return 0; }

@image{fft-real-mixedradix}

Low-pass filtered version of a real pulse, output from the example program.

Go to the first, previous, next, last section, table of contents.