The Codes of Matrix Class
Matrix.h：
#ifndef MATRIX_H
#define MATRIX_H
#include<iostream>
#include<iomanip>
#include<cassert>
#include<cmath>
#include"MatrixTypedef.h"// declare typedef‘s header file
class Matrix{
public:
Matrix(const un_int &r = 0, const un_int &c = 0, const double &number = 0);// The constructor with the parameters
Matrix(const Matrix &mat);// The copy constructor
~Matrix();// The destructor
un_int getRows(void) const { return m_rows; }// Accessor, get the value of rows
un_int getCols(void) const { return m_cols; }// Accessor，get the value of cols
void resize(const un_int &r, const un_int &c, const double &number);// Reseting the values of rows, cols and matrix members
bool isEmpty(void) const;// The judgment if matrix is empty
vec& operator [](const un_int &i) ;// Overloading the subscript operator[]
const vec& operator [](const un_int &i) const;// Overloading the subscript operator[]
friend istream& operator >>(istream &sin, Matrix &mat);// Overloading the operator >>
friend ostream& operator <<(ostream &sout, const Matrix &mat);// Overloading the operator <<
friend Matrix operator +(const Matrix &l, const Matrix &r);// Overloading matrix addtion
friend Matrix operator -(const Matrix &l, const Matrix &r);// Overloading matrix subtraction
friend Matrix operator *(const double &x, const Matrix &mat);// Overloading matrix multiplication
friend Matrix operator *(const Matrix &mat, const double &x);// Overloading matrix multiplication
friend Matrix operator *(const Matrix &l, const Matrix &r);// Overloading matrix multiplication
Matrix operator !(void);// Solving the inverse of a matrix
Matrix operator ~(void);// Solving the transpose of the matrix
double Det(void);// Solving the Determinant
private:
un_int m_rows, m_cols;// The values of rows and cols
Mat data;// The values of Matrix
void Resize(Mat &mat, const un_int &r, const un_int &c);// Resetting vector<vector<double>>‘s size
double GetDet(const Mat &mat, const un_int &n);// Solving the Determinan
double GetCofactor(const un_int m, const un_int n);// Solving algebraic cofactor
};
#endif
Matrix.cpp：
#include"Matrix.h"
// The constructor with the parameters
Matrix::Matrix(const un_int &r, const un_int &c, const double &number){
// If cols and rows are greater than or equal to 0
assert(r >= 0);
assert(c >= 0);
m_rows = r; m_cols = c;
// Resetting and initialising the matrix
Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
for(un_int j = 0;j < m_cols;++j){
data[i][j] = number;
}
}
}
// The destructor
Matrix::~Matrix(void){
// Using swap function forcing to release the memory space
for(un_int i = 0;i < m_rows;++i){
vec().swap(data[i]);
}
Mat().swap(data);
}
// The copy constructor
Matrix::Matrix(const Matrix &mat){
if(!mat.isEmpty()){
m_rows = mat.getRows();
m_cols = mat.getCols();
// Resetting matrix‘s size and values
Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
for(un_int j = 0;j < m_cols;++j){
data[i][j] = mat[i][j];
}
}
}
}
// The definition of resize function
void Matrix::resize(const un_int &r, const un_int &c, const double &number){
// If cols and rows are greater than or equal to 0
assert(r >= 0);
assert(c >= 0);
m_rows = r;
m_cols = c;
// Resetting matrix‘s size and values
Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
for(un_int j = 0;j < m_cols;++j){
data[i][j] = number;
}
}
}
// If matrix is empty
bool Matrix::isEmpty(void) const{
bool flag = true; // If all of the member of matrix is empty
for(un_int i = 0;i < m_rows;++i){
if(!data[i].empty()){
flag = false; break;
}
}
return flag;
}
// Overloading the subscript operator[]
vec& Matrix::operator [](const un_int &i) {
// If memory accessing is out of bounds
assert(i >= 0);
assert(i < m_rows);
return data[i];
}
// Overloading the subscript operator[]
const vec& Matrix::operator [](const un_int &i) const {
// If memory accessing is out of bounds
assert(i >= 0);
assert(i < m_rows);
return data[i];
}
// Overloading the operator >>
istream& operator >>(istream &sin, Matrix &mat){
sin >> mat.m_rows >> mat.m_cols;
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
// Resetting matrix‘s size and values
mat.resize(mat.m_rows, mat.m_cols, 0);
for (un_int i = 0;i < mat.m_rows;++i) {
for (un_int j = 0;j < mat.m_cols;++j) {
sin >> mat[i][j];
}
}
return sin;
}
// Overloading the operator <<
ostream& operator <<(ostream &sout, const Matrix &mat){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
// Outputting matrix
for (un_int i = 0;i < mat.m_rows;++i){
for(un_int j = 0;j < mat.m_cols;++j){
sout.setf(ios::fixed);
sout.precision(3);
sout << right << setw(6) << mat[i][j] << (j == (mat.m_cols - 1)?‘\n‘ : ‘ ‘);
}
}
cout << endl;
return sout;
}
// Overloading matrix multiplication
Matrix operator *(const double &x, const Matrix &mat){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
Matrix temp(mat.m_rows, mat.m_cols, 0);
for(un_int i = 0;i < mat.m_rows;++i){
for(un_int j = 0;j < mat.m_cols;++j){
temp[i][j] = x * mat[i][j];
}
}
return temp;
}
// Overloading matrix multiplication
Matrix operator *(const Matrix &mat, const double &x){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
Matrix temp(mat.m_rows, mat.m_cols, 0);
for(un_int i = 0;i < mat.m_rows;++i){
for(un_int j = 0;j < mat.m_cols;++j){
temp[i][j] = x * mat[i][j];
}
}
return temp;
}
// Overloading matrix addtion
Matrix operator +(const Matrix &l, const Matrix &r){
// If the rows and cols between the two matrixs are equal
assert(l.m_rows == r.m_rows);
assert(l.m_cols == r.m_cols);
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
for(un_int j = 0;j < l.m_cols;++j){
temp[i][j] = l[i][j] + r[i][j];
}
}
return temp;
}
// Overloading matrix subtraction
Matrix operator -(const Matrix &l, const Matrix &r){
// If the rows and cols between the two matrixs are equal
assert(l.m_rows == r.m_rows);
assert(l.m_cols == r.m_cols);
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
for(un_int j = 0;j < l.m_cols;++j){
temp[i][j] = l[i][j] - r[i][j];
}
}
return temp;
}
// Overloading matrix multiplication
Matrix operator *(const Matrix &l, const Matrix &r){
// If the left operand‘s cols is equal to the right operand‘s rows
assert(l.m_cols == r.m_rows);
// Using formula solving matrix multiplication
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
for(un_int j = 0;j < r.m_cols;++j){
for(un_int k = 0;k < l.m_cols;++k){
temp[i][j] += (l[i][k] * r[k][j]);
}
}
}
return temp;
}
// Solving the inverse of a matrix
Matrix Matrix::operator !(void){
const double det = Det();// Solving the Determinan
// If determinan is equal to 0 and matrix‘s rows is equal to cols
assert(fabs(det) > EPS);
assert(m_rows == m_cols);
// Solving the inverse of a matrix
Mat temp = data; for(un_int i = 0,k = 0;i < m_rows;++i, ++k){
for(un_int j = 0, l = 0;j < m_cols;++j, ++l){
double n = GetCofactor(k, l) / det;
if(fabs(n) < EPS) n = 0.0; // If double value is equal to 0
data[j][i] = n;
}
}
return *this;
}
// Solving the transpose of the matrix
Matrix Matrix::operator ~(void){
// If cols and rows are greater than or equal to 0
assert(m_rows > 0);
assert(m_cols > 0);
// If rows is equal to cols
if(m_rows == m_cols){
for(un_int i = 1;i < m_rows;++i){
for(un_int j = 0;j <= i;++j){
swap(data[i][j],data[j][i]); } }
return *this;
}
// If rows is diffierent from cols
else { Matrix temp(m_cols, m_rows, 0);
for(un_int i = 0;i < m_cols;++i){
for(un_int j = 0;j < m_rows;++j){
temp[i][j] = data[j][i];
}
}
return temp;
}
}
// Solving the Determinant
double Matrix::Det(void){
// If rows is equal to cols
assert(m_rows == m_cols);
return GetDet(data, m_rows);
}
// The definition of Resize function
void Matrix::Resize(Mat &mat, const un_int &r, const un_int &c){
// Resetting cols
mat.resize(r);
// Resetting rows
for(un_int i = 0;i < r;++i){ mat[i].resize(c); }}
// The definition of GetDet function
GetDet double Matrix::GetDet(const Mat &mat,const un_int &n){ double ans = 0;
// Solving the determinant
if(n == 1) {return mat[0][0]; }
else { Mat temp; temp.resize(n);
for(un_int i = 0;i < n;++i){ temp[i].resize(n); }
for(un_int i = 0;i < n;++i){ // Getting algebraic cofactor of first row,j+1 th col
un_int p = 0; for(un_int j = 0;j < n;++j){
if(j != 0){ un_int q = 0;
for(un_int k = 0;k < n;++k){
if(k != i){ temp[p][q] = mat[j][k]; ++q;
}
}
++p;
}
}
ans += pow(-1, i)*mat[0][i]*GetDet(temp, n - 1); }
return ans;
}
}
// The definition of GetCofactor function
double Matrix::GetCofactor(const un_int m, const un_int n){
Matrix temp(m_rows - 1, m_cols - 1, 0);
// Getting algebraic cofactor of m th row,n th col
for(un_int i = 0, k = 0, l = 0;i < m_rows;++i){
for(un_int j = 0;j < m_cols;++j){
if(i != m && j != n){
temp[k][l] = data[i][j]; ++l;
if(l == m_cols - 1){ l = 0; ++k;
}
}
}
}
const int sign = (((m + n + 2) & 1) == 0?1 : -1);
return sign * temp.Det();// Getting cofactor‘s determinant
}
MatrixTypedef.h:
#ifndef MATRIXTYPEDEF_H
#define MATRIXTYPEDEF_H
#include<vector>
using namespace std;
typedef vector<double> vec;
typedef vector<vec> Mat;
typedef unsigned int un_int;
const double EPS = 1e-6;
#endif
原文链接：http://user.qzone.qq.com/1043480007/main