mikera.matrixx.algo

Class FFT

java.lang.Object

mikera.matrixx.algo.FFT

public class FFT
extends Object

Computes 1D Discrete Fourier Transform (DFT) of complex and real, double 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
FFT(int n) Creates new instance of DoubleFFT_1D.

Method Summary

Methods

Modifier and Type	Method and Description
void	complexForward(double[] a) Computes 1D forward DFT of complex data leaving the result in a.
void	complexForward(double[] a, int offa) Computes 1D forward DFT of complex data leaving the result in a.
void	complexInverse(double[] a, boolean scale) Computes 1D inverse DFT of complex data leaving the result in a.
void	complexInverse(double[] a, int offa, boolean scale) Computes 1D inverse DFT of complex data leaving the result in a.
static boolean	isPowerOf2(int x) Checks if x is a power-of-two number.
static int	nextPow2(int x) Returns the closest power-of-two number greater than or equal to x.
static int	prevPow2(int x) Returns the closest power-of-two number less than or equal to x.
void	realForward(double[] a) Computes 1D forward DFT of real data leaving the result in a .
void	realForward(double[] a, int offa) Computes 1D forward DFT of real data leaving the result in a .
void	realForwardFull(double[] a) Computes 1D forward DFT of real data leaving the result in a .
void	realForwardFull(double[] a, int offa) Computes 1D forward DFT of real data leaving the result in a .
void	realInverse(double[] a, boolean scale) Computes 1D inverse DFT of real data leaving the result in a .
void	realInverse(double[] a, int offa, boolean scale) Computes 1D inverse DFT of real data leaving the result in a .
protected void	realInverse2(double[] a, int offa, boolean scale)
void	realInverseFull(double[] a, boolean scale) Computes 1D inverse DFT of real data leaving the result in a .
void	realInverseFull(double[] 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

FFT

public FFT(int n)

Creates new instance of DoubleFFT_1D.

Parameters:

n - size of data

Method Detail

nextPow2

public static int nextPow2(int x)

Returns the closest power-of-two number greater than or equal to x.

Parameters:

x -

Returns:

the closest power-of-two number greater than or equal to x

prevPow2

public static int prevPow2(int x)

Returns the closest power-of-two number less than or equal to x.

Parameters:

x -

Returns:

the closest power-of-two number less then or equal to x

isPowerOf2

public static boolean isPowerOf2(int x)

Checks if x is a power-of-two number.

Parameters:

x -

Returns:

true if x is a power-of-two number

complexForward

public void complexForward(double[] a)

Computes 1D forward DFT of complex data leaving the result in a. Complex number is stored as two double 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(double[] a,
                  int offa)

Computes 1D forward DFT of complex data leaving the result in a. Complex number is stored as two double 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(double[] a,
                  boolean scale)

Computes 1D inverse DFT of complex data leaving the result in a. Complex number is stored as two double 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(double[] a,
                  int offa,
                  boolean scale)

Computes 1D inverse DFT of complex data leaving the result in a. Complex number is stored as two double 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(double[] 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(double[] 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(double[] 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(double[] 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(double[] 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(double[] 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(double[] 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(double[] 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(double[] a,
                int offa,
                boolean scale)