vector.hpp

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

/* 
 * Vector.hpp
*/
//复制构造函数同构造函数一样，也一定要创建对象!
//它们只能用来创建或销毁对象，不能修改已有对象
//----------------------------------------------------------------------------//
#include <complex>
#include <limits>
using namespace std;
typedef complex<int>    cxi;
typedef complex<long>   cxl;
typedef complex<float>  cxf;
typedef complex<double> cxd;

//独立函数
//max min 与cmath中的函数同名，不可重复定义，而cmath在complex中已包含! 
//template<typename T> T max(T x,T y) {return x>y?x:y ;}
//template<typename T> T min(T x,T y) {return x<y?x:y ;}
template<typename T> T zero(T n)    {return 0;}
template<typename T> T ones(T n)    {return 1;}
template<typename T> T rand(T n)    {return rand()/32768.;}
using std::cout;using std::endl;
//Vector类的定义 
template<typename T=int> class Vector
{
       int   length;
       T*    v_element;
       void  construct(int);
public:
       Vector(int);
       Vector(const Vector&);
       ~Vector();
       Vector& operator=(const Vector&);
       T& operator[](int);
       T& operator()(int);
       
       Vector<T> operator+(const Vector&);
       Vector<T> operator-(const Vector&);
       Vector<T> operator*(T);
       Vector<T> operator/(T);
       T operator*(const Vector&);
       
       int  size() {return length;}
       void show();
       void clear() { construct(0); }
       void setwith(T (*)(T),int);
       void clean(int);
};
//构造函数
template<typename T> Vector<T>::Vector(int n=0)  {  construct(n);  }
template<typename T> void Vector<T>::construct(int n)
{
    length=n;v_element=new T [length];
    for(int i=0;i<length;i++) v_element[i]=0;
} 
//复制构造函数
template<typename T>
Vector<T>::Vector(const Vector<T>& vobj)
{
    construct(vobj.length);
    for(int i=0;i<length;i++)
       v_element[i]=vobj.v_element[i];
}
//析构函数 
template<typename T>
Vector<T>::~Vector()  {  delete [] v_element; v_element=NULL;  }
//重载运算符 
template<typename T>
Vector<T>& Vector<T>::operator=(const Vector& vobj)
{
     construct(vobj.length);
     for(int i=0;i<length;i++)
        v_element[i]=vobj.v_element[i];
     return *this;
}

template<typename T>
T& Vector<T>::operator[](int n)
{
    if(n>=length)
    {
        Vector<T> vx=*this;
        construct(n+1);
        for(int i=0;i<vx.length;i++)
            v_element[i]=vx.v_element[i];
    }
    return v_element[n];
}

template<typename T>
T& Vector<T>::operator()(int n)  {return operator[](n-1);}

template<typename T>
Vector<T> Vector<T>::operator+(const Vector& vobj)
{
    if(length!=vobj.length) exit(1);
    Vector<T> vx=*this;
    for(int i=0;i<vx.length;i++)
        vx.v_element[i]+=vobj.v_element[i];
    return vx;
}

template<typename T>
Vector<T> Vector<T>::operator-(const Vector& vobj)
{
    if(length!=vobj.length) exit(1);
    Vector<T> vx=*this;
    for(int i=0;i<vx.length;i++)
       vx.v_element[i]-=vobj.v_element[i];
    return vx;
}

template<typename T>
Vector<T> Vector<T>::operator*(T n)
{
    Vector<T> vx=*this;
    for(int i=0;i<vx.length;i++)
       vx.v_element[i]*=n;
    return vx;
}

template<typename T>
Vector<T> Vector<T>::operator/(T n)
{
    Vector<T> vx=*this;
    for(int i=0;i<vx.length;i++)
       vx.v_element[i]/=n;
    return vx;
}

template<typename T>
T Vector<T>::operator*(const Vector& vobj)
{
    if(length!=vobj.length) exit(1);
    T s=0;
    for(int i=0;i<length;i++)
       s+=v_element[i]*vobj.v_element[i];
    return s;
}
//show
template<typename T>
void Vector<T>::show()
{
    for(int i=0;i<length;i++)
      cout <<v_element[i]<<"\t";
    cout <<"length="<<length<<endl;
}
//setwith
template<typename T>
void Vector<T>::setwith(T (*f)(T) =zero,int k=0)
{
    if(f=rand)//以时间为种子 
    {srand( (unsigned)time(NULL) );rand();}
    if(k==0) k=length;
    if(length>=k) 
    {for(int i=0;i<k;i++) v_element[i]=f(i);}
    else
    {
        construct(k);
        for(int i=0;i<length;i++)
        v_element[i]=f(i);
    }
}
//clean
template<typename T>
void Vector<T>::clean(int k=1)
{
    if(k==0) return;
    Vector<T> vx=*this;
    construct(length-k);
    for(int i=0;i<length;i++)
       v_element[i]=vx.v_element[i];
}