谁有比较简单的矩阵类库？？(散分)

[bugzhao]

能实现矩阵的加减、乘、转置就可以
支持double型的
我从网上找了几个，都太复杂了，偶看不懂。。。
而且都是英文的

[FengYuanMSFT]

Check D3DXMATRIX class in d3dmath.h

[bugzhao]

what is d3dmath.h?

[FengYuanMSFT]

d3dxmath.h, it's part of D3D SDK or platform SDK.

It's for D3D game programming, but you can also use it for other purposes.

[itmaster]

http://peppermint.jp/products/death/doc/d3dmath_8h.html

[theoldman]

#include <iostream>
#include <vector>
using namespace std;

class Matrix
{
public:
Matrix(int);
Matrix(const Matrix&);
Matrix& operator=(const Matrix&);
int operator()(int,int) const;
int& operator()(int,int);
Matrix& operator +=(const Matrix&);
Matrix& operator -=(const Matrix&);
Matrix& operator *=(int);
Matrix& operator *=(const Matrix&);
Matrix GetQuarter(int) const ;//得到1/4个矩阵
Matrix& SetQuarter(const Matrix&,int);//设置1/4个矩阵
int Side() const;//矩阵的行/列
void Show() const;//打印矩阵
private:
void Malloc(int);//设置一个仿二维数组的大小
const int MN;//矩阵的行/列
vector< vector<int> > Data;//矩阵的数据
};

Matrix operator +(const Matrix&,const Matrix&);//全局函数:矩阵相加
Matrix operator -(const Matrix&,const Matrix&);//全局函数:矩阵相减
Matrix operator *(int,const Matrix&);//全局函数:整数乘以矩阵,在本程序中没用到
Matrix operator *(const Matrix&,int);//全局函数:矩阵乘以整数,在本程序中没用到
Matrix operator *(const Matrix&,const Matrix&);//全局函数:矩阵相乘

void Matrix::Malloc(int mn)//设定一个仿二维数组,大小为mn*mn;
{
Data.resize(mn);
for(int i=0;i<mn;++i)
Data[i].resize(mn);
}

Matrix::Matrix(int mn):MN(mn)
{
Malloc(MN);
}

Matrix::Matrix(const Matrix& rhs):MN(rhs.MN)//拷贝构造
{
Malloc(MN);
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]=rhs.Data[i][j];
}

Matrix& Matrix::operator=(const Matrix& rhs)//矩阵赋值
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]=rhs.Data[i][j];
return *this;
}

int Matrix::operator()(int m,int n) const//得到矩阵的某个元素,坐标从0开始
{ return Data[m][n];
}

int& Matrix::operator()(int m,int n)//得到矩阵的某个元素,坐标从0开始,可以赋值
{ return Data[m][n];
}

Matrix& Matrix::operator +=(const Matrix& rhs)//类公开函数,A+=B;
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]+=rhs.Data[i][j];
return *this;
}

Matrix& Matrix::operator -=(const Matrix& rhs)//类公开函数,A-=B;
{
if(MN!=rhs.MN) throw;
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]-=rhs.Data[i][j];
return *this;
}

Matrix& Matrix::operator *=(int Num)//类公开函数,A*=i;
{
for(int i=0;i<MN;++i)
for(int j=0;j<MN;++j)
Data[i][j]*=Num;
return *this;
}

Matrix Matrix::GetQuarter(int Pos) const//得到1/4个矩阵,Pos=0代表左上,Pos=1代表右上...
{
int X,Y;
switch(Pos%4)
{
case 0:X=Y=0;break;
case 1:X=0;Y=MN/2;break;
case 2:X=MN/2;Y=0;break;
case 3:X=Y=MN/2;
}
Matrix T(MN/2);
for(int i=0;i<T.MN;++i)
for(int j=0;j<T.MN;++j)
T.Data[i][j]=Data[i+X][j+Y];
return T;
}

Matrix& Matrix::SetQuarter(const Matrix& rhs,int Pos)//把rhs的值拷贝为自身的1/4个矩阵,Pos含义同上
{
int X,Y;
switch(Pos%4)
{
case 0:X=Y=0;break;
case 1:X=0;Y=MN/2;break;
case 2:X=MN/2;Y=0;break;
case 3:X=Y=MN/2;
}
for(int i=0;i<rhs.MN;++i)
for(int j=0;j<rhs.MN;++j)
Data[i+X][j+Y]=rhs.Data[i][j];
return *this;
}

int Matrix::Side() const//得到行/列
{
return MN;
}

Matrix& Matrix::operator *=(const Matrix& rhs)//类公开函数 A*=B;
{
*this= *this * rhs;//调用全局函数:矩阵相乘
return *this;
}

void Matrix::Show() const//打印矩阵
{ cout<<"Display Matrix:"<<endl;
for(int i=0;i<MN;++i){
for(int j=0;j<MN;++j)
cout<<Data[i][j]<<' ';
cout<<endl;
}
}

Matrix operator +(const Matrix& rhs1,const Matrix& rhs2)//全局函数:矩阵相加
{
Matrix T(rhs1);
return T+=rhs2;//调用类公开函数+=
}

Matrix operator -(const Matrix& rhs1,const Matrix& rhs2)//全局函数:矩阵相减
{
Matrix T(rhs1);
return T-=rhs2;//调用类公开函数-=
}

Matrix operator *(int Num,const Matrix& rhs)//全局函数:整数乘以矩阵
{
Matrix T(rhs);
return T*=Num;//调用类公开函数*=
}

Matrix operator *(const Matrix& rhs,int Num)//全局函数:矩阵乘以整数
{
Matrix T(rhs);
return T*=Num;//调用类公开函数*=
}

Matrix operator *(const Matrix& rhs1,const Matrix& rhs2)//全局函数,矩阵相乘
{ if(rhs1.Side()!=rhs2.Side()) throw;
if(rhs1.Side()==2){//行/列为2,按照常规方法计算
Matrix T(2);
T(0,0)=rhs1(0,0)*rhs2(0,0)+rhs1(0,1)*rhs2(1,0);//A11B11+A12B21;
T(0,1)=rhs1(0,0)*rhs2(0,1)+rhs1(0,1)*rhs2(1,1);//A11B12+A12B22
T(1,0)=rhs1(1,0)*rhs2(0,0)+rhs1(1,1)*rhs2(1,0);//A21B11+A22B21
T(1,1)=rhs1(1,0)*rhs2(0,1)+rhs1(1,1)*rhs2(1,1);//A21B12+A22B22
return T;
};
Matrix A11(rhs1.GetQuarter(0));//第一个矩阵的左上1/4矩阵
Matrix A12(rhs1.GetQuarter(1));//第一个矩阵的右上1/4矩阵
Matrix A21(rhs1.GetQuarter(2));//第一个矩阵的左下1/4矩阵
Matrix A22(rhs1.GetQuarter(3));//第一个矩阵的右下1/4矩阵
Matrix B11(rhs2.GetQuarter(0));//第二个矩阵的左上1/4矩阵
Matrix B12(rhs2.GetQuarter(1));//第二个矩阵的右上1/4矩阵
Matrix B21(rhs2.GetQuarter(2));//第二个矩阵的左下1/4矩阵
Matrix B22(rhs2.GetQuarter(3));//第二个矩阵的右下1/4矩阵
Matrix M1(A11*(B12-B22));//递归调用全局函数,矩阵相乘
Matrix M2((A11+A12)*B22);//递归调用全局函数,矩阵相乘
Matrix M3((A21+A22)*B11);//递归调用全局函数,矩阵相乘
Matrix M4(A22*(B21-B11));//递归调用全局函数,矩阵相乘
Matrix M5((A11+A22)*(B11+B22));//递归调用全局函数,矩阵相乘
Matrix M6((A12-A22)*(B21+B22));//递归调用全局函数,矩阵相乘
Matrix M7((A11-A21)*(B11+B12));//递归调用全局函数,矩阵相乘
Matrix C11(M5+M4-M2+M6);//调用全局函数,矩阵相加/减
Matrix C12(M1+M2);//调用全局函数,矩阵相加
Matrix C21(M3+M4);//调用全局函数,矩阵相加
Matrix C22(M5+M1-M3-M7);//调用全局函数,矩阵相加/减

Matrix T(rhs1.Side());//返回的矩阵
//设置C11-C22为T的四个小矩阵
T.SetQuarter(C11,0).SetQuarter(C12,1).SetQuarter(C21,2).SetQuarter(C22,3);
return T;
}

bool Is2Pow(int i)//判断i是否是2的n次方
{ if(i<2) return false;
while(i>2){
if(i%2) return false;
i/=2;
}
return i==2 ? true:false;
}
int main()
{ int M;
cout<<"Input two matrixes[M*M],and culculate multiply with Strassen!"<<endl;
cout<<"M=";
cin>>M;
if(Is2Pow(M)==false){
cout<<"Error:M should equal 2^n";
return 1;
}
cout<<"Input Matrix A["<<M<<"*"<<M<<"]:"<<endl;
Matrix A(M);
for(int i=0;i<M;++i)
for(int j=0;j<M;++j)
cin>>A(i,j);
cout<<"Input Matrix B["<<M<<"*"<<M<<"]:"<<endl;
Matrix B(M);
for(int i=0;i<M;++i)
for(int j=0;j<M;++j)
cin>>B(i,j);
Matrix AB(A*B);
cout<<"A*B"<<endl;
AB.Show();
Matrix BA(B*A);
cout<<"B*A"<<endl;
BA.Show();
return 0;
}

[theoldman]

上面我是转贴别人的。

[aqfox]

MATRIX.H
#include "iostream.h"
class MATRIX
{
double **data;//矩阵数据
int n,m;//n行m列
public:
MATRIX();
~MATRIX();
void input();
void output();
MATRIX(MATRIX&);
MATRIX(int,int);
MATRIX operator+(const MATRIX&);
MATRIX operator-(const MATRIX&);
MATRIX operator*(const MATRIX&);
MATRIX operator*(double);
MATRIX operator/(double);
friend MATRIX operator*(double,MATRIX);
friend double det(MATRIX);//行列式值
friend MATRIX yzs(MATRIX,int,int);//代数余子式
friend MATRIX inv(MATRIX);//矩阵逆
double get(int,int);//取第i行第j列的值
friend double Vmax(MATRIX M1);//求向量最大分量
friend double tzz(MATRIX M1);//幂法求最大特征值
void put(double,int,int);//将一个值输入到第i行j列
void LU(MATRIX,MATRIX);//LU分解放入传入的两个矩阵中
MATRIX(double**,int,int);//将一个2维数组转化为矩阵
};
double abs(double);//绝对值
我也转的

[aqfox]

MATRIX.CPP
#include "MATRIX.h"
MATRIX::MATRIX()
{
n=0;m=0;
}
MATRIX::MATRIX(int a,int b)
{
n=a;
m=b;
data=new (double*[n+1]);
int i,j;
for(i=1;i<=n;i++)
data[i]=new (double[m+1]);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
data[i][j]=0;
}
MATRIX::MATRIX(MATRIX& M)
{
this->m=M.m;
this->n=M.n;
data=new (double*[n+1]);
int i,j;
for(i=1;i<=n;i++)
data[i]=new (double[m+1]);
for(i=1;i<=this->n;i++)
for(j=1;j<=this->m;j++)
this->data[i][j]=M.data[i][j];
}
MATRIX::~MATRIX()
{
int i;
if(n!=0&&m!=0)
{
for(i=1;i<=n;i++)
delete data[i];
delete data;
}
}
MATRIX MATRIX::operator +(const MATRIX& M1)
{
if(M1.n==this->n&&M1.m==this->m)
{
MATRIX ret(this->n,this->m);
for(int i=1;i<=M1.n;i++)
for(int j=1;j<=M1.m;j++)
ret.data[i][j]=M1.data[i][j]+this->data[i][j];
return ret;
}
else
{
cout<<"error"<<endl;
return MATRIX();
}
}
MATRIX MATRIX::operator -(const MATRIX& M1)
{
if(this->n==M1.n&&this->m==M1.m)
{
MATRIX ret(this->n,this->m);
for(int i=1;i<=M1.n;i++)
for(int j=1;j<=M1.m;j++)
ret.data[i][j]=this->data[i][j]-M1.data[i][j];
return ret;
}
else
{
cout<<"error"<<endl;
return MATRIX();
}
}
MATRIX MATRIX::operator *(const MATRIX& M1)
{
if(this->n==M1.m&&this->m==M1.n)
{
MATRIX ret(this->n,M1.m);
double sum;
for(int i=1;i<=this->n;i++)
for(int j=1;j<=M1.m;j++)
{
sum=0;
for(int k=1;k<=this->m;k++)
sum+=this->data[i][k]*M1.data[k][j];
ret.data[i][j]=sum;
}
return ret;
}
else
{
cout<<"error"<<endl;
return MATRIX();
}
}
MATRIX MATRIX::operator /(double d)
{
if(d!=0)
{
MATRIX ret(this->n,this->m);
for(int i=1;i<=this->n;i++)
for(int j=1;j<=this->m;j++)
ret.data[i][j]=this->data[i][j]/d;
return ret;
}
else
{
cout<<"error"<<endl;
return MATRIX();
}
}
MATRIX MATRIX::operator *(double d)
{
if(d!=0)
{
MATRIX ret(this->n,this->m);
for(int i=1;i<=this->n;i++)
for(int j=1;j<=this->m;j++)
ret.data[i][j]=this->data[i][j]*d;
return ret;
}
else
{
cout<<"error"<<endl;
return MATRIX();
}
}
double det(MATRIX M1)
{
if(M1.n==1&&M1.m==1)
return M1.data[1][1];
if(M1.n==M1.m)
{
int sign=1;
double sum=0;
for(int i=1;i<=M1.n;i++)
{
MATRIX M2(M1.n-1,M1.m-1);
for(int j=1;j<=M2.n;j++)
for(int k=1;k<=M2.m;k++)
{
if(k<i)
M2.data[j][k]=M1.data[j+1][k];
else
M2.data[j][k]=M1.data[j+1][k+1];
}
sum+=sign*M1.data[1][i]*det(M2);
sign=sign*(-1);
}
return sum;
}
else
{
cout<<"error"<<endl;
return 0;
}
}
void MATRIX::input()
{
for(int i=1;i<=this->n;i++)
for(int j=1;j<=this->m;j++)
{
cout<<i<<"行"<<j<<"列"<<endl;
cin>>this->data[i][j];
}
}
void MATRIX::output()
{
for(int i=1;i<=this->n;i++)
{
for(int j=1;j<=this->m;j++)
{
cout<<this->data[i][j]<<" ";
}
cout<<endl;
}
}
MATRIX yzs(MATRIX M1,int a,int b)
{
if(a<=M1.n&&b<=M1.m)
{
MATRIX M2(M1.n-1,M1.m-1);
for(int i=1;i<=M2.n;i++)
for(int j=1;j<=M2.m;j++)
{
if(i>=a)
{
if(j>=b)
{
M2.data[i][j]=M1.data[i+1][j+1];
}
else
{
M2.data[i][j]=M1.data[i+1][j];
}
}
else
{
if(j>=b)
{
M2.data[i][j]=M1.data[i][j+1];
}
else
{
M2.data[i][j]=M1.data[i][j];
}
}
}
return M2;
}
else
{
return MATRIX();
}
}
MATRIX inv(MATRIX M1)
{
if(M1.n!=M1.m)
{
return MATRIX();
}
MATRIX M2(M1.n,M1.m);
for(int i=1;i<=M2.n;i++)
for(int j=1;j<=M2.m;j++)
M2.data[i][j]=det(yzs(M1,i,j));
return (M2/det(M1));
}
double MATRIX::get(int i,int j)
{
return this->data[i][j];
}
double Vmax(MATRIX M1)
{
if(M1.m!=1)
return 0;
double max=M1.data[1][1];
for(int i=1;i<=M1.n;i++)
if(M1.data[i][1]>max)
max=M1.data[i][1];
return max;
}
double tzz(MATRIX M1)
{
if(M1.n!=M1.m)
return 0;
double t1,t2;
MATRIX m_nVector1(M1.n,1),m_nVector2(M1.n,1);
for(int i=1;i<=M1.n;i++)
m_nVector1.data[i][1]=M1.data[i][1];
m_nVector2=M1*m_nVector1;
t1=Vmax(m_nVector2);
m_nVector1=m_nVector2/t1;
for(i=0;i<100000;i++)
{
m_nVector2=M1*m_nVector1;
t2=Vmax(m_nVector2);
if(abs(t1-t2)<0.00005)
return t1;
m_nVector1=m_nVector2/t2;
t1=t2;
}
return 0;
}
double abs(double t1)
{
if(t1<0)
return (0-t1);
else
return t1;
}
MATRIX operator*(double a,MATRIX M1)
{
return M1*a;
}
void MATRIX::LU(MATRIX L,MATRIX U)
{
if(n!=m)
{
cout<<"error"<<endl;
return;
}
double **l,**u;
l=new (double*[n+1]);
u=new (double*[n+1]);
int i,j,k;
for(i=1;i<=n;i++)
{
l[i]=new (double[n+1]);
u[i]=new (double[n+1]);
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
l[i][j]=0;
u[i][j]=0;
}
for(i=1;i<=n;i++)
l[i][i]=1;
for(i=1;i<=n;i++)
u[1][i]=data[1][i];
for(i=2;i<=n;i++)
l[i][1]=data[i][1]/u[1][1];
double sum=0;
for(int r=2;r<=n;r++)
{
for(i=r;i<=n;i++)
{
sum=0;
for(k=1;k<=r-1;k++)
sum+=l[r][k]*u[k][i];
u[r][i]=data[r][i]-sum;
sum=0;
for(k=1;k<=r-1;k++)
sum+=l[i][k]*u[k][r];
l[i][r]=(data[i][r]-sum)/u[r][r];
}
}
MATRIX MT1(n,n),MT2(n,n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
MT1.put(l[i][j],i,j);
MT2.put(u[i][j],i,j);
}
L=MT1;
U=MT2;
return;
}
void MATRIX::put(double c,int a,int b)
{
this->data[a][b]=c;
return;
}
MATRIX::MATRIX(double** c,int a,int b)
{
this->n=a;
this->m=b;
data=new (double*[n+1]);
int i,j;
for(i=1;i<=n;i++)
data[i]=new (double[m+1]);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
}