public final class DoubleFFT_1D extends Object
Constructor and Description 

DoubleFFT_1D(long n)
Creates new instance of DoubleFFT_1D.

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 
complexForward(pl.edu.icm.jlargearrays.DoubleLargeArray a)
Computes 1D forward DFT of complex data leaving the result in
a . 
void 
complexForward(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long 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 
complexInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a,
boolean scale)
Computes 1D inverse DFT of complex data leaving the result in
a . 
void 
complexInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long 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 
realForward(pl.edu.icm.jlargearrays.DoubleLargeArray a)
Computes 1D forward DFT of real data leaving the result in
a
. 
void 
realForward(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long 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 
realForwardFull(pl.edu.icm.jlargearrays.DoubleLargeArray a)
Computes 1D forward DFT of real data leaving the result in
a
. 
void 
realForwardFull(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long 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 
realInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a,
boolean scale)
Computes 1D inverse DFT of real data leaving the result in
a
. 
void 
realInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long offa,
boolean scale)
Computes 1D inverse DFT of real data leaving the result in
a
. 
protected void 
realInverse2(double[] a,
int offa,
boolean scale) 
protected void 
realInverse2(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long 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
. 
void 
realInverseFull(pl.edu.icm.jlargearrays.DoubleLargeArray a,
boolean scale)
Computes 1D inverse DFT of real data leaving the result in
a
. 
void 
realInverseFull(pl.edu.icm.jlargearrays.DoubleLargeArray a,
long offa,
boolean scale)
Computes 1D inverse DFT of real data leaving the result in
a
. 
public DoubleFFT_1D(long n)
n
 size of datapublic 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 complexForward(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 complexInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 realForward(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 realForwardFull(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 realInverse(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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(pl.edu.icm.jlargearrays.DoubleLargeArray 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 performedpublic void realInverseFull(pl.edu.icm.jlargearrays.DoubleLargeArray a, long 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 performedprotected void realInverse2(double[] a, int offa, boolean scale)
protected void realInverse2(pl.edu.icm.jlargearrays.DoubleLargeArray a, long offa, boolean scale)
Copyright © 2015. All rights reserved.