|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectmath.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 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/)
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<(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.
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<(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.
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<(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
.
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<(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
.
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
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |