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

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:
 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]

 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

`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
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
```protected void bitreverse(double[] data,