wtorek, 16 maja 2017

other example how it is possible to calculate inverse fourier transform iFFT


//other example how it is possible to calculate inverse fourier transform iFFT only example withoud implementation FFT algorithm
//author marcin matysek (r)ewertyn.PL

 //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

    //https://community.arm.com/graphics/b/blog/posts/speeding-up-fast-fourier-transform-mixed-radix-on-mobile-arm-mali-gpu-by-means-of-opencl---part-1
    //book: "Cyfrowe przetwarzanie sygnalow" - Tomasz Zielinski it has quick version of radix-2 because it calculates less sin() and cos()




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


using namespace std;

void fun_inverse_bits(int N,double *tablica2);
void fast_fourier_transform_FFT(int N,double *tablica2);
//not used:
void inverse_fast_fourier_transform_FFT(int N,double *tablica2);

//method nr 2
//for inverse with standard fourier FFT requires 2 times less storing information
double scaling_re_and_im(int N,double *tablica);
//method 2 works only if audio samples are not complex numbers but result of FFT can be comlex numbers
//that are combinet to normal number


int main()
{
    //assumption: if N==signal period in table tab[] then resolution = 1 Hz but N=2^b;
    //when we have signal period 22000 Hz and N=2^15=32768 then
    //the fundamental frequency is 0,671 Hz
    //that means that in F(1) is 1*0,671 Hz =0,671 Hz
    //in F(2) is 2*0,671 Hz =1,342 Hz
    //in F(9) is 9*0,671 Hz =6,039 Hz
    //in F(30) is 30*0,671 Hz =20,13 Hz that means in F(30) we will see what value has our signal in 20,13 Hz


    int N=16;//N=2^b;
     //tab[A] A=2*N;

    // signal period=16  samples= 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};

   // signal period=12  samples= 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[0 to N-1]  -re numbers
    //tab[N-1 to 2N-1]  -im numbers

//tab[21]=-4.93;//im number


cout<<"next method only normal numbers"<<endl<<endl<<endl;
system("pause");
/////////////////////////

cout<<"     method 2 "<<endl<<endl;

//It works only if audio samples are not complex numbers but result of FFT can be comlex numbers
//that are combinet to normal number

 cout<<"signal g(x)"<<endl;

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

 fun_inverse_bits(N,tab);
 fast_fourier_transform_FFT(N,tab);

 cout<<"frequency Hz"<<endl;

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

 scaling_re_and_im(N,tab);

 cout<<"scaled"<<endl;

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

 fun_inverse_bits(N,tab);
 //not inverse but makes it inverse
 fast_fourier_transform_FFT(N,tab);//not inverse but makes it inverse
 scaling_re_and_im(N,tab);

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

  cout<<"inverse"<<endl;
    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_inverse_bits(int N,double *tablica2)  // wielkooa N zawsze potega 2: N^2
{
    double (*(tablica1)[2]);
    tablica1[0]=&tablica2[0];
    tablica1[1]=&tablica2[0+N];

  ////////////////////
//////////////////////
}    // koniec void fun_inverse_bits
/////////////////////////////////////////////////////////////

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

void fast_fourier_transform_FFT(int N,double *tablica2)//+void fun_inverse_bits
{

    double (*(tablica1)[2]);
    tablica1[0]=&tablica2[0];
    tablica1[1]=&tablica2[0+N];

 /////////////////
////////////////////
}    //koniec funkcji: void fast_fourier_transform_FFT
/////////////////////////////////////////////////////////////

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

void inverse_fast_fourier_transform_FFT(int N,double *tablica2)//+void fun_inverse_bits????
{


    double (*(tablica1)[2]);
    tablica1[0]=&tablica2[0];
    tablica1[1]=&tablica2[0+N];


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

}    //koniec funkcji: void inverse_fast_fourier_transform_FFT
/////////////////////////////////////////////////////////////










double scaling_re_and_im(int N,double *tablica)
{
    double (*(tablica1)[2]);
    tablica1[0]=&tablica[0];
    tablica1[1]=&tablica[0+N];

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

}



1 komentarz:

  1. http://inverse-fourier-transformdftalgorithm.blogspot.com/2017/02/inverse-discrete-fourier-transform-idft_3.html

    OdpowiedzUsuń