math.fourierTransforms.interleaved
Class RealFloatFFT_Radix2

java.lang.Object
  math.fourierTransforms.interleaved.RealFloatFFT
      math.fourierTransforms.interleaved.RealFloatFFT_Radix2

public class RealFloatFFT_Radix2
extends RealFloatFFT

Computes FFT's of real, single precision data where n is an integral power of 2. The physical layout of the mathematical data d[i] in the array data is as follows:

 d[i] = data[i0 + stride*i]
 

The FFT (D[i]) of real data (d[i]) is complex, but restricted by symmetry:

 D[n-i] = conj(D[i])
 

It turns out that there are still n `independent' values, so the transformation can still be carried out in-place. For RealFloatFFT_Radix2, the correspondence is as follows:

Logical		Physical
Re(D[0])	=	data[0]
Im(D[0])	=	0
Re(D[1])	=	data[1]
Im(D[1])	=	data[n-1]
...		...
Re(D[k])	=	data[k]
Im(D[k])	=	data[n-k]
...		...
Re(D[n/2])	=	data[n/2]
Im(D[n/2])	=	0
...		...
Re(D[n-k])	=	data[k]
Im(D[n-k])	=	-data[n-k]
...		...
Re(D[n-1])	=	data[1]
Im(D[n-1])	=	-data[n-1]

Author:

Bruce R. Miller bruce.miller@nist.gov, Contribution of the National Institute of Standards and Technology,, not subject to copyright., Derived from GSL (Gnu Scientific Library), GSL's FFT Code by Brian Gough bjg@vvv.lanl.gov, Since GSL is released under, GPL,, this package must also be.

Constructor Summary

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

Method Summary

void	backtransform(float[] data, int i0, int stride) Compute the (unnomalized) inverse FFT of data, leaving it in place.
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, int i0, int stride) Compute the Fast Fourier Transform of data leaving the result in data.

Methods inherited from class math.fourierTransforms.interleaved.RealFloatFFT

backtransform, inverse, inverse, normalization, transform

Methods inherited from class java.lang.Object

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

Constructor Detail

RealFloatFFT_Radix2

public RealFloatFFT_Radix2(int n)

Create an FFT for transforming n points of real, single precision data. n must be an integral power of 2.

Method Detail

transform

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

Compute the Fast Fourier Transform of data leaving the result in data. See Radix2 Transform Layout for description of the resulting data layout.

Specified by:

transform in class RealFloatFFT

backtransform

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

Compute the (unnomalized) inverse FFT of data, leaving it in place. The data must be in the same arrangement as that produced by transform.

Specified by:

backtransform in class RealFloatFFT

toWraparoundOrder

public float[] toWraparoundOrder(float[] data)

Return data in wraparound order.

Overrides:

toWraparoundOrder in class RealFloatFFT

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=1) format.

Specified by:

toWraparoundOrder in class RealFloatFFT

See Also:

wraparound format