main.cpp

Matrix_and_Vector packetMatrix_and_Vector packetMatrix_and_Vector packetMatrix_and_Vector packetMatr

	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;	
}

Vector Matrix::Get_Row(int i)					//获取第i行，以向量形式返回
{
	Vector X(this->Line_Dimension);
	if(i>=1&&i<=this->Row_Dimension)
	{
		for(int j=1;j<=this->Line_Dimension;j++)
			X.Set_Element(j,this->Get_Element(i,j));
	}
	else
		cout<<"获取矩阵行数超界!"<<endl;
	return X;
}
void Matrix::Set_Row(int i,Vector X)			//设置第i行为X的值
{
	if(i>=1&&i<=this->Row_Dimension)
	{
		for(int j=1;j<=this->Line_Dimension;j++)
			this->Set_Element(i,j,X.Get_Element(j));
	}
	else
		cout<<"设置矩阵行数超界!"<<endl;
}
Vector Matrix::Get_Line(int j)					//获取第j列，以向量形式返回
{
	Vector X(this->Row_Dimension);
	if(j>=1&&j<=this->Line_Dimension)
	{
		for(int i=1;i<=this->Row_Dimension;i++)
			X.Set_Element(i,this->Get_Element(i,j));
	}
	else
		cout<<"获取矩阵列数超界!"<<endl;
	return X;
}
void Matrix::Set_Line(int j,Vector X)			//设置第j列为X的值
{
	if(j>=1&&j<=this->Line_Dimension)
	{
		for(int i=1;i<=this->Row_Dimension;i++)
			this->Set_Element(i,j,X.Get_Element(i));
	}
	else
	{
		cout<<"设置矩阵列数超界!"<<endl;
		cout<<"j="<<j<<endl;
	}
}
void Matrix::Delete_Row(int i)			//删除第i行,第i行之后的元素统一前移一行
{
	if(i>=1&&i<=this->Row_Dimension)
	{
		for(int j=i;j<this->Row_Dimension;j++)
			this->Set_Row(j,this->Get_Row(j+1));

		this->Row_Dimension--;
	}
	else
		cout<<"删除矩阵行超界! i="<<i<<endl;
}
void Matrix::Delete_Line(int j)			//删除第j列,第j列之后的元素统一前移一列
{
	if(j>=1&&j<=this->Line_Dimension)
	{
		for(int i=j;i<this->Line_Dimension;i++)
		{
			Vector X=this->Get_Line(i+1);
			this->Set_Line(i,X);
		}
		this->Line_Dimension--;	
	}
	else
		cout<<"删除矩阵列超界! j="<<j<<endl;
}

//-----------------------------------矩阵类完-----------------------------------------------------------------

//-----------------------------------以下是依赖Matrix类的非成员函数----------------------------------------------
Matrix T(Matrix M) //返回矩阵的转置
{
	Matrix M2(M.Get_Line_Dimension(),M.Get_Row_Dimension());
	for(int i=1;i<=M2.Get_Row_Dimension();i++)
		for(int j=1;j<=M2.Get_Line_Dimension();j++)
			M2.Set_Element(i,j,M.Get_Element(j,i));
	return M2;

}
#define Max_Demension 50		//要求的行列式最大的阶数
double Matrix_Value(Matrix A) //返回行列式的值|A|
{
	double A_Value=1;
	if(A.Get_Line_Dimension()==A.Get_Row_Dimension())
	{
		int n=A.Get_Line_Dimension();
		double a[Max_Demension+1][Max_Demension+1];
		
		for(int r=1;r<=n;r++)
		{
			for(int s=1;s<=n;s++)
				a[r][s]=A.Get_Element(r,s); 
		}
		double sum=0;
		for(int k=1;k<=n;k++)
		{
			for(int j=k;j<=n;j++)
			{	
				sum=0;
				for(int t=1;t<=k-1;t++)
					sum+=a[k][t]*a[t][j];
				a[k][j]=a[k][j]-sum;
			}
			for(int i=k+1;i<=n&&k<n;i++)
			{
				sum=0;
				for(int t=1;t<=k-1;t++)
					sum+=a[i][t]*a[t][k];
				a[i][k]=(a[i][k]-sum)/a[k][k];
			}
		}

		

		for(int i=1;i<=n;i++)
			A_Value*=a[i][i];

	}
	else
		cout<<"行数和列数不相等，不能求行列式的值!";
	return A_Value;
}
//这个函数的功能是返回A的伴随矩阵
Matrix Get_Adjoint(Matrix A)
{
	int m=A.Get_Row_Dimension();
	int n=A.Get_Line_Dimension();
	Matrix B(n,m);
	if(m==n)
	{
		Matrix C(n-1,n-1);		//用于获取代数余子式	
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				double Adjoint_Element=0;
				C=A;
				C.Delete_Row(i);
				C.Delete_Line(j);
				Adjoint_Element=pow(-1,i+j)*Matrix_Value(C);
				B.Set_Element(j,i,Adjoint_Element);
			}
	}
	else
		cout<<"矩阵行列数不相等，不能获取伴随矩阵!"<<endl;
	return B;
}
//这个函数的功能是返回矩阵A的逆矩阵
Matrix Get_Converse_Matrix(Matrix A)
{
	int m=A.Get_Row_Dimension();
	int n=A.Get_Line_Dimension();
	Matrix B(m,n);
	if(m==n)
		B=Get_Adjoint(A)/Matrix_Value(A);		//逆矩阵等于伴随矩阵除以行列式的值
	else
		cout<<"矩阵行列数不相等，不存在取逆矩阵!"<<endl;
	return B;

}

//在屏幕上输出矩阵
#define Display_Precision 15		//显示精度
void Display(Matrix M)	
{
//	cout<<setw(15);
	cout<<setiosflags(ios::left)<<setprecision(Display_Precision);
	for(int i=1;i<=M.Get_Row_Dimension();i++)
	{
		for(int j=1;j<=M.Get_Line_Dimension();j++)
		{

			cout<<setw(Display_Precision+4)<<setiosflags(ios::left)<<M.Get_Element(i,j);

		}
		cout<<endl;
	}
	cout<<endl;
	cout<<resetiosflags(ios::left);

}
void Display(Vector X)	
{
	cout<<setiosflags(ios::left)<<setprecision(Display_Precision);
	for(int i=1;i<=X.Get_Dimension();i++)
	{
		cout<<setw(Display_Precision+4)<<setiosflags(ios::left)<<X.Get_Element(i);
		cout<<endl;
	}
	cout<<endl;
	cout<<resetiosflags(ios::left);
}

//将矩阵存盘
//用法示例: 
//Save(b,"E:\\study\\VCprjct\\矩阵和向量\\test.txt");
#define Save_Precision 15		//储存精度
void Save(Matrix M,ofstream out)	
{
	out<<setiosflags(ios::fixed)<<setiosflags(ios::left)<<setprecision(Save_Precision);
	for(int i=1;i<=M.Get_Row_Dimension();i++)
	{
		for(int j=1;j<=M.Get_Line_Dimension();j++)
		{
			out<<setw(Save_Precision+4)<<setiosflags(ios::left)<<M.Get_Element(i,j);
		}
		out<<endl;
	}
	out<<endl;
	out<<resetiosflags(ios::left);
}
void Save(Vector X,ofstream out)	
{
	out<<setiosflags(ios::fixed)<<setiosflags(ios::left)<<setprecision(Save_Precision);
	for(int i=1;i<=X.Get_Dimension();i++)
	{
		out<<setw(Save_Precision+4)<<setiosflags(ios::left)<<X.Get_Element(i);
		out<<endl;
	}
	out<<endl;
	out<<resetiosflags(ios::left);
}
//杜利特尔分解法解线性方程组Ax=b
//返回值：解向量x
Vector Doolittle(Matrix A,Vector b)
{
	int m=A.Get_Row_Dimension();
	int n=A.Get_Line_Dimension();
	int b_n=b.Get_Dimension();
	Vector X(n);
	if(m==n&&n==b_n)
	{	 
		//----------------------------------分解过程----------------------------------------
		double sum=0;
		for(int k=1;k<=n;k++)
		{
			for(int j=k;j<=n;j++)
			{	
				sum=0;
				for(int t=1;t<=k-1;t++)
					sum+=A.Get_Element(k,t)*A.Get_Element(t,j);
				A.Set_Element(k,j,A.Get_Element(k,j)-sum);
			}
			for(int i=k+1;i<=n&&k<n;i++)
			{
				sum=0;
				for(int t=1;t<=k-1;t++)
					sum+=A.Get_Element(i,t)*A.Get_Element(t,k);
				A.Set_Element(i,k,(A.Get_Element(i,k)-sum)/A.Get_Element(k,k));
			}
		}
		//--------------------------------求解过程--------------------------------------------------

		double y[100];
		y[1]=b.Get_Element(1);
		for(int i=2;i<=n;i++)
		{
			sum=0;
			for(int t=1;t<=i-1;t++)
				sum+=A.Get_Element(i,t)*y[t];
			y[i]=b.Get_Element(i)-sum;
		}
		X.Set_Element(n,y[n]/A.Get_Element(n,n));
		for(i=n-1;i>=1;i--)
		{
			sum=0;
			for(int t=i+1;t<=n;t++)
				sum+=A.Get_Element(i,t)*X.Get_Element(t);
			X.Set_Element(i,(y[i]-sum)/A.Get_Element(i,i));
			//x[i]=(y[i]-sum)/a[i][i];
		}
		//-------------------------------------输出解------------------------------------------------------

	}
	else
	{
		cout<<"矩阵行列数与方程右端向量维数不相等，Doolittle无法解此方程!"<<endl;
	}
	return X;
}

//-----------------------------------矩阵和向量程序包完----------------------------------------------------------