## jnt.FFT Class ComplexDoubleFFT

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

public abstract class ComplexDoubleFFT
extends java.lang.Object

Abstract Class representing FFT's of complex, double precision data. Concrete classes are typically named ComplexDoubleFFT_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 `ComplexDoubleFFT(int n)`           Create an FFT for transforming n points of complex, double precision data.

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

### ComplexDoubleFFT

`public ComplexDoubleFFT(int n)`
Create an FFT for transforming n points of complex, double precision data.
 Method Detail

### getInstance

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

### checkData

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

### transform

`public void transform(double[] 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.

### transform

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

### toWraparoundOrder

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

### backtransform

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

### backtransform

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

### inverse

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

### inverse

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