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

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]

 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. `protected  void` ```bitreverse(float[] data, int i0, int stride)``` ` 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 jnt.FFT.RealFloatFFT ```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 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.
Overrides:
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.
Overrides:
backtransform in class RealFloatFFT

### toWraparoundOrder

`public float[] toWraparoundOrder(float[] data)`
Return data in wraparound order.
Overrides:
toWraparoundOrder in class RealFloatFFT
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.
Overrides:
toWraparoundOrder in class RealFloatFFT
```protected void bitreverse(float[] data,