矩阵运算v1

实现了程序矩阵的 加减乘除求逆等操作，通过vector建立二维矩阵进行计算。

• 主要实现方法为通过对运算符进行重载来实现运算操作。

/*

###############################################################

FileName:Matrix Cacualte

Tips:Using Vector to caculate Matrix ,e.g. + _ * /	etc

Editer:KimHuang

LastTime:11.11.19

###############################################################

*/

#include<iostream>
#include<vector>
#include<math.h>
using namespace std;

class Matrix
{
public:
	Matrix();							//无默认参数构造对象
	Matrix(Matrix &Temp);				//对象赋值
	Matrix(vector<vector<double>> A);	//用二维vector对对象赋值
	Matrix(vector<double> Vec,int col);	//用一维vector对对象赋值
	~Matrix();							//析构函数
	void resize(int row, int column);	//重新设置矩阵的行列
	void InputData(vector<vector<double>> A);
	Matrix& operator=(Matrix &A);		
	Matrix& operator+(Matrix &A);
	Matrix& operator+=(Matrix &A);
	Matrix& operator*(Matrix &A);
	Matrix& operator^(int t);
	Matrix& operator/(Matrix &A);
	Matrix& Adj();						//计算矩阵的伴随矩阵Adjugate matrix
	vector<double> operator[](int a);
	double det();						//计算矩阵行列式
	//ostream& operator<<(ostream&);
public:
	vector<vector<double>> Array;
};
ostream& operator<<(ostream& output, Matrix& A);

Matrix temper;							//作为中间变量对运算过程中的数据进行临时的保存
Matrix temper1;

Matrix::Matrix()
{
	this->resize(1, 1);
}

Matrix::Matrix(Matrix &Temp)
{
	vector<vector<double>> Array(Temp.Array);
}

Matrix::Matrix(vector<double> Vec, int col)
{
	int length = Vec.size();
	int row = length / col;
	this->resize(row, col);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			Array[i][j] = Vec[i*col + j];
		}
	}
}

Matrix::Matrix(vector<vector<double>> A)
{
	int row = A.size();
	int col = A[0].size();
	this->resize(row, col);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
			this->Array[i][j] = A[i][j];
	}
}

Matrix::~Matrix()
{
	Array.~vector<vector<double>>();
}

void Matrix::resize(int row, int column)
{
	Array.resize(row);
	for (int i = 0; i < Array.size(); i++)
		Array[i].resize(column);
}

void Matrix::InputData(vector<vector<double>> A)
{
	int row = A.size();
	int col = A[0].size();
	this->resize(row, col);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			this->Array[i][j] = A[i][j];
		}
	}
	
}
Matrix& Matrix::operator=(Matrix& A)
{
	int row = A.Array.size();
	int col = A.Array[0].size();
	this->resize(row, col);
	for (int i = 0; i < row; i++)			//利用遍历进行矩阵的复制
	{
		for (int j = 0; j < col; j++)
		{
			this->Array[i][j] = A.Array[i][j];
		}
	}
	return *this;
}

Matrix& Matrix::operator+=(Matrix& A)
{
	int r1, r2, c1, c2;
	r1 = A.Array.size();
	r2 = this->Array.size();
	c1 = A.Array[0].size();
	c2 = this->Array[0].size();
	if (r1 == r2 &&c1 == c2)
	{
		for (int i = 0; i < r1; i++)
		{
			for (int j = 0; j < c1; j++)
			{
				this->Array[i][j] = this->Array[i][j] + A.Array[i][j];
			}
		}
	}
	else
	{
		cerr << "Error! The size of Matrix is wrong!" << endl;
	}
	return *this;
}

Matrix& Matrix::operator+(Matrix &A)		//利用+=实现+的操作
{
	temper = *this;
	temper += A;
	return temper;
}

Matrix& Matrix::operator*(Matrix &A)
{
	int row = this->Array.size();
	int col = A.Array[0].size();
	temper.resize(row, col);
	double t = 1;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			t = 0;
			for (int a = 0; a < this->Array[0].size(); a++)
				//实现矩阵1的第i行所有元素，与矩阵2的第j列所有元素的乘积之和
				t += this->Array[i][a] * A.Array[a][j];
			temper.Array[i][j] = t;
		}
	}
	return temper;
}



vector<double> Matrix::operator[](int a)	//实现对矩阵的序列号输出
{
	return this->Array[a];
}

Matrix& Matrix::operator^(int t)			//矩阵乘方
{
	temper = *this;
	int row = this->Array.size();
	int col = this->Array[0].size();
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			temper[i][j] = pow(temper[i][j], t);
		}
	}
	return temper;
}

//利用递归，通过不断降阶实现矩阵的代数余子式计算
double reduce_order(vector<vector<double>> vec, int n)	
{
	if (n == 1)
	{
		return vec[0][0];
	}
	else
	{
		int sum = 0;
		for (int i = 0; i < n; i++)//operator with the Ar1
		{
			vector<vector<double>> s;
			for (int j = 1; j < n; j++)	//row,start with the second row
			{
				vector<double> t;	//建立一维矩阵，存放矩阵的行
				for (int k = 0; k < n; k++)	//column
				{
					if (k != i)
					{
						//余子式中的一行（除去所指向行列的元素）
						t.push_back(vec[j][k]);	//data of a row,start  with the  second row
					}
				}
				//将余子式中的一行，添加到二维矩阵中，形成余子式
				s.push_back(t);	//add data to 2-dimensions vecotr
			}
			//主语句
			sum += pow(-1, i)*vec[0][i] * reduce_order(s, n - 1);	//递归调用
		}
		return sum;
	}
}

//求矩阵的行列式（引用上述函数） Tips:为避免递归可能造成的不良影响，故将递归计算部分单独写成函数
double Matrix::det()
{
	int row = this->Array.size();
	int col = this->Array[0].size();
	double res;
	if (row != col)
	{
		cerr << "The Matrix's row must be equal to it's column!" << endl;
		return 0.000;
	}
	//调用计算函数
	res = reduce_order(this->Array, row);
	//cout << res << endl;
	return res;
}

//计算矩阵的伴随矩阵Adjugate matrix
Matrix& Matrix::Adj()
{
	int row = this->Array.size();
	int col = this->Array[0].size();
	temper.resize(row, col);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			vector<vector<double>> Mat;
			for (int a = 0; a < row; a++)
			{
				vector<double> line;
				for (int b = 0; b < col; b++)
				{
					if (b != j)
						line.push_back(this->Array[a][b]);
				}
				if (a != i)
					Mat.push_back(line);
			}
			temper1.InputData(Mat);
			int A = temper1.det();
			temper[i][j] = A;
		}
	}
	return temper;
}

Matrix& Matrix::operator/(Matrix& A)
{
	//What we have to do is caculat the second Matrix 
	//secondly,we should let the result muliply the fisrt Matrix
	//First Matrix
	int row1 = this->Array.size();
	int col1 = this->Array[0].size();
	//Second Matrix
	int row2 = A.Array.size();
	int col2 = A.Array[0].size();
	double Adet = A.det();
	temper.resize(row2, col2);
	temper1 = A.Adj;
	for (int i = 0; i < row2; i++)		//计算A*/|A|;
	{
		for (int j = 0; j < col2; j++)
		{
			temper1.Array[i][j] = temper1.Array[i][j] / Adet;
		}
	}

	temper = *this*temper1;			//计算B/a=B*(A^-1);
	//cout << temper << endl;
	return temper;
}

ostream&  operator<<(ostream& output,Matrix &A)
{
	for (int i = 0; i < A.Array.size(); i++)
	{
		for (int j = 0; j < A.Array[i].size(); j++)
		{
			output << A.Array[i][j] << " ";
		}
		output << endl;
	}
	return output;
}



//测试程序
int main()
{
	vector<double> a;
	a.push_back(1);
	a.push_back(2);
	a.push_back(3);
	a.push_back(2);
	a.push_back(2);
	a.push_back(1);
	a.push_back(3);
	a.push_back(4);
	a.push_back(3);
	vector<double>c;
	for (int i = 1; i <= 9; i++)
	{
		c.push_back((double)i);
	}
	Matrix x(c, 2);
	vector<double> b(a);
	Matrix Test1(c, 3);
	Matrix Test2(a, 3);
	cout << Test2.det() << endl;
	system("pause");
	return 0;
}