Explain this FFT Radix 2 DIT java code line by line

Hello,
can someone explain me this java code line by line on the selected part of the code:

Here is the whole code:

/**Radix-2 Decimation-in-Time (DIT)**/

public class Fft {

int n, m;

double[] cos;
   double[] sin;

public Fft(int n) {
     this.n = n;
     this.m = (int)(Math.log(n) / Math.log(2));

// tablice obliczone wczesniej
     cos = new double[n/2];
     sin = new double[n/2];

for(int i=0; i<n/2; i++) {
       cos[i] = Math.cos(-2*Math.PI*i/n);
       sin[i] = Math.sin(-2*Math.PI*i/n);
     }
   }

public void fft(double[] x, double[] y)
   {
     int i,j,k,n1,n2,a;
     double c,s,t1,t2;

// zmiana bitow - zmiana oryginalej struktury
     j = 0;
     n2 = n/2;
     for (i=1; i < n - 1; i++) {
       n1 = n2;
       while ( j >= n1 ) {
         j = j - n1;
         n1 = n1/2;
       }
       j = j + n1;

if (i < j) {
         t1 = x[i];
         x[i] = x[j];
         x[j] = t1;
         t1 = y[i];
         y[i] = y[j];
         y[j] = t1;
       }
     }

// FFT
     n1 = 0;
     n2 = 1;

for (i=0; i < m; i++) {
       n1 = n2;
       n2 = n2 + n2;
       a = 0;

for (j=0; j < n1; j++) {
         c = cos[a];
         s = sin[a];
         a +=  1 << (m-i-1);

for (k=j; k < n; k=k+n2) {
           t1 = c*x[k+n1] - s*y[k+n1];
           t2 = s*x[k+n1] + c*y[k+n1];
           x[k+n1] = x[k] - t1;
           y[k+n1] = y[k] - t2;
           x[k] = x[k] + t1;
           y[k] = y[k] + t2;
         }
       }
     }
   }

// testowanie za pomoca sygnalu trojkatnego
   public static void main(String[] args) {

System.out.print("Algorytm dla FFT długości 8 punktów ");
       int N = 8;   //dlugosc algorymu FFT=8

Fft fft = new Fft(N);

// tablice rzeczywiste i urojone o dlugosci N
     double[] re = new double[N];
     double[] im = new double[N];

// Sygnal trojkatny
     for(int i=0; i<N; i++) {
       re[i] = i;
       im[i] = 0;                  //im = 0
      }
       beforeAfter(fft, re, im);

}    //wyswietlanie 'przed' i 'po'
   protected static void beforeAfter(Fft fft, double[] re, double[] im) {
     System.out.println("Before: ");
     printReIm(re, im);
     fft.fft(re, im);
     System.out.println("After: ");
     printReIm(re, im);
   }
     //wyswietlanie wartosci 're' i 'im'
   protected static void printReIm(double[] re, double[] im) {
     System.out.print("Re: [");
     for(int i=0; i<re.length; i++)
       System.out.print(((int)(re[i]*1000)/1000.0) + " ");

System.out.print("]\nIm: [");
     for(int i=0; i<im.length; i++)
       System.out.print(((int)(im[i]*1000)/1000.0) + " ");

System.out.println("]");
   }
}

Well, yes, but it would be a waste of time for both of us:

1. Assign zero to j.

2. Divide n by 2 and assign the result to n2.

And so on. I don't think that's what you were looking for. Could you perhaps produce a more practical question?

I've read about fft and i found few steps how to do this. I don't know how to assign them to this code.

1.Prepare input data for summation — put them into convenient order;
2.For every summation level:
2.1For every exponent factor of the half-period:
2.2Calculate factor;
2.1.1For every sum of this factor:
2.1.2Calculate product of the factor and the second term of the sum;
2.1.3Calculate sum;
2.1.4Calculate difference.

What's FFT and DIT? You should always explain abbreviations.

. . . and welcome to the Ranch

FFT - Fast Fourier Transfomate
DIT - Decimation In Time

There is some bit reverse (i dont know how it exacly works) and calculation called butterflies. I am begginer in programming and I need a little patiece :P

Thank you.

Piotr Orzech wrote:I am begginer in programming...

Do you understand the mathematics behind FFT and DIT? That is the hard part here. You need to get good grasp of this first and then to analyze code you didn't even write. Trying to understand the algorithm from a foreign code (possibly optimized using clever mathematical tricks, or - worse - even buggy) when you're a beginner in programming would certainly be a frustrating task.

Quick search for "FFT explained" gave me this.

Lines 12-18 in the first code look like a standard method for swapping two elements in arrays, but there are two swaps.