You are on page 1of 3

Carlo del Mundo Virginia Tech 7-5-2011

Integer Fast Fourier Transform


Week 1

This Weeks Summary


The first week was spent reviewing the applications and derivations of the Fourier Transform and a sequential CPU implementation in C.

Discrete Fourier Transform


The Discrete Fourier Transform is defined by the following formula: Suppose we have a vector, x, where an element of x is a complex-valued number. Then, the Discrete Fourier transform of the vector, x, will be defined as follows:

Where

is a complex root of unity.

Derivations of the Fast Fourier Transform (Radix-2)


We start with the basic form of the DFT:

We can split the summation into two parts, one starting from j = 0 to j = = .

and another from j =

to j

By changing the index of summation in the second sum to summation:

, we arrive at an equivalent

Carlo del Mundo Virginia Tech 7-5-2011 We clean up a bit by factoring:

We have successfully decomposed the original DFT into two separate summations essentially halving the problem set. By continuing to halve the problem, we can divide and conquer smaller problem sets. For n output elements, each element takes about log n calculations, the resultant running time is then ( ).

Serial FFT Implementation Discussion


The algorithm delineated above is called a radix-2 FFT. The problem can be essentially halved until we reach only one element. The Fourier Transform of one element is itself. Other radix-n algorithms exist, which just subdivide the problem using different index partitions. The order in which elements are recursively evaluated in a radix-2 FFT is called a bit-wise permutation. We can implement the above algorithm iteratively by mimicking the recursive steps. By performing a bit-wise permutation on the original set, the iterative algorithm essentially performs the same steps done by the recursion.

Next Weeks Plans


A paper, Integer Fast Fourier Transform by Oraintara, Chen, and Nguyen, published in the IEEE journal has provided plenty of insight into the problem. Specifically, they use lifting schemes to eliminate multiplications. The Fourier coefficients are calculated from a series of additions and bit shifts. I plan to answer the following questions in next weeks discussion: How do we utilize lifting schemes to eliminate multiplications? o What is a biorthogonal filterbank? o What does it mean to have perfect reconstruction? How do we implement a split-radix FFT? What is the difference between fixed-FFT and integer-FFT? o Both use shifts & additions; no multiplications (different from the vanilla FFT)

Carlo del Mundo Virginia Tech 7-5-2011

Appendix: Implementations
Serial Fast Fourier Transformation (Incomplete, Full Source Code Attached in Zip)
// Fast Fourier Implementation Using Iteration (Mimics Recursion) void iterativeFFT(complex *list, int size) { unsigned int n = size; complex *A; A = bitPermutation(list, N); int s; for (s = 0; s <= log2(n); ++s) { int m = exp2(s); complex omega_m; omega_m.real = cos(2 * PI / n); omega_m.imaginary = sin(2 * PI / n); int k; for (k = 0; k <= n-1; k += m) { complex omega; omega.real = 1; omega.imaginary = 0; int j; for (j = 0; j <= m/2-1; ++j) { complex t = multiplyComplex(omega, A[k+j+m/2]); complex u = A[k+j]; A[k+j] = addComplex(u,t); A[k+j+m/2] = subComplex(u,t); omega = multiplyComplex(omega, omega_m); } } } printArray(N, A); free(A); } int main() { // allocate complex structure arrays of size N complex *A = (complex*)malloc(sizeof(complex) * N); srand(SEED_VALUE); int i; for (i = 0; i < N; ++i) { A[i].real = rand() % CEILING_LIMIT; A[i].imaginary = rand() % CEILING_LIMIT; } printf("\n"); iterativeFFT(A, N); free(A); }