sequence.hpp

此程序基于c语言实现fft快速傅里叶变换

#include "Vector.hpp"
namespace seq{
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
const double eps=1e-6;
typedef cxd TP;
class Sequence
{
      Vector<TP> left,right;            //以后改为值与标号 
      int   delta;
      void  construct(int,int);
      int   leftsize() { return left.size(); }
      int   rightsize() { return right.size(); }
      int   cycle() { return left.size()+right.size(); }
public:
      Sequence(int l=0,int r=0){
          delta=0;
          if(l+r)  construct(l,r);
          }
      ~Sequence() {}
      
      void     show();
      TP&      operator[](const int);

      Sequence setwith(TP [],int,int);
      Sequence setwith(float (*)(float),int,int);
      Sequence clean();
      Sequence zeros();
      
      Sequence  operator+(Sequence);
      Sequence  operator-(Sequence);
      Sequence  operator*(TP);
      Sequence  operator/(TP);
      Sequence& operator=(const Sequence&);
      Sequence  operator()(int);//移位 
      
      friend Sequence  lincon(Sequence,Sequence);
      friend Sequence  cyccon(Sequence,Sequence,int);
      friend Sequence   ft(Sequence,int,string);
      friend Sequence  dft(Sequence,int);
      friend Sequence  fft(Sequence,int);
      friend Sequence ifft(Sequence,int);
};
//-------------------------------<成员函数>-----------------------------------//
void Sequence::construct(int lsize,int rsize)
{
     left.clear();right.clear();
     operator[](rsize-1);operator[](-lsize);
}
void Sequence::show()
{
     cout <<"{\n";
     for(int i=-left.size();i<rightsize();i++)
         if( imag(operator[](i))>0 )
            cout <<real(operator[](i))<<" + "
                 <<imag(operator[](i))<<"j\n";
         else if( imag(operator[](i))<0 )
            cout <<real(operator[](i))<<" - "
                 <<-imag(operator[](i))<<"j\n";
         else
            cout <<real(operator[](i))<<endl;
     cout <<"}\n取值区间: ["<<-leftsize()+delta
          <<","<<rightsize()-1+delta<<"]\n"<<endl;
}
Sequence Sequence::setwith(TP a[],int N,int k=1)
{
     construct(0,N*k);
     for(int i=0;i<k;i++)
        for(int j=0;j<N;j++)
           operator[](N*i+j)=a[j];
     return *this;
}
Sequence Sequence::setwith(float (*f)(float),int N,int k=1)
{
    construct(0,N*k);
    for(int i=0;i<k;i++)
        for(int j=0;j<N;j++)
           operator[](N*i+j)=TP(f(j));
     return *this;
}
Sequence Sequence::clean()
{
    int ci=0;
    for(int i=-left.size();i<0;i++)
       if( abs(operator[](i))<eps )
          ci++;
       else break;
    left.clean(ci);
    ci=0;
    for(int i=right.size()-1;i>=0;i--)
       if( abs(operator[](i))<eps )
          ci++;
    right.clean(ci);
    return *this;
}
//----------------重载运算符 
TP& Sequence::operator[](int n)
{
    int nn=n-delta;
    if(nn>=0) return right[nn];
    else return left(-nn);
}
Sequence Sequence::operator+(Sequence se)
{
    int rsize=max(rightsize(),se.rightsize());
    int lsize=max(leftsize(),se.leftsize());
    Sequence rse(lsize,rsize);
    for(int i=-lsize;i<rsize;i++)
        rse[i]=operator[](i)+se[i];
    return rse;
}
Sequence Sequence::operator-(Sequence se)
{     
    int rsize=max(rightsize(),se.rightsize());
    int lsize=max(leftsize(),se.leftsize());
    Sequence rse(lsize,rsize);
    for(int i=-lsize;i<rsize;i++)
        rse[i]=operator[](i)-se[i];
    return rse;
}
Sequence Sequence::operator*(TP c)
{
    Sequence rse(leftsize(),rightsize());
    for(int i=-leftsize();i<rightsize();i++)
        rse[i]=operator[](i)*c;
    return rse;
}
Sequence Sequence::operator/(TP c)
{
    if(abs(c)==0) exit(1);
    Sequence rse(leftsize(),rightsize());
    for(int i=-leftsize();i<rightsize();i++)
        rse[i]=operator[](i)/c;
    return rse;
}
Sequence& Sequence::operator=(const Sequence& rse)
{
    left=rse.left;
    right=rse.right;
    delta=rse.delta;
    return *this;
}
Sequence Sequence::operator()(int k)
{
    Sequence rse;
    rse=*this;
    rse.delta+=k;
    return rse;
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}