math.fourierTransforms.interleaved
Class ComplexFloatFFT

java.lang.Object
  math.fourierTransforms.interleaved.ComplexFloatFFT

Direct Known Subclasses:

ComplexFloatFFT_Mixed, ComplexFloatFFT_Radix2

public abstract class ComplexFloatFFT
extends java.lang.Object

Abstract Class representing FFT's of complex, single precision data. Concrete classes are typically named ComplexFloatFFT_method, implement the FFT using some particular method.

Complex data is represented by 2 double values in sequence: the real and imaginary parts. Thus, in the default case (i0=0, stride=2), N data points is represented by a double array dimensioned to 2*N. To support 2D (and higher) transforms, an offset, i0 (where the first element starts) and stride (the distance from the real part of one value, to the next: affineTransform least 2 for complex values) can be supplied. The physical layout in the array data, of the mathematical data d[i] is as follows:

 Re(d[i])
 = data[i0 + stride*i] Im(d[i]) = data[i0 + stride*i+1] 

The transformed data is returned in the original data array in wrap-around order.

Author:

Bruce R. Miller bruce.miller@nist.gov, Contribution of the National Institute of Standards and Technology,, not subject to copyright.

Constructor Summary

ComplexFloatFFT(int n)
Create an FFT for transforming n points of Complex, single precision data.

Method Summary

void	backtransform(float[] data) Compute the (unnomalized) inverse FFT of data, leaving it in place.
abstract void	backtransform(float[] data, int i0, int stride) Compute the (unnomalized) inverse FFT of data, leaving it in place.
static float[]	complexToReal(float[] complex)
ComplexFloatFFT	getInstance(int n) Creates an instance of a subclass of ComplexFloatFFT appropriate for data of n elements.
static float[]	getInterleavedData(float[] re, float[] im)
void	inverse(float[] data) Compute the (nomalized) inverse FFT of data, leaving it in place.
void	inverse(float[] data, int i0, int stride) Compute the (nomalized) inverse FFT of data, leaving it in place.
float	normalization() Return the normalization factor.
float[]	toWraparoundOrder(float[] data) Return data in wraparound order.
float[]	toWraparoundOrder(float[] data, int i0, int stride) Return data in wraparound order.
void	transform(float[] data) Compute the Fast Fourier Transform of data leaving the result in data.
abstract void	transform(float[] data, int i0, int stride) Compute the Fast Fourier Transform of data leaving the result in data.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ComplexFloatFFT

public ComplexFloatFFT(int n)

Create an FFT for transforming n points of Complex, single precision data.

Method Detail

complexToReal

public static float[] complexToReal(float[] complex)

getInterleavedData

public static float[] getInterleavedData(float[] re,
                                         float[] im)

getInstance

public ComplexFloatFFT getInstance(int n)

Creates an instance of a subclass of ComplexFloatFFT appropriate for data of n elements.

transform

public void transform(float[] data)

Compute the Fast Fourier Transform of data leaving the result in data. The array data must be dimensioned (affineTransform least) 2*n, consisting of alternating real and imaginary parts.

toWraparoundOrder

public float[] toWraparoundOrder(float[] data)

Return data in wraparound order.

See Also:

wraparound format

toWraparoundOrder

public float[] toWraparoundOrder(float[] data,
                                 int i0,
                                 int stride)

Return data in wraparound order. i0 and stride are used to traverse data; the new array is in packed (i0=0, stride=2) format.

See Also:

wraparound format

transform

public abstract void transform(float[] data,
                               int i0,
                               int stride)

Compute the Fast Fourier Transform of data leaving the result in data. The array data must contain the data points in the following locations:

 Re(d[i]) = data[i0 + stride*i] Im(d[i]) = data[i0 +
 stride*i+1] 

backtransform

public void backtransform(float[] data)

Compute the (unnomalized) inverse FFT of data, leaving it in place.

backtransform

public abstract void backtransform(float[] data,
                                   int i0,
                                   int stride)

Compute the (unnomalized) inverse FFT of data, leaving it in place. The frequency domain data must be in wrap-around order, and be stored in the following locations:

 Re(D[i]) = data[i0 +
 stride*i] Im(D[i]) = data[i0 + stride*i+1] 

normalization

public float normalization()

Return the normalization factor. Multiply the elements of the backtransform'ed data to get the normalized inverse.

inverse

public void inverse(float[] data)

Compute the (nomalized) inverse FFT of data, leaving it in place.

inverse

public void inverse(float[] data,
                    int i0,
                    int stride)

Compute the (nomalized) inverse FFT of data, leaving it in place. The frequency domain data must be in wrap-around order, and be stored in the following locations:

 Re(D[i]) = data[i0 +
 stride*i] Im(D[i]) = data[i0 + stride*i+1]