
Parallel Colt 0.7.2  
PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 
java.lang.Object edu.emory.mathcs.jtransforms.fft.DoubleFFT_2D
public class DoubleFFT_2D
Computes 2D Discrete Fourier Transform (DFT) of complex and real, double
precision data. The sizes of both dimensions can be arbitrary numbers. This
is a parallel implementation of splitradix and mixedradix algorithms
optimized for SMP systems.
Part of the code is derived from General Purpose FFT Package written by
Takuya Ooura (http://www.kurims.kyotou.ac.jp/~ooura/fft.html)
Constructor Summary  

DoubleFFT_2D(int rows,
int columns)
Creates new instance of DoubleFFT_2D. 
Method Summary  

void 
complexForward(double[] a)
Computes 2D forward DFT of complex data leaving the result in a . 
void 
complexForward(double[][] a)
Computes 2D forward DFT of complex data leaving the result in a . 
void 
complexInverse(double[][] a,
boolean scale)
Computes 2D inverse DFT of complex data leaving the result in a . 
void 
complexInverse(double[] a,
boolean scale)
Computes 2D inverse DFT of complex data leaving the result in a . 
void 
realForward(double[] a)
Computes 2D forward DFT of real data leaving the result in a
. 
void 
realForward(double[][] a)
Computes 2D forward DFT of real data leaving the result in a
. 
void 
realForwardFull(double[] a)
Computes 2D forward DFT of real data leaving the result in a
. 
void 
realForwardFull(double[][] a)
Computes 2D forward DFT of real data leaving the result in a
. 
void 
realInverse(double[][] a,
boolean scale)
Computes 2D inverse DFT of real data leaving the result in a
. 
void 
realInverse(double[] a,
boolean scale)
Computes 2D inverse DFT of real data leaving the result in a
. 
void 
realInverseFull(double[][] a,
boolean scale)
Computes 2D inverse DFT of real data leaving the result in a
. 
void 
realInverseFull(double[] a,
boolean scale)
Computes 2D inverse DFT of real data leaving the result in a
. 
Methods inherited from class java.lang.Object 

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Constructor Detail 

public DoubleFFT_2D(int rows, int columns)
rows
 number of rowscolumns
 number of columnsMethod Detail 

public void complexForward(double[] a)
a
. The data is stored in 1D array in rowmajor order.
Complex number is stored as two double values in sequence: the real and
imaginary part, i.e. the input array must be of size rows*2*columns. The
physical layout of the input data has to be as follows:a[k1*2*columns+2*k2] = Re[k1][k2], a[k1*2*columns+2*k2+1] = Im[k1][k2], 0<=k1<rows, 0<=k2<columns,
a
 data to transformpublic void complexForward(double[][] a)
a
. The data is stored in 2D array. Complex data is
represented by 2 double values in sequence: the real and imaginary part,
i.e. the input array must be of size rows by 2*columns. The physical
layout of the input data has to be as follows:a[k1][2*k2] = Re[k1][k2], a[k1][2*k2+1] = Im[k1][k2], 0<=k1<rows, 0<=k2<columns,
a
 data to transformpublic void complexInverse(double[] a, boolean scale)
a
. The data is stored in 1D array in rowmajor order.
Complex number is stored as two double values in sequence: the real and
imaginary part, i.e. the input array must be of size rows*2*columns. The
physical layout of the input data has to be as follows:a[k1*2*columns+2*k2] = Re[k1][k2], a[k1*2*columns+2*k2+1] = Im[k1][k2], 0<=k1<rows, 0<=k2<columns,
a
 data to transformscale
 if true then scaling is performedpublic void complexInverse(double[][] a, boolean scale)
a
. The data is stored in 2D array. Complex data is
represented by 2 double values in sequence: the real and imaginary part,
i.e. the input array must be of size rows by 2*columns. The physical
layout of the input data has to be as follows:a[k1][2*k2] = Re[k1][k2], a[k1][2*k2+1] = Im[k1][k2], 0<=k1<rows, 0<=k2<columns,
a
 data to transformscale
 if true then scaling is performedpublic void realForward(double[] a)
a
. This method only works when the sizes of both dimensions are
poweroftwo numbers. The physical layout of the output data is as
follows:
a[k1*columns+2*k2] = Re[k1][k2] = Re[rowsk1][columnsk2], a[k1*columns+2*k2+1] = Im[k1][k2] = Im[rowsk1][columnsk2], 0<k1<rows, 0<k2<columns/2, a[2*k2] = Re[0][k2] = Re[0][columnsk2], a[2*k2+1] = Im[0][k2] = Im[0][columnsk2], 0<k2<columns/2, a[k1*columns] = Re[k1][0] = Re[rowsk1][0], a[k1*columns+1] = Im[k1][0] = Im[rowsk1][0], a[(rowsk1)*columns+1] = Re[k1][columns/2] = Re[rowsk1][columns/2], a[(rowsk1)*columns] = Im[k1][columns/2] = Im[rowsk1][columns/2], 0<k1<rows/2, a[0] = Re[0][0], a[1] = Re[0][columns/2], a[(rows/2)*columns] = Re[rows/2][0], a[(rows/2)*columns+1] = Re[rows/2][columns/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.
a
 data to transformpublic void realForward(double[][] a)
a
. This method only works when the sizes of both dimensions are
poweroftwo numbers. The physical layout of the output data is as
follows:
a[k1][2*k2] = Re[k1][k2] = Re[rowsk1][columnsk2], a[k1][2*k2+1] = Im[k1][k2] = Im[rowsk1][columnsk2], 0<k1<rows, 0<k2<columns/2, a[0][2*k2] = Re[0][k2] = Re[0][columnsk2], a[0][2*k2+1] = Im[0][k2] = Im[0][columnsk2], 0<k2<columns/2, a[k1][0] = Re[k1][0] = Re[rowsk1][0], a[k1][1] = Im[k1][0] = Im[rowsk1][0], a[rowsk1][1] = Re[k1][columns/2] = Re[rowsk1][columns/2], a[rowsk1][0] = Im[k1][columns/2] = Im[rowsk1][columns/2], 0<k1<rows/2, a[0][0] = Re[0][0], a[0][1] = Re[0][columns/2], a[rows/2][0] = Re[rows/2][0], a[rows/2][1] = Re[rows/2][columns/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.
a
 data to transformpublic void realForwardFull(double[] a)
a
. This method computes 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 input
array must be of size rows*2*columns, with only the first rows*columns
elements filled with real data. To get back the original data, use
complexInverse
on the output of this method.
a
 data to transformpublic void realForwardFull(double[][] a)
a
. This method computes 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 input
array must be of size rows by 2*columns, with only the first rows by
columns elements filled with real data. To get back the original data,
use complexInverse
on the output of this method.
a
 data to transformpublic void realInverse(double[] a, boolean scale)
a
. This method only works when the sizes of both dimensions are
poweroftwo numbers. The physical layout of the input data has to be as
follows:
a[k1*columns+2*k2] = Re[k1][k2] = Re[rowsk1][columnsk2], a[k1*columns+2*k2+1] = Im[k1][k2] = Im[rowsk1][columnsk2], 0<k1<rows, 0<k2<columns/2, a[2*k2] = Re[0][k2] = Re[0][columnsk2], a[2*k2+1] = Im[0][k2] = Im[0][columnsk2], 0<k2<columns/2, a[k1*columns] = Re[k1][0] = Re[rowsk1][0], a[k1*columns+1] = Im[k1][0] = Im[rowsk1][0], a[(rowsk1)*columns+1] = Re[k1][columns/2] = Re[rowsk1][columns/2], a[(rowsk1)*columns] = Im[k1][columns/2] = Im[rowsk1][columns/2], 0<k1<rows/2, a[0] = Re[0][0], a[1] = Re[0][columns/2], a[(rows/2)*columns] = Re[rows/2][0], a[(rows/2)*columns+1] = Re[rows/2][columns/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
.
a
 data to transformscale
 if true then scaling is performedpublic void realInverse(double[][] a, boolean scale)
a
. This method only works when the sizes of both dimensions are
poweroftwo numbers. The physical layout of the input data has to be as
follows:
a[k1][2*k2] = Re[k1][k2] = Re[rowsk1][columnsk2], a[k1][2*k2+1] = Im[k1][k2] = Im[rowsk1][columnsk2], 0<k1<rows, 0<k2<columns/2, a[0][2*k2] = Re[0][k2] = Re[0][columnsk2], a[0][2*k2+1] = Im[0][k2] = Im[0][columnsk2], 0<k2<columns/2, a[k1][0] = Re[k1][0] = Re[rowsk1][0], a[k1][1] = Im[k1][0] = Im[rowsk1][0], a[rowsk1][1] = Re[k1][columns/2] = Re[rowsk1][columns/2], a[rowsk1][0] = Im[k1][columns/2] = Im[rowsk1][columns/2], 0<k1<rows/2, a[0][0] = Re[0][0], a[0][1] = Re[0][columns/2], a[rows/2][0] = Re[rows/2][0], a[rows/2][1] = Re[rows/2][columns/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
.
a
 data to transformscale
 if true then scaling is performedpublic void realInverseFull(double[] a, boolean scale)
a
. This method computes 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 input
array must be of size rows*2*columns, with only the first rows*columns
elements filled with real data.
a
 data to transformscale
 if true then scaling is performedpublic void realInverseFull(double[][] a, boolean scale)
a
. This method computes 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 input
array must be of size rows by 2*columns, with only the first rows by
columns elements filled with real data.
a
 data to transformscale
 if true then scaling is performed

Parallel Colt 0.7.2  
PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 