C++中矩阵和向量的运算

// Matrix and Vector.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "math.h"
#include
#include
using namespace std;

class Vtr{
int lenth;
double* ets;
public:
Vtr(int ,double*);
Vtr(int=0,double d=0);
Vtr(const Vtr&);
~Vtr(){delete[] ets;}

int size() const {return lenth;}
Vtr& operator=(const Vtr&);
Vtr& operator+=(const Vtr&);
Vtr& operator-=(const Vtr&);
double maxnorm() const;
double twonorm() const;
double& operator[] (int i) const {return ets[i];}
friend Vtr operator+(const Vtr&);
friend Vtr operator-(const Vtr&);
friend Vtr operator+(const Vtr&,const Vtr&);
friend Vtr operator-(const Vtr&,const Vtr&);
friend Vtr operator*(double,const Vtr&);
friend Vtr operator*(const Vtr&,double);
friend Vtr operator/(const Vtr&,double);
friend Vtr operator*(const Vtr&,const Vtr&);
friend double dot(const Vtr&,const Vtr&);
friend ostream& operator<<(ostream&,const Vtr&);
};
inline void error(char* v){
cout<exit(1);

}

Vtr::Vtr(int n,double* abd){
ets=new double [lenth=n];
for(int i=0;i
}

Vtr::Vtr(int n,double a){
ets=new double [lenth=n];
for(int i=0;i
}

Vtr::Vtr(const Vtr&v){
ets=new double [lenth=v.lenth];
for(int i=0;i
}

Vtr& Vtr::operator =(const Vtr&v){
if (this!=&v){
if (lenth!=v.lenth) error("bad vector sizes");
for(int i=0;i
}
return *this;

}

Vtr& Vtr::operator +=(const Vtr& v){
if (lenth!=v.lenth) error("bad vector sizes");
for(int i=0;ireturn *this;

}

Vtr& Vtr::operator-=(const Vtr& v){
if (lenth!=v.lenth) error("bad vector sizes");
for(int i=0;ireturn *this;

}

inline Vtr operator+(const Vtr& v){
return v;
}

inline Vtr operator-(const Vtr& v){
return Vtr(v.lenth)-v;
}

Vtr operator+(const Vtr& v1,const Vtr& v2){
if (v1.lenth!=v2.lenth) error("bad vector sizes");
Vtr sum=v1;
sum+=v2;
return sum;

}

Vtr operator-(const Vtr& v1,const Vtr& v2){
if (v1.lenth!=v2.lenth) error("bad vector sizes");
Vtr sum=v1;
sum-=v2;
return sum;

}

Vtr operator*(double scalar,const Vtr& v){
Vtr tm(v.lenth);
for(int i=0;ireturn tm;

}

inline Vtr operator*(const Vtr& v,double scalar){
return scalar*v;

}

Vtr operator*(const Vtr& v1,const Vtr& v2){
if (v1.lenth!=v2.lenth) error("bad vector sizes");
int n=v1.lenth;
Vtr tm(n);
for(int i=0;ireturn tm;

}

Vtr operator/(const Vtr& v,double scalar){
if (!scalar) error("division by zero in vector-scalar division");

return (1.0/scalar)*v;
}

double Vtr::twonorm() const{
double norm=ets[0]*ets[0];
for (int i=1;ireturn

sqrt(norm);

}

double Vtr::maxnorm() const{
double norm=fabs(ets[0]);
for (int i=1;inorm=max(norm,fabs(ets[i]));
return norm;

}

double dot(const Vtr &v1,const Vtr& v2){
if (v1.lenth!=v2.lenth) error("bad vector sizes");
double tm=v1[0]*v2[0];

for(int i=0;ireturn tm;

}

ostream& operator<<(ostream& s,const Vtr& v){
for (int i=0;is<if (i%10==9) s<<"\n";
}
return s;
}


class Mtx{
private:
int nrows;
int ncols;
double ** ets;
public:
Mtx(int n,int m,double **);
Mtx(int n,int m,double d=0);
Mtx(const Mtx &);
~Mtx();

Mtx& operator=(const Mtx&);
Mtx& operator+=(const Mtx&);
Mtx& operator-=(const Mtx&);
Vtr operator*(const Vtr&) const;
double* operator[](int i) const{return ets[i];}
double& operator()(int i,int j) {return ets[i][j];}
Mtx& operator+(const Mtx&);
Mtx operator+(const Mtx&) const;
friend Mtx operator-(const Mtx&);
friend Mtx operator-(const Mtx&,const Mtx&);

};

Mtx::Mtx(int n,int m,double **dbp){
nrows=n;
ncols=m;
ets=new double*[nrows];
for (int i=0;iets[i]=new double [ncols];
for (int j=0;j
}
}

Mtx::Mtx(int n,int m,double a){

ets=new double*[nrows=n];
ncols=m;
for (int i=0;iets[i]=new double [ncols];
for (int j=0;j
}
}

Mtx::Mtx(const Mtx & mat){
ets=new double*[nrows=mat.nrows];
ncols=mat.ncols;
for (int i=0;iets[i]=new double [ncols];
for (int j=0;j
}
}

inline Mtx::~Mtx(){
for (int i=0;idelete[] ets;

}

Mtx& Mtx::operator=(const Mtx& mat){
if (this !=&mat){
if (nrows!=mat.nrows||ncols!=mat.ncols)
error("bad matrix sizes");
for (int i=0;ifor(int j=0;jets[i][j]=mat[i][j];

}
return *this;
}

Mtx& Mtx::operator+=(const Mtx& mat){
if (nrows !=mat.nrows||ncols!=mat.ncols)
error("bad matrix sizes");
for (int i=0;ifor(int j=0;jets[i][j]+=mat[i][j];
return *this;
}

Mtx& Mtx::operator-=(const Mtx& mat){
if (nrows !=mat.nrows||ncols!=mat.ncols)
error("bad matrix sizes");
for (int i=0;ifor(int j=0;jets[i][j]-=mat[i][j];
return *this;
}

inline Mtx& Mtx::operator+(const Mtx&mat){
return *this;
}

inline Mtx operator -(const Mtx&mat) {
return Mtx(mat.nrows,mat.ncols)-mat;
}

Mtx Mtx::operator+(const Mtx & mat)const{
if (nrows !=mat.nrows||ncols!=mat.ncols)

error("bad matrix sizes");
Mtx sum=*this;
sum+=mat;
return sum;

}

Mtx operator-(const Mtx & m1,const Mtx&m2){
if (m1.nrows !=m2.nrows||m1.ncols!=m2.ncols)

error("bad matrix sizes");
Mtx sum=m1;
sum-=m2;
return sum;

}

Vtr Mtx::ope

rator*(const Vtr & v )const{
if (nrows !=v.size())

error("matrix and vector sizes do not match");
Vtr tm(nrows);
for (int i=0;ifor(int j=0;jtm[i]+=ets[i][j]*v[j];


return tm;

}





int _tmain(int argc, _TCHAR* argv[])
{
int k=300;
double **mt=new double*[k];
for(int i=0;ifor(int i=0;ifor(int j=0;jMtx m1(k,k,mt);
Mtx m2(k,k,5);
Mtx m3(k,k);
for (int i=0;ifor (int j=0;jm3+=-m1+m2;
m1-=m3;

Vtr vv(k);
for (int i=0;ivv=m3*vv;

ofstream fout;

fout.open("f:/g.m");

fout<
fout.close();



cout<int a;
cin>>a;
return 0;
}