FourierTransformer Class

public sealed class FourierTransformer

Public NotInheritable Class FourierTransformer

public ref class FourierTransformer sealed

[<SealedAttribute>]
type FourierTransformer = class end

Inheritance

Object    FourierTransformer

A Fourier transform decomposes a function into a sum of different frequency components. This is useful for a wide array of applications.

Mathematically, the DFT is an N-dimensional linear transfromation with coefficients that are the Nth complex roots of unity.

An instance of the FourierTransformer class performs DFTs on series of a particular length, given by its Length property. This specialization allows certain parts of the DFT calculation, which are indepdent of the transformed series but dependent on the length of the series, to be performed only once and then re-used for all transforms of that length. This saves time and improves performance. If you need to perform DFTs on series with different lengths, simply create a seperate instance of the FourierTransform class for each required length.

Many simple DFT implementations require that the series length be a power of two (2, 4, 8, 16, etc.). Meta.Numerics supports DFTs of any length. Our DFT implementation is fast -- order O(N log N) -- for all lengths, including lengths that have large prime factors.

The following code performs a simple DFT and then inverts it to re-obtain the original data.

// Create a Fourier transformer for length-6 series
FourierTransformer ft = new FourierTransformer(6);
// Create a length-6 series and transform it
Complex[] x = new Complex[] { 0.0, 1.0, 0.0, 0.0, 0.0, 0.0 };
Complex[] xt = ft.Transform(x);
// Re-use the same transformer to transform a different  series
Complex[] y = new Complex[] { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
Complex[] yt = ft.Transform(y);
// Transform them back
Complex[] xtt = ft.InverseTransform(xt);
Complex[] ytt = ft.InverseTransform(yt);

Reference

Other Resources