signalproc.algorithms

Class FFTC

java.lang.Object

signalproc.algorithms.FFTC

public final class FFTC
extends java.lang.Object

FFTC is a class in which all methods are declared static. This means that you don't have to instantiate it to use the functions within it.

See Also:

FFT, Counter, Factorizer, FFTPhase

Method Summary

Methods

Modifier and Type	Method and Description
static java.util.ArrayList	FFT_C(double[] xReal, double[] xImag, boolean forward, boolean verbose) Class method that takes the Fourier transform of input argument vectors xReal and xImag of arbitrary length, overwriting the input data.
static java.util.ArrayList	FFT_C(double[] xReal, double[] xImag, boolean forward, boolean overwrite, boolean verbose) Class method that makes the Fourier transform of input argument vectors xReal and xImag, which can be of arbitrary length.
static int	testConjugateSymmetry(double[] xr, double[] xi) Class method to test whether a data set has the symmetry property that will result in its transform being pure real or pure imaginary.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

FFT_C

public static java.util.ArrayList FFT_C(double[] xReal,
                        double[] xImag,
                        boolean forward,
                        boolean overwrite,
                        boolean verbose)

Class method that makes the Fourier transform of input argument vectors xReal and xImag, which can be of arbitrary length. It has a boolean argument to denote forward or backward (inverse) and a boolean argument to govern whether the input data are overwritten by the returned data or not. It returns an ArrayList containing the real and imaginary parts of the discrete Fourier transform of the input. The input vectors can be of any length, and they are not padded to 2^m. No normalizing factors are applied to the data; divisions by n or sqrt(n) are left to the calling method.

The method is a prime-factor radix method using a block-matrix decomposition approach, in which the input data set is put into a hyper-matrix of dimension equal to the number of prime factors of the number of input elements. The method uses a succession of discrete Fourier transforms along the different directions, where the data transformed is the result of the previous transform times complex factors called twiddle factors.

The method does not know ahead of time how many factors the data set length has (dimensions of the hyper-matrix), so it uses a list of instantiations of the class Counter to keep track of the indices in the different dimensions.

The FFT elements are in the order where all positive frequencies are first, in ascending order, and then all negative frequencies, again in ascending order. This is the form of the output data for a forward transform, and it is the expected form of the input data for an inverse transform. Thus, the data must be two-sided; one-sided data sets will be supported in a future version.

Parameters:

double[] - xReal The real part of the input complex data

double[] - xImag The imaginary part of the input complex data

boolean - forward True denotes a forward or normal Fourier transform (time->frequency); false denotes an inverse transform

boolean - overwrite True if input data is to be overwritten by output

boolean - verbose True if printing log to System.out is desired

Returns:

ArrayList The real and imaginary parts of the transform

FFT_C

public static java.util.ArrayList FFT_C(double[] xReal,
                        double[] xImag,
                        boolean forward,
                        boolean verbose)

Class method that takes the Fourier transform of input argument vectors xReal and xImag of arbitrary length, overwriting the input data. A boolean argument denotes forward or backward (inverse) transforms. The method returns an ArrayList containing the real and imaginary parts of the discrete Fourier transform of the input. The input vectors can be of any length, and they are not padded to 2^m. No normalizing factors are applied to the data; divisions by n or sqrt(n) are left to the calling method.

The method is a prime-factor radix method using a block-matrix decomposition approach, in which the input data set is put into a hyper-matrix of dimension equal to the number of prime factors of the number of input elements. The method uses a succession of discrete Fourier transforms along the different directions, where the data transformed is the result of the previous transform times complex factors called twiddle factors.

The method does not know ahead of time how many factors the data set length has (dimensions of the hyper-matrix), so it uses a list of instantiations of the class Counter to keep track of the indices in the different dimensions.

The FFT elements are returned in the order where all positive frequencies are first, in ascending order, and then all negative frequencies, again in ascending order. This is the form of the output data for a forward transform, and it is the expected form of the input data for an inverse transform. Thus, the data must be two-sided; one-sided data sets will be supported in a future version.

To cover the case where the input data is real, this method returns the ArrayList containing the transform even though the operation is performed in place and the real part at least can be read from the input data vectors.

Parameters:

double[] - xReal The real part of the input complex data, to be replaced by the real part of its Fourier transform

double[] - xImag The imaginary part of the input complex data, to be replaced by the imaginary part of its Fourier transform if it exists

boolean - forward True denotes a forward or normal Fourier transform (time->frequency); false denotes an inverse transform

boolean - verbose True if printing log to System.out is desired

Returns:

ArrayList The real and imaginary parts of the transform

testConjugateSymmetry

public static int testConjugateSymmetry(double[] xr,
                        double[] xi)

Class method to test whether a data set has the symmetry property that will result in its transform being pure real or pure imaginary. If, for a full data set (not one-sided spectra, which will automatically transform to real), x[k] = ComplexConjugate(x[N-k]), then the transform will be real. If x[k] = -ComplexConjugate(x[N-k]) then the transform will be imaginary. This test should only be applied to the full data set that will be transformed.

The return value is an int. It has value +1 if the transform will be real, -1 if imaginary, 0 if there is no special symmetry.

Parameters:

double[] - xr The real part of the input data set (can be null)

double[] - xi The imaginary part of the input data set (can be null)

Returns:

int Takes value =1, 0, or -1