(原创)利用克拉默法则求解多元一次方程组

(原创)利用克拉默法则求解多元一次方程组
package zouyf.matrix;
/**
* @author zouyf 2008-4-7 本程序利用克拉默法则求解多元一次方程组
*/
public class GetMatrix
{
private double[][] savequot;// 保存变量系数
private double[] constquot;// 保存常量系数
private double[] saveResult;// 保存解的集合
public GetMatrix(double quot[][])
{
int count = quot.length;
savequot = new double[count][count];
constquot = new double[count];
saveResult = new double[count];
int i = 0, j = 0;
for(i = 0; i < count; i++)
{
for(j = 0; j < count; j++)
{
savequot[i][j] = quot[i][j];
}
constquot[i] = quot[i][count];
saveResult[i] = 0;
}
}
private double getMatrixResult(double input[][])// 递归的方法求得某个行列式的值
{
if(input.length == 2)//递归出口，为二阶行列式时，直接返回
{
return input[0][0] * input[1][1] - inp
ut[0][1] * input[1][0];
}
else
{
double[] temp = new double[input.length ];//存放第一列的系数值
double[][] tempinput = new double[input .length - 1][input.length - 1];
double result = 0;
for(int i = 0; i < input.length; i ++)
{
temp[i] = input[i][0];
int m = 0, n = 0;
for(int k = 0; k < input.le ngth; k++)
{
if(k != i)
{
for(m = 0; m < input.length - 1; m++)
{
tempinput[n ][m] = input[k][m + 1];//删除当前变量系数所在的行和列，得到减少一阶的新的行列式
}
n++;
}
}
if(i % 2 == 0)// 递归调用，利用代数余子式与相应系数变量的乘积之和得到多阶行列式的值
{
result = result + temp[ i] * getMatrixResult(tempinput);
}
else
{
result = result - temp[ i] * getMatrixResult(tempinput);
}
}
return result;
}
}
private double[][] getReplaceMatrix(int i)// 用常数系数替换相应的变量系数,得到新的行列式
{
double tempresult[][] = new double[savequot.len gth][savequot.length];
for(int m = 0; m < savequot.length; m++)
{
for(int n = 0; n < savequot.length; n++)
{
if(i != m)
{
tempresult[n][m] = savequ ot[n][m];
}
else
{
tempresult[n][i] = constq uot[n];// 用常量系数替换当前变量系数
}
}
}
return tempresult;
}
public double[] getResult()
{
double basic = 0;
basic = getMatrixResult(savequot);//得到变量系数行列式的值
if(Math.abs(basic) < 0.00001)//得到行列式的值为零时，表示此方程组没有唯一解
{
System.out.println("it dose not have th e queue result!");
return saveResult;
}
double[][] temp = new double[saveResult.length] [saveResult.length];
for(int i = 0; i < saveResult.length; i++)
{
temp = getReplaceMatrix(i);
saveResult[i] = getMatrixResult(temp) /
basic;//依次计算得到每一个变量的解
}
return saveResult;
}
public static void main(String[] args)
{
/**
* 测试方程组
* 2a+b-5c+d=8
* a-3b-6d=9
* 2b-c+2d=-5
* a+4b-7c+6d=0
*/
double [][] test = { { 2, 1, -5, 1, 8 }, { 1, -3, 0, -6, 9 },
{ 0, 2, -1, 2, -5 }, { 1, 4, -7, 6, 0 } };
GetMatrix gm = new GetMatrix(test);
double [] uu = new double [test.length];// 返回结果集
uu = gm.getResult();
for (int i = 0; i < uu.length; i++)
{
System.out.println(uu[i] + ",");
}
}
}
C++版
#include "stdafx.h"
#include <math.h>
#include <vector>
#include <iostream>
//本程序利用克拉默法则求解多元一次方程组
using namespace std ;
class GetMatrix
{
public :
GetMatrix(vector< vector<double> > quot);
double getMatrixResult(vector< vector<double> > input);
vector< vector<double> > getReplaceMatrix(int i);
vector<double> getResult();
private:
vector< vector<double> > savequot;
vector< double > constquot;
vector< double > saveResult;
};
GetMatrix::GetMatrix(vector< vector<double> > quot)
{
int count = quot.size();
savequot.resize(count);
for (int i=0;i<count;i++)
{
savequot[i].resize(count);
}
constquot.resize(count);
saveResult.resize(count);
int i = 0, j = 0;
for (i = 0; i < count; i++)
{
for (j = 0; j < count; j++)
{
savequot[i][j] = quot[i][j];
}
constquot[i] = quot[i][count];
saveResult[i] = 0;
}
}
double GetMatrix::getMatrixResult(vector< vector<double> > input)// 递归的方法求得某个行列式的值
{
if (input.size() == 2)//递归出口，为二阶行列式时，直接返回
{
return input[0][0] * input[1][1] - input[0][1] * input[1][0];
}
else
{
int iLength=input.size();
vector<double> temp(iLength);
vector< vector<double> > tempinput(iLength-1,vector<double>(iLength-1));
double result = 0;
for (int i = 0; i < iLength; i++)
{
temp[i] = input[i][0];
int m = 0, n = 0;
for (int k = 0; k < iLength; k++)
{
if (k != i)
{
for (m = 0; m < iLength - 1; m++)
{
tempinput[n][m] = input[k][m + 1];//删除当前变量系数所在的行和列，得到减少一阶的新的行列式
}
n++;
}
}
if (i % 2 == 0)// 递归调用，利用代数余子式与相应系数变量的乘积之和得到多阶行列式的值
{
result = result + temp[i] * getMatrixResult(tempinput);
}
else
{
result = result - temp[i] * getMatrixResult(tempinput);
}
}
return result;
}
}
vector< vector<double> > GetMatrix::getReplaceMatrix(int i)// 用常数系数替换相应的变量系数,得到新的行列式
{
vector< vector<double> > tempresult(savequot);
for (int m = 0; m < savequot.size(); m++)
{
for (int n = 0; n < savequot.size(); n++)
{
if (i != m)
{
tempresult[n][m] = savequot[n][m];
}
else
{
tempresult[n][i] = constquot[n];// 用常量系数替换当前变量系数}
}
}
return tempresult;
}
vector<double> GetMatrix::getResult()
{
double basic = 0;
basic = getMatrixResult(savequot);//得到变量系数行列式的值
if (abs(basic) < 0.00001)//得到行列式的值为零时，表示此方程组没有唯一解
{
cout<<"it dose not have the queue result!"<<endl;
return saveResult;
}
int iLength=saveResult.size();
vector< vector<double> > temp(iLength,vector<double>(iLength));;
for (int i = 0; i < iLength; i++)
{
temp = getReplaceMatrix(i);
saveResult[i] = getMatrixResult(temp) / basic;//依次计算得到每一个变量的解}
return saveResult;
}
int_tmain(int argc, _TCHAR* argv[])
{
/**
* 测试方程组
* 2a+b-5c+d=8
* a-3b-6d=9
* 2b-c+2d=-5
* a+4b-7c+6d=0
*/
/*double test1[4][5] = { { 2, 1, -5, 1, 8 }, { 1, -3, 0, -6, 9 },
{ 0, 2, -1, 2, -5 }, { 1, 4, -7, 6, 0 } };*/
/**
* 测试方程组
* 4a+b=3
* 8a+b=6
*/
double test1[2][3] = { { 4, 1 ,3}, { 8, 1,6 } };
vector< vector< double > > test(2,vector<double>(3));
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
test[i][j]=test1[i][j];
}
}
GetMatrix* gm = new GetMatrix(test);
vector<double> uu(gm->getResult());// 返回结果集
for (int i = 0; i < uu.size(); i++)
{
cout<<uu[i] <<endl;
}
delete gm;
gm=0;
system("pause");
return 0;
}。