FftSharp Documentation

The ddst routine implements a discrete sine transform by appending a butterfly operation to rdft.

In a backward transform, it processes an input array a[] to create an intermediate array r[], calls rdft of length $n$, and then maps the results $A[k]$ to the final sine coefficients $S[k]$ using the following relationship:

• $S[2*k] = ext{Re}(A[k] * (1+i))$
• $S[2*k-1] = - ext{Im}(A[k] * (1+i))$

Windowing involves multiplying a waveform by a bell-shaped curve before performing an FFT. This process improves the frequency resolution and signal-to-noise ratio at lower frequencies by reducing spectral leakage.

In FftSharp, you can use window functions in two ways:

1. window.ApplyInPlace(signal): Modifies the original array.
2. window.Apply(signal): Returns a new array containing the windowed signal.

Common window functions include Hanning, Hamming, Blackman, and Tukey.

double[] signal = FftSharp.SampleData.SampleAudio1();

var window = new FftSharp.Windows.Hanning();
double[] windowed = window.Apply(signal);

These routines are used to split transforms into half-length components:

• dfct: Splits a Cosine Transform into dfct and ddct of half length. It uses ddct recursively. To maintain in-place operation, data in fft*g_h.* versions are sorted in bit-reversal order.
• dfst: Splits a Sine Transform into dfst and ddst of half length. It uses ddst recursively. To maintain in-place operation, data in fft*g_h.* versions are sorted in bit-reversal order.

The rdft routine implements a real transform by appending a butterfly operation to a cdft call.

In a forward transform, it takes an array a[] and produces an array x[] where x[j] = a[2*j] + i*a[2*j+1]. It then calls cdft of length $n/2$. The final results $A[k]$ are derived from the cdft output $X[k]$ using complex conjugates and specific weighting factors to account for the real-valued input symmetry.

The ddct routine implements a discrete cosine transform by appending a butterfly operation to rdft.

In a backward transform, it processes an input array a[] to create an intermediate array r[] (using real and imaginary parts of the input), calls rdft of length $n$, and then maps the results $A[k]$ to the final cosine coefficients $C[k]$ using the following relationship:

• $C[2*k] = ext{Re}(A[k] * (1-i))$
• $C[2*k-1] = - ext{Im}(A[k] * (1-i))$

The package provides several file variations depending on your performance and memory needs:

• fft4g*.*: Optimized for most machines (uses radix 4,2).
• fft8g*.*: Fast on UltraSPARC architectures (uses radix 8,4,2).
• fftsg*.*: Optimized for machines with multi-level caches (L1, L2, etc.) using a Split-Radix algorithm.
• fft*g_h.c (Simple Versions): These versions use no work area (no extra memory allocation), making them suitable for memory-constrained environments, though they may be slower than the fast versions.
• Fast Versions (fft*g.*): These use work areas to achieve higher performance.

To determine the frequency resolution of your FFT, use the following formula based on the number of samples and the sampling period:

Resolution = 1.0 / (sampleLength * samplePeriod)

var Resolution = 1.0 / (sampleLength * samplePeriod)

FftSharp provides several versions of FFT (Fast Fourier/Cosine/Sine Transform) optimized for different hardware and performance requirements. All implementations calculate transforms for 1-dimensional sequences of length $2^N$.

Fast Versions (Use work areas for speed)

• fft4g*.*: Optimized for most general-purpose machines (uses radix 4,2).
• fft8g*.*: Optimized for UltraSPARC architectures (uses radix 8,4,2).
• fftsg*.*: Optimized for machines with multi-level caches (L1, L2, etc.) using a Split-Radix recursive algorithm.

Simple Versions (No work area required)

• fft*g_h.c: These versions use no additional work area but are generally slower than the fast versions. They are available in C for radix 4,2, radix 8,4,2, and Split-Radix variants.

The implementation method for cdft depends on the package version used:

• fft4g*.* and fft8g*.*: Uses an in-place, radix $2^M$, Sande-Tukey (decimation in frequency) method. The butterfly loop index is in bit-reverse order to maintain continuous memory access.
• fftsg*.*: Uses an in-place, Split-Radix, recursive fast algorithm.