## jnt.FFT Class ComplexFloatFFT

```java.lang.Object
|
+--jnt.FFT.ComplexFloatFFT
```
Direct Known Subclasses:

public abstract class ComplexFloatFFT
extends java.lang.Object

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

 Constructor Summary `ComplexFloatFFT(int n)`           Create an FFT for transforming n points of Complex, single precision data.

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

 Methods inherited from class java.lang.Object ```clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait```

 Constructor Detail

### ComplexFloatFFT

`public ComplexFloatFFT(int n)`
Create an FFT for transforming n points of Complex, single precision data.
 Method Detail

### getInstance

`public ComplexFloatFFT getInstance(int n)`
Creates an instance of a subclass of ComplexFloatFFT appropriate for data of n elements.

### checkData

```protected void checkData(float[] data,
int i0,
int stride)```

### transform

`public void transform(float[] data)`
Compute the Fast Fourier Transform of data leaving the result in data. The array data must be dimensioned (at least) 2*n, consisting of alternating real and imaginary parts.

### toWraparoundOrder

`public float[] toWraparoundOrder(float[] data)`
Return data in wraparound order.
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=2) format.
wraparound format

### transform

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

### backtransform

`public void backtransform(float[] data)`
Compute the (unnomalized) inverse FFT of data, leaving it in place.

### backtransform

```public abstract void backtransform(float[] 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 float normalization()`
Return the normalization factor. Multiply the elements of the backtransform'ed data to get the normalized inverse.

### inverse

`public void inverse(float[] data)`
Compute the (nomalized) inverse FFT of data, leaving it in place.

### inverse

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