jnt.FFT
Class RealDoubleFFT_Radix2

java.lang.Object
  |
  +--jnt.FFT.RealDoubleFFT
        |
        +--jnt.FFT.RealDoubleFFT_Radix2

public class RealDoubleFFT_Radix2
extends RealDoubleFFT

Computes FFT's of real, double 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 RealDoubleFFT_Radix2, the correspondence is as follows:
LogicalPhysical
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]


Constructor Summary
RealDoubleFFT_Radix2(int n)
          Create an FFT for transforming n points of real, double precision data.
 
Method Summary
 void backtransform(double[] data, int i0, int stride)
          Compute the (unnomalized) inverse FFT of data, leaving it in place.
protected  void bitreverse(double[] data, int i0, int stride)
           
 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, int i0, int stride)
          Compute the Fast Fourier Transform of data leaving the result in data.
 
Methods inherited from class jnt.FFT.RealDoubleFFT
backtransform, checkData, inverse, inverse, normalization, transform
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

RealDoubleFFT_Radix2

public RealDoubleFFT_Radix2(int n)
Create an FFT for transforming n points of real, double precision data. n must be an integral power of 2.
Method Detail

transform

public void transform(double[] 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.
Overrides:
transform in class RealDoubleFFT

backtransform

public void backtransform(double[] 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.
Overrides:
backtransform in class RealDoubleFFT

toWraparoundOrder

public double[] toWraparoundOrder(double[] data)
Return data in wraparound order.
Overrides:
toWraparoundOrder in class RealDoubleFFT
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=1) format.
Overrides:
toWraparoundOrder in class RealDoubleFFT
See Also:
wraparound format

bitreverse

protected void bitreverse(double[] data,
                          int i0,
                          int stride)