FloatFFT_1D (JTransforms 3.1 API)

java.lang.Object
- org.jtransforms.fft.FloatFFT_1D

```
public final 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(long n)
Creates new instance of FloatFFT_1D.

Constructors
Constructor and Description
`FloatFFT_1D(long n)` Creates new instance of FloatFFT_1D.

Method Summary

All Methods Instance Methods Concrete 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`	`complexForward(pl.edu.icm.jlargearrays.FloatLargeArray a)` Computes 1D forward DFT of complex data leaving the result in `a`.
`void`	`complexForward(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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`	`complexInverse(pl.edu.icm.jlargearrays.FloatLargeArray a, boolean scale)` Computes 1D inverse DFT of complex data leaving the result in `a`.
`void`	`complexInverse(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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`	`realForward(pl.edu.icm.jlargearrays.FloatLargeArray a)` Computes 1D forward DFT of real data leaving the result in `a` .
`void`	`realForward(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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`	`realForwardFull(pl.edu.icm.jlargearrays.FloatLargeArray a)` Computes 1D forward DFT of real data leaving the result in `a` .
`void`	`realForwardFull(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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` .
`void`	`realInverse(pl.edu.icm.jlargearrays.FloatLargeArray a, boolean scale)` Computes 1D inverse DFT of real data leaving the result in `a` .
`void`	`realInverse(pl.edu.icm.jlargearrays.FloatLargeArray a, long offa, boolean scale)` Computes 1D inverse DFT of real data leaving the result in `a` .
`protected void`	`realInverse2(float[] a, int offa, boolean scale)`
`protected void`	`realInverse2(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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` .
`void`	`realInverseFull(pl.edu.icm.jlargearrays.FloatLargeArray a, boolean scale)` Computes 1D inverse DFT of real data leaving the result in `a` .
`void`	`realInverseFull(pl.edu.icm.jlargearrays.FloatLargeArray a, long 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(long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - complexForward
```
public void complexForward(pl.edu.icm.jlargearrays.FloatLargeArray a,
                           long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - complexInverse
```
public void complexInverse(pl.edu.icm.jlargearrays.FloatLargeArray a,
                           long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - realForward
```
public void realForward(pl.edu.icm.jlargearrays.FloatLargeArray a,
                        long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - realForwardFull
```
public void realForwardFull(pl.edu.icm.jlargearrays.FloatLargeArray a,
                            long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - realInverse
```
public void realInverse(pl.edu.icm.jlargearrays.FloatLargeArray a,
                        long 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(pl.edu.icm.jlargearrays.FloatLargeArray 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
  - realInverseFull
```
public void realInverseFull(pl.edu.icm.jlargearrays.FloatLargeArray a,
                            long 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)
```
  - realInverse2
```
protected void realInverse2(pl.edu.icm.jlargearrays.FloatLargeArray a,
                            long offa,
                            boolean scale)
```

Class FloatFFT_1D

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FloatFFT_1D

Method Detail

complexForward

complexForward

complexForward

complexForward

complexInverse

complexInverse

complexInverse

complexInverse

realForward

realForward

realForward

realForward

realForwardFull

realForwardFull

realForwardFull

realForwardFull

realInverse

realInverse

realInverse

realInverse

realInverseFull

realInverseFull

realInverseFull

realInverseFull

realInverse2

realInverse2