# Java Program to Compute Discrete Fourier Transform using Naive Approach

«
»
This is the java implementation of Naive DFT approach over function. Formula for calculating the coefficient is X(k) = Sum(x(n)*cos(2*PI*k*n/N) – iSum(x(n)*sin(2*PI*k*n/N)) over 0 to N-1. This approach tries to many transforms using different values of k from 0 to N-1.

Here is the source code of the Java Program to Compute Discrete Fourier Transform Using Naive Approach. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.

1. `//This is a java program to perform the DFT using naive approach`
2. `import java.util.Scanner;`
3. ` `
4. `public class DFT_Naive_Approach `
5. `{`
6. `    double real,  img;`
7. `    public DFT_Naive_Approach() `
8. `    {`
9. `        this.real = 0.0;`
10. `        this.img = 0.0;`
11. `    }`
12. `    public static void main(String args[])`
13. `    {`
14. `        int N = 10;`
15. `        Scanner sc = new Scanner(System.in);`
16. `        System.out.println("Disd=crete Fourier Transform using naive method");`
17. `        System.out.println("Enter the coefficient of simple linear funtion:");`
18. `        System.out.println("ax + by = c");`
19. `        double a = sc.nextDouble();`
20. `        double b = sc.nextDouble();`
21. `        double c = sc.nextDouble();`
22. ` `
23. `        double []function = new double[N];`
24. `        for(int i=0; i<N; i++)`
25. `        {`
26. `            function[i] = (((a*(double)i) + (b*(double)i)) - c);`
27. `        }`
28. ` `
29. `        System.out.println("Enter the max K value: ");`
30. `        int k = sc.nextInt();`
31. ` `
32. `        DFT_Naive_Approach []dft_val = new DFT_Naive_Approach[k];`
33. ` `
34. `        System.out.println("The coefficients are: ");`
35. `        for(int j=0; j<k; j++)`
36. `        {            `
37. `            dft_val[j] = new DFT_Naive_Approach();            `
38. `            for(int i=0; i<N; i++)`
39. `            {`
40. `                dft_val[j].real += function[i] * Math.cos((2 * i * j * Math.PI) / N);;`
41. `                dft_val[j].img += function[i] * Math.sin((2 * i * j * Math.PI) / N);;            `
42. `            }`
43. `            System.out.println("("+dft_val[j].real + ") - " + "("+dft_val[j].img + " i)");`
44. `        }`
45. `        sc.close();`
46. `    }`
47. `}`

Output:

```\$ javac DFT_Naive_Approach.java
\$ java DFT_Naive_Approach

Discrete Fourier Transform using naive method
Enter the coefficient of simple linear funtion:
ax + by = c
1 2 3
Enter the max K value:
20
The coefficients are:
(105.0) - (0.0 i)
(-15.00000000000001) - (-46.1652530576288 i)
(-15.00000000000001) - (-20.6457288070676 i)
(-15.000000000000005) - (-10.898137920080407 i)
(-15.000000000000004) - (-4.873795443493586 i)
(-15.0) - (1.4695761589768243E-14 i)
(-14.999999999999996) - (4.873795443493611 i)
(-15.000000000000103) - (10.898137920080355 i)
(-14.999999999999968) - (20.64572880706762 i)
(-14.999999999999922) - (46.16525305762871 i)
(105.0) - (-1.7634913907721884E-13 i)
(-15.00000000000012) - (-46.16525305762882 i)
(-15.000000000000053) - (-20.645728807067577 i)
(-14.999999999999911) - (-10.898137920080416 i)
(-15.000000000000037) - (-4.87379544349373 i)
(-15.0) - (1.0803613098771371E-13 i)
(-14.999999999999984) - (4.873795443493645 i)
(-14.99999999999996) - (10.89813792008029 i)
(-14.999999999999677) - (20.645728807067492 i)
(-14.999999999999769) - (46.16525305762875 i)```

Sanfoundry Global Education & Learning Series – 1000 Java Programs. 