edu.emory.mathcs.jtransforms.fft

## Class FloatFFT_1D

• ```public class FloatFFT_1D
extends Object```
Computes 1D Discrete Fourier Transform (DFT) of complex and real, single precision data. The size of the data can be an arbitrary number. This is a parallel implementation of split-radix and mixed-radix algorithms optimized for SMP systems.

This code is derived from General Purpose FFT Package written by Takuya Ooura (http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html) and from JFFTPack written by Baoshe Zhang (http://jfftpack.sourceforge.net/)
Author:
Piotr Wendykier (piotr.wendykier@gmail.com)
• ### Constructor Summary

Constructors
Constructor and Description
`FloatFFT_1D(int n)`
Creates new instance of FloatFFT_1D.
• ### Method Summary

All Methods
Modifier and Type Method and Description
`void` `complexForward(float[] a)`
Computes 1D forward DFT of complex data leaving the result in `a`.
`void` ```complexForward(float[] a, int offa)```
Computes 1D forward DFT of complex data leaving the result in `a`.
`void` ```complexInverse(float[] a, boolean scale)```
Computes 1D inverse DFT of complex data leaving the result in `a`.
`void` ```complexInverse(float[] a, int offa, boolean scale)```
Computes 1D inverse DFT of complex data leaving the result in `a`.
`void` `realForward(float[] a)`
Computes 1D forward DFT of real data leaving the result in `a` .
`void` ```realForward(float[] a, int offa)```
Computes 1D forward DFT of real data leaving the result in `a` .
`void` `realForwardFull(float[] a)`
Computes 1D forward DFT of real data leaving the result in `a` .
`void` ```realForwardFull(float[] a, int offa)```
Computes 1D forward DFT of real data leaving the result in `a` .
`void` ```realInverse(float[] a, boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` .
`void` ```realInverse(float[] a, int offa, boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` .
`protected void` ```realInverse2(float[] a, int offa, boolean scale)```
`void` ```realInverseFull(float[] a, boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` .
`void` ```realInverseFull(float[] a, int offa, boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` .
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Constructor Detail

• #### FloatFFT_1D

`public FloatFFT_1D(int n)`
Creates new instance of FloatFFT_1D.
Parameters:
`n` - size of data
• ### Method Detail

• #### complexForward

`public void complexForward(float[] a)`
Computes 1D forward DFT of complex data leaving the result in `a`. Complex number is stored as two float values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
``` a[2*k] = Re[k],
a[2*k+1] = Im[k], 0<=k<n
```
Parameters:
`a` - data to transform
• #### complexForward

```public void complexForward(float[] a,
int offa)```
Computes 1D forward DFT of complex data leaving the result in `a`. Complex number is stored as two float values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
``` a[offa+2*k] = Re[k],
a[offa+2*k+1] = Im[k], 0<=k<n
```
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
• #### complexInverse

```public void complexInverse(float[] a,
boolean scale)```
Computes 1D inverse DFT of complex data leaving the result in `a`. Complex number is stored as two float values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
``` a[2*k] = Re[k],
a[2*k+1] = Im[k], 0<=k<n
```
Parameters:
`a` - data to transform
`scale` - if true then scaling is performed
• #### complexInverse

```public void complexInverse(float[] a,
int offa,
boolean scale)```
Computes 1D inverse DFT of complex data leaving the result in `a`. Complex number is stored as two float values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
``` a[offa+2*k] = Re[k],
a[offa+2*k+1] = Im[k], 0<=k<n
```
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
`scale` - if true then scaling is performed
• #### realForward

`public void realForward(float[] a)`
Computes 1D forward DFT of real data leaving the result in `a` . The physical layout of the output data is as follows:
if n is even then
``` a[2*k] = Re[k], 0<=k<n/2
a[2*k+1] = Im[k], 0<k<n/2
a[1] = Re[n/2]
```
if n is odd then
``` a[2*k] = Re[k], 0<=k<(n+1)/2
a[2*k+1] = Im[k], 0<k<(n-1)/2
a[1] = Im[(n-1)/2]
```
This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real forward transform, use `realForwardFull`. To get back the original data, use `realInverse` on the output of this method.
Parameters:
`a` - data to transform
• #### realForward

```public void realForward(float[] a,
int offa)```
Computes 1D forward DFT of real data leaving the result in `a` . The physical layout of the output data is as follows:
if n is even then
``` a[offa+2*k] = Re[k], 0<=k<n/2
a[offa+2*k+1] = Im[k], 0<k<n/2
a[offa+1] = Re[n/2]
```
if n is odd then
``` a[offa+2*k] = Re[k], 0<=k<(n+1)/2
a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
a[offa+1] = Im[(n-1)/2]
```
This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real forward transform, use `realForwardFull`. To get back the original data, use `realInverse` on the output of this method.
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
• #### realForwardFull

`public void realForwardFull(float[] a)`
Computes 1D forward DFT of real data leaving the result in `a` . This method computes the full real forward transform, i.e. you will get the same result as from `complexForward` called with all imaginary parts equal 0. Because the result is stored in `a`, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data. To get back the original data, use `complexInverse` on the output of this method.
Parameters:
`a` - data to transform
• #### realForwardFull

```public void realForwardFull(float[] a,
int offa)```
Computes 1D forward DFT of real data leaving the result in `a` . This method computes the full real forward transform, i.e. you will get the same result as from `complexForward` called with all imaginary part equal 0. Because the result is stored in `a`, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data. To get back the original data, use `complexInverse` on the output of this method.
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
• #### realInverse

```public void realInverse(float[] a,
boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` . The physical layout of the input data has to be as follows:
if n is even then
``` a[2*k] = Re[k], 0<=k<n/2
a[2*k+1] = Im[k], 0<k<n/2
a[1] = Re[n/2]
```
if n is odd then
``` a[2*k] = Re[k], 0<=k<(n+1)/2
a[2*k+1] = Im[k], 0<k<(n-1)/2
a[1] = Im[(n-1)/2]
```
This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real inverse transform, use `realInverseFull`.
Parameters:
`a` - data to transform
`scale` - if true then scaling is performed
• #### realInverse

```public void realInverse(float[] a,
int offa,
boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` . The physical layout of the input data has to be as follows:
if n is even then
``` a[offa+2*k] = Re[k], 0<=k<n/2
a[offa+2*k+1] = Im[k], 0<k<n/2
a[offa+1] = Re[n/2]
```
if n is odd then
``` a[offa+2*k] = Re[k], 0<=k<(n+1)/2
a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
a[offa+1] = Im[(n-1)/2]
```
This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real inverse transform, use `realInverseFull`.
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
`scale` - if true then scaling is performed
• #### realInverseFull

```public void realInverseFull(float[] a,
boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` . This method computes the full real inverse transform, i.e. you will get the same result as from `complexInverse` called with all imaginary part equal 0. Because the result is stored in `a`, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data.
Parameters:
`a` - data to transform
`scale` - if true then scaling is performed
• #### realInverseFull

```public void realInverseFull(float[] a,
int offa,
boolean scale)```
Computes 1D inverse DFT of real data leaving the result in `a` . This method computes the full real inverse transform, i.e. you will get the same result as from `complexInverse` called with all imaginary part equal 0. Because the result is stored in `a`, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data.
Parameters:
`a` - data to transform
`offa` - index of the first element in array `a`
`scale` - if true then scaling is performed
• #### realInverse2

```protected void realInverse2(float[] a,
int offa,
boolean scale)```