math.fourierTransforms.interleaved
Class ComplexDoubleFFT

java.lang.Object
  math.fourierTransforms.interleaved.ComplexDoubleFFT

Direct Known Subclasses:

ComplexDoubleFFT_Mixed, ComplexDoubleFFT_Radix2

public abstract class ComplexDoubleFFT
extends java.lang.Object

Abstract Class representing FFT's of complex, double precision data. Concrete classes are typically named ComplexDoubleFFT_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

ComplexDoubleFFT(int n)
Create an FFT for transforming n points of complex, double precision data.

Method Summary

void	backtransform(double[] data) Compute the (unnomalized) inverse FFT of data, leaving it in place.
abstract void	backtransform(double[] data, int i0, int stride) Compute the (unnomalized) inverse FFT of data, leaving it in place.
ComplexDoubleFFT	getInstance(int n) Creates an instance of a subclass of ComplexDoubleFFT appropriate for data of n elements.
void	inverse(double[] data) Compute the (nomalized) inverse FFT of data, leaving it in place.
void	inverse(double[] data, int i0, int stride) Compute the (nomalized) inverse FFT of data, leaving it in place.
double	normalization() Return the normalization factor.
double[]	toWraparoundOrder(double[] data) Return data in wraparound order.
double[]	toWraparoundOrder(double[] data, int i0, int stride) Return data in wraparound order.
void	transform(double[] data) Compute the Fast Fourier Transform of data leaving the result in data.
abstract void	transform(double[] 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

ComplexDoubleFFT

public ComplexDoubleFFT(int n)

Create an FFT for transforming n points of complex, double precision data.

Method Detail

getInstance

public ComplexDoubleFFT getInstance(int n)

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

transform

public void transform(double[] 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.

transform

public abstract void transform(double[] 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]

toWraparoundOrder

public double[] toWraparoundOrder(double[] data)

Return data in wraparound order.

See Also:

wraparound format

toWraparoundOrder

public double[] toWraparoundOrder(double[] 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

backtransform

public void backtransform(double[] data)

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

backtransform

public abstract void backtransform(double[] 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 double normalization()

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

inverse

public void inverse(double[] data)

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

inverse

public void inverse(double[] 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]