universal mixed radix-2-3-4-5-7-11 inverse iFFT standard version

Mixed-Radix FFT/iFFT with Phase Shift

https://github.com/rewertynpl/mixed-radix-iFFT

A flexible, open-source C++ implementation of the Mixed-Radix Fast Fourier Transform (FFT) and its inverse (iFFT). Designed for educational purposes, it supports signals of arbitrary composite lengths and includes a unique phase-shift feature.

📖 About The Project

This project provides a standalone C++ implementation of the Mixed-Radix Cooley-Tukey algorithm. Unlike standard Radix-2 FFTs, which require the signal length to be a power of two ($2^n$), this algorithm supports any length $N$ that can be factorized into a product of small prime numbers.

The code is written to be explicit and verbose, serving as a learning tool to demonstrate how "butterfly" computations work for various radixes.

Key Features

• Mixed-Radix Support: Works with any signal length $N$ factorizable into implemented radixes.
• Wide Radix Base: Native support for Radix-2, 3, 4, 5, 7, 11, and a generic implementation for primes up to 97.
• Phase Shift (fi): A unique global parameter allowing for circular signal shifting directly within the frequency domain transform.
• Verification: Includes a generic $O(N^2)$ DFT implementation for accuracy verification.
• License: MIT License.

inverse fourier transform DFT and 1 stage FFT

//inverse fourier transform  DFT and 1 stage FFT




//author marcin matysek (r)ewertyn.PL


#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_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[]);
void fun_inverse_fourier_transform_DFT_method5_full_complex(int N,std::complex<double> tab[]);


void DFT_FFT_1_stage(int N,std::complex<double> tab[]);
void inverse_DFT_FFT_1_stage(int N,std::complex<double> tab[]);


int a2,a3,a4,a5,a6,a7;
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=10;

    std::complex<double> tab2[4096]={};
    std::complex<double> tab3[4096]={};
    std::complex<double> tab4[4096]={};
    for(int i=0;i<N;i++)
    {
        tab2[i].real()=i*1.2+1;
        tab2[i].imag()=-N-i-1;
        tab3[i].real()=i*1.2+1;
        tab3[i].imag()=-N-i-1;
        tab4[i].real()=i*1.2+1;
        tab4[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();

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

    }



 for(int i2=0;i2<9;i2++)
 {

    if(i2==0)
    {
    a2=0;
    }
    else if(i2==1)
    {
    a2=1;
    }
    else if(i2==2)
    {
    a2=2;
    }
    else if(i2==3)
    {
    a2=3;
    }
    else if(i2==4)
    {
    a2=4;
    }
    else if(i2==5)
    {
    a2=5;
    }
    else if(i2==6)
    {
    a2=6;
    }
    else if(i2==7)
    {
    a2=7;
    }
    else if(i2==8)
    {
    a2=8;
    }
   for(int i3=0;i3<2;i3++)
 {
        if(i3==0)
    {
    a3=0;
    }
    else{a3=1;}
   for(int i4=0;i4<2;i4++)
 {
     if(i4==0)
    {
    a4=0;
    }
    else{a4=1;}
   for(int i5=0;i5<2;i5++)
 {
     if(i5==0)
    {
    a5=0;
    }
    else{a5=1;}

    for(int i6=0;i6<2;i6++)
 {
     if(i6==0)
    {
    a6=0;
    }
    else{a6=1;}
    for(int i7=0;i7<2;i7++)
 {
     if(i7==0)
    {
    a7=0;
    }
    else{a7=1;}


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


    fun_fourier_transform_DFT_method5_full_complex(N,tab3);
    DFT_FFT_1_stage(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;
*/
   //  system("pause");
   // 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<<"j= "<<j<<"   "<<round(tab2[j].real()*1000)/1000<<"    ";
            //system("pause");
          }
            else {
                cout<<-99<<" .. ";
            }
        }


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

    /////////////////////////////////////////////////////////////////

    fun_inverse_fourier_transform_DFT_method5_full_complex(N,tab3);
    inverse_DFT_FFT_1_stage(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;
*/
    //fun_inverse_fourier_transform_DFT_method5_full_complex(N,tab3);
       for(int j=0;j<N;j++)
        {
          if(((tab4[j].imag()-tab3[j].imag()>=-0.03)&&(tab4[j].imag()-tab3[j].imag()<=0.03))&&
             ((tab4[j].real()-tab3[j].real()>=-0.03)&&(tab4[j].real()-tab3[j].real()<=0.03))
             )
          {

            cout.precision(4);
           // cout<<"j= "<<j<<"  "<<a2<<" "<<a3<<" "<<a4<<" "<<a5<<" "<<a6<<" "<<a7<<"  "<<tab4[j].real()<<" = "<<round(tab3[j].real()*1000)/1000<<"  ,  "<<tab4[j].imag()<<" =  "<<round(tab3[j].imag()*1000)/1000<<" ";
            //system("pause");
          }
            else {
                //cout<<-99<<" .. ";
            }
        }


        //inverse_DFT_FFT_1_stage(N,tab2);

if(((tab4[1].imag()-tab2[1].imag()>=-0.03)&&(tab4[1].imag()-tab2[1].imag()<=0.03))&&
   ((tab4[3].imag()-tab2[3].imag()>=-0.03)&&(tab4[3].imag()-tab2[3].imag()<=0.03))
   )
    {

       for(int j=0;j<N;j++)
        {
          if(((tab4[j].imag()-tab2[j].imag()>=-0.03)&&(tab4[j].imag()-tab2[j].imag()<=0.03))&&
             ((tab4[j].real()-tab2[j].real()>=-0.03)&&(tab4[j].real()-tab2[j].real()<=0.03))
             )
          {
            cout<<"OK ";
            cout.precision(4);
            //cout<<"j= "<<j<<"  "<<a2<<" "<<a3<<" "<<a4<<" "<<a5<<" "<<a6<<" "<<a7<<"  "<<tab4[j].real()<<" = "<<round(tab2[j].real()*1000)/1000<<"  ,  "<<tab4[j].imag()<<" =  "<<round(tab2[j].imag()*1000)/1000<<" ";
            //system("pause");
          }
            else {
                //cout<<-99<<" .. ";
            }
        if(((tab4[j].imag()-tab2[1].imag()>=-0.03)&&(tab4[j].imag()-tab2[1].imag()<=0.03)))
           {
                cout<<"j= "<<j<<"  "<<a2<<" "<<a3<<" "<<a4<<" "<<a5<<" "<<a6<<" "<<a7<<" | "<<tab4[1].real()<<" = "<<round(tab2[1].real()*1000)/1000<<"  ,  "<<tab4[1].imag()<<" =  "<<round(tab2[1].imag()*1000)/1000<<" "<<endl;
                cout<<tab4[3].real()<<" = "<<round(tab2[3].real()*1000)/1000<<"  ,  "<<tab4[3].imag()<<" =  "<<round(tab2[3].imag()*1000)/1000<<" "<<endl;
                system("pause");
           }
        }
    }

 }}}}}}

    cout<<endl;
    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[4096]={};    // tab2[]==N
    std::complex<double>  w[1]={{1,0}};


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];


    }
    //cout<<tab2[1]<<endl;
}


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

    /*
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real();
      tab[j].imag() =tab2[j].imag();
    }
*/
}
///////////////////////////////////////////////////
void fun_inverse_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,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
int nr1=0,nr2=0,nr3=0,nr4=0;
   std::complex<double>  nr5=0;
double zmienna1=2*pi/(float)N;
double fi2=fi;


//////////////////////////
    if(a2==0)
    {
    w3[0].real()=-1;
    w3[0].imag()=-1;
    }
    else if(a2==1)
    {
    w3[0].real()=-1;
    w3[0].imag()=0;
    }
    else if(a2==2)
    {
    w3[0].real()=-1;
    w3[0].imag()=1;
    }
    else if(a2==3)
    {
    w3[0].real()=0;
    w3[0].imag()=-1;
    }
    else if(a2==4)
    {
    w3[0].real()=0;
    w3[0].imag()=0;
    }
    else if(a2==5)
    {
    w3[0].real()=0;
    w3[0].imag()=1;
    }
    else if(a2==6)
    {
    w3[0].real()=1;
    w3[0].imag()=-1;
    }
    else if(a2==7)
    {
    w3[0].real()=1;
    w3[0].imag()=0;
    }
    else if(a2==8)
    {
    w3[0].real()=1;
    w3[0].imag()=1;
    }
////////////////

if(a3==0){nr1=-1;}
else{nr1=1;}
if(a4==0){nr2=-1;}
else{nr2=1;}

if(a5==0){nr3=-1;}
else{nr3=1;}
if(a6==0){nr4=-1;}
else{nr4=1;}
if(a7==0){nr5.real()=-1,nr5.imag()=0;}
else{nr5.real()=1,nr5.imag()=0;}

for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
          //complex number method:
          w[0].real()=nr1*cos(nr3*i*j*zmienna1+fi2);
          w[0].imag()=nr2*sin(nr4*i*j*zmienna1+fi2);
          tab2[i]=tab2[i]+nr5*tab[j]*w[0]*w3[0];
    }
    //cout<<tab2[1]<<endl;
}


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

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

void inverse_DFT_FFT_1_stage(int N,std::complex<double> tab[])
{
    const double pi=3.141592653589793238462;
    std::complex<double> tab2[4096]={};    // tab2[]==N
    std::complex<double>  w[8]={{1,0}};
    std::complex<double>  w2[1]={{1,0}};
    std::complex<double>  w3[1]={{1,0}};
    std::complex<double>  w4[1]={{1,0}};
    int nr1=0,nr2=0,nr3=0,nr4=0,nr6=0,nr7=0,nr8=0,nr9=0;
    std::complex<double>  nr5=0;
    std::complex<double>  nr10=0;
    double zmienna1=2*pi/(float)N;
    double fi2=fi;
//////////////////////////
    if(a2==0)
    {
    w3[0].real()=-1;
    w3[0].imag()=-1;
    }
    else if(a2==1)
    {
    w3[0].real()=-1;
    w3[0].imag()=0;
    }
    else if(a2==2)
    {
    w3[0].real()=-1;
    w3[0].imag()=1;
    }
    else if(a2==3)
    {
    w3[0].real()=0;
    w3[0].imag()=-1;
    }
    else if(a2==4)
    {
    w3[0].real()=0;
    w3[0].imag()=0;
    }
    else if(a2==5)
    {
    w3[0].real()=0;
    w3[0].imag()=1;
    }
    else if(a2==6)
    {
    w3[0].real()=1;
    w3[0].imag()=-1;
    }
    else if(a2==7)
    {
    w3[0].real()=1;
    w3[0].imag()=0;
    }
    else if(a2==8)
    {
    w3[0].real()=1;
    w3[0].imag()=1;
    }
////////////////

if(a3==0){nr1=-1;}
else{nr1=1;}
if(a4==0){nr2=-1;}
else{nr2=1;}

if(a5==0){nr3=-1;}
else{nr3=1;}
if(a6==0){nr4=-1;}
else{nr4=1;}
if(a7==0){nr5.real()=-1,nr5.imag()=0;}
else{nr5.real()=1,nr5.imag()=0;}
/////////////////////////
for(int k=0;k<N;k=k+2)
{
    for(int n=0;n<(N/2);n++)
    {
      //complex number method:
        w[0].real()=nr1*cos(nr3*k*n*zmienna1);
        w[0].imag()=nr2*sin(nr4*k*n*zmienna1);

        w[1].real()=nr1*cos(nr3*(k+1)*n*zmienna1);
        w[1].imag()=nr2*sin(nr4*(k+1)*n*zmienna1);

        //parzyste:
        tab2[k]=tab2[k]    +nr5*w[0]*(tab[n]+tab[N/2+n])*w3[0];
        //nieparzyste
        tab2[k+1]=tab2[k+1]+nr5*w[1]*(tab[n]-tab[N/2+n])*w3[0];
    }
}
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*0.5;
      tab[j].imag() =tab2[j].imag()*0.5;
    }
    /*
    for(int i=0;i<N;i++)
    {
    }
    */

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

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


for(int k=0;k<N;k=k+2)
{
    for(int n=0;n<(N/2);n++)
    {
      //complex number method:
        w[0].real()= cos(k*n*zmienna1);
        w[0].imag()=-sin(k*n*zmienna1);

        w[1].real()= cos((k+1)*n*zmienna1);
        w[1].imag()=-sin((k+1)*n*zmienna1);

        //parzyste:
        tab2[k]=tab2[k]+w[0]*(tab[n]+tab[N/2+n]);
        //nieparzyste
        tab2[k+1]=tab2[k+1]+w[1]*(tab[n]-tab[N/2+n]);
    }
}
    for(int j=0;j<N;j++)
    {
      tab[j].real() =tab2[j].real()*2/N;
      tab[j].imag() =tab2[j].imag()*2/N;
    }
    /*
    for(int i=0;i<N;i++)
    {
            tab[i]=tab2[i];
    }
    */

}

inverse fourier transform iDFT ifft 4 methods in open office + something extra

inverse fourier transform iDFT ifft 4 methods in open office + something extra

http://www.mediafire.com/file/hyz4dbski4w00pb/inverse+fourier+transform+iDFT+ifft+4+methods+in+open+office+++something+extra.ods


http://www.mediafire.com/file/59bpnci966ulec9/DFT+FFT+RADIX-2+DIT+algorytm+Transformacja+Fouriera+analitycznie+v3.4.xlsx

inverse discrete fourier transform iDFT 1D algorithm c++ source code

inverse discrete fourier transform iDFT 1D algorithm source code implementation
odwrotna dyskretna transformacja fouriera iDFT 1D c++ kod źródłowy

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

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

#include <complex>

using namespace std;


//complex number method:
 void fun_fourier_transform_DFT_method5_full_complex(int N,double *table2);
//fun_fourier_transform_DFT_method6_full_complex(int N,std::complex<double> tab[])

void fun_inverse_fourier_transform_DFT_method5_full_complex_inverse(int N,double *table2);

//these others work only  if audio samples are not complex numbers but result of DFT  it shows complex numbers Hzthat but numbers are combinet to normal number
void fun_fourier_transform_DFT_method1(int N,double *table2);
void fun_inverse_fourier_transform_DFT_method1(int N,double *table2);

void fun_fourier_transform_DFT_method2(int N,double *table2);
void fun_inverse_fourier_transform_DFT_method2(int N,double *table2);

void fun_fourier_transform_DFT_method3(int N,double *table2);
void fun_inverse_fourier_transform_DFT_method3(int N,double *table2);

void fun_fourier_transform_DFT_method4(int N,double *table2);
void fun_inverse_fourier_transform_DFT_method4(int N,double *table2);

//inverse_method4 works only witch discrete _method4
//inverse_method2 works only witch discrete _method2
//inverse_method3 works only witch discrete _method3

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

     //tab[A] A=2*N;
//tab[0 to N-1]  -re numbers
//tab[N-1 to 2N-1]  -im numbers

    // period= 16  samples=16
N=16;
    double tab[32]={-0.923879533,0.382683432,1.03153013,0.923879533,0.923879533,1.465075634,1.796896994,0.923879533,-0.923879533,
    -2.230442498,-1.796896994,-0.158512669,0.923879533,0.382683432,-1.03153013,-1.689246397};

   // period=12  samples=12
   //N=12;
   // double tab[32]={-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
   // -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192};

//tab[20]=3.86;//im number


double time2;

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

    clock_t start = clock();
    //fun_fourier_transform_DFT_method1(N,tab);
    fun_fourier_transform_DFT_method5_full_complex(N,tab);
    time2=diffclock( start, clock() );

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

    //fun_inverse_fourier_transform_DFT_method1(N,tab);
    fun_inverse_fourier_transform_DFT_method5_full_complex_inverse(N,tab);

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

    system("pause");
    return 0;
}


void fun_fourier_transform_DFT_method5_full_complex(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];
    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
//complex number method:
           table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
          table3[1][i]=table3[1][i]-table1[0][j]*sin(i*j*2*pi/(float)N);
          table3[0][i]=table3[0][i]-table1[1][j]*sin(i*j*2*pi/(float)N)*-1;//im*im
          table3[1][i]=table3[1][i]+table1[1][j]*cos(i*j*2*pi/(float)N);

//other that methot is for B from inverse transform
       //   table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
       // table3[0][i]=table3[0][i]-table1[1][j]*sin(i*j*2*pi/(float)N);
      //    table3[1][i]=table3[1][i]-table1[1][j]*cos(i*j*2*pi/(float)N);
      //  table3[1][i]=table3[1][i]-table1[0][j]*sin(i*j*2*pi/(float)N);

//that methot is for C from inverse transform
        //   table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
       // table3[0][i]=table3[0][i]+table1[1][j]*sin(i*j*2*pi/(float)N);
      //    table3[1][i]=table3[1][i]+table1[1][j]*cos(i*j*2*pi/(float)N);
      //  table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

//that methot is for D from inverse transform
      //     table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
       //   table3[0][i]=table3[0][i]-table1[1][j]*sin(i*j*2*pi/(float)N);
       //   table3[1][i]=table3[1][i]+table1[1][j]*cos(i*j*2*pi/(float)N);
       //   table3[1][i]=table3[1][i]-table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j];
      table1[1][j] =table3[1][j];
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_inverse_fourier_transform_DFT_method5_full_complex_inverse(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 4; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
//complex number method:
          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
          table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);
          table3[0][i]=table3[0][i]+table1[1][j]*sin(i*j*2*pi/(float)N)*-1;//im*im
          table3[1][i]=table3[1][i]+table1[1][j]*cos(i*j*2*pi/(float)N);

//other that methot is for B from discrete transform
          //table3[0][i]=table3[0][i]-table1[0][j]*cos(i*j*2*pi/(float)N);
       // table3[0][i]=table3[0][i]+table1[1][j]*sin(i*j*2*pi/(float)N);
       //   table3[1][i]=table3[1][i]-table1[1][j]*cos(i*j*2*pi/(float)N);
      //  table3[1][i]=table3[1][i]-table1[0][j]*sin(i*j*2*pi/(float)N);

//that methot is for C from discrete transform
      //    table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
      //  table3[0][i]=table3[0][i]+table1[1][j]*sin(i*j*2*pi/(float)N);
      //    table3[1][i]=table3[1][i]+table1[1][j]*cos(i*j*2*pi/(float)N);
     //   table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

 //that methot is for D from discrete transform
         // table3[0][i]=table3[0][i]-table1[0][j]*cos(i*j*2*pi/(float)N);
         // table3[0][i]=table3[0][i]+table1[1][j]*sin(i*j*2*pi/(float)N);
         //table3[1][i]=table3[1][i]-table1[1][j]*cos(i*j*2*pi/(float)N);
         // table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j]/N;
      table1[1][j] =table3[1][j]/N;
    }

   for( int i = 0; i < 4; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_fourier_transform_DFT_method1(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];
    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j]+table3[1][j];
      table1[1][j] =0;
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_inverse_fourier_transform_DFT_method1(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =(table3[0][j]+table3[1][j])/N;//tylko tym się różni od normalnej transformnacji
      table1[1][j] =0;
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_fourier_transform_DFT_method2(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j];
      table1[1][j] =table3[1][j];
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_inverse_fourier_transform_DFT_method2(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[4];
    for( int i = 0; i < 4; ++i)
    {
      table3[i] = new double[N];
    }
for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);
          table3[2][i]=table3[2][i]+table1[1][j]*cos(i*j*2*pi/(float)N);
        table3[3][i]=table3[3][i]+table1[1][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =(table3[0][j]+table3[1][j]+table3[2][j]+table3[3][j])/N;//tylko tym się różni od normalnej transformnacji
      table1[1][j] = 0;
    }

   for( int i = 0; i < 4; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_fourier_transform_DFT_method3(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j];
      table1[1][j] =table3[1][j];
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_inverse_fourier_transform_DFT_method3(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[4];
    for( int i = 0; i < 4; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);
          table3[2][i]=table3[2][i]+table1[1][j]*cos(i*j*2*pi/(float)N);
        table3[3][i]=table3[3][i]+table1[1][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =(table3[0][j]+table3[3][j])/N;
      table1[1][j] =(table3[1][j]+table3[2][j])/N;

      if(table1[0][j]>=0)
      {
      table1[0][j]=table1[0][j]*table1[0][j];
      }
      else
      {
      table1[0][j]=table1[0][j]*table1[0][j]*-1;
      }

      if(table1[1][j]>=0)
      {
      table1[1][j]=table1[1][j]*table1[1][j];
      }
      else
      {
      table1[1][j]=table1[1][j]*table1[1][j]*-1;
      }

      if(table1[0][j]+table1[1][j]>=0)
      {
      table1[0][j]=sqrt(fabs(table1[0][j]+table1[1][j]));
      }
      else
      {
      table1[0][j]=sqrt(fabs(table1[0][j]+table1[1][j]))*-1;
      }

      table1[1][j]=0;
    }

   for( int i = 0; i < 4; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}
void fun_fourier_transform_DFT_method4(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =table3[0][j]-table3[1][j];
      table1[1][j] =0;
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_inverse_fourier_transform_DFT_method4(int N,double *table2)
{
    int i=N,j=N;
    double (*(table1)[2]);
    table1[0]=&table2[0];
    table1[1]=&table2[0+N];
    const double pi=3.141592653589793238462;

    double** table3 = new double*[2];
    for( int i = 0; i < 2; ++i)
    {
      table3[i] = new double[N];

    }
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {
       table3[i][j]=0;
    }
}
for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {

          table3[0][i]=table3[0][i]+table1[0][j]*cos(i*j*2*pi/(float)N);
        table3[1][i]=table3[1][i]+table1[0][j]*-1*sin(i*j*2*pi/(float)N);

    }
}
    for(int j=0;j<N;j++)
    {
      table1[0][j] =(table3[0][j]+table3[1][j])/N;
      table1[1][j] =0;
    }

   for( int i = 0; i < 2; ++i)
   {
       delete[] table3[i];
    }
    delete[] table3;

}

void fun_fourier_transform_DFT_method6_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}};
    std::complex<double>  w2[1]={{1,1}};



for (int i=0;i<N;i++)
{
    for(int j=0;j<N;j++)
    {
          //complex number method:
          w[0].real()=cos(i*j*2*pi/(float)N);
          w[0].imag()=(-sin(i*j*2*pi/(float)N));
          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;
    }
*/
}

http://inverse-fast-fourier-transform-fft.blogspot.com/

DFT:

inverse fourier transform iDFT 4 methods in open office

inverse discrete fourier transform iDFT 2D algorithm source code

inverse discrete fourier transform iDFT 2D algorithm source code
odwrotna dyskretna transformacja fouriera idft 2d algorytm kod źródłowy

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


using namespace std;

//complex number method:
void fun_inverse_discrete_fourier_transform_DFT_2D_method1(int N,double table[][12][12]);
void fun_discrete_fourier_transform_DFT_2D_method1(int N,double table[][12][12]);

//complex number method:
void fun_inverse_discrete_fourier_transform_DFT_2D_method2(int N,double table[][12][12]);
void fun_discrete_fourier_transform_DFT_2D_method2(int N,double table[][12][12]);

//other method not complex number signal need to be normal number
void fun_inverse_discrete_fourier_transform_DFT_2D_method3(int N,double table[][12][12]);
void fun_discrete_fourier_transform_DFT_2D_method3(int N,double table[][12][12]);


//inverse_method1 works only witch discrete _method1
//inverse_method2 works only witch discrete _method2
//inverse_method3 works only witch discrete _method3

static double diffclock(clock_t clock2,clock_t clock1)
{

    double diffticks=clock1-clock2;
    double diffms=(diffticks)/(CLOCKS_PER_SEC/1000);
    return diffms;
}

int main()
{
    //zał N=okres sygnału w tablicy tab[] wtedy rodzielczość = 1 Hz

    int N=12;
    double time2;
    //tab[0]][N][N]=re
    //tab[1]][N][N]=im
    double tab[2][12][12]={{
    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-1.630526192,-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.735499212,-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192},

    {-0.923879533,0.70664666,0.996551596,0.923879533,1.659378744,1.369473808,-0.923879533,
    -2.29335334,-0.735499212,0.923879533,-0.072672064,-1.630526192}
    }};

//tab[0]][N][N]=re
//tab[1]][N][N]=im

    tab[1][0][0]=5.1234;//im number
    tab[1][1][0]=9.1234;//im number
    tab[1][2][1]=-3.1234;//im number

    cout<<" "<<tab[1][0][0]<<endl;
    cout<<" "<<tab[1][1][0]<<endl;
    cout<<" "<<tab[1][2][1]<<endl;

cout<<"signal g(x):"<<endl<<endl;
    for(int i=0;i<N;i++)
    {
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab[0][i][j]*100)/100<<"  ";
    }
    cout<<endl;
    }
    cout<<endl;

    clock_t start = clock();
    fun_discrete_fourier_transform_DFT_2D_method2(N,tab);
    time2=diffclock( start, clock() );

    cout<<" time="<<time2/1000<<endl;
    cout<<"transformation 2D re"<<endl<<endl;
    for(int i=0;i<N;i++)
    {
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab[0][i][j]*100)/100<<"  ";
    }
    cout<<endl;
    }
    cout<<endl;
 cout<<"transformation 2D im"<<endl<<endl;
    for(int i=0;i<N;i++)
    {
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab[1][i][j]*100)/100<<"  ";
    }
    cout<<endl;
    }
    cout<<endl;
    fun_inverse_discrete_fourier_transform_DFT_2D_method2(N,tab);

 cout<<"inverse transformation 2D"<<endl<<endl;
    for(int i=0;i<N;i++)
    {
    for(int j=0;j<N;j++)
    {
    cout.precision(4);
    cout<<round(tab[0][i][j]*100)/100<<"  ";
    }
    cout<<endl;
    }
    cout<<" "<<round(tab[1][0][0]*100)/100<<endl;
    cout<<" "<<round(tab[1][1][0]*100)/100<<endl;
    cout<<" "<<round(tab[1][2][1]*100)/100<<endl;
    cout<<endl;

    system("pause");
    return 0;
}

void fun_discrete_fourier_transform_DFT_2D_method1(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }
for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
for (int m=0;m<N;m++)
{
    for(int n=0;n<N;n++)
    {
        //nr 1 complex number method: other combinations are possible but you need other combination in inverse method too
          table3[0][k][l]=table3[0][k][l]+table[0][m][n]*cos((k*m+n*l)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]-table[0][m][n]*sin((k*m+n*l)*2*pi/(float)N);
        table3[0][k][l]=table3[0][k][l]-table[1][m][n]*sin((k*m+n*l)*2*pi/(float)N)*-1;//im*im
          table3[1][k][l]=table3[1][k][l]+table[1][m][n]*cos((k*m+n*l)*2*pi/(float)N);
    }}}
}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {
        //nr 1;
      table[0][i][j] =(table3[0][i][j]);
      table[1][i][j] =(table3[1][i][j]);

      //nr 2
      //table[0][i][j] =(table3[0][i][j]+table3[1][i][j]+table3[2][i][j]+table3[3][i][j]);
     // table[1][i][j] = 0;
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}
void fun_inverse_discrete_fourier_transform_DFT_2D_method1(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }
for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
for (int m=0;m<N;m++)
{
    for(int n=0;n<N;n++)
    {
        // nr 1 complex number method: other combinations are possible but you need other combination in discrete method too
          table3[0][k][l]=table3[0][k][l]+table[0][m][n]*cos((k*m+n*l)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]+table[0][m][n]*sin((k*m+n*l)*2*pi/(float)N);
        table3[0][k][l]=table3[0][k][l]+table[1][m][n]*sin((k*m+n*l)*2*pi/(float)N)*-1;//im*im
          table3[1][k][l]=table3[1][k][l]+table[1][m][n]*cos((k*m+n*l)*2*pi/(float)N);
    }}}
}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {
      table[0][i][j] =(table3[0][i][j])/(N*N);
      table[1][i][j] =(table3[1][i][j])/(N*N);
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}


void fun_discrete_fourier_transform_DFT_2D_method2(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }

    double table4[2][12][12]={};


for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table4[i][j][k]=0;
    }
    }
}

for (int m=0;m<N;m++)
{
    for(int l=0;l<N;l++)
    {
    for(int n=0;n<N;n++)
    {//complex number method:
        //nr 1 complex number method: other combinations are possible but you need other combination in inverse method too
          table4[0][m][l]=table4[0][m][l]+table[0][m][n]*cos((n*l)*2*pi/(float)N);
        table4[1][m][l]=table4[1][m][l]-table[0][m][n]*sin((n*l)*2*pi/(float)N);
        table4[0][m][l]=table4[0][m][l]-table[1][m][n]*sin((n*l)*2*pi/(float)N)*-1;//im*im;
          table4[1][m][l]=table4[1][m][l]+table[1][m][n]*cos((n*l)*2*pi/(float)N);
}}}

 for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
    for(int m=0;m<N;m++)
    {//complex number method:
        table3[0][k][l]=table3[0][k][l]+table4[0][m][l]*cos((k*m)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]-table4[0][m][l]*sin((k*m)*2*pi/(float)N);
        table3[0][k][l]=table3[0][k][l]-table4[1][m][l]*sin((k*m)*2*pi/(float)N)*-1;//im*im;
          table3[1][k][l]=table3[1][k][l]+table4[1][m][l]*cos((k*m)*2*pi/(float)N);
    }}}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {

      table[0][i][j] =(table3[0][i][j]);
      table[1][i][j] =table3[1][i][j];
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}
void fun_inverse_discrete_fourier_transform_DFT_2D_method2(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }
    double table4[2][12][12]={};


for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table4[i][j][k]=0;
    }
    }
}

for (int m=0;m<N;m++)
{
    for(int l=0;l<N;l++)
    {
    for(int n=0;n<N;n++)
    {
        //complex number method:
        // nr 1 complex number method: other combinations are possible but you need other combination in discrete method too
          table4[0][m][l]=table4[0][m][l]+table[0][m][n]*cos((n*l)*2*pi/(float)N);
        table4[1][m][l]=table4[1][m][l]+table[0][m][n]*sin((n*l)*2*pi/(float)N);
        table4[0][m][l]=table4[0][m][l]+table[1][m][n]*sin((n*l)*2*pi/(float)N)*-1;//im*im;
          table4[1][m][l]=table4[1][m][l]+table[1][m][n]*cos((n*l)*2*pi/(float)N);
}}}

 for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
    for(int m=0;m<N;m++)
    {
        //complex number method:
        table3[0][k][l]=table3[0][k][l]+table4[0][m][l]*cos((k*m)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]+table4[0][m][l]*sin((k*m)*2*pi/(float)N);
        table3[0][k][l]=table3[0][k][l]+table4[1][m][l]*sin((k*m)*2*pi/(float)N)*-1;//im*im;
          table3[1][k][l]=table3[1][k][l]+table4[1][m][l]*cos((k*m)*2*pi/(float)N);
    }}}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {
      table[0][i][j] =(table3[0][i][j])/(N*N);
      table[1][i][j] =table3[1][i][j]/(N*N);
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}

void fun_discrete_fourier_transform_DFT_2D_method3(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }

    double table4[2][12][12]={};


for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table4[i][j][k]=0;
    }
    }
}

for (int m=0;m<N;m++)
{
    for(int l=0;l<N;l++)
    {
    for(int n=0;n<N;n++)
    {

          table4[0][m][l]=table4[0][m][l]+table[0][m][n]*cos((n*l)*2*pi/(float)N);
        table4[1][m][l]=table4[1][m][l]+table[0][m][n]*sin((n*l)*2*pi/(float)N);
        table4[0][m][l]=table4[0][m][l]+table[1][m][n]*sin((n*l)*2*pi/(float)N)*-1;//im*im
          table4[1][m][l]=table4[1][m][l]+table[1][m][n]*cos((n*l)*2*pi/(float)N);
}}}

 for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
    for(int m=0;m<N;m++)
    {
        table3[0][k][l]=table3[0][k][l]+table4[0][l][m]*cos((k*m)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]+table4[0][l][m]*sin((k*m)*2*pi/(float)N);
        table3[0][k][l]=table3[0][k][l]+table4[1][l][m]*sin((k*m)*2*pi/(float)N)*-1;//im*im
          table3[1][k][l]=table3[1][k][l]+table4[1][l][m]*cos((k*m)*2*pi/(float)N);
    }}}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {
        //nr 1;
      //table[0][i][j] =(table3[0][i][j]+table3[3][i][j]);
      //table[1][i][j] =(table3[1][i][j]+table3[2][i][j]);

      //nr 2
      table[0][i][j] =(table3[0][i][j]+table3[1][i][j]+table3[2][i][j]+table3[3][i][j]);
      table[1][i][j] =0;
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}
void fun_inverse_discrete_fourier_transform_DFT_2D_method3(int N,double table[][12][12])
{
     int i=N,j=N,k=N,m=N;
    const double pi=3.141592653589793238462;

    double*** table3 = new double**[4];
    //double*** table = new double**[4];//do 3 wymiarowej
    for( int i = 0; i < 4; ++i)
    {
      //table[i] = new double*[N];//do 3 wymiarowej
      table3[i] = new double*[N];

      for( int j = 0; j < N; ++j)
      {
          table3[i][j]= new double[N];
      }

    }
    double table4[2][12][12]={};


for (int i=0;i<4;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table3[i][j][k]=0;
    }
    }
}
for (int i=0;i<2;i++)
{
    for(int j=0;j<N;j++)
    {    for(int k=0;k<N;k++)
    {
       table4[i][j][k]=0;
    }
    }
}

for (int m=0;m<N;m++)
{
    for(int l=0;l<N;l++)
    {
    for(int n=0;n<N;n++)
    {

          table4[0][m][l]=table4[0][m][l]+table[0][m][n]*cos((n*l)*2*pi/(float)N);
        table4[1][m][l]=table4[1][m][l]+table[0][m][n]*sin((n*l)*2*pi/(float)N);
}}}

 for (int k=0;k<N;k++)
{
    for(int l=0;l<N;l++)
    {
    for(int m=0;m<N;m++)
    {
        table3[0][k][l]=table3[0][k][l]+table4[0][l][m]*cos((k*m)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]+table4[0][l][m]*sin((k*m)*2*pi/(float)N);
          table3[0][k][l]=table3[0][k][l]+table4[1][l][m]*cos((k*m)*2*pi/(float)N);
        table3[1][k][l]=table3[1][k][l]+table4[1][l][m]*sin((k*m)*2*pi/(float)N);
    }}}

for(int i=0;i<N;i++)
{

    for(int j=0;j<N;j++)
    {
      table[0][i][j] =(table3[0][i][j]+table3[1][i][j]+table3[2][i][j]+table3[3][i][j])/(N*N);
    }
}

   for( int i = 0; i < 4; ++i)
   {
    for( int j = 0; j < N; ++j)
        {
       delete[] table3[i][j];
        }
       delete[] table3[i];
   }
    delete[] table3;

}



http://inverse-fast-fourier-transform-fft.blogspot.com/