org.das2.math.fft.jnt

Class ComplexFloatFFT

java.lang.Object

org.das2.math.fft.jnt.ComplexFloatFFT

Direct Known Subclasses:

ComplexFloatFFT_Mixed

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: at 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.

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and Description
void	backtransform(ComplexArray.Float data) Compute the (unnomalized) inverse FFT of data, leaving it in place.
abstract void	backtransform(ComplexArray.Float data, int i0, int stride) Compute the (unnomalized) inverse FFT of data, leaving it in place.
protected void	checkData(ComplexArray.Float data, int i0, int stride)
ComplexFloatFFT	getInstance(int n) Creates an instance of a subclass of ComplexFloatFFT appropriate for data of n elements.
void	inverse(ComplexArray.Float data) Compute the (nomalized) inverse FFT of data, leaving it in place.
void	inverse(ComplexArray.Float data, int i0, int stride) Compute the (nomalized) inverse FFT of data, leaving it in place.
float	normalization() Return the normalization factor.
void	transform(ComplexArray.Float data) Compute the Fast Fourier Transform of data leaving the result in data.
abstract void	transform(ComplexArray.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

clone, equals, finalize, 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

getInstance

public ComplexFloatFFT getInstance(int n)

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

checkData

protected void checkData(ComplexArray.Float data,
                         int i0,
                         int stride)

transform

public void transform(ComplexArray.Float data)

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

transform

public abstract void transform(ComplexArray.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(ComplexArray.Float data)

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

backtransform

public abstract void backtransform(ComplexArray.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(ComplexArray.Float data)

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

inverse

public void inverse(ComplexArray.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]