通过本文主要向大家介绍了c++矩阵转置,c++蛇形矩阵,c++矩阵求逆算法,c++求矩阵的行列式,c++矩阵求逆等相关知识,希望对您有所帮助,也希望大家支持linkedu.com www.linkedu.com
重构-C++实现矩阵的简单实例
#include <iostream>
#include <cmath>
using namespace std;
double cofactor(double* detPtr,int rank,int t); //代数余子式
double valDet( double *detPtr, int rank); //行列式
template <class T>
void exchange(T& t1,T& t2){T temp;temp=t1;t1=t2;t2=temp;} //交换
class SquareMatrix;
class Matrix{
public:
friend class SquareMatrix; //配合转换函数食用
Matrix(){m=n=mn=0;} //默认构造函数
Matrix(int mt,int nt); //构造矩阵
Matrix(const Matrix& mtrx); //复制构造函数
Matrix(int mt,int nt,double* a); //数组初始化矩阵
Matrix transposeMtrx(); //转置矩阵
//初等变换
void exchangeRow(int r1,int r2,int c=0); //交换行
void multiRow(int r,int k,int c=0); //数乘行
void addMultiRow(int r1,int r2,int k=1,int c=0); //r1+=k*r2
void exchangeColumn(int c1,int c2,int r=0); //交换列
void multiColumn(int c,int k,int r=0); //数乘列
void addMultiColumn(int c1,int c2,int k=1,int r=0); //c1+=k*c2
Matrix& operator =(const Matrix& mtrx); //赋值构造函数
friend istream& operator>>(istream& input,Matrix& mtrx);
friend ostream& operator<<(ostream& output,Matrix& mtrx); //输出矩阵
friend Matrix operator*(Matrix& m1,Matrix& m2); //矩阵乘法
protected:
int m;
int n;
int mn;
double* matrixPtr;
};
class SquareMatrix:public Matrix{
public:
SquareMatrix():Matrix(){} //默认构造函数
SquareMatrix(int mt):Matrix(mt,mt){}; //构造函数
SquareMatrix(int mt,double* a):Matrix(mt,mt,a){}; //数组初始化方阵
SquareMatrix(const Matrix& mtrx); //矩阵到方阵转换
SquareMatrix transposeSqrMtrx(); //转置方阵
SquareMatrix adjugateSqrMatrix(); //伴随矩阵
SquareMatrix inverseSqrMatrix(); //逆矩阵
friend istream& operator>>(istream& input,SquareMatrix& mtrx);
//输入方阵
friend SquareMatrix operator *(SquareMatrix& sm1,SquareMatrix& sm2);
//方阵乘法
double getDet(); //行列式的值
private:
};
Matrix::Matrix(int mt,int nt){ //初始化m*n矩阵
m=mt;n=nt;mn=m*n;
matrixPtr=new double[mn];
}
Matrix::Matrix(const Matrix& mtrx){ //复制构造函数
m=mtrx.m;n=mtrx.n;mn=mtrx.mn;
matrixPtr=new double[mn];
for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
}
Matrix::Matrix(int mt,int nt,double* a){ //数组初始化m*n矩阵
m=mt;n=nt;mn=m*n;
matrixPtr=new double[mn];
for(int i=0;i<mn;i++)
matrixPtr[i]=a[i];
}
istream& operator>>(istream& input,Matrix& mtrx){ //重载>>
if(!mtrx.m){
cout<<"enter the m,n of matrix:";
input>>mtrx.m>>mtrx.n;
mtrx.mn=mtrx.m*mtrx.n;
mtrx.matrixPtr=new double[mtrx.mn];
cout<<"enter the matrix:"<<endl;
}
else cout<<"enter a "<<mtrx.m<<'*'<<mtrx.n<<" matrix:"<<endl;
for(int i=0;i<mtrx.mn;i++) input>>mtrx.matrixPtr[i];
return input;
}
Matrix Matrix::transposeMtrx(){ //转置矩阵
Matrix mtrx(n,m);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
mtrx.matrixPtr[m*i+j]=matrixPtr[n*j+i];
return mtrx;
}
void Matrix::exchangeRow(int r1,int r2,int c){ //交换行,默认c=0
for(int i=c;i<n;i++)
exchange(matrixPtr[n*r1+i],matrixPtr[n*r2+i]);
}
void Matrix::multiRow(int r,int k,int c){ //数乘行,默认c=0
for(int i=c;i<n;i++)
matrixPtr[n*r+i]*=k;
}
void Matrix::addMultiRow(int r1,int r2,int k,int c){ //r1+=k*r2,默认k=1,c=0
for(int i=c;i<n;i++)
matrixPtr[n*r1+i]+=matrixPtr[n*r2+i]*k;
}
void Matrix::exchangeColumn(int c1,int c2,int r){ //交换列,默认r=0
for(int i=r;i<m;i++)
exchange(matrixPtr[n*i+c1],matrixPtr[n*i+c2]);
}
void Matrix::multiColumn(int c,int k,int r){ //数乘列,默认k=1,r=0
for(int i=r;i<m;i++)
matrixPtr[n*i+c]*=k;
}
void Matrix::addMultiColumn(int c1,int c2,int k,int r){ //c1+=k*c2,默认r=0
for(int i=r;i<m;i++)
matrixPtr[n*i+c1]+=matrixPtr[n*i+c2]*k;
}
Matrix& Matrix::operator=(const Matrix& mtrx){ //重载=
m=mtrx.m;n=mtrx.n;mn=m*n;
matrixPtr=new double[mn];
for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
return *this;
}
ostream& operator<<(ostream& output,Matrix& mtrx){ //重载<<
output<<endl;
for(int i=0;i<mtrx.m;i++){
for(int j=0;j<mtrx.n;j++)
output<<mtrx.matrixPtr[mtrx.n*i+j]<<' ';
output<<endl;
}
output<<endl;
return output;
}
Matrix operator *(Matrix& m1,Matrix& m2){ //重载*
Matrix m3(m1.m,m2.n);
for(int i=0;i<m3.m;i++)
for(int j=0;j<m3.n;j++){
double val=0;
for(int k=0;k<m2.m;k++)
val+=m1.matrixPtr[m1.n*i+k]*m2.matrixPtr[m2.n*k+j];
m3.matrixPtr[m3.n*i+j]=val;
}
return m3;
}
//我是萌萌哒分割线-------------------------------------------------------
SquareMatrix::SquareMatrix(const Matrix& mtrx){ //构造函数
m=n=mtrx.m;mn=m*n;matrixPtr=new double[mn];
for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
}
istream& operator>>(istream& input,SquareMatrix& mtrx){ //重载>>
if(!mtrx.m){
cout<<"enter the m of squareMatrix:";
input>>mtrx.m;
mtrx.n=mtrx.m;mtrx.mn=mtrx.m*mtrx.n;
mtrx.matrixPtr=new double[mtrx.mn];
cout<<"enter the squareMatrix:"<<endl;
}
else cout<<"enter a "<<mtrx.m<<" order squareMatrix:"<<endl;
for(int i=0;i<mtrx.mn;i++) input>>mtrx.matrixPtr[i];
return input;
}
SquareMatrix SquareMatrix::transposeSqrMtrx(){ //转置方阵
return SquareMatrix((*this).transposeMtrx());
}
SquareMatrix SquareMatrix::adjugateSqrMatrix(){ //伴随矩阵
SquareMatrix aSM(m);
for(int i=0;i<mn;i++)
aSM.matrixPtr[i]=cofactor(matrixPtr,m,i);
aSM=aSM.transposeSqrMtrx();
return aSM;
}
SquareMatrix SquareMatrix::inverseSqrMatrix(){ //逆矩阵
double det=getDet();
if(det==0){
cerr<<"this is a singular matrix!"<<endl; //判断奇异矩阵
return 0;
}
SquareMatrix aSM(m),iSM(m);
aSM=adjugateSqrMatrix();
for(int i=0;i<mn;i++)
iSM.matrixPtr[i]=aSM.matrixPtr[i]/det;
return iSM;
}
SquareMatrix operator *(SquareMatrix& sm1,SquareMatrix& sm2){ //重载*
SquareMatrix sm3(sm1.m);
for(int i=0;i<sm3.m;i++)
for(int j=0;j<sm3.n;j++){
double val=0;
for(int k=0;k<sm2.m;k++)
val+=sm1.matrixPtr[sm1.n*i+k]*sm2.matrixPtr[sm2.n*k+j];
sm3.matrixPtr[sm3.n*i+j]=val;
}
return sm3;
}
double SquareMatrix::getDet(){ //行列式
return valDet(matrixPtr,m);
}
//又是一条萌萌哒分割线------------------------------------------
double valDet( double *detPtr, int rank)
{
double val=0;
if(rank==1) return detPtr[0];
for(int i=0;i<rank;i++) //计算余子式保存在nextDetPtr[]中
{
double *nextDetPtr=new double[(rank-1)*(rank-1)];
for(int j=0;j<rank-1;j++)
for(int k=0;k<i;k++)
nextDetPtr[j*(rank-1)+k]=detPtr[(j+1)*rank+k];
for(int j=0;j<rank-1;j++)
for(int k=i;k<rank-1;k++)
nextDetPtr[j*(rank-1)+k]=detPtr[(j+1)*rank+k+1];
val+=detPtr[i]*valDet(nextDetPtr,rank-1)*pow(-1.0,i);
}
return val;
}
double cofactor(double* detPtr,int rank,int t){ //计算代数余子式
double *nextDetPtr=new double[(rank-1)*(rank-1)];
for(int i=0,j=0;i<rank*rank;i++)
if(i>=(t/rank)*rank&&i<(t/rank)*rank+rank||!((t-i)%rank)); //如果i和t同行或同列
else{
nextDe