diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..2b6a312
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,21 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "windowsSdkVersion": "10.0.19041.0",
+            "compilerPath": "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "windows-msvc-x64"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/5_practice.c b/5_practice.c
index 70d6651..9f36ffc 100644
--- a/5_practice.c
+++ b/5_practice.c
@@ -9,32 +9,43 @@ int main() {
 	time_t t;
 
 	// Input the number N
-	
+	printf("Enter N = ");
+	scanf("%d",&N);
 	
 	// Locate the memory for x, yr, yi;
-
-	// Initial setting for x, for example, x[k] = k
-	
-	
+	x = (double *) malloc(N*sizeof(double));
+	yr = (double *) malloc(N*sizeof(double));
+	yi = (double *) malloc(N*sizeof(double));
 	
+	// Initial setting for x, for example, x[k] = k
+	for(int i = 0; i<N; i++){
+		x[i] = i;
+		yr[i] = 0.0;
+		yi[i] = 0.0;
+	}
 	
 	t = clock();	
 	// yr[n]+i*yi[n] = sum(exp(-i 2 Pi k n / N)*x[k], k=0..N-1), n=0..N-1 
-
-
-
-
-
-
+	//					cos(2 PI k n / N)		i sin(2 PI k n / N)
+	double tmp = 2*M_PI/N;
+	double theta;
+	for (int i = 1; i<N; i++){
+ 		for(int j = 1; j<N; j++){
+			theta = tmp*i*j;
+			yr[i] += cos(theta)*x[i];
+			yi[i] -= sin(theta)*x[i];
+		}
+	}
 
 	// output the results
 	t = clock() - t;
 	printf("%d ms for discrete Fourier Transform of %d elements\n", t, N);
 
 	// free the memory located by x, yr, yi
-	
-	
-	
-	return 100;
+	free(yi);
+	free(yr);
+	free(x);
+
+	return 0;
 }
 
diff --git a/FFTP.c b/FFTP.c
new file mode 100644
index 0000000..63d7d51
--- /dev/null
+++ b/FFTP.c
@@ -0,0 +1,130 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "complex.h"
+
+int roundup(int a, int b){
+    int c;
+    if(a%b){
+        a += (b-a%b);
+    }
+    c = a/b;
+    return c;
+}
+
+complex FFTP(complex *y, complex *x, int N, int p){
+    
+    //declare some variables 
+    int i, j, k, Np = N/p;     //i,j,k for index using
+
+    //prime factorization
+    //delcare some variables
+    int nextp, nextN, psize;
+    int *prime, *ptime;     //record prime and square number
+    int Ntmp = N, index = 0, t, ctrl, final;
+
+    //memory allocation for prime and its square number
+    psize = roundup(N,2);
+    prime = (int *) malloc( psize * sizeof(int));
+    ptime = (int *) malloc( psize * sizeof(int));
+        
+    for(i = 2; i < psize; i++){
+        t = 0;
+        while(Ntmp%i == 0){
+            Ntmp /= i;
+            t++;                //sum up square number
+            ctrl = 1;           //switch the position of the array
+        }
+
+        if(ctrl == 1){
+            prime[index] = i;   //prime        
+            ptime[index] = t;   //square number of the prime resp.
+            index++;
+        }
+        ctrl = 0;
+    }
+    if(!index){
+        nextp = N;
+        final = 1;              //as N = p, do the final FFT
+        prime[index] = N;
+        ptime[index] = 1;
+    }else if(ptime[index-1] > 1){
+        nextp = prime[index-1];
+    }else{
+        nextp = prime[index-2];
+    }
+
+    //FFTP
+    if(Np == 1 || final){
+        p = N;
+        complex *w;
+        w = (complex *) malloc( p * sizeof(complex) );
+        for(i = 0; i < p; i++){
+            w[i] = wtrans(N,i);
+        }
+        for(i = 0; i < p; i++){
+            y[i].Re = 0;
+            y[i].Im = 0;
+            for(j = 0; j < p; j++){
+                y[i] = Cadd(y[i], Cmulti( x[j] ,w[(i*j)%N] ) );
+            } 
+        }
+        free(w);
+    }else{
+
+        //memory allocation for subseq
+        nextN = N / nextp;
+        complex **xsub, **ysub;
+        xsub = (complex **) malloc( nextp * sizeof(complex) );
+        ysub = (complex **) malloc( nextp * sizeof(complex) );
+        for(i = 0; i < nextp; i++){
+            xsub[i] = (complex *) malloc( nextN * sizeof(complex) );
+            ysub[i] = (complex *) malloc( nextN * sizeof(complex) );
+        }
+
+        //assign x subseq and y
+        for(i = 0; i < nextN; i++){
+            for(j = 0; j < nextp; j++){
+                xsub[i][j] = x[nextp*j + i];
+                y[i*nextN + j].Re = 0;
+                y[i*nextN + j].Im = 0;
+            }
+        }
+
+        //do the subseq FFT
+        for(i = 0;i < nextp; i++){
+            FFTP( *(ysub+i), *(xsub+i), nextN, nextp);
+        }
+
+        //combine the subseq 
+        complex *w;
+        w = (complex *) malloc( nextp * sizeof(complex));
+        for( j = 0; j < nextp; j++){
+            w[j] = wtrans(N,i);
+        }
+        for(i = 0; i < nextp; i++){
+            for( j = 0; j < nextN; j++){
+                for(k = 0; k < nextp; k++){
+                    y[ nextp * i + j ] = Cadd( y[ nextp * i + j ] , \
+					Cmulti(ysub[k][j], w[ ( k* (i*N/p+j) ) %N] ) );
+                }
+            }
+        }
+        //free every memory
+        free(w);
+        for(i = 0; i < nextp; i++){
+            free(xsub[i]);
+            free(ysub[i]);
+        }
+        free(xsub);free(ysub);
+        
+    }
+
+    free(prime);free(ptime);
+
+    //end
+    complex c;
+    c.Re = 0;
+    c.Im = 0;
+    return c;
+}
diff --git a/FFT_235.c b/FFT_235.c
new file mode 100644
index 0000000..f673901
--- /dev/null
+++ b/FFT_235.c
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+#include "fft.h"
+
+//declare the function FFT
+int FFT(double *yr, double *yi, double *xr, double *xi, int N);
+
+int main(){
+
+    //declare variables
+    //Suppose N is the total number, pqr are square of 235 respec.
+    //Suppose 
+    int k, n, N, p, q, r, ctrl;
+    double *xr, *xi, *yr, *yi, t, a, b, an, bn, c, s;
+    time_t T;
+
+    xr = (double *) malloc(N*sizeof(double));
+    xi = (double *) malloc(N*sizeof(double));
+    yr = (double *) malloc(N*sizeof(double));
+    yi = (double *) malloc(N*sizeof(double));
+
+    printf("Memory Done! \n");
+
+    for(k = 0;k<5;++k){
+        printf("%d: %f \n",k,xr[k]);
+    }
+
+    T = clock();
+
+    a = cos(2 * M_PI / N); b = sin(2 * M_PI / N);
+    an = 1; bn = 0;
+    for(n = 0; n < N; n++){
+        yr[n] = 0.0;
+        yi[n] = 0.0;
+        c = 1; s = 0;
+        for(k = 0; k<N; ++k){
+            yr[n] += c*xr[k];
+            yi[n] -= s*xr[k];
+            t = c * an - bn * b;
+            s = c * bn + s * an;
+            c = t;
+        }
+        t = an * a - bn * b;
+        bn = an * b + bn * a;
+        an = t;
+    }
+
+    T = clock() - T;
+    printf("%d ms for DFT of %d elements\n",T,N);
+
+    free(xr);free(xi);free(yr);free(yi);
+
+    return 0;
+}
+
+int FFT(double *yr, double *yi, double *xr, double *xi, int N){
+    if(N == 2){
+        yr[0] = xr[0]+xr[1];
+        yi[0] = xi[0]+xi[1];
+        yr[1] = xr[0]-xr[1];
+        yr[1] = xi[0]-xi[1];
+    } else {
+        int k;
+        double *yEr, *yEi, *yOr, *yOi;
+        double *xEr, *xEi, *xOr, *xOi;
+        double c, s;
+
+        xEr = (double *) malloc((N/2)*sizeof(double));
+        xEi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yEi = (double *) malloc((N/2)*sizeof(double));
+        xOr = (double *) malloc((N/2)*sizeof(double));
+        xOi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yOi = (double *) malloc((N/2)*sizeof(double));
+        
+        for(k = 0; k<N/2; ++k){
+            xEr[k] = xr[2*k];
+            xEi[k] = xi[2*k];
+            xOr[k] = xr[2*k+1];
+            xOi[k] = xi[2*k+1];
+
+        }
+        FFT(yEr, yEi, xEr, xEi, N/2);
+        FFT(yOr, yOi, xOr, xOi, N/2);
+        for(k = 0; k < N/2; ++k){
+            c = cos(2*M_PI*k/N);
+            s = -sin(2*M_PI*k/N);
+            yr[k] = yEr[k] + (yOr[k]*c - yOi[k]*s);
+            yi[k] = yEi[k] + (yOr[k]*s + yOi[k]*c);
+            yr[N/2+k] = yEr[k] - (yOr[k]*c - yOi[k]*s);
+            yi[N/2+k] = yEi[k] - (yOr[k]*s + yOi[k]*c);
+        }
+        
+        free(xEr);free(xEi);
+        free(xOr);free(xOi);
+        free(yEr);free(yEi);
+        free(yOr);free(yOi);
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/Readme_FFT.txt b/Readme_FFT.txt
new file mode 100644
index 0000000..55c9062
--- /dev/null
+++ b/Readme_FFT.txt
@@ -0,0 +1,3 @@
+我的FFT設計的想法是對於任意數N，先做質因數分解，依據最大質數p_max做子序列分割，所以就會有p_max個長度為N/p_max的子序列，接這對這些子序列再做一樣的步驟，直到每個子序列的元素數量為質數便開始做最低層的傅立葉相加，接著往上堆疊回去得到最後的答案。
+
+現在時間是4/29 23:55，目前的進度是有跑，但是跑出來數據不太對，目前推測是在FFT疊代的時候出了問題。
diff --git a/fft.c b/fft.c
new file mode 100644
index 0000000..298fe34
--- /dev/null
+++ b/fft.c
@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+
+int FFT(double *yr, double *yi, double *xr, double *xi, int N);
+
+int main(){
+    int k,n,N;
+    double *xr, *xi, *yr, *yi, *zr, *zi, *ur, *ui, t, a, b, an, bn, c, s;
+    time_t T;
+
+    FILE *fp;
+    char ch;
+    int L = 0;
+    fp = fopen("wave.csv","r");
+    while(!feof(fp)){
+        ch = fgetc(fp);
+        if(ch=='\n'){
+            L++;
+        }
+    }
+    fclose(fp);
+    printf("Total Lines: %d \n",L);
+
+    N = 1;
+    while(N<L){
+        N = N * 2;
+    }
+    N = N / 2;
+    printf("Line: %d, Use: %d \n",L,N);
+
+    xr = (double *) malloce(N*sizeof(double));
+    xi = (double *) malloce(N*sizeof(double));
+    yr = (double *) malloce(N*sizeof(double));
+    yi = (double *) malloce(N*sizeof(double));
+    zr = (double *) malloce(N*sizeof(double));
+    zi = (double *) malloce(N*sizeof(double));
+    ur = (double *) malloce(N*sizeof(double));
+    ui = (double *) malloce(N*sizeof(double));
+
+    printf("Memory Done! \n");
+
+    fp = fopen("file","r");
+    for(k = 0;k<N;k++){
+        fscanf(fp,"%d %d", &n, &L);
+        xr[k] = 1.0*L;
+        xi[k] = 0.0;
+    }
+    fclose(fp);
+
+    for(k = 0;k<5;++k){
+        printf("%d: %f \n",k,xr[k]);
+    }
+
+    T = clock();
+
+    a = cos(2 * M_PI / N); b = sin(2 * M_PI / N);
+    an = 1; bn = 0;
+    for(n = 0; n < N; n++){
+        yr[n] = 0.0;
+        yi[n] = 0.0;
+        c = 1; s = 0;
+        for(k = 0; k<N; ++k){
+            yr[n] += c*xr[k];
+            yi[n] -= s*xr[k];
+            t = c * an - bn * b;
+            s = c * bn + s * an;
+            c = t;
+        }
+        t = an * a - bn * b;
+        bn = an * b + bn * a;
+        an = t;
+    }
+
+    T = clock() - T;
+    printf("%d ms for DFT of %d elements\n",T,N);
+
+    T = clock();
+    FFT(zr, zi, xr, xi, N);
+    T = clock() - T;
+    printf("%d ms for FFT of %d elements\n", T, N);
+
+    t = 0;
+    for(k = 0; k<N; ++k){
+        t += pow((yr[k] - zr[k]),2) + pow((yi[k] - zi[k]),2);
+    }
+    printf("Error: %e\n",sqrt(t/N));
+
+    t = 0;
+    for(k = 0; k<N; ++k){
+        if(sqrt(zr[k]*zr[k]+zi[k]*zi[k])>t){
+            n = k;
+            t = sqrt(zr[k]*zr[k]+zi[k]*zi[k]);
+        }
+    }
+    printf("mazimum at %d, value = %f\n", n, t/N*2);
+    printf("BPM %f\n",60.0*n/(N/240)); //240 = Sample Rate
+
+    free(xr);free(xi);free(yr);free(yi);
+
+    return 0;
+
+}
+
+int FFT(double *yr, double *yi, double *xr, double *xi, int N){
+    if(N == 2){
+        yr[0] = xr[0]+xr[1];
+        yi[0] = xi[0]+xi[1];
+        yr[1] = xr[0]-xr[1];
+        yr[1] = xi[0]-xi[1];
+    } else {
+        int k;
+        double *yEr, *yEi, *yOr, *yOi;
+        double *xEr, *xEi, *xOr, *xOi;
+        double c, s;
+
+        xEr = (double *) malloc((N/2)*sizeof(double));
+        xEi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yEi = (double *) malloc((N/2)*sizeof(double));
+        xOr = (double *) malloc((N/2)*sizeof(double));
+        xOi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yOi = (double *) malloc((N/2)*sizeof(double));
+        for(k = 0; k<N/2; ++k){
+            xEr[k] = xr[2*k];
+            xEi[k] = xi[2*k];
+            xOr[k] = xr[2*k+1];
+            xOi[k] = xi[2*k+1];
+
+        }
+        FFT(yEr, yEi, xEr, xEi, N/2);
+        FFT(yOr, yOi, xOr, xOi, N/2);
+        for(k = 0; k < N/2; ++k){
+            c = cos(2*M_PI*k/N);
+            s = -sin(2*M_PI*k/N);
+            yr[k] = yEr[k] + (yOr[k]*c - yOi[k]*s);
+            yi[k] = yEi[k] + (yOr[k]*s + yOi[k]*c);
+            yr[N/2+k] = yEr[k] - (yOr[k]*c - yOi[k]*s);
+            yi[N/2+k] = yEi[k] - (yOr[k]*s + yOi[k]*c);
+        }
+        
+        free(xEr);free(xEi);
+        free(xOr);free(xOi);
+        free(yEr);free(yEi);
+        free(yOr);free(yOi);
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/fft.h b/fft.h
new file mode 100644
index 0000000..2dc52d8
--- /dev/null
+++ b/fft.h
@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <complex.h>
+
+int roundup(int a, int b){
+    int c;
+    if(a%b){
+        a += (b-a%b);
+    }
+    c = a/b;
+    return c;
+}
+
+complex FFT(complex *y, complex *x, int N){
+    //declare some variables 
+    int i, j, k, tmp;     //i,j,k for index using
+
+    //prime factorization
+    //delcare some variables
+    int nextp, nextN, psize;
+    int *prime, *ptime;     //record prime and square number
+    int Ntmp = N, index = 0, t, ctrl, final=0;
+
+    //memory allocation for prime and its square number
+    psize = roundup(N,2);
+    prime = (int *) malloc( psize * sizeof(int));
+    ptime = (int *) malloc( psize * sizeof(int));
+
+    for(i = 2; i < N; i++){
+        t = 0;
+        while(Ntmp%i == 0){
+            Ntmp /= i;
+            t++;                //sum up square number
+            ctrl = 1;           //switch the position of the array
+        }
+
+        if(ctrl == 1){
+            prime[index] = i;   //prime        
+            ptime[index] = t;   //square number of the prime resp.
+            index++;
+        }
+        ctrl = 0;
+    }
+    prime[index] = N;
+    ptime[index] = 1;
+
+    if((prime[0] == N && ptime[0] == 1)||(!index)){  //as N = p, do the final FFT
+        nextp = N;
+        final = 1;
+        //printf("1. N is %d, nextp is %d \n",N,nextp);
+    }else if(ptime[index-1] >= 1){
+        nextp = prime[index-1];
+        //printf("2. N is %d, nextp is %d \n",N,nextp);
+    }else{
+        nextp = prime[index-2];
+    }
+
+    //FFT
+    complex wN = cexp(-2*M_PI*I/N);
+
+    complex *w;
+    w = (complex *) malloc( N * sizeof(complex) );
+    for( j = 0; j < N; j++){
+            w[j] = cpow(wN,j);
+    }
+    if(final){      //final subseq, p = N
+        for(i = 0; i < N; i++){
+            for(j = 0; j < N; j++){
+                y[i] += x[j] * w[(i*j)%N];
+            } 
+        }
+    }
+    else{
+
+        complex *xsub, *ysub;
+        xsub = (complex *) malloc( N * sizeof(complex) );
+        ysub = (complex *) malloc( N * sizeof(complex) );
+
+        //memory allocation for subseq
+        nextN = N/nextp;
+
+        //assign x subseq and set y zero seq
+        for(i = 0; i < nextp; i++){
+            tmp = nextN*i;
+            for(j = 0; j < nextN; j++){
+                index = j + tmp;
+                xsub[index] = x[nextp*j + i];
+                ysub[index] = 0;
+            }
+        }
+        tmp = 0;index = 0;
+
+        //do the subseq FFT
+        for(i = 0; i < nextp; i++){
+            FFT( ysub+i*nextN, xsub+i*nextN, nextN);
+        }
+
+        for(i = 0; i < nextp; i++){           //in how many parts
+            tmp = nextN*i;
+            for( j = 0; j < nextN; j++){      //seq index
+                index = tmp + j;
+                for(k = 0; k < nextp; k++){   //subseq index
+                    y[index] += ysub[nextN*k+j] * w[(k*index)%N];
+                }
+            }
+        }
+        index = 0;
+        free(ysub);
+        free(xsub);
+    }
+    free(w);
+    free(ptime);
+    free(prime);
+
+    return 0;
+}
+
+int max_prime(int N){
+    int i, p = 1, ctrl = 0, Ntmp = N;
+    for(i = 2; i < roundup(N,2); i++){
+        while( Ntmp%i == 0){
+            Ntmp /= i;
+            ctrl = 1;
+            p = i;
+        }
+    }
+    if(ctrl == 0){
+        p = N;
+    }
+    return p;
+}
\ No newline at end of file
diff --git a/fft_shu.cpp b/fft_shu.cpp
new file mode 100644
index 0000000..5648528
--- /dev/null
+++ b/fft_shu.cpp
@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+
+int FFT(double *yr, double *yi, double *xr, double *xi, int N);
+
+int main(){
+    int k,n,N;
+    double *xr, *xi, *yr, *yi, *zr, *zi, *ur, *ui, t, a, b, an, bn, c, s;
+    time_t T;
+
+    FILE *fp;
+    char ch;
+    int L = 0;
+    fp = fopen("wave.csv","r");
+    while(!feof(fp)){
+        ch = fgetc(fp);
+        if(ch=='\n'){
+            L++;
+        }
+    }
+    fclose(fp);
+    printf("Total Lines: %d \n",L);
+
+    N = 1;
+    while(N<L){
+        N = N * 2;
+    }
+    N = N / 2;
+    printf("Line: %d, Use: %d \n",L,N);
+
+    xr = (double *) malloc(N*sizeof(double));
+    xi = (double *) malloc(N*sizeof(double));
+    yr = (double *) malloc(N*sizeof(double));
+    yi = (double *) malloc(N*sizeof(double));
+    zr = (double *) malloc(N*sizeof(double));
+    zi = (double *) malloc(N*sizeof(double));
+    ur = (double *) malloc(N*sizeof(double));
+    ui = (double *) malloc(N*sizeof(double));
+
+    printf("Memory Done! \n");
+
+    fp = fopen("file","r");
+    for(k = 0;k<N;k++){
+        fscanf(fp,"%d %d", &n, &L);
+        xr[k] = 1.0*L;
+        xi[k] = 0.0;
+    }
+    fclose(fp);
+
+    for(k = 0;k<5;++k){
+        printf("%d: %f \n",k,xr[k]);
+    }
+
+    T = clock();
+
+    a = cos(2 * M_PI / N); b = sin(2 * M_PI / N);
+    an = 1; bn = 0;
+    for(n = 0; n < N; n++){
+        yr[n] = 0.0;
+        yi[n] = 0.0;
+        c = 1; s = 0;
+        for(k = 0; k<N; ++k){
+            yr[n] += c*xr[k];
+            yi[n] -= s*xr[k];
+            t = c * an - bn * b;
+            s = c * bn + s * an;
+            c = t;
+        }
+        t = an * a - bn * b;
+        bn = an * b + bn * a;
+        an = t;
+    }
+
+    T = clock() - T;
+    printf("%d ms for DFT of %d elements\n",T,N);
+
+    T = clock();
+    FFT(zr, zi, xr, xi, N);
+    T = clock() - T;
+    printf("%d ms for FFT of %d elements\n", T, N);
+
+    t = 0;
+    for(k = 0; k<N; ++k){
+        t += pow((yr[k] - zr[k]),2) + pow((yi[k] - zi[k]),2);
+    }
+    printf("Error: %e\n",sqrt(t/N));
+
+    t = 0;
+    for(k = 0; k<N; ++k){
+        if(sqrt(zr[k]*zr[k]+zi[k]*zi[k])>t){
+            n = k;
+            t = sqrt(zr[k]*zr[k]+zi[k]*zi[k]);
+        }
+    }
+    printf("mazimum at %d, value = %f\n", n, t/N*2);
+    printf("BPM %f\n",60.0*n/(N/240)); //240 = Sample Rate
+
+    free(xr);free(xi);free(yr);free(yi);
+
+    return 0;
+
+}
+
+int FFT(double *yr, double *yi, double *xr, double *xi, int N){
+    if(N == 2){
+        yr[0] = xr[0]+xr[1];
+        yi[0] = xi[0]+xi[1];
+        yr[1] = xr[0]-xr[1];
+        yr[1] = xi[0]-xi[1];
+    } else {
+        int k;
+        double *yEr, *yEi, *yOr, *yOi;
+        double *xEr, *xEi, *xOr, *xOi;
+        double c, s;
+
+        xEr = (double *) malloc((N/2)*sizeof(double));
+        xEi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yEi = (double *) malloc((N/2)*sizeof(double));
+        xOr = (double *) malloc((N/2)*sizeof(double));
+        xOi = (double *) malloc((N/2)*sizeof(double));
+        yEr = (double *) malloc((N/2)*sizeof(double));
+        yOi = (double *) malloc((N/2)*sizeof(double));
+        for(k = 0; k<N/2; ++k){
+            xEr[k] = xr[2*k];
+            xEi[k] = xi[2*k];
+            xOr[k] = xr[2*k+1];
+            xOi[k] = xi[2*k+1];
+
+        }
+        FFT(yEr, yEi, xEr, xEi, N/2);
+        FFT(yOr, yOi, xOr, xOi, N/2);
+        for(k = 0; k < N/2; ++k){
+            c = cos(2*M_PI*k/N);
+            s = -sin(2*M_PI*k/N);
+            yr[k] = yEr[k] + (yOr[k]*c - yOi[k]*s);
+            yi[k] = yEi[k] + (yOr[k]*s + yOi[k]*c);
+            yr[N/2+k] = yEr[k] - (yOr[k]*c - yOi[k]*s);
+            yi[N/2+k] = yEi[k] - (yOr[k]*s + yOi[k]*c);
+        }
+        
+        free(xEr);free(xEi);
+        free(xOr);free(xOi);
+        free(yEr);free(yEi);
+        free(yOr);free(yOi);
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/prime_fac.c b/prime_fac.c
new file mode 100644
index 0000000..e8ad373
--- /dev/null
+++ b/prime_fac.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void p_fac(int N, int &p, int &q, int &r);
+
+int main(){
+	int N = 10800000, p = 0, q = 0, r = 0;
+	
+	p_fac(N, p, q, r);
+	
+	printf("p = %d, q = %d, r = %d\n", p, q, r);
+	
+	return 0;
+}
+
+void p_fac(int N, int &p, int &q, int &r){
+	while(N%5==0){
+		r++;
+		N /= 5;
+	}
+	while(N%3==0){
+		q++;
+		N /= 3;
+	}
+	while(N%2==0){
+		p++;
+		N /= 2;
+	}
+}
\ No newline at end of file
diff --git a/prime_fac.h b/prime_fac.h
new file mode 100644
index 0000000..563629a
--- /dev/null
+++ b/prime_fac.h
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void p_fac(int N, int &p, int &q, int &r, int &ctrl){
+	int O = N;
+
+	while(N%5==0){
+		r++;
+		N /= 5;
+	}
+	while(N%3==0){
+		q++;
+		N /= 3;
+	}
+	while(N%2==0){
+		p++;
+		N /= 2;
+	}
+
+	if( ( p==0 & q==0 & r==0 ) || N!=1 ){
+		ctrl = 1;
+		printf("The number %d doesn't have prime factorization in 2,3,5\n",O);
+	}
+}
+
+int roundup(int a, int b){
+    int c;
+    if(a%b){
+        a += (b-a%b);
+    }
+    c = a/b;
+    return c;
+}
diff --git a/quick_sort.c b/quick_sort.c
new file mode 100644
index 0000000..a338359
--- /dev/null
+++ b/quick_sort.c
@@ -0,0 +1,95 @@
+#include <stdio.h>	// for printf function
+#include <stdlib.h>	// for memory allocation
+#include <time.h>	// for time calculation
+#include <math.h>	// for sine and cosine functions
+int main() {
+	// Declare all the variables
+	int k, m, n, N;
+	double *x, *y, z, p;
+	time_t t;
+
+	// Input the number N
+	printf("Input N: ");
+	scanf("%d",&N);
+	
+	// Locate the memory for x and y;
+	x = (double *) malloc(N*sizeof(double));
+	y = (double *) malloc(N*sizeof(double));
+
+	// Initial setting for x, for example, x[k] = 1.0*rand()/RAND_MAX
+	srand( time(NULL) );
+	for(k=0;k<N;++k){
+		x[k] = y[k] = 1.0*rand()/RAND_MAX;
+	}
+	
+	t = clock();	
+	// sorting x (bubble sort) from small to large
+	for(n=0;n<N;++n) {
+		for(k=n+1;k<N;++k) {
+			if (x[n] > x[k]) {
+				z = x[n];
+				x[n] = x[k];
+				x[k] = z;
+			}
+		}
+	}
+	t = clock() - t;
+
+	// print y, x, and time
+	printf("Sorting %d elements: %f s\n", N, 1.0*t/CLOCKS_PER_SEC);
+	if(N<10) {
+		printf("y \t\t x\n");
+		for(k=0;k<N;++k) {
+			printf("%f\t%f\n",y[k],x[k]);
+		}
+	}
+
+	// reset x
+	for(k=0;k<N;++k){
+		x[k] = y[k];
+	}
+
+	// quick sort
+	t = clock();
+	quick_sort(x, 0, N);
+	t = clock() - t;	
+	
+	// free the memory located by x, y
+	free(x);
+	free(y);	
+	
+	return 0;
+}
+
+int quick_sort(double *x, int L, int R){
+	//sort from L to R-1
+
+	//set the break situation
+	if (R<L) return 0; 
+
+	//declare variables for pivot, tmp(z), index k n
+	double p, z;
+	int k, n;
+
+	//set pivot and starting index, then start the process
+	p = X[R-1]; n = L;
+	for (k = L; k < R-1; k++){
+		if(x[k] < p){
+			z = x[n];
+			x[n] = x[k];
+			x[k] = z;
+			n++;
+		}
+	}
+
+	//swap the pivot to the correct location
+	z = x[n];
+	x[n] = x[R-1];
+	x[R-1] = z;
+
+	//do the quick sort for subsequence
+	quick_sort(x,L,n);
+	quick_sort(x,n+1,R);
+	
+	return 0;
+}
\ No newline at end of file
diff --git a/result1.jpg b/result1.jpg
new file mode 100644
index 0000000..9d36859
Binary files /dev/null and b/result1.jpg differ
diff --git a/result2.jpg b/result2.jpg
new file mode 100644
index 0000000..cd15711
Binary files /dev/null and b/result2.jpg differ
diff --git a/run_fft.c b/run_fft.c
new file mode 100644
index 0000000..69f6633
--- /dev/null
+++ b/run_fft.c
@@ -0,0 +1,33 @@
+#include <time.h>
+#include "fft.h"
+
+int main(){
+    int k, n, v, i;
+	int L = 1<<20;
+    complex *x, *y;
+
+    x = (complex *) malloc( L * sizeof(complex) );
+    y = (complex *) malloc( L * sizeof(complex) );
+
+    for(k = 0;k<L;k++){
+        x[k] = k;
+        y[k] = 0.0;
+    }
+    
+    time_t T = clock();
+    printf("start FFT\n");
+    FFT(y, x, L);
+    printf("end FFT\n");
+    T = clock() - T;
+    
+    printf("Use %d ms for doing FFT.\n",T);
+    printf("Some results: \n");
+    for(i = 0; i < 10; i++){
+    	printf("y[%d] = %f + %f i  \n", i, creal(y[i]),cimag(y[i]));
+	}
+	
+	free(y);
+	free(x);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..c337741
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "complex.h"
+
+int roundup(int a, int b){
+    int c;
+    if(a%b){
+        a += (b-a%b);
+    }
+    c = a/b;
+    return c;
+}
+
+int main(){
+	int i, j, k, tmp, N = 2;     //i,j,k for index using
+
+    //prime factorization
+    //delcare some variables
+    int nextp, nextN, psize;
+    int *prime, *ptime;     //record prime and square number
+    int Ntmp = N, index = 0, t, ctrl, final;
+
+    //memory allocation for prime and its square number
+    psize = roundup(N,2);
+    prime = (int *) malloc( psize * sizeof(int));
+    ptime = (int *) malloc( psize * sizeof(int));
+        
+    for(i = 2; i <= N; i++){
+        t = 0;
+        while(Ntmp%i == 0){
+            Ntmp /= i;
+            t++;                //sum up square number
+            ctrl = 1;           //switch the position of the array
+        }
+
+        if(ctrl == 1){
+            prime[index] = i;   //prime        
+            ptime[index] = t;   //square number of the prime resp.
+            index++;
+        }
+        ctrl = 0;
+    }
+    prime[index] = N;
+    ptime[index] = 1;
+    printf("prime done\n");
+    if((prime[0] == N && ptime[0] == 1)||(!index)){  //as N = p, do the final FFT
+        printf("one time\n");
+        final = 1;              
+    }else if(ptime[index-1] > 1){
+    	printf("two time\n");
+        nextp = prime[index-1];
+    }else{
+    	printf("three time\n");
+        nextp = prime[index-2];
+    }
+}
\ No newline at end of file
diff --git a/trubleshoot.cpp b/trubleshoot.cpp
new file mode 100644
index 0000000..60d7be1
--- /dev/null
+++ b/trubleshoot.cpp
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+int main(){
+	int n = 10, m = 2,k;
+	
+	for(k = 2; k<m ;k++){
+		printf("run\n");
+	}
+	
+	return 0;
+}
\ No newline at end of file