The Extreme Optimization Numerical Libraries for .NET provide a set of classes for computing
the Discrete Fourier Transform of real and complex signals.
One time FFT's
When only very few Fourier transforms of a given length need to be computed, the VectorComplexVector classes provide methods
that can perform this computation in one line of code.
To compute the Fourier transform of a real sequence, use FourierTransform(Vector).
This method takes as its only parameter a Vector that specifies the signal that is to be transformed.
It returns a ComplexVector that contains the transform.
The inverse transform is computed using the
InverseFourierTransform(ComplexVector) method.
This method takes a ComplexVector
and returns a Vector. Only the first n/2+1 components
are used in the computation.
The following example computes the Fourier transform of a short vector, and then computes the inverse transform. The result
is a vector identical to the first one:
| C# |
 Copy
|
DenseVector r1 = Vector.Create(1.0, 2.0, 3.0, 4.0);
ComplexVector c1 = Vector.FourierTransform(r1);
Vector r2 = Vector.InverseFourierTransform(c1);
|
| Visual Basic |
Copy
|
Dim r1 As DenseVector = Vector.Create(1.0, 2.0, 3.0, 4.0)
Dim c1 As ComplexVector = Vector.FourierTransform(r)
Dim r2 As Vector = Vector.InverseFourierTransform(c)
|
For complex signals, the ComplexVector
class has a FourierTransform(ComplexVector)
and a InverseFourierTransform(ComplexDenseVector)
method. Each method takes one parameter: a ComplexVector,
and also returns a ComplexVector.
Multiple FFT's of the same size
In many applications, many Fourier transforms of the same length need to be calculated. To make this process more efficient,
you can use Fft objects, that represent the implementation of an
FFT of a given length. Fft objects are created through an
FftProvider.
FFT Providers
The FftProvider is the base class for accessing
a specific set of FFT algorithms. Two FFT providers are shipped with the library: a managed provider that uses 100% managed code,
and a 'native' provider that uses hand-optimized unmanaged code and is an order of magnitude faster for longer transforms.
In order to use the native provider, the assembly containing the native FFT code for the current processor architecture must be
present. This assembly is called Extreme.NativeFft.x86.20.dll on 32 bit systems and Extreme.NativeFft.x64.20.dll
on 64 bit systems. If this assembly cannot be found, the managed provider is used instead.
You can access the two providers through the ManagedProvider()()()()
and NativeProvider()()()() properties.
The managed provider has two additional properties that indicate when to switch to the native provider (if it is present).
The RealManagedThresholdLength
property specifies the shortest length of a real FFT for which the native FFT provider will be used. The default is 64.
The ComplexManagedThresholdLength
property specifies the shortest length of a complex FFT for which the native FFT provider will be used. The default is 32.
Using FFT providers, you can obtain Fft objects for
one-dimensional transforms and Fft2D objects for
two-dimensional transforms.
The Fft and Fft
classes implement System..::..IDisposable, so you should always use a using statement
or call Dispose()()()() once you are done using the object.