## pfft.pfft

- class Fft(T);
- A class for calculating discrete fourier transform. The methods of this class
use split format for complex data. This means that a complex data set is
represented as two arrays - one for the real part and one for the imaginary
part. An instance of this class can only be used for transforms of one
particular size. The template parameter is the floating point type that the
methods of the class will operate on.

**Example:**

import std.stdio, std.conv, std.exception; import pfft.pfft; void main(string[] args) { auto n = to!int(args[1]); enforce((n & (n-1)) == 0, "N must be a power of two."); alias

__Fft__!float F; auto f = new F(n); auto re = F.allocate(n); auto im = F.allocate(n); foreach(i, _; re) readf("%s %s\n", &re[i], &im[i]); f.fft(re, im); foreach(i, _; re) writefln("%s\t%s", re[i], im[i]); }

- this(size_t n);
- The Fft constructor. The parameter is the size of data sets that
`fft`

and`ifft`

will operate on. I will refer to this number as n in the rest of the documentation for this class.Tables used in fft and ifft are calculated in the constructor.

- void fft(T[] re, T[] im);
- Calculates discrete fourier transform.
*re*should contain the real part of the data and*im*the imaginary part of the data. The method operates in place - the result is saved back to*re*and*im*. Both arrays must be properly aligned - to obtain a properly aligned array you can use`allocate`

.

- void ifft(T[] re, T[] im);
- Calculates inverse discrete fourier transform scaled by n. The arguments have
the same role as they do in
`fft`

.

- T[] allocate(size_t n);
- Allocates an array that is aligned properly for use with
`fft`

,`ifft`

and`scale`

methods.

- void scale(T[] data, T k);
- Scales an array data by factor k. The array must be properly aligned. To obtain
a properly aligned array, use
`allocate`

.

- class Rfft(T);
- A class for calculating real discrete fourier transform. The methods of this
class use split format for complex data. This means that complex data set is
represented as two arrays - one for the real part and one for the imaginary
part. An instance of this class can only be used for transforms of one
particular size. The template parameter is the floating point type that the
methods of the class will operate on.

**Example:**

import std.stdio, std.conv, std.exception; import pfft.pfft; void main(string[] args) { auto n = to!int(args[1]); enforce((n & (n-1)) == 0, "N must be a power of two."); alias

__Rfft__!float F; auto f = new F(n); auto data = F.allocate(n); foreach(ref e; data) readf("%s\n", &e); f.rfft(data); foreach(i; 0 .. n / 2 + 1) writefln("%s\t%s", data[i], (i == 0 || i == n / 2) ? 0 : data[i]); }

- this(size_t n);
- The Rfft constructor. The parameter is the size of data sets that
`rfft`

will operate on. I will refer to this number as n in the rest of the documentation for this class. All tables used in rfft are calculated in the constructor.

- void rfft(T[] data);
- Calculates discrete fourier transform of the real valued sequence in data.
The method operates in place. When the method completes, data contains the
result. First
*n / 2 + 1*elements contain the real part of the result and the rest contains the imaginary part. Imaginary parts at position 0 and*n / 2*are known to be equal to 0 and are not stored, so the content of data looks like this:

`r(0), r(1), ... r(n / 2), i(1), i(2), ... i(n / 2 - 1)`

The elements of the result at position greater than n / 2 can be trivially calculated from the relation*DFT(f)[i] = DFT(f)[n - i]**that holds because the input sequence is real.

The length of the array must be equal to n and the array must be properly aligned. To obtain a properly aligned array you can use`allocate`

.

- void irfft(T[] data);
- Calculates the inverse of
`rfft`

, scaled by n (You can use`scale`

to normalize the result). Before the method is called, data should contain a complex sequence in the same format as the result of`rfft`

. It is assumed that the input sequence is a discrete fourier transform of a real valued sequence, so the elements of the input sequence not stored in data can be calculated from*DFT(f)[i] = DFT(f)[n - i]**. When the method completes, the array contains the real part of the inverse discrete fourier transform. The imaginary part is known to be equal to 0.

The length of the array must be equal to n and the array must be properly aligned. To obtain a properly aligned array you can use`allocate`

.

- alias allocate;
- An alias for Fft!T.
allocate

- alias scale;
- An alias for Fft!T.
scale