Package de.gsi.math.spectra.fft

Class FloatFFT_2D

  • public class FloatFFT_2D
extends java.lang.Object
    Computes 2D Discrete Fourier Transform (DFT) of complex and real, single precision data. The sizes of both dimensions can be arbitrary numbers. This is a parallel implementation of split-radix and mixed-radix algorithms optimized for SMP systems.

    Part of the code is derived from General Purpose FFT Package written by Takuya Ooura (http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html)
    Author:
    Piotr Wendykier (piotr.wendykier@gmail.com)

    • Constructor Summary

      Constructors 
      Constructor Description
      FloatFFT_2D​(int rows, int columns)
      Creates new instance of FloatFFT_2D.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void complexForward​(float[] a)
      Computes 2D forward DFT of complex data leaving the result in a.
      void complexForward​(float[][] a)
      Computes 2D forward DFT of complex data leaving the result in a.
      void complexInverse​(float[][] a, boolean scale)
      Computes 2D inverse DFT of complex data leaving the result in a.
      void complexInverse​(float[] a, boolean scale)
      Computes 2D inverse DFT of complex data leaving the result in a.
      void realForward​(float[] a)
      Computes 2D forward DFT of real data leaving the result in a .
      void realForward​(float[][] a)
      Computes 2D forward DFT of real data leaving the result in a .
      void realForwardFull​(float[] a)
      Computes 2D forward DFT of real data leaving the result in a .
      void realForwardFull​(float[][] a)
      Computes 2D forward DFT of real data leaving the result in a .
      void realInverse​(float[][] a, boolean scale)
      Computes 2D inverse DFT of real data leaving the result in a .
      void realInverse​(float[] a, boolean scale)
      Computes 2D inverse DFT of real data leaving the result in a .
      void realInverseFull​(float[][] a, boolean scale)
      Computes 2D inverse DFT of real data leaving the result in a .
      void realInverseFull​(float[] a, boolean scale)
      Computes 2D inverse DFT of real data leaving the result in a .

      • Methods inherited from class java.lang.Object

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

    • Constructor Detail

      • FloatFFT_2D

        public FloatFFT_2D​(int rows,
                   int columns)
        Creates new instance of FloatFFT_2D.
        Parameters:
        rows - number of rows
        columns - number of columns

    • Method Detail

      • complexForward

        public void complexForward​(float[] a)
        Computes 2D forward DFT of complex data leaving the result in a. The data is stored in 1D array in row-major order. Complex number is stored as two float 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,
        Parameters:
        a - data to transform

      • complexForward

        public void complexForward​(float[][] a)
        Computes 2D forward DFT of complex data leaving the result in a. The data is stored in 2D array. Complex data is represented by 2 float 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,
        Parameters:
        a - data to transform

      • complexInverse

        public void complexInverse​(float[] a,
                           boolean scale)
        Computes 2D inverse DFT of complex data leaving the result in a. The data is stored in 1D array in row-major order. Complex number is stored as two float 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,
        Parameters:
        a - data to transform
        scale - if true then scaling is performed

      • complexInverse

        public void complexInverse​(float[][] a,
                           boolean scale)
        Computes 2D inverse DFT of complex data leaving the result in a. The data is stored in 2D array. Complex data is represented by 2 float 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,
        Parameters:
        a - data to transform
        scale - if true then scaling is performed

      • realForward

        public void realForward​(float[] a)
        Computes 2D forward DFT of real data leaving the result in a . This method only works when the sizes of both dimensions are power-of-two numbers. The physical layout of the output data is as follows: 
         a[k1*columns+2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
 a[k1*columns+2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
       0<k1<rows, 0<k2<columns/2,
 a[2*k2] = Re[0][k2] = Re[0][columns-k2],
 a[2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
       0<k2<columns/2,
 a[k1*columns] = Re[k1][0] = Re[rows-k1][0],
 a[k1*columns+1] = Im[k1][0] = -Im[rows-k1][0],
 a[(rows-k1)*columns+1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
 a[(rows-k1)*columns] = -Im[k1][columns/2] = Im[rows-k1][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.
        Parameters:
        a - data to transform

      • realForward

        public void realForward​(float[][] a)
        Computes 2D forward DFT of real data leaving the result in a . This method only works when the sizes of both dimensions are power-of-two numbers. The physical layout of the output data is as follows: 
         a[k1][2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
 a[k1][2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
       0<k1<rows, 0<k2<columns/2,
 a[0][2*k2] = Re[0][k2] = Re[0][columns-k2],
 a[0][2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
       0<k2<columns/2,
 a[k1][0] = Re[k1][0] = Re[rows-k1][0],
 a[k1][1] = Im[k1][0] = -Im[rows-k1][0],
 a[rows-k1][1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
 a[rows-k1][0] = -Im[k1][columns/2] = Im[rows-k1][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.
        Parameters:
        a - data to transform

      • realForwardFull

        public void realForwardFull​(float[] a)
        Computes 2D forward DFT of real data leaving the result in 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.
        Parameters:
        a - data to transform

      • realForwardFull

        public void realForwardFull​(float[][] a)
        Computes 2D forward DFT of real data leaving the result in 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.
        Parameters:
        a - data to transform

      • realInverse

        public void realInverse​(float[] a,
                        boolean scale)
        Computes 2D inverse DFT of real data leaving the result in a . This method only works when the sizes of both dimensions are power-of-two numbers. The physical layout of the input data has to be as follows: 
         a[k1*columns+2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
 a[k1*columns+2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
       0<k1<rows, 0<k2<columns/2,
 a[2*k2] = Re[0][k2] = Re[0][columns-k2],
 a[2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
       0<k2<columns/2,
 a[k1*columns] = Re[k1][0] = Re[rows-k1][0],
 a[k1*columns+1] = Im[k1][0] = -Im[rows-k1][0],
 a[(rows-k1)*columns+1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
 a[(rows-k1)*columns] = -Im[k1][columns/2] = Im[rows-k1][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.
        Parameters:
        a - data to transform
        scale - if true then scaling is performed

      • realInverse

        public void realInverse​(float[][] a,
                        boolean scale)
        Computes 2D inverse DFT of real data leaving the result in a . This method only works when the sizes of both dimensions are power-of-two numbers. The physical layout of the input data has to be as follows: 
         a[k1][2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
 a[k1][2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
       0<k1<rows, 0<k2<columns/2,
 a[0][2*k2] = Re[0][k2] = Re[0][columns-k2],
 a[0][2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
       0<k2<columns/2,
 a[k1][0] = Re[k1][0] = Re[rows-k1][0],
 a[k1][1] = Im[k1][0] = -Im[rows-k1][0],
 a[rows-k1][1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
 a[rows-k1][0] = -Im[k1][columns/2] = Im[rows-k1][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.
        Parameters:
        a - data to transform
        scale - if true then scaling is performed

      • realInverseFull

        public void realInverseFull​(float[] a,
                            boolean scale)
        Computes 2D inverse DFT of real data leaving the result in 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.
        Parameters:
        a - data to transform
        scale - if true then scaling is performed

      • realInverseFull

        public void realInverseFull​(float[][] a,
                            boolean scale)
        Computes 2D inverse DFT of real data leaving the result in 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.
        Parameters:
        a - data to transform
        scale - if true then scaling is performed