main.cpp

Matrix_and_Vector packetMatrix_and_Vector packetMatrix_and_Vector packetMatrix_and_Vector packetMatr

#include"iostream.h"
#include"math.h"
#include"stdio.h"
#include"iomanip.h"
#include"fstream.h"

//这是一个向量类
#define Max_Dimension	50	 //向量最大的维数，也是默认情况下向量的维数			
class	Vector					
{
private:
	double	Element[Max_Dimension+1];
	int Dimension;
public:
	Vector();
	Vector(int Dimension);
	~Vector();

	Vector operator +(Vector	X2);
	Vector operator -(Vector	X2);
	Vector operator *(double 	X2);
	Vector operator /(double 	X2);
	double Get_Element(int i);		//获取第i个元素的值
	void Set_Element(int i,double Element_Known);		//获取第i个元素的值

	int Get_Dimension();
};
//不带参数的构造函数
//把元素全置0
Vector::Vector()
{
	Dimension=Max_Dimension;
	for(int i=1;i<=Dimension;i++)
		this->Element[i]=0;
}
//带参数的构造函数
Vector::Vector(int Dimension_You_Want)
{
	Dimension=Dimension_You_Want;
	for(int i=1;i<=Dimension;i++)
		this->Element[i]=0;
}
Vector::~Vector()
{
}
int Vector::Get_Dimension()
{
	return Dimension;
}
double Vector::Get_Element(int i)		//获取第i个元素的值
{
	if(i>=1&&i<=Dimension)
		return this->Element[i];
	else
	{
		cout<<"获取向量元素数组越界!"<<endl;
		cout<<"i="<<i<<endl;
		return 0;
	}
}
void Vector::Set_Element(int i,double Element_Known)		//设置第i个元素的值
{	
	if(i>=1&&i<=Dimension)
		this->Element[i]=Element_Known;
	else
		cout<<"设置向量元素数组越界!"<<endl;


}
//针对向量的操作符重载
Vector Vector:: operator -(Vector	X2)
{
	Vector	X3(Dimension);
	if(X2.Get_Dimension()==Dimension)
	{
		for(int i=1;i<=Dimension;i++)
			X3.Set_Element(i,this->Element[i]-X2.Get_Element(i));
	}
	else
		cout<<"两向量维数不同，不能相减!"<<endl;
	return X3;
}
Vector Vector:: operator +(Vector	X2)
{

	Vector	X3(Dimension);
	if(X2.Get_Dimension()==Dimension)
	{
		for(int i=1;i<=Dimension;i++)
			X3.Set_Element(i,this->Element[i]+X2.Get_Element(i));
	}
	else
		cout<<"两向量维数不同，不能相加!"<<endl;
	return X3;
}
//这个函数实现向量除以实数
Vector Vector:: operator /(double	X2)
{
	Vector	X3(Dimension);
	for(int i=1;i<=Dimension;i++)
	X3.Set_Element(i,Element[i]/X2);
	return X3;
}
//这个函数实现向量乘以实数
Vector Vector:: operator *(double	X2)
{
	Vector	X3(Dimension);
	for(int i=1;i<=Dimension;i++)
	X3.Set_Element(i,Element[i]*X2);
	return X3;
}

//这个函数返回 T(X1)*X2
double T_Multiply(Vector X1,Vector X2)
{
	double sum=0;
	if(X1.Get_Dimension()==X2.Get_Dimension())
	{
		for(int i=1;i<=X1.Get_Dimension();i++)
			sum+=X1.Get_Element(i)*X2.Get_Element(i);
	}
	else
		cout<<"两向量维数不同，不能相乘!"<<endl;
	return sum;
}

//------------------------------------向量类完----------------------------------------------------------------

//------------------------------------矩阵类----------------------------------------------------------
#define Max_Row_Dimension  50			//矩阵的最大行数，也是默认情况下的行数
#define Max_Line_Dimension 50			//矩阵的最大列数，也是默认情况下的列数
class Matrix
{
private:
	double Element[Max_Row_Dimension+1][Max_Line_Dimension+1];			
	int	Row_Dimension,Line_Dimension;		
public:
	Matrix();
	Matrix(int Row_Dimension_You_Want,int Line_Dimension_You_Want);	//带参数的构造函数，其参数是想声明的矩阵的行列数	
	~Matrix();							//析构函数

	Vector operator *(Vector	X);		//operator overload Matrix * Vector
	Vector Get_Row(int i);					//获取第i行，以向量形式返回
	void   Set_Row(int i,Vector X);			//设置第i行为X的值
	Vector Get_Line(int j);					//获取第j列，以向量形式返回
	void   Set_Line(int j,Vector X);			//设置第j列为X的值

	//写这两个函数的主要目的是为了编写获取代数余子式的函数，从而编写求伴随矩阵的函数	
	void   Delete_Row(int i);				//删除第i行,第i行之后的元素统一前移一行
	void   Delete_Line(int j);				//删除第j列,第j列之后的元素统一前移一列
	


	void Set_Element(int i,int j,double Element_Known);	//设置第i行，第j列的元素
	double Get_Element(int i,int j);	//获取第i行，第j列的元素	
	int Get_Row_Dimension();	// 获取矩阵的行数
	int Get_Line_Dimension();	// 获取矩阵的列数
	
	Matrix operator *(double M);	//实现矩阵与数的相乘
	Matrix operator /(double M);	//实现矩阵与数的相除

	Matrix operator *(Matrix M2);	//实现矩阵与矩阵的相乘
	Matrix operator +(Matrix M2);	//实现矩阵与矩阵的相乘
	Matrix operator -(Matrix M2);	//实现矩阵与矩阵的相乘
	

};
//不带参数的构造函数
//把元素全置0
Matrix::Matrix()
{
	Row_Dimension=Max_Row_Dimension;
	Line_Dimension=Max_Line_Dimension;
	for(int i=0;i<=Row_Dimension;i++)
		for(int j=0;j<=Line_Dimension;j++)
			Element[i][j]=0;
}
Matrix::Matrix(int Row_Dimension_You_Want,int Line_Dimension_You_Want)
{

	Row_Dimension=Row_Dimension_You_Want;
	Line_Dimension=Line_Dimension_You_Want;
	for(int i=0;i<=Row_Dimension;i++)
		for(int j=0;j<=Line_Dimension;j++)
			Element[j][i]=0;
}
Matrix::~Matrix()
{
}


//实现矩阵与向量的相乘
Vector Matrix::operator *(Vector	X)
{	

	Vector	X2(this->Row_Dimension);
	if(this->Line_Dimension==X.Get_Dimension())
	{
		for(int i=1;i<=this->Row_Dimension;i++)
		{
			double sum=0;
			for(int j=1;j<=Line_Dimension;j++)
			{
				sum+=Get_Element(i,j)*X.Get_Element(j);
			}
			X2.Set_Element(i,sum);
		}
	}
	else
		cout<<"矩阵列数和向量维数不相等，不能相乘!"<<endl;
	return X2;
}


void Matrix::Set_Element(int i,int j,double Element_Known)
{
	if(i>=1&&i<=Row_Dimension&&j>=1&&j<=Line_Dimension)
		this->Element[i][j]=Element_Known;
	else
	{
		cout<<"设置数组元素越界!"<<endl;
		cout<<"i="<<i<<" j="<<j<<endl;
	}
}
double Matrix::Get_Element(int i,int j)
{
	if(i>=1&&i<=Row_Dimension&&j>=1&&j<=Line_Dimension)
		return this->Element[i][j];
	else
	{
		cout<<"获取数组元素越界!"<<endl;
		cout<<"i="<<i<<" j="<<j<<endl;
		return 0;
	}
}

int Matrix::Get_Line_Dimension()	// 获取矩阵的列数
{
	return this->Line_Dimension;

}
int Matrix::Get_Row_Dimension()	// 获取矩阵的列数
{
	return this->Row_Dimension;
}

Matrix Matrix::operator *(double M)	//实现矩阵与数的相乘
{
	Matrix M2(this->Row_Dimension,this->Line_Dimension);
	for(int i=1;i<=this->Row_Dimension;i++)
		for(int j=1;j<=this->Line_Dimension;j++)
			M2.Set_Element(i,j,(this->Element[i][j])*M); 
	return M2;
}
Matrix Matrix::operator /(double M)	//实现矩阵与数的相除
{
	Matrix M2(this->Row_Dimension,this->Line_Dimension);
	for(int i=1;i<=this->Row_Dimension;i++)
		for(int j=1;j<=this->Line_Dimension;j++)
			M2.Set_Element(i,j,(this->Element[i][j])/M);
	return M2;
}
Matrix Matrix::operator *(Matrix M2)	//实现矩阵与矩阵的相乘
{
	Matrix M3(this->Row_Dimension,M2.Get_Line_Dimension());	
	if(this->Line_Dimension==M2.Get_Row_Dimension())		//判断相乘条件
	{
		for(int i=1;i<=M3.Get_Row_Dimension();i++)
		{
			for(int j=1;j<=M3.Get_Line_Dimension();j++)
			{
				M3.Set_Element(i,j,T_Multiply(this->Get_Row(i),M2.Get_Line(j)));						///???????????????????????+
			}
		}
	}
	else
	{
		cout<<"该矩阵列数与被乘矩阵行数不相等，不能相乘!"<<endl;
		cout<<"该矩阵列数="<<this->Line_Dimension<<" "<<"被乘矩阵行数="<<M2.Get_Row_Dimension()<<endl;
	}
	return M3;	

}
Matrix Matrix::operator +(Matrix M2)	//实现矩阵与矩阵的相加
{
	Matrix M3(this->Row_Dimension,this->Line_Dimension);	
	if(this->Row_Dimension==M2.Get_Row_Dimension()&&this->Line_Dimension==M2.Get_Line_Dimension())		//判断相加条件
	{
		for(int i=1;i<=M3.Get_Row_Dimension();i++)
		{
			for(int j=1;j<=M3.Get_Line_Dimension();j++)
			{
				M3.Set_Element(i,j,this->Element[i][j]+M2.Get_Element(i,j));						
			}
		}
	}
	else
		cout<<"该矩阵行列数与被乘矩阵行列数不相等，不能相加!"<<endl;	
	return M3;	

}
Matrix Matrix::operator -(Matrix M2)	//实现矩阵与矩阵的相减
{
	Matrix M3(this->Row_Dimension,this->Line_Dimension);	
	//判断相减条件