Shared memory by 2 variables instead of pointers, 2 variables in 1 memory

//Shared memory by 2 variables instead of pointers, 2 variables in 1 memory
//współdzielenie pamięci przez 2 zmienne zamiast wskaźników, 2 zmienne w 1 pamięci
 //source:
//http://stackoverflow.com/questions/4629317/what-does-int-mean
// http://www.cplusplus.com/forum/windows/17153/
//author marcin matysek (r)ewertyn.PL
#include <iostream>
#include <conio.h>
#include <stdlib.h>

using namespace std;
void funkcja(int & nb3);

int main()
{
    int nb1=0;
    int &nb2=nb1;

    cout<<"Variable1 value= "<<nb1<<" Its address is: "<<&nb1<<endl;
    cout<<"Variable2 value= "<<nb2<<" Its address is: "<<&nb2<<endl;
    nb2=10;
    cout<<endl;
    cout<<"After modifying the 2 variables have value:"<<endl;
    cout<<"Variable1 value= "<<nb1<<" Its address is: "<<&nb1<<endl;
    cout<<"Variable2 value= "<<nb2<<" Its address is: "<<&nb2<<endl;

    funkcja(nb1);
    cout<<endl;
    cout<<"After leaving the function:"<<endl;
    cout<<"Variable1 value= "<<nb1<<" Its address is: "<<&nb1<<endl;
    cout<<"Variable2 value= "<<nb2<<" Its address is: "<<&nb2<<endl;

    system("pause");
    return 0;
}

void funkcja(int & nb3)
{
    cout<<endl;
    cout<<"in function Variable 3 have value and address of Variable1:"<<endl;
    cout<<"Variable3 value= "<<nb3<<" Its address is: "<<&nb3<<endl;
    cout<<"after modification Variable 3 ,Variable 3 In function has value:"<<endl;
    nb3=20;
    cout<<endl;
    cout<<"Variable3 value= "<<nb3<<" Its address is: "<<&nb3<<endl;
}

inverse fourier transform iFFT radix-4 for N=4096 algorithm c++ source code implementation

//source:
//https://www.google.ch/patents/US6957241
//http://www.google.ch/patents/US20020083107
//https://www.beechwood.eu/fft-implementation-r2-dit-r4-dif-r8-dif/
//http://www.cmlab.csie.ntu.edu.tw/cml/dsp/training/coding/transform/fft.html
//http://dsp.stackexchange.com/questions/3481/radix-4-fft-implementation

//author marcin matysek (r)ewertyn.PL

//szybka odwrotna transformacja fouriera iFFT radix-4 dla N=4096 algorytm c++ kod zródlowy implementacja
//inverse fourier transform iFFT radix-4 for N=4096 algorithm c++ source code implementation

#include <iostream>
#include "conio.h"
#include <stdlib.h>
#include <math.h>
#include <cmath>
#include <time.h>
#include <complex>
#include <fstream>

using namespace std;

//complex number method:
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[]);
void fun_fourier_transform_FFT_radix_4_N_4096(int N,std::complex<double> tab[]);
void fun_inverse_fourier_transform_FFT_radix_4_N_4096(int N,std::complex<double> tab[]);
void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[]);

int fi=0;


static double diffclock(clock_t clock2,clock_t clock1)
{
    double diffticks=clock1-clock2;
    double diffms=(diffticks)/(CLOCKS_PER_SEC/1000);
    return diffms;
}
int main()
{
    int N;
    //if N==period of signal in table tab[] then resolution = 1 Hz


    N=4096;
    std::complex<double> tab2[4096]={};
    std::complex<double> tab3[4096]={};


    for(int i=0;i<N;i++)
    {
        tab2[i].real()=i+1;
        tab2[i].imag()=N+i+1;
        tab3[i].real()=i+1;
        tab3[i].imag()=N+i+1;
    }

    double time2;
    double zmienna=0;

    cout<<"signal 1="<<endl;
     system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;

    cout<<"signal 2="<<endl;
     system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
     system("pause");
    clock_t start = clock();

    fun_fourier_transform_DFT_method5_full_complex(N,tab3);
    //////////////////////////////////////////////////////////
    fun_fourier_transform_FFT_radix_4_N_4096(N,tab2);
    fun_inverse_bits_radix_4(N,tab2);
    ///////////////////////////////////////////////////////////

    time2=diffclock( start, clock() );

    cout<<"frequency Hz radix-4 real()"<<endl;
    system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<"frequency Hz radix-4 imag()"<<endl;
     system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;

    cout<<"frequency Hz DFT real()"<<endl;
     system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<"frequency Hz DFT imag()"<<endl;
     system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<"if radix-4 == DFT tab2[j].real(): "<<endl;system("pause");
       for(int j=0;j<N;j++)
        {
          if(((tab3[j].real()-tab2[j].real()>=-0.03)&&(tab3[j].real()-tab2[j].real()<=0.03)))
          {

            cout.precision(4);
            cout<<round(tab2[j].real()*1000)/1000<<"  ";//system("pause");
          }
            else {
                cout<<-1<<" ........ ";
            }
        }


    system("pause");
    cout<<endl;

    /////////////////////////////////////////////////////////////////
    fun_inverse_fourier_transform_FFT_radix_4_N_4096(N,tab2);
    fun_inverse_bits_radix_4(N,tab2);
    ////////////////////////////////////////////////////////////////


    cout<<"inverse/signal= real()"<<endl;
       system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<"inverse/signal= imag()"<<endl;
    system("pause");
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;



    cout<<endl;
    system("pause");
    return 0;
}
//////////////////////////////////////////////
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[])
{


}
///////////////////////////////////////////////////
void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double> tab2[4096]={};    // tab2[]==N
    std::complex<double>  w[1]={{1,1}};


double zmienna1=2*pi/(float)N;
double fi2=fi;

for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
          //complex number method:
          w[0].real()=cos(i*j*zmienna1+fi2);
          w[0].imag()=(-sin(i*j*zmienna1+fi2));
          tab2[i]=tab2[i]+tab[j]*w[0];

    }
}

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

}
//////////////////
void fun_fourier_transform_FFT_radix_4_N_4096(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    std::complex<double>  w5[1]={{1,0}};
    std::complex<double>  w6[1]={{1,0}};
    std::complex<double> tmp1,tmp2,tmp3,tmp4;
    std::complex<double> tmp10,tmp20,tmp30,tmp40;
    int nr1=0,nr2=0,nr3=0,nr4=0,nr5=0;;
    int nb_stages=0,rx4=0;
    double tmp5;
    int increment=0;
    int nn=0;




    w5[0].real()=0;
    w5[0].imag()=-1;
    w6[0].real()=0;
    w6[0].imag()=1;

    tmp5=2*pi/(N/1);
    rx4=4;//radix-4
    nn=N;
    for(int i=0;i<100;i++)
    {

        nn=(float)nn/(float)rx4;
         if(nn>=1.0)
         {
         nb_stages++;
         }
    }
//stage 1
        for(int i=0;i<(N/rx4);i++)
        {
          w1[0].real()=cos(0*tmp5);
          w1[0].imag()=-sin(0*tmp5);
          w2[0].real()=cos(0*tmp5);
          w2[0].imag()=-sin(0*tmp5);
          w3[0].real()=cos(0*tmp5);
          w3[0].imag()=-sin(0*tmp5);
          w4[0].real()=cos(0*tmp5);
          w4[0].imag()=-sin(0*tmp5);

          tmp1=w1[0]*tab[i+0];
          tmp2=w2[0]*tab[i+N/4];
          tmp3=w3[0]*tab[i+N/2];
          tmp4=w4[0]*tab[i+3*N/4];
         //radix-4
        tmp10=tmp1+tmp2+       tmp3+tmp4;
        tmp20=tmp1-tmp3+w5[0]*(tmp2-tmp4);
        tmp30=tmp1-tmp2+       tmp3-tmp4;
        tmp40=tmp1-tmp3+w6[0]*(tmp2-tmp4);
          tab[i]       =tmp10;
          tab[i+N/4]   =tmp20;
          tab[i+N/2]   =tmp30;
          tab[i+3*N/4] =tmp40;
        }
/////////////////////////////////////////////////////////////////////////////////

    increment=0;

    for(int stg=1;stg<nb_stages;stg++)
    {
    nr1=pow(rx4,0+increment);
    nr2=pow(rx4,1+increment);
    nr3=pow(rx4,2+increment);
    nr4=pow(rx4,(nb_stages-2-increment));
    nr5=pow(rx4,0+increment);
    for(int m=0;m<nr5;m++)//stage 2
    {
        for(int i=0;i<rx4;i++)
        {
            for(int j=0;j<nr4;j++)
            {
                w1[0].real()= cos((nr5*0*i*(j+nr4*0)+nr5*1*i*j)*tmp5);
                w1[0].imag()=-sin((nr5*0*i*(j+nr4*0)+nr5*1*i*j)*tmp5);
                w2[0].real()= cos((nr5*1*i*(j+nr4*1)+nr5*0*i*j)*tmp5);
                w2[0].imag()=-sin((nr5*1*i*(j+nr4*1)+nr5*0*i*j)*tmp5);
                w3[0].real()= cos((nr5*2*i*(j+nr4*1)-nr5*1*i*j)*tmp5);
                w3[0].imag()=-sin((nr5*2*i*(j+nr4*1)-nr5*1*i*j)*tmp5);
                w4[0].real()= cos((nr5*3*i*(j+nr4*1)-nr5*2*i*j)*tmp5);
                w4[0].imag()=-sin((nr5*3*i*(j+nr4*1)-nr5*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp2=w2[0]*tab[1*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp3=w3[0]*tab[2*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp4=w4[0]*tab[3*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                //radix-4
                tmp10=tmp1+tmp2+       tmp3+tmp4;
                tmp20=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tmp30=tmp1-tmp2+       tmp3-tmp4;
                tmp40=tmp1-tmp3+w6[0]*(tmp2-tmp4);

                tab[0*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp10;
                tab[1*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp20;
                tab[2*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp30;
                tab[3*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp40;
            }
        }
    }
    increment++;
}
////////////////////////////////////////////////////////////////////////////////
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*2/N;
      tab[j].imag() =tab[j].imag()*2/N;
    }

}
////////////////////////////////

void fun_inverse_fourier_transform_FFT_radix_4_N_4096(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    std::complex<double>  w5[1]={{1,0}};
    std::complex<double>  w6[1]={{1,0}};
    std::complex<double> tmp1,tmp2,tmp3,tmp4;
    std::complex<double> tmp10,tmp20,tmp30,tmp40;
    int nr1=0,nr2=0,nr3=0,nr4=0,nr5=0;;
    int nb_stages=0,rx4=0;
    double tmp5;
    int increment=0;
    int nn=0;


    w5[0].real()=0;
    w5[0].imag()=1;
    w6[0].real()=0;
    w6[0].imag()=-1;

    tmp5=2*pi/(N/1);
    rx4=4;//radix-4
    nn=N;
    for(int i=0;i<100;i++)
    {

        nn=(float)nn/(float)rx4;
         if(nn>=1.0)
         {
         nb_stages++;
         }
    }
//stage 1
        for(int i=0;i<(N/rx4);i++)
        {
          w1[0].real()=cos(0*tmp5);
          w1[0].imag()= sin(0*tmp5);
          w2[0].real()=cos(0*tmp5);
          w2[0].imag()= sin(0*tmp5);
          w3[0].real()=cos(0*tmp5);
          w3[0].imag()= sin(0*tmp5);
          w4[0].real()=cos(0*tmp5);
          w4[0].imag()= sin(0*tmp5);

          tmp1=w1[0]*tab[i+0];
          tmp2=w2[0]*tab[i+N/4];
          tmp3=w3[0]*tab[i+N/2];
          tmp4=w4[0]*tab[i+3*N/4];
         //radix-4
        tmp10=tmp1+tmp2+       tmp3+tmp4;
        tmp20=tmp1-tmp3+w5[0]*(tmp2-tmp4);
        tmp30=tmp1-tmp2+       tmp3-tmp4;
        tmp40=tmp1-tmp3+w6[0]*(tmp2-tmp4);
          tab[i]       =tmp10;
          tab[i+N/4]   =tmp20;
          tab[i+N/2]   =tmp30;
          tab[i+3*N/4] =tmp40;
        }
/////////////////////////////////////////////////////////////////////////////////

    increment=0;

    for(int stg=1;stg<nb_stages;stg++)
    {
    nr1=pow(rx4,0+increment);
    nr2=pow(rx4,1+increment);
    nr3=pow(rx4,2+increment);
    nr4=pow(rx4,(nb_stages-2-increment));
    nr5=pow(rx4,0+increment);
    for(int m=0;m<nr5;m++)//stage 2
    {
        for(int i=0;i<rx4;i++)
        {
            for(int j=0;j<nr4;j++)
            {
                w1[0].real()= cos((nr5*0*i*(j+nr4*0)+nr5*1*i*j)*tmp5);
                w1[0].imag()= sin((nr5*0*i*(j+nr4*0)+nr5*1*i*j)*tmp5);
                w2[0].real()= cos((nr5*1*i*(j+nr4*1)+nr5*0*i*j)*tmp5);
                w2[0].imag()= sin((nr5*1*i*(j+nr4*1)+nr5*0*i*j)*tmp5);
                w3[0].real()= cos((nr5*2*i*(j+nr4*1)-nr5*1*i*j)*tmp5);
                w3[0].imag()= sin((nr5*2*i*(j+nr4*1)-nr5*1*i*j)*tmp5);
                w4[0].real()= cos((nr5*3*i*(j+nr4*1)-nr5*2*i*j)*tmp5);
                w4[0].imag()= sin((nr5*3*i*(j+nr4*1)-nr5*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp2=w2[0]*tab[1*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp3=w3[0]*tab[2*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                tmp4=w4[0]*tab[3*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j];
                //radix-4
                tmp10=tmp1+tmp2+       tmp3+tmp4;
                tmp20=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tmp30=tmp1-tmp2+       tmp3-tmp4;
                tmp40=tmp1-tmp3+w6[0]*(tmp2-tmp4);

                tab[0*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp10;
                tab[1*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp20;
                tab[2*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp30;
                tab[3*N/(nr3)+N/(nr2)*i+N/(nr1)*m+j]=tmp40;
            }
        }
    }
    increment++;
}
/////////////////////////////////////////////////////////////
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*0.5;
      tab[j].imag() =tab[j].imag()*0.5;
    }

}
//////////////////








//this is new in that method:


//when you want to have equal results that are in false modificator in normal FFT then change this:
/*
 fun_fourier_transform_FFT_radix_4_N_256_official
{
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*2/N;
      tab[j].imag() =tab[j].imag()*2/N;
    }
}
//and:

fun_inverse_fourier_transform_FFT_radix_4_N_256_official
{
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*0.5;
      tab[j].imag() =tab[j].imag()*0.5;
    }
}

//for official modificator that is only in inverse FFT:

 fun_fourier_transform_FFT_radix_4_N_256_official
{

}
fun_inverse_fourier_transform_FFT_radix_4_N_256_official
{
    for(int i=0;i<N;i++)
    {
        tablica1[0][i]=tablica1[0][i]*1/(float)N;
        tablica1[1][i]=tablica1[1][i]*1/(float)N;
    }
}

*/



//haven't try it with other function that cos(x)+jsin(x)=sin(x+pi/2)+jsin(x)

fast inverse fourier transform iFFT radix-4 for N=1024 algorithm c++ source code implementation

//source:
//https://www.google.ch/patents/US6957241
//http://www.google.ch/patents/US20020083107
//https://www.beechwood.eu/fft-implementation-r2-dit-r4-dif-r8-dif/
//http://www.cmlab.csie.ntu.edu.tw/cml/dsp/training/coding/transform/fft.html
//http://dsp.stackexchange.com/questions/3481/radix-4-fft-implementation

//author marcin matysek (r)ewertyn.PL
//fast inverse fourier transform iFFT radix-4 for N=1024 algorithm c++ source code implementation
//szybka odwrotna transformacja fouriera iFFT radix-4 dla N=1024 algorytm c++ kod źródłowy implementacja

#include <iostream>
#include "conio.h"
#include <stdlib.h>
#include <math.h>
#include <cmath>
#include <time.h>
#include <complex>
#include <fstream>

using namespace std;

//complex number method:
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[]);
void fun_fourier_transform_FFT_radix_4_N_1024(int N,std::complex<double> tab[]);
void fun_inverse_fourier_transform_FFT_radix_4_N_1024(int N,std::complex<double> tab[]);
void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[]);

int fi=0;


static double diffclock(clock_t clock2,clock_t clock1)
{
    double diffticks=clock1-clock2;
    double diffms=(diffticks)/(CLOCKS_PER_SEC/1000);
    return diffms;
}
int main()
{
    int N;
    //if N==period of signal in table tab[] then resolution = 1 Hz

    N=1024;
    std::complex<double> tab2[4096]={};
    std::complex<double> tab3[4096]={};
    for(int i=0;i<N;i++)
    {
        tab2[i].real()=i+1;
        tab2[i].imag()=N+i+1;
        tab3[i].real()=i+1;
        tab3[i].imag()=N+i+1;
    }

    double time2;
    double zmienna=0;

    cout<<"signal 1="<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;

    cout<<"signal 2="<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
     system("pause");
    clock_t start = clock();

    fun_fourier_transform_DFT_method5_full_complex(N,tab3);
    //////////////////////////////////////////////////////////
    fun_fourier_transform_FFT_radix_4_N_1024(N,tab2);
    fun_inverse_bits_radix_4(N,tab2);
    ///////////////////////////////////////////////////////////

    time2=diffclock( start, clock() );

    cout<<"frequency Hz radix-4"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;

    cout<<"frequency Hz DFT"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<"if radix-4 == DFT tab2[j].real(): "<<endl;system("pause");
       for(int j=0;j<N;j++)
        {
          if(((tab3[j].real()-tab2[j].real()>=-0.03)&&(tab3[j].real()-tab2[j].real()<=0.03)))
          {

            cout.precision(4);
            cout<<round(tab2[j].real()*1000)/1000<<"  ";//system("pause");
          }
            else {
                cout<<-1<<" ........ ";
            }
        }


    system("pause");
    cout<<endl;

    /////////////////////////////////////////////////////////////////
    fun_inverse_fourier_transform_FFT_radix_4_N_1024(N,tab2);
    fun_inverse_bits_radix_4(N,tab2);
    ////////////////////////////////////////////////////////////////


    cout<<"inverse/signal="<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;



    cout<<endl;
    system("pause");
    return 0;
}
//////////////////////////////////////////////
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[])
{


}
///////////////////////////////////////////////////
void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double> tab2[4096]={};    // tab2[]==N
    std::complex<double>  w[1]={{1,1}};


double zmienna1=2*pi/(float)N;
double fi2=fi;

for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
          //complex number method:
          w[0].real()=cos(i*j*zmienna1+fi2);
          w[0].imag()=(-sin(i*j*zmienna1+fi2));
          tab2[i]=tab2[i]+tab[j]*w[0];

    }
}

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

}
//////////////////
void fun_fourier_transform_FFT_radix_4_N_1024(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double>  tab2[4096]={};    // tab2[]==N
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    std::complex<double>  w5[1]={{1,0}};
    std::complex<double>  w6[1]={{1,0}};
    std::complex<double> tmp1,tmp2,tmp3,tmp4;
    double tmp5;


    w5[0].real()=0;
    w5[0].imag()=-1;
    w6[0].real()=0;
    w6[0].imag()=1;

    tmp5=2*pi/(N/1);

//stage 1
        for(int i=0;i<(N/4);i++)//256
        {
          w1[0].real()=cos(0*tmp5);
          w1[0].imag()=-sin(0*tmp5);
          w2[0].real()=cos(0*tmp5);
          w2[0].imag()=-sin(0*tmp5);
          w3[0].real()=cos(0*tmp5);
          w3[0].imag()=-sin(0*tmp5);
          w4[0].real()=cos(0*tmp5);
          w4[0].imag()=-sin(0*tmp5);

          tmp1=w1[0]*tab[i+0];
          tmp2=w2[0]*tab[i+N/4];
          tmp3=w3[0]*tab[i+N/2];
          tmp4=w4[0]*tab[i+3*N/4];
         //radix-4
          tab2[i]       =tmp1+tmp2+tmp3+tmp4;
          tab2[i+N/4]   =tmp1-tmp3+w5[0]*(tmp2-tmp4);
          tab2[i+N/2]   =tmp1-tmp2+tmp3-tmp4;
          tab2[i+3*N/4] =tmp1-tmp3+w6[0]*(tmp2-tmp4);
        }
/////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<1;m++)//stage 2
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4*4;j++)
            {
                w1[0].real()= cos((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w1[0].imag()=-sin((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w2[0].real()= cos((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w2[0].imag()=-sin((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w3[0].real()= cos((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w3[0].imag()=-sin((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w4[0].real()= cos((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);
                w4[0].imag()=-sin((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4)+N/(4)*i+N/(1)*m+j];
                //radix-4
                tab[0*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4;m++)//stage 3
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4;j++)
            {
                w1[0].real()= cos((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w2[0].real()= cos((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w3[0].real()= cos((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w4[0].real()= cos((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4*4;m++)//stage 4
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                w1[0].real()= cos((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w3[0].real()= cos((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                //radix-4
                tab[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
///////////////////////////////////////////////////////////////////////////////
   for(int m=0;m<4*4*4;m++)//stage 5
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<1;j++)
            {
                w1[0].real()= cos((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w3[0].real()= cos((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

}
//////////////////
void fun_inverse_fourier_transform_FFT_radix_4_N_1024(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double>  tab2[4096]={};    // tab2[]==N
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    std::complex<double>  w5[1]={{1,0}};
    std::complex<double>  w6[1]={{1,0}};
    std::complex<double> tmp1,tmp2,tmp3,tmp4;
    double tmp5;


    w5[0].real()=0;
    w5[0].imag()=1;
    w6[0].real()=0;
    w6[0].imag()=-1;

    tmp5=2*pi/(N/1);

//stage 1
        for(int i=0;i<(N/4);i++)//256
        {
          w1[0].real()=cos(0*tmp5);
          w1[0].imag()=sin(0*tmp5);
          w2[0].real()=cos(0*tmp5);
          w2[0].imag()=sin(0*tmp5);
          w3[0].real()=cos(0*tmp5);
          w3[0].imag()=sin(0*tmp5);
          w4[0].real()=cos(0*tmp5);
          w4[0].imag()=sin(0*tmp5);

          tmp1=w1[0]*tab[i+0];
          tmp2=w2[0]*tab[i+N/4];
          tmp3=w3[0]*tab[i+N/2];
          tmp4=w4[0]*tab[i+3*N/4];
         //radix-4
          tab2[i]       =tmp1+tmp2+tmp3+tmp4;
          tab2[i+N/4]   =tmp1-tmp3+w5[0]*(tmp2-tmp4);
          tab2[i+N/2]   =tmp1-tmp2+tmp3-tmp4;
          tab2[i+3*N/4] =tmp1-tmp3+w6[0]*(tmp2-tmp4);
        }
/////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<1;m++)//stage 2
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4*4;j++)
            {
                w1[0].real()= cos((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w1[0].imag()=sin((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w2[0].real()= cos((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w2[0].imag()=sin((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w3[0].real()= cos((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w3[0].imag()=sin((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w4[0].real()= cos((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);
                w4[0].imag()=sin((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4)+N/(4)*i+N/(1)*m+j];
                //radix-4
                tab[0*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4;m++)//stage 3
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4;j++)
            {
                w1[0].real()= cos((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w1[0].imag()=sin((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w2[0].real()= cos((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w2[0].imag()=sin((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w3[0].real()= cos((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w3[0].imag()=sin((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w4[0].real()= cos((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);
                w4[0].imag()=sin((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4*4;m++)//stage 4
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                w1[0].real()= cos((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w1[0].imag()=sin((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w2[0].imag()=sin((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w3[0].real()=cos((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w3[0].imag()=sin((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);
                w4[0].imag()=sin((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                //radix-4
                tab[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
///////////////////////////////////////////////////////////////////////////////
   for(int m=0;m<4*4*4;m++)//stage 5
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<1;j++)
            {
                w1[0].real()= cos((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w1[0].imag()=sin((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w2[0].imag()=sin((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w3[0].real()= cos((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w3[0].imag()=sin((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);
                w4[0].imag()=sin((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*0.5;
      tab[j].imag() =tab2[j].imag()*0.5;
    }

}



//this is new in that method:

//when you want to have equal results that are in false modificator in normal FFT then change this:
/*
 fun_fourier_transform_FFT_radix_4_N_256_official
{
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*2/N;
      tab[j].imag() =tab[j].imag()*2/N;
    }
}
//and:

fun_inverse_fourier_transform_FFT_radix_4_N_256_official
{
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab[j].real()*0.5;
      tab[j].imag() =tab[j].imag()*0.5;
    }
}

//for official modificator that is only in inverse FFT:
 fun_fourier_transform_FFT_radix_4_N_256_official
{

}
fun_inverse_fourier_transform_FFT_radix_4_N_256_official
{
    for(int i=0;i<N;i++)
    {
        tablica1[0][i]=tablica1[0][i]*1/(float)N;
        tablica1[1][i]=tablica1[1][i]*1/(float)N;
    }
}

*/

//haven't try it with other function that cos(x)+jsin(x)=sin(x+pi/2)+jsin(x)

fast fourier transform FFT radix-4 for N=1024 algorithm c++ source code implementation

//source:
//https://www.google.ch/patents/US6957241
//http://www.google.ch/patents/US20020083107
//https://www.beechwood.eu/fft-implementation-r2-dit-r4-dif-r8-dif/
//http://www.cmlab.csie.ntu.edu.tw/cml/dsp/training/coding/transform/fft.html
//http://dsp.stackexchange.com/questions/3481/radix-4-fft-implementation

//author marcin matysek (r)ewertyn.PL
//fast fourier transform FFT radix-4 for N=1024 algorithm c++ source code implementation

void fun_fourier_transform_FFT_radix_4_N_1024(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double>  tab2[4096]={};    // tab2[]==N
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    std::complex<double>  w5[1]={{1,0}};
    std::complex<double>  w6[1]={{1,0}};
    std::complex<double> tmp1,tmp2,tmp3,tmp4;
    double tmp5;


    w5[0].real()=0;
    w5[0].imag()=-1;
    w6[0].real()=0;
    w6[0].imag()=1;

    tmp5=2*pi/(N/1);

//stage 1
        for(int i=0;i<(N/4);i++)//256
        {
          w1[0].real()=cos(0*tmp5);
          w1[0].imag()=-sin(0*tmp5);
          w2[0].real()=cos(0*tmp5);
          w2[0].imag()=-sin(0*tmp5);
          w3[0].real()=cos(0*tmp5);
          w3[0].imag()=-sin(0*tmp5);
          w4[0].real()=cos(0*tmp5);
          w4[0].imag()=-sin(0*tmp5);

          tmp1=w1[0]*tab[i+0];
          tmp2=w2[0]*tab[i+N/4];
          tmp3=w3[0]*tab[i+N/2];
          tmp4=w4[0]*tab[i+3*N/4];
         //radix-4
          tab2[i]       =tmp1+tmp2+tmp3+tmp4;
          tab2[i+N/4]   =tmp1-tmp3+w5[0]*(tmp2-tmp4);
          tab2[i+N/2]   =tmp1-tmp2+tmp3-tmp4;
          tab2[i+3*N/4] =tmp1-tmp3+w6[0]*(tmp2-tmp4);
        }
/////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<1;m++)//stage 2
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4*4;j++)
            {
                w1[0].real()= cos((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w1[0].imag()=-sin((1*0*i*(j+4*4*4*0)+1*1*i*j)*tmp5);
                w2[0].real()= cos((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w2[0].imag()=-sin((1*1*i*(j+4*4*4*1)+1*0*i*j)*tmp5);
                w3[0].real()= cos((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w3[0].imag()=-sin((1*2*i*(j+4*4*4*1)-1*1*i*j)*tmp5);
                w4[0].real()= cos((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);
                w4[0].imag()=-sin((1*3*i*(j+4*4*4*1)-1*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4)+N/(4)*i+N/(1)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4)+N/(4)*i+N/(1)*m+j];
                //radix-4
                tab[0*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4)+N/(4)*i+N/(1)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4;m++)//stage 3
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4*4;j++)
            {
                w1[0].real()= cos((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*0*i*(j+4*4*0)+4*1*i*j)*tmp5);
                w2[0].real()= cos((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*1*i*(j+4*4*1)+4*0*i*j)*tmp5);
                w3[0].real()= cos((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*2*i*(j+4*4*1)-4*1*i*j)*tmp5);
                w4[0].real()= cos((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*3*i*(j+4*4*1)-4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////
    for(int m=0;m<4*4;m++)//stage 4
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                w1[0].real()= cos((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*4*0*i*(j+4*0)+4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*4*1*i*(j+4*1)+4*4*0*i*j)*tmp5);
                w3[0].real()= cos((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*4*2*i*(j+4*1)-4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*4*3*i*(j+4*1)-4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab2[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp2=w2[0]*tab2[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp3=w3[0]*tab2[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                tmp4=w4[0]*tab2[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j];
                //radix-4
                tab[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
///////////////////////////////////////////////////////////////////////////////
   for(int m=0;m<4*4*4;m++)//stage 5
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<1;j++)
            {
                w1[0].real()= cos((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w1[0].imag()=-sin((4*4*4*0*i*(j+1*0)+4*4*4*1*i*j)*tmp5);
                w2[0].real()= cos((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w2[0].imag()=-sin((4*4*4*1*i*(j+1*1)+4*4*4*0*i*j)*tmp5);
                w3[0].real()= cos((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w3[0].imag()=-sin((4*4*4*2*i*(j+1*1)-4*4*4*1*i*j)*tmp5);
                w4[0].real()= cos((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);
                w4[0].imag()=-sin((4*4*4*3*i*(j+1*1)-4*4*4*2*i*j)*tmp5);

                tmp1=w1[0]*tab[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp2=w2[0]*tab[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp3=w3[0]*tab[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                tmp4=w4[0]*tab[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j];
                //radix-4
                tab2[0*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1+tmp2+       tmp3+tmp4;
                tab2[1*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w5[0]*(tmp2-tmp4);
                tab2[2*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp2+       tmp3-tmp4;
                tab2[3*N/(4*4*4*4*4)+N/(4*4*4*4)*i+N/(4*4*4)*m+j]=tmp1-tmp3+w6[0]*(tmp2-tmp4);
            }
        }
    }
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real();
      tab[j].imag() =tab2[j].imag();
    }
/*

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

*/

}
///////////////////////////////////////////////

FFT radix-4 multiplier Wn for N=256

//FFT radix-4 multiplier Wn for N=256

//stage 1  FFT radix-4 multiplier Wn for N=256
//////////////////////////////////
//////////////////////////////////
    for(int m=0;m<1;m++)//stage 2
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<16;j++)
            {
                 tab5[0*N/(4*4)+N/(4)*i+j]=1*0*i*(j+16*0)+1*1*i*j;
                 tab5[1*N/(4*4)+N/(4)*i+j]=1*1*i*(j+16*1)+1*0*i*j;
                 tab5[2*N/(4*4)+N/(4)*i+j]=1*2*i*(j+16*1)-1*1*i*j;
                 tab5[3*N/(4*4)+N/(4)*i+j]=1*3*i*(j+16*1)-1*2*i*j;
            }

        }
    }
//////////////////////////////////
    for(int m=0;m<4;m++)//stage 3
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                 tab5[0*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=4*0*i*(j+4*0)+4*1*i*j;
                 tab5[1*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=4*1*i*(j+4*1)+4*0*i*j;
                 tab5[2*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=4*2*i*(j+4*1)-4*1*i*j;
                 tab5[3*N/(4*4*4)+N/(4*4)*i+N/(4)*m+j]=4*3*i*(j+4*1)-4*2*i*j;
            }

        }
    }
//////////////////////////////////
    for(int m=0;m<16;m++)//stage 4
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<1;j++)
            {
                 tab5[0*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=16*0*i*(j+1*0)+16*1*i*j;
                 tab5[1*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=16*1*i*(j+1*1)+16*0*i*j;
                 tab5[2*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=16*2*i*(j+1*1)-16*1*i*j;
                 tab5[3*N/(4*4*4*4)+N/(4*4*4)*i+N/(4*4)*m+j]=16*3*i*(j+1*1)-16*2*i*j;
            }

        }
    }
/////////////////////////////////

my interpretation of FFT 16*radix-4 for N=16 algorithm c++ source code

////https://www.beechwood.eu/fft-implementation-r2-dit-r4-dif-r8-dif/

//my interpretation of FFT 16*radix-4 for N=16 algorithm c++ source code it works witch
// FFT=+/-cos(w+fi)-isin(w+fi) and maybe witch other functions that are mirror inverse
//author marcin matysek (r)ewertyn.PL
#include <iostream>
#include "conio.h"
#include <stdlib.h>
#include <math.h>
#include <complex>
#include <fstream>
using namespace std;

void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[]);
void fun_fourier_transform_FFT_radix_4_N_4(int N,std::complex<double> tab[]);
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[]);

int b1,b2,b3;
double fi=-0.41;


int main()
{
    std::complex<double>tab2[16]={};
    std::complex<double>tab3[16]={};

    std::fstream plik;

    plik.open("test.txt", std::ios::in | std::ios::out);

/*
    if( plik.good() == false )
    {

        cout<<"create file : test.txt"<<endl;
        system("pause");

    }
*/

    int N=16;

    for(int i=0;i<N;i++)
    {
        tab2[i].real()=i*1.2+1;
        tab2[i].imag()=i*3.2+11;
        tab3[i].real()=i*1.2+1;
        tab3[i].imag()=i*3.2+11;
    }


    cout<<endl;
cout<<"signal g(x)"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }

    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
cout<<"signal g(x)"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }

    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;


    for(int i1=0;i1<2;i1++)
    {
        if(i1==0){b1=0;}
        if(i1==1){b1=1;}
    for(int i2=0;i2<2;i2++)
    {
        if(i2==0){b2=0;}
        if(i2==1){b2=1;}
    for(int i3=0;i3<2;i3++)
    {
        if(i3==0){b3=0;}
        if(i3==1){b3=1;}


    for(int i=0;i<N;i++)
    {
        tab2[i].real()=i*1.2+1;
        tab2[i].imag()=i*3.2+11;
        tab3[i].real()=i*1.2+1;
        tab3[i].imag()=i*3.2+11;
    }


    fun_fourier_transform_DFT_method5_full_complex(N,tab2);
    fun_fourier_transform_FFT_radix_4_N_4(N,tab3);


    cout<<endl;
    cout<<endl;
    cout<<endl;
    cout<<endl;
    cout<<"frequency Hz DFT:"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].real()*1000)/1000<<"  ";
    }

    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab2[j].imag()*1000)/1000<<"  ";
    }

    cout<<endl;
    cout<<endl;
    cout<<endl;

    cout<<"frequency Hz radix4:"<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].real()*1000)/1000<<"  ";
    }

    cout<<endl;
    cout<<endl;
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab3[j].imag()*1000)/1000<<"  ";
    }
    cout<<endl;
    cout<<endl;
    cout<<endl;

        if((((fabs(tab3[0].real())-fabs(tab2[0].real())>=-0.03)&&(fabs(tab3[0].real())-fabs(tab2[0].real())<=0.03))&&
           ((fabs(tab3[1].real())-fabs(tab2[1].real())>=-0.03)&&(fabs(tab3[1].real())-fabs(tab2[1].real())<=0.03))&&
           ((fabs(tab3[2].real())-fabs(tab2[2].real())>=-0.03)&&(fabs(tab3[2].real())-fabs(tab2[2].real())<=0.03))&&
           ((fabs(tab3[3].real())-fabs(tab2[3].real())>=-0.03)&&(fabs(tab3[3].real())-fabs(tab2[3].real())<=0.03)))
          )
        {
            cout<<"DFT==FFT =>";
            cout<<endl;
        for(int j=0;j<N;j++)
        {
          if(((tab3[j].real()-tab2[j].real()>=-0.03)&&(tab3[j].real()-tab2[j].real()<=0.03)))
          {

            cout.precision(4);
            cout<<round(tab2[j].real()*1000)/1000<<"  ";//system("pause");
          }
            else {
                cout<<-1<<" . ";
            }
        }
        cout<<endl<<endl;
        cout<<", b1="<<b1<<" b2="<<b2<<" b3="<<b3<<endl<<endl;system("pause");
        //    plik<<a1<<" "<<a2<<" "<<a3<<" "<<a4<<" "<<a5<<" "<<a11<<" , "<<a12<<" "<<a13<<" "<<a14<<" "<<a15<<" "<<a16<<" "<<endl;
       }
   }}}
    //cout<<"end:"<<endl;
    cout<<endl;
    cout<<endl;
    //plik.close();
    system("pause");
    return 0;
}
///////////////
void fun_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double> tab2[16]={};    // tab2[]==N
    std::complex<double>  w[1]={{1,1}};


double zmienna1=2*pi/(float)N;
double fi2=fi;

for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
          //complex number method:
          w[0].real()=-cos(i*j*zmienna1+fi2);
          w[0].imag()=(-sin(i*j*zmienna1+fi2));
          tab2[i]=tab2[i]+tab[j]*w[0];

    }
}

    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

}
//////////////////
void fun_inverse_bits_radix_4(int N,std::complex<double> tab[])
{

}
///////////////////
void fun_fourier_transform_FFT_radix_4_N_4(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double> tab2[64]={};    // tab2[]==N

    std::complex<double>  w0[1]={{1,0}};
    std::complex<double>  w1[1]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  a0,a1,a2,a3,a4,a6,a9;

    double zm=2*pi/4;
    double wbm=2*pi/N;
    double fi1;

    int nr1=1;
    int nr2=1;
    int nr3=1;

        if(b1==0){nr1=-1;}
        else if(b1==1){nr1=1;}
        else{}
        if(b2==0){nr2=-1;}
        else if(b2==1){nr2=1;}
        else{}
        if(b3==0){nr3=-1;}
        else if(b3==1){nr3=1;}
        else{}
        //cout<<"b1="<<b1<<endl<<endl;

   // nr1=1;
   // nr2=-1;
   // nr3=1;

    fi1=fi;

          a0.real()=nr1*cos(0*zm+fi1);
          a0.imag()=-sin(0*zm+fi1);
          a1.real()=nr1*cos(1*zm+fi1);
          a1.imag()=-sin(1*zm+fi1);
          a2.real()=nr1*cos(2*zm+fi1);
          a2.imag()=-sin(2*zm+fi1);
          a3.real()=nr1*cos(3*zm+fi1);
          a3.imag()=-sin(3*zm+fi1);
          a4.real()=nr1*cos(4*zm+fi1);
          a4.imag()=-sin(4*zm+fi1);
          a6.real()=nr1*cos(6*zm+fi1);
          a6.imag()=-sin(6*zm+fi1);
          a9.real()=nr1*cos(9*zm+fi1);
          a9.imag()=-sin(9*zm+fi1);

        //cout.precision(3);
        //cout<<" ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] "<<endl;
       //// cout<<" ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a1.real()*1000)/1000<<" "<<round(a1.imag()*1000)/1000<<"i] ["<<round(a2.real()*1000)/1000<<" "<<round(a2.imag()*1000)/1000<<"i] ["<<round(a3.real()*1000)/1000<<" "<<round(a3.imag()*1000)/1000<<"i] "<<endl;
       // cout<<" ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a2.real()*1000)/1000<<" "<<round(a2.imag()*1000)/1000<<"i] ["<<round(a4.real()*1000)/1000<<" "<<round(a4.imag()*1000)/1000<<"i] ["<<round(a6.real()*1000)/1000<<" "<<round(a6.imag()*1000)/1000<<"i] "<<endl;
        //cout<<" ["<<round(a0.real()*1000)/1000<<" "<<round(a0.imag()*1000)/1000<<"i] ["<<round(a3.real())<<" "<<round(a3.imag())<<"i] ["<<round(a6.real())<<" "<<round(a6.imag())<<"i] ["<<round(a9.real())<<" "<<round(a9.imag())<<"i] "<<endl;
       //system("pause");

    //radix-4

          w0[0].real()=nr3*cos(0+fi1);
          w0[0].imag()=-sin(0+fi1);

    for(int k=0;k<4;k++)
    {
        for(int n=0;n<4;n++)
        {

          w2[0].real()=nr2*cos(n*k*2*pi/(N/4)+fi1);
          w2[0].imag()=-sin(n*k*2*pi/(N/4)+fi1);

          tab2[4*k+0]=tab2[4*k+0]+(-a0*tab[n]-a0*tab[n+4]-a0*tab[n+8]-a0*tab[n+12])*w0[0]*w2[0];

          w1[0].real()=nr3*cos(n*wbm+fi1);
          w1[0].imag()=-sin(n*wbm+fi1);

          tab2[4*k+1]=tab2[4*k+1]+(-a0*tab[n]-a1*tab[n+4]-a2*tab[n+8]-a3*tab[n+12])*w1[0]*w2[0];

          w1[0].real()=nr3*cos(2*n*wbm+fi1);
          w1[0].imag()=-sin(2*n*wbm+fi1);
          tab2[4*k+2]=tab2[4*k+2]+(-a0*tab[n]-a2*tab[n+4]-a4*tab[n+8]-a6*tab[n+12])*w1[0]*w2[0];

          w1[0].real()=nr3*cos(3*n*wbm+fi1);
          w1[0].imag()=-sin(3*n*wbm+fi1);

          tab2[4*k+3]=tab2[4*k+3]+(-a0*tab[n]-a3*tab[n+4]-a6*tab[n+8]-a9*tab[n+12])*w1[0]*w2[0];
        }
    }
/////////////////////////////
    //inverse

    std::complex<double> tmp;
    tmp=tab2[4];
    tab2[4]=tab2[12];
    tab2[12]=tmp;

    tmp=tab2[4+1];
    tab2[4+1]=tab2[12+1];
    tab2[12+1]=tmp;

    tmp=tab2[4+2];
    tab2[4+2]=tab2[12+2];
    tab2[12+2]=tmp;

    tmp=tab2[4+3];
    tab2[4+3]=tab2[12+3];
    tab2[12+3]=tmp;


    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }

}