jm.audio.math

## Class RealFloatFFT_Radix2

- java.lang.Object
- - jm.audio.math.RealFloatFFT
  - - jm.audio.math.RealFloatFFT_Radix2

-     public class RealFloatFFT_Radix2
      extends RealFloatFFT

  Computes FFT's of real, single precision data where n is an integral power of 2. The physical layout of the mathematical data d[i] in the array data is as follows:

          d[i] = data[i0 + stride*i]

  The FFT (D[i]) of real data (d[i]) is complex, but restricted by symmetry:

          D[n-i] = conj(D[i])

  It turns out that there are still n `independent' values, so the transformation can still be carried out in-place. For RealFloatFFT_Radix2, the correspondence is as follows:

  Logical |  | Physical
  Re(D[0]) | = | data[0]
  Im(D[0]) | = | 0
  Re(D[1]) | = | data[1]
  Im(D[1]) | = | data[n-1]
  ... |  | ...
  Re(D[k]) | = | data[k]
  Im(D[k]) | = | data[n-k]
  ... |  | ...
  Re(D[n/2]) | = | data[n/2]
  Im(D[n/2]) | = | 0
  ... |  | ...
  Re(D[n-k]) | = | data[k]
  Im(D[n-k]) | = | -data[n-k]
  ... |  | ...
  Re(D[n-1]) | = | data[1]
  Im(D[n-1]) | = | -data[n-1]

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `RealFloatFFT_Radix2(int n)` Create an FFT for transforming n points of real, single precision data.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `backtransform(float[] data, int i0, int stride)` Compute the (unnomalized) inverse FFT of data, leaving it in place.
    `protected void` | `bitreverse(float[] data, int i0, int stride)`
    `float[]` | `toWraparoundOrder(float[] data)` Return data in wraparound order.
    `float[]` | `toWraparoundOrder(float[] data, int i0, int stride)` Return data in wraparound order.
    `void` | `transform(float[] data, int i0, int stride)` Compute the Fast Fourier Transform of data leaving the result in data.

    - ### Methods inherited from class jm.audio.math.RealFloatFFT

      `backtransform, checkData, inverse, inverse, normalization, transform`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### RealFloatFFT_Radix2

          public RealFloatFFT_Radix2(int n)

      Create an FFT for transforming n points of real, single precision data. n must be an integral power of 2.

  - ### Method Detail

    - #### transform

          public void transform(float[] data,
                       int i0,
                       int stride)

      Compute the Fast Fourier Transform of data leaving the result in data. See Radix2 Transform Layout for description of the resulting data layout.
      Specified by:
        `transform` in class `RealFloatFFT`

    - #### backtransform

          public void backtransform(float[] data,
                           int i0,
                           int stride)

      Compute the (unnomalized) inverse FFT of data, leaving it in place. The data must be in the same arrangement as that produced by `transform`.
      Specified by:
        `backtransform` in class `RealFloatFFT`

    - #### toWraparoundOrder

          public float[] toWraparoundOrder(float[] data)

      Return data in wraparound order.
      Overrides:
        `toWraparoundOrder` in class `RealFloatFFT`
      See Also:
        wraparound format

    - #### toWraparoundOrder

          public float[] toWraparoundOrder(float[] data,
                                  int i0,
                                  int stride)

      Return data in wraparound order. i0 and stride are used to traverse data; the new array is in packed (i0=0, stride=1) format.
      Specified by:
        `toWraparoundOrder` in class `RealFloatFFT`
      See Also:
        wraparound format

    - #### bitreverse

          protected void bitreverse(float[] data,
                        int i0,
                        int stride)