overlap.cpp

数字信号处理中卷积运算中的重叠保留法,可以很好地进行信号的卷积运算

//#include <stdafx.h>
#include"fft.h"
#include<string.h>
#include<conio.h>
#include<math.h>
#include <iostream.h>
//#include "fft.cpp"




void main()
{
	
	float h[8]={1,0,-2,1,0,0,0,0};
	int i,j;
/*    for(i=0;i<10;i++)
	{
		t[i*6+0]=-1.0;
        t[i*6+1]=1.0;
		t[i*6+2]=2.0;
		t[i*6+3]=3.0;
		t[i*6+4]=4.0;
		t[i*6+5]=5.0;
	}*/
/*	float **x=new float*[13];
	for(i=0;i<13;i++)
	{
		x[i]=new float[8];
	}

	x[0][0]=x[0][1]=x[0][2]=0;
	x[0][3]=-1;
	x[0][4]=1;
	x[0][5]=2;
	x[0][6]=3;
	x[0][7]=4;
	for(j=1;j<=11;j++)
	{
		for(k=0;k<8;k++)
		{
			for(i=j*5-4+1;i<=(j+1)*5-1;i++)
			{
				x[j][k]=t[i];
			}
		}
	}
	x[12][0]=3;
	x[12][1]=4;
	x[12][2]=5;
	x[12][3]=x[12][4]=x[12][5]=x[12][6]=x[12][7]=0;
	*/
	float x[8]={0,0,0,-1,1,2,3,4};
    float y[8];


		for(j=0;j<8;j++)
		{
			y[j]=0;
		}

		float y1[8]={0};

      
      
	   Sigproc sig0(x,y,8);
	   sig0.bitrev();
       sig0.fft(3);
       complex a1(x[0],y[0]);
	   complex a2(x[1],y[1]);
	   complex a3(x[2],y[2]);
	   complex a4(x[3],y[3]);
	   complex a5(x[4],y[4]);
	   complex a6(x[5],y[5]);
	   complex a7(x[6],y[6]);
	   complex a8(x[7],y[7]);
	  
          
  /*   
	   Sigproc sig1(x[1],y[1],8);
	   sig1.bitrev();
       sig1.fft(3);

	   complex b1(x[1][5],y[1][5]);
	   complex b2(x[1][6],y[1][6]);
	   complex b3(x[1][7],y[1][7]);
	   complex b4(x[1][8],y[1][8]);
	   complex b5(x[1][9],y[1][9]);
          

	   Sigproc sig2(x[2],y[2],8);
	   sig2.bitrev();
       sig2.fft(3);

//	   complex c1(x[2][10],y[2][10]);
//	   complex c2(x[2][11],y[2][11]);
//	   complex c3(x[2][12],y[2][12]);
//	   complex c4(x[2][13],y[2][13]);
//	   complex c5(x[2][14],y[2][14]);

	   Sigproc sig3(x[3],y[3],8);
	   sig3.bitrev();
       sig3.fft(3);

	   complex d1(x[3][15],y[3][15]);
	   complex d2(x[3][16],y[3][16]);
	   complex d3(x[3][17],y[3][17]);
	   complex d4(x[3][18],y[3][18]);
	   complex d5(x[3][19],y[3][19]);

	   Sigproc sig4(x[4],y[4],8);
	   sig4.bitrev();
       sig4.fft(3);

	   complex e1(x[4][20],y[4][20]);
	   complex e2(x[4][21],y[4][21]);
	   complex e3(x[4][22],y[4][22]);
	   complex e4(x[4][23],y[4][23]);
	   complex e5(x[4][24],y[4][24]);

	   Sigproc sig5(x[5],y[5],8);
	   sig5.bitrev();
       sig5.fft(3);


	   Sigproc sig6(x[6],y[6],8);
	   sig6.bitrev();
       sig6.fft(3);

	   Sigproc sig7(x[7],y[7],8);
	   sig7.bitrev();
       sig7.fft(3);

	   Sigproc sig8(x[8],y[8],8);
	   sig8.bitrev();
       sig8.fft(3);

	   Sigproc sig9(x[9],y[9],8);
	   sig9.bitrev();
       sig9.fft(3);

	   Sigproc sig10(x[10],y[10],8);
	   sig10.bitrev();
       sig10.fft(3);

	   Sigproc sig11(x[11],y[11],8);
	   sig11.bitrev();
       sig11.fft(3);


	   Sigproc sig12(x[12],y[12],8);
	   sig12.bitrev();
       sig12.fft(3);


       Sigproc sig(h,y1,8);
	   sig.bitrev();
       sig.fft(3);*/
       
	   complex h1(h[0],y1[0]);
	   complex h2(h[1],y1[1]);
	   complex h3(h[2],y1[2]);
	   complex h4(h[3],y1[3]);
	   complex h5(h[4],y1[4]);
	   complex h6(h[5],y1[5]);
	   complex h7(h[6],y1[6]);
	   complex h8(h[7],y1[7]);

	   float m[8];
	   float n[8];
	   complex c1;
	   c1=a1*h1;
       m[0]=c1.real;
	   n[0]=-c1.imag;
	   complex c2;
	   c2=a2*h2;
	   m[1]=c2.real;
	   n[1]=-c2.imag;
	   complex c3;
	   c3=a3*h3;
	   m[2]=c3.real;
	   n[2]=-c3.imag;
	   complex c4;
	   c4=a4*h4;
	   m[3]=c4.real;
	   n[3]=-c4.imag;
	   complex c5;
	   c5=a5*h5;
	   m[4]=c5.real;
	   n[4]=-c5.imag;
	   complex c6;
	   c6=a6*h6;
	   m[5]=c6.real;
	   n[5]=-c6.imag;
	   complex c7;
	   c7=a7*h7;
	   m[6]=c7.real;
	   n[6]=-c7.imag;
	   complex c8;
	   c8=a8*h8;
	   m[7]=c8.real;
	   n[7]=-c8.imag;
	  
	   Sigproc ss(m,n,8);
       ss.bitrev();
       ss.fft(3);
	   ss.signalM();
	   for(i=0;i<8;i++)
	   {
		   m[i]/=8;
		   n[i]=-(n[i]/8);
	   }
	   for(i=0;i<8;i++)
	   {
		   cout<<m[i];
		   if(n[i]>=0)
		   {
			   cout<<"+";
		   }
		   cout<<n[i]<<"j"<<endl;
	   }
	  

	 

       
	 /*  complex **a=new complex*[13];
	   for(i=0;i<13;i++)
	   {
		   a[i]=new complex[5];
	   }
/*	   for(i=0;i<13;i++)
	   {
		   for(j=i*5;j<=(i+1)*5-1;j++)
		   {
			   complex a[i][j](x[i][j],y[i][j]);
		   }
	   }*/
    /*   complex *b=new complex[5];
       for(i=3;i<8;i++)
	   {
	       complex b[i](h[i],y1[i]);
	   }
       complex **c=new complex*[13];
	   for(i=0;i<13;i++)
	   {
		   c[i]=new complex[5];
	   }
	   for(i=0;i<13;i++)
	   {
		   for(j=i*5;j<=(i+1)*5-1;j++)
		   {
			   c[i][j]=a[i][j] * b[(j+3)%5];
		   }
	   }

		  

		  

	   for(i=0;i<13;i++)
	   {
		   delete []x[i];
	   }
       for(i=0;i<13;i++)
	   {
		   delete []y[i];
	   }*/
	  
 
}