
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_1D
public class DoubleFFT_1D
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 splitradix and mixedradix algorithms optimized
for SMP systems.
This code is derived from General Purpose FFT Package written by Takuya Ooura
(http://www.kurims.kyotou.ac.jp/~ooura/fft.html) and from JFFTPack written
by Baoshe Zhang (http://jfftpack.sourceforge.net/)
Constructor Summary  

DoubleFFT_1D(int n)
Creates new instance of DoubleFFT_1D. 
Method Summary  

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 . 
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
. 
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 

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

public DoubleFFT_1D(int n)
n
 size of dataMethod Detail 

public void complexForward(double[] a)
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
a
 data to transformpublic void complexForward(double[] a, int offa)
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
a
 data to transformoffa
 index of the first element in array a
public void complexInverse(double[] a, boolean scale)
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
a
 data to transformscale
 if true then scaling is performedpublic void complexInverse(double[] a, int offa, boolean scale)
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
a
 data to transformoffa
 index of the first element in array a
scale
 if true then scaling is performedpublic void realForward(double[] a)
a
. The physical layout of the output data is as follows: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<(n1)/2 a[1] = Im[(n1)/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, int offa)
a
. The physical layout of the output data is as follows: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<(n1)/2 a[offa+1] = Im[(n1)/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 transformoffa
 index of the first element in array a
public void realForwardFull(double[] a)
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.
a
 data to transformpublic void realForwardFull(double[] a, int offa)
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.
a
 data to transformoffa
 index of the first element in array a
public void realInverse(double[] a, boolean scale)
a
. The physical layout of the input data has to be as follows: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<(n1)/2 a[1] = Im[(n1)/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, int offa, boolean scale)
a
. The physical layout of the input data has to be as follows: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<(n1)/2 a[offa+1] = Im[(n1)/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 transformoffa
 index of the first element in array a
scale
 if true then scaling is performedpublic void realInverseFull(double[] a, boolean scale)
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.
a
 data to transformscale
 if true then scaling is performedpublic void realInverseFull(double[] a, int offa, boolean scale)
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.
a
 data to transformoffa
 index of the first element in array a
scale
 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 