```cpp
#ifndef CALCULATEMATRIX_H
#define CALCULATEMATRIX_H
#include<iostream>
#include<assert.h>
template <class Type>
class myMatrix
{
typedef myMatrix<Type> _matrix;
public:
myMatrix(int nrows, int ncols);
myMatrix(const myMatrix<Type> & _Matrix);
~myMatrix();
void initialize(const Type**rhs, int nrow, int ncol);//自定义初始化
myMatrix<Type> reverse();//转置
myMatrix<Type> Inverse();//求逆
int getRow();//获取行
int getCol();//获取列
const Type operator()(int nrow, int ncol)const;
Type& operator()(int nrow, int ncol);
friend myMatrix<Type> operator + (const myMatrix<Type>& lmatrix, const myMatrix<Type>&rmatrix)
{
if (lmatrix.nSizeCol != rmatrix.nSizeCol || lmatrix.nSizeRow != rmatrix.nSizeRow)
{
//行列必须一致
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
myMatrix<Type> matrix(lmatrix.nSizeRow, lmatrix.nSizeCol);
for (int i = 0; i < lmatrix.nSizeRow; i++)
{
for (int j = 0; j < lmatrix.nSizeCol; j++)
{
matrix.ppdMatrix[i][j] = lmatrix.ppdMatrix[i][j] + rmatrix.ppdMatrix[i][j];
}
}
return matrix;
};
friend _matrix operator - (const _matrix& lmatrix, const _matrix&rmatrix)
{
if (lmatrix.nSizeCol != rmatrix.nSizeCol || lmatrix.nSizeRow != rmatrix.nSizeRow)
{
//行列必须一致
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
myMatrix<Type> matrix(lmatrix.nSizeRow, lmatrix.nSizeCol);
for (int i = 0; i < lmatrix.nSizeRow; i++)
{
for (int j = 0; j < lmatrix.nSizeCol; j++)
{
matrix.ppdMatrix[i][j] = lmatrix.ppdMatrix[i][j] - rmatrix.ppdMatrix[i][j];
}
}
return matrix;
};
friend _matrix operator * (const _matrix& lmatrix, const _matrix&rmatrix)
{
if (lmatrix.nSizeCol != rmatrix.nSizeRow)
{
//行列对应
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
myMatrix<Type> matrix(lmatrix.nSizeRow, rmatrix.nSizeCol);
for (int i = 0; i < lmatrix.nSizeRow; i++)
{
for (int j = 0; j < rmatrix.nSizeCol; j++)
{
Type _value = 0;
for (int k = 0; k < rmatrix.nSizeRow; k++)
{
double a = lmatrix.ppdMatrix[i][k];
a= rmatrix.ppdMatrix[k][j];
_value += lmatrix.ppdMatrix[i][k] * rmatrix.ppdMatrix[k][j];
}
matrix.ppdMatrix[i][j] = _value;
}
}
return matrix;
};
myMatrix<Type>& operator=(const myMatrix<Type>& curmatrix);
int nSizeRow;//行
int nSizeCol;//列
Type**ppdMatrix;//矩阵
protected:
private:
};
template<class Type>
inline myMatrix<Type>::myMatrix(int nrows, int ncols)
{
//初始化为0
if (nrows < 0 || ncols < 0)
{
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
else
{
nSizeRow = nrows;
nSizeCol = ncols;
ppdMatrix = new Type*[nSizeRow];
for (int i = 0; i < nSizeRow; i++)
{
ppdMatrix[i] = new Type[nSizeCol];
memset(ppdMatrix[i], 0, nSizeCol * sizeof(Type));
}
}
}
template<class Type>
inline myMatrix<Type>::myMatrix(const myMatrix<Type>& _Matrix)
{
//为临时对象构造函数
if (_Matrix.nSizeRow < 0 || _Matrix.nSizeCol < 0)
{
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
else
{
nSizeRow = _Matrix.nSizeRow;
nSizeCol = _Matrix.nSizeCol;
ppdMatrix = new Type*[nSizeRow];
for (int i = 0; i < nSizeRow; i++)
{
ppdMatrix[i] = new Type[nSizeCol];
}
int i = 0, j = 0;
for (i = 0; i < nSizeRow; i++)
{
for (j = 0; j < nSizeCol; j++)
{
ppdMatrix[i][j] = _Matrix(i, j);
}
}
}
}
template<class Type>
myMatrix<Type>::~myMatrix()
{
for (int i = 0; i < nSizeRow; i++)
{
delete[]ppdMatrix[i];
}
delete[]ppdMatrix;
ppdMatrix = NULL;
/*delete matrix;*/
}
template<class Type>
inline const Type myMatrix<Type>::operator()(int nrow, int ncol) const
{
//获取矩阵指定位置值
if (nSizeRow <= nrow || nSizeCol <= ncol)
{
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
return (Type)ppdMatrix[nrow][ncol];
}
template<class Type>
inline Type & myMatrix<Type>::operator()(int nrow, int ncol)
{
//更改矩阵指定位置值
if (nSizeRow <= nrow || nSizeCol <= ncol)
{
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
return (Type&)ppdMatrix[nrow][ncol];
}
template<class Type>
inline void myMatrix<Type>::initialize(const Type ** rhs, int nrow, int ncol)
{
//自定义初始化
if (nrow < 0 || ncol < 0)
{
cerr << "[err] error col's number or row's number!\n";
exit(-1);
}
else
{
nSizeRow = nrows;
nSizeCol = ncols;
ppdMatrix = new Type*[nSizeRow];
int i = 0, j = 0;
for (i= 0; i < nSizeRow; i++)
{
ppdMatrix[i] = new Type[nSizeCol];
memset(ppdMatrix[i], 0, nSizeCol * sizeof(Type));
}
for (i = 0; i < nrow; i++)
{
for (j = 0; j < ncol; j++)
{
ppdMatrix[i][j] = rhs[i][j];
}
}
}
}
template<class Type>
inline myMatrix<Type> myMatrix<Type>::reverse()
{
//转置
myMatrix<Type> _matrix2(nSizeCol, nSizeRow);
int i, j;
for (i = 0; i < _matrix2.nSizeRow; i++)
{
for (j = 0; j < _matrix2.nSizeCol; j++)
{
_matrix2(i,j) =ppdMatrix[j][i];
}
}
return _matrix2;
}
template<class Type>
inline myMatrix<Type> myMatrix<Type>::Inverse()
{
//Cholesky法求解
//求逆
if (nSizeCol != nSizeRow)
{
cerr << "[err] The number of rows and columns must be equal !\n";
exit(-1);
}
myMatrix<Type> _matrixT(nSizeRow, nSizeCol);
myMatrix<Type> _matrixR(nSizeRow, nSizeCol);
//calculate T
int i = 0, j = 0, k = 0;
Type _Tki = 0;
_matrixT(0, 0) = sqrt(ppdMatrix[0][0]);
for (j = 1; j < nSizeCol; j++)
{
//calculate the first row value of _matrixT 计算矩阵T的第一行
_matrixT(0, j) = ppdMatrix[0][j] / _matrixT(0, 0);
}
for (i = 1; i < nSizeRow; i++)
{
_Tki = 0;
for (k = 0; k <= i - 1; k++)
{
_Tki += _matrixT(k, i)*_matrixT(k, i);
}
//calculate Tii 计算Tii
_Tki = ppdMatrix[i][i] - _Tki;
_matrixT(i, i) = sqrt(_Tki);
for (j = i + 1; j < nSizeCol; j++)
{
_Tki = 0;
for (k = 0; k <= i - 1; k++)
{
_Tki += _matrixT(k, i)*_matrixT(k, j);
}
//calculate Tij 计算Tij
_matrixT(i, j) = (ppdMatrix[i][j] - _Tki) / _matrixT(i, i);
}
}
//calculate R 计算矩阵R
for (i = 0; i < nSizeRow; i++)
{
//calculate Rii 计算Rii
_matrixR(i, i) = 1 / _matrixT(i, i);
}
for (i = nSizeRow - 2; i >= 0; i--)
{
for (j = i + 1; j < nSizeCol; j++)
{
_Tki = 0;
for (k = i + 1; k <= j; k++)
{
_Tki += _matrixT(i, k)*_matrixR(k, j);
}
//calculate Rij 计算Rij
_matrixR(i, j) = (-1 * _Tki) / _matrixT(i, i);
}
}
myMatrix<double> matrix_N = _matrixR * _matrixR.reverse();
return matrix_N;
}
template<class Type>
inline int myMatrix<Type>::getRow()
{
//获取行
return nSizeRow;
}
template<class Type>
inline int myMatrix<Type>::getCol()
{
//获取列
return nSizeCol;
}
template<class Type>
inline myMatrix<Type>& myMatrix<Type>::operator=(const myMatrix<Type>& curmatrix)
{
for (int i = 0; i < curmatrix.nSizeRow; i++)
{
for (int j = 0; j < curmatrix.nSizeCol; j++)
{
this->ppdMatrix[i][j] = curmatrix.ppdMatrix[i][j];
}
}
return *this;
}
#endif
调用
myMatrix<double> A(3, 3),B(3,3), C(3, 3);//构建
A(1, 2) = -1;//赋值
A.getCol();//获取列数
A.getRow();//获取行数
A.reverse();//转置
A.Inverse();//求逆(只适用正定矩阵)
C = A + B;
C = A * B;
C = A.Inverse() - B.reverse();