C++实现R语言向量化运算（向量类：c 矩阵类：matrix）2015.9.11

类源代码：

#include
using std::cout;
using std::endl;
using std::cin;
using std::istream;
using std::ios_base;
#include
using std::vector;
#include
using std::initializer_list;
#include
using std::for_each;
using std::sort;
using std::copy;
using std::find;
#include
using std::runtime_error;
#include
using std::srand;
using std::rand;
using std::system;
#include
using std::time;
#include
using std::sqrt;
#include
using std::pair;
using std::make_pair;
#include
using std::setw;
#include
using std::multiset;
using std::set;
#include
using std::unordered_map;
using std::unordered_multimap;
#include
using std::multimap;
using std::map; 
class matrix;
class c
{
private:
    vector c_val;
    size_t dim;
public:
    c():c_val(vector()),dim(0){}
    c(initializer_listlst);
    c(const vector&c_v):c_val(c_v),dim(c_v.size()){}
    c(const matrix&m);
    void out(size_t n=1)const{cout<<"The vector is:\n";for(size_t i=0;i<<setw(n)<<c_val[i]<<" ";cout<<endl<<endl;}
    double operator[](size_t i)const{return c_val[i];}
    double& operator[](size_t i){return c_val[i];}
    size_t re_dim()const{return dim;}
    friend c operator+(const c&a,const c&b);
    friend c operator-(const c&a);
    friend c operator-(const c&a,const c&b);
    friend c rep(const double&d,size_t n);
    friend c operator+(const c&a,const double&d);
    friend c operator-(const c&a,const double&d);
    friend c operator+(const double&d,const c&a);
    friend c operator-(const double&d,const c&a);
    friend c operator*(const double&d,const c&a);
    friend c operator*(const c&a,const double&d);
    friend c operator/(const double&d,const c&a);
    friend c operator/(const c&a,const double&d);
    friend c operator*(const c&a,const c&b);
    friend bool operator==(const c&a,const c&b){return a.c_val==b.c_val;}
    friend bool operator!=(const c&a,const c&b){return a.c_val!=b.c_val;}
    vector const_re_c_val()const{return c_val;}
};
class matrix
{
private:
    vector m_val;
    size_t rdim;
    size_t cdim;
public:
    matrix():m_val(vector()),rdim(0),cdim(0){}
    matrix(const vector&m):m_val(m),rdim(m_val.size()),cdim(m_val[0].re_dim()){}
    matrix(size_t m,size_t n,const double&d):m_val(vector(m,vector(n,d))),rdim(m),cdim(n){}
    matrix(const c&v,size_t r,size_t c);
    matrix(const c&v);
    c operator[](size_t i)const{return m_val[i];}
    c& operator[](size_t i){return m_val[i];}
    void out(size_t n=3)const;
    c col(size_t i)const;
    void col_change(size_t i,const c&a);
    friend matrix operator+(const matrix&a,const matrix&b);
    friend matrix operator-(const matrix&a);
    friend matrix operator-(const matrix&a,const matrix&b);
    friend matrix operator+(const matrix&a,const double&d);
    friend matrix operator+(const double&d,const matrix&a);
    friend matrix operator-(const matrix&a,const double&d);
    friend matrix operator-(const double&b,const matrix&a);
    friend matrix operator*(const matrix&a,const double&d);
    friend matrix operator*(const double&d,const matrix&a);
    friend matrix operator/(const matrix&a,const double&d);
    friend matrix operator/(const double&d,const matrix&a);
    void Swap(size_t i,size_t j)
    {c temp=this->operator[](i);this->operator[](i)=this->operator[](j);this->operator[](j)=temp;}
    void col_Swap(size_t i,size_t j)
    {
        auto temp=this->col(i);
        this->col_change(i,this->col(j));
        this->col_change(j,temp);
    }
    friend bool operator==(const matrix&a,const matrix&b){return a.m_val==b.m_val;}
    friend bool operator!=(const matrix&a,const matrix&b){return a.m_val!=b.m_val;}
    pair re_dim()const{return make_pair(rdim,cdim);}
    friend c operator%(const matrix&m,const c&v);
    friend matrix operator%(const matrix&a,const matrix&b);
    friend matrix operator%(const c&v,const matrix&m);
};
 
//类c的有关定义
c::c(initializer_listlst)
{
    vectorout;
    for_each(lst.begin(),lst.end(),[&](const double&d){out.push_back(d);});
    c_val=out;
    dim=out.size();
}
c operator+(const c&a,const c&b)
{
    size_t MAX=b.re_dim();
    if(a.re_dim()>b.re_dim())
        MAX=a.re_dim();
    vectortemp0(MAX,0);
    vectortemp1(MAX,0);
    vectortemp2(MAX,0);
    copy(a.c_val.begin(),a.c_val.end(),temp0.begin());
    copy(b.c_val.begin(),b.c_val.end(),temp1.begin());
    for(size_t i=0;i
        temp2[i]=temp0[i]+temp1[i];
    return c(temp2);
}
c operator-(const c&a)
{
    c out(a);
    for(size_t i=0;i
        out[i]=-out[i];
    return out;
}
c operator-(const c&a,const c&b)
{
    return (a+(-b));
}
c rep(const double&d,size_t n)
{
    return c(vector(n,d));
}
c operator+(const c&a,const double&d)
{
    return a+rep(d,a.re_dim());
}
c operator-(const c&a,const double&d)
{
    return (a+(-d));
}
c operator+(const double&d,const c&a)
{
    return a+d;
}
c operator-(const double&d,const c&a)
{
    return (-a)+d;
}
c operator*(const double&d,const c&a)
{
    c out(a);
    for(size_t i=0;i
        out[i]*=d;
    return out;
}
c operator*(const c&a,const double&d)
{
    return d*a;
}
c operator/(const double&d,const c&a)
{
    c out(a);
    for