📄 lequations.java
字号:
/*
* 求解线性方程组的类 LEquations
*
* 周长发编制
*/
package javaalgorithm.algorithm;
/**
* 求解线性方程组的类 LEquations
* @author 周长发
* @version 1.0
*/
public class LEquations
{
private Matrix mtxLECoef; // 系数矩阵
private Matrix mtxLEConst; // 常数矩阵
/**
* 基本构造函数
*/
public LEquations()
{
}
/**
* 指定系数和常数构造函数
*
* @param mtxCoef - 指定的系数矩阵
* @param mtxConst - 指定的常数矩阵
*/
public LEquations(Matrix mtxCoef, Matrix mtxConst)
{
init(mtxCoef, mtxConst);
}
/**
* 初始化函数
*
* @param mtxCoef - 指定的系数矩阵
* @param mtxConst - 指定的常数矩阵
* @return boolean 型，初始化是否成功
*/
public boolean init(Matrix mtxCoef, Matrix mtxConst)
{
if (mtxCoef.getNumRows() != mtxConst.getNumRows())
return false;
mtxLECoef = new Matrix(mtxCoef);
mtxLEConst = new Matrix(mtxConst);
return true;
}
/**
* 获取系数矩阵
*
* @return Matrix 型，返回系数矩阵
*/
public Matrix getCoefMatrix()
{
return mtxLECoef;
}
/**
* 获取常数矩阵
*
* @return Matrix 型，返回系数矩阵
*/
public Matrix getConstMatrix()
{
return mtxLEConst;
}
/**
* 获取方程个数
*
* @return int 型，返回方程组方程的个数
*/
public int getNumEquations()
{
return getCoefMatrix().getNumRows();
}
/**
* 获取未知数个数
*
* @return int 型，返回方程组未知数的个数
*/
public int getNumUnknowns()
{
return getCoefMatrix().getNumColumns();
}
/**
* 全选主元高斯消去法
*
* @param mtxResult - Matrix对象，返回方程组的解
* @return boolean 型，方程组求解是否成功
*/
public boolean getRootsetGauss(Matrix mtxResult)
{
int l,k,i,j,nIs=0,p,q;
double d,t;
// 方程组的属性，将常数矩阵赋给解矩阵
mtxResult.setValue(mtxLEConst);
double[] pDataCoef = mtxLECoef.getData();
double[] pDataConst = mtxResult.getData();
int n = getNumUnknowns();
// 临时缓冲区，存放列数
int[] pnJs = new int[n];
// 消元
l=1;
for (k=0;k<=n-2;k++)
{
d=0.0;
for (i=k;i<=n-1;i++)
{
for (j=k;j<=n-1;j++)
{
t=Math.abs(pDataCoef[i*n+j]);
if (t>d)
{
d=t;
pnJs[k]=j;
nIs=i;
}
}
}
if (d == 0.0)
l=0;
else
{
if (pnJs[k]!=k)
{
for (i=0;i<=n-1;i++)
{
p=i*n+k;
q=i*n+pnJs[k];
t=pDataCoef[p];
pDataCoef[p]=pDataCoef[q];
pDataCoef[q]=t;
}
}
if (nIs!=k)
{
for (j=k;j<=n-1;j++)
{
p=k*n+j;
q=nIs*n+j;
t=pDataCoef[p];
pDataCoef[p]=pDataCoef[q];
pDataCoef[q]=t;
}
t=pDataConst[k];
pDataConst[k]=pDataConst[nIs];
pDataConst[nIs]=t;
}
}
// 求解失败
if (l==0)
{
return false;
}
d=pDataCoef[k*n+k];
for (j=k+1;j<=n-1;j++)
{
p=k*n+j;
pDataCoef[p]=pDataCoef[p]/d;
}
pDataConst[k]=pDataConst[k]/d;
for (i=k+1;i<=n-1;i++)
{
for (j=k+1;j<=n-1;j++)
{
p=i*n+j;
pDataCoef[p]=pDataCoef[p]-pDataCoef[i*n+k]*pDataCoef[k*n+j];
}
pDataConst[i]=pDataConst[i]-pDataCoef[i*n+k]*pDataConst[k];
}
}
// 求解失败
d=pDataCoef[(n-1)*n+n-1];
if (d == 0.0)
{
return false;
}
// 求解
pDataConst[n-1]=pDataConst[n-1]/d;
for (i=n-2;i>=0;i--)
{
t=0.0;
for (j=i+1;j<=n-1;j++)
t=t+pDataCoef[i*n+j]*pDataConst[j];
pDataConst[i]=pDataConst[i]-t;
}
// 调整解的位置
pnJs[n-1]=n-1;
for (k=n-1;k>=0;k--)
{
if (pnJs[k]!=k)
{
t=pDataConst[k];
pDataConst[k]=pDataConst[pnJs[k]];
pDataConst[pnJs[k]]=t;
}
}
return true;
}
/**
* 全选主元高斯－约当消去法
*
* @param mtxResult - Matrix对象，返回方程组的解
* @return boolean 型，方程组求解是否成功
*/
public boolean GetRootsetGaussJordan(Matrix mtxResult)
{
int l,k,i,j,nIs=0,p,q;
double d,t;
// 方程组的属性，将常数矩阵赋给解矩阵
mtxResult.setValue(mtxLEConst);
double[] pDataCoef = mtxLECoef.getData();
double[] pDataConst = mtxResult.getData();
int n = getNumUnknowns();
int m = mtxLEConst.getNumColumns();
// 临时缓冲区，存放变换的列数
int[] pnJs = new int[n];
// 消元
l=1;
for (k=0;k<=n-1;k++)
{
d=0.0;
for (i=k;i<=n-1;i++)
{
for (j=k;j<=n-1;j++)
{
t=Math.abs(pDataCoef[i*n+j]);
if (t>d)
{
d=t;
pnJs[k]=j;
nIs=i;
}
}
}
if (d+1.0==1.0)
l=0;
else
{
if (pnJs[k]!=k)
{
for (i=0;i<=n-1;i++)
{
p=i*n+k;
q=i*n+pnJs[k];
t=pDataCoef[p];
pDataCoef[p]=pDataCoef[q];
pDataCoef[q]=t;
}
}
if (nIs!=k)
{
for (j=k;j<=n-1;j++)
{
p=k*n+j;
q=nIs*n+j;
t=pDataCoef[p];
pDataCoef[p]=pDataCoef[q];
pDataCoef[q]=t;
}
for (j=0;j<=m-1;j++)
{
p=k*m+j;
q=nIs*m+j;
t=pDataConst[p];
pDataConst[p]=pDataConst[q];
pDataConst[q]=t;
}
}
}
// 求解失败
if (l==0)
{
return false;
}
d=pDataCoef[k*n+k];
for (j=k+1;j<=n-1;j++)
{
p=k*n+j;
pDataCoef[p]=pDataCoef[p]/d;
}
for (j=0;j<=m-1;j++)
{
p=k*m+j;
pDataConst[p]=pDataConst[p]/d;
}
for (j=k+1;j<=n-1;j++)
{
for (i=0;i<=n-1;i++)
{
p=i*n+j;
if (i!=k)
pDataCoef[p]=pDataCoef[p]-pDataCoef[i*n+k]*pDataCoef[k*n+j];
}
}
for (j=0;j<=m-1;j++)
{
for (i=0;i<=n-1;i++)
{
p=i*m+j;
if (i!=k)
pDataConst[p]=pDataConst[p]-pDataCoef[i*n+k]*pDataConst[k*m+j];
}
}
}
// 调整
for (k=n-1;k>=0;k--)
{
if (pnJs[k]!=k)
{
for (j=0;j<=m-1;j++)
{
p=k*m+j;
q=pnJs[k]*m+j;
t=pDataConst[p];
pDataConst[p]=pDataConst[q];
pDataConst[q]=t;
}
}
}
return true;
}
/**
* 复系数方程组的全选主元高斯消去法
*
* @param mtxCoefImag - 系数矩阵的虚部矩阵
* @param mtxConstImag - 常数矩阵的虚部矩阵
* @param mtxResult - Matrix对象，返回方程组解矩阵的实部矩阵
* @param mtxResultImag - Matrix对象，返回方程组解矩阵的虚部矩阵
* @return boolean 型，方程组求解是否成功
*/
public boolean GetRootsetGauss(Matrix mtxCoefImag, Matrix mtxConstImag, Matrix mtxResult, Matrix mtxResultImag)
{
int l,k,i,j,nIs=0,u,v;
double p,q,s,d;
// 方程组的属性，将常数矩阵赋给解矩阵
mtxResult.setValue(mtxLEConst);
mtxResultImag.setValue(mtxConstImag);
double[] pDataCoef = mtxLECoef.getData();
double[] pDataConst = mtxResult.getData();
double[] pDataCoefImag = mtxCoefImag.getData();
double[] pDataConstImag = mtxResultImag.getData();
int n = getNumUnknowns();
int m = mtxLEConst.getNumColumns();
// 临时缓冲区，存放变换的列数
int[] pnJs = new int[n];
// 消元
for (k=0;k<=n-2;k++)
{
d=0.0;
for (i=k;i<=n-1;i++)
{
for (j=k;j<=n-1;j++)
{
u=i*n+j;
p=pDataCoef[u]*pDataCoef[u]+pDataCoefImag[u]*pDataCoefImag[u];
if (p>d)
{
d=p;
pnJs[k]=j;
nIs=i;
}
}
}
// 求解失败
if (d == 0.0)
{
return false;
}
if (nIs!=k)
{
for (j=k;j<=n-1;j++)
{
u=k*n+j;
v=nIs*n+j;
p=pDataCoef[u];
pDataCoef[u]=pDataCoef[v];
pDataCoef[v]=p;
p=pDataCoefImag[u];
pDataCoefImag[u]=pDataCoefImag[v];
pDataCoefImag[v]=p;
}
p=pDataConst[k];
pDataConst[k]=pDataConst[nIs];
pDataConst[nIs]=p;
p=pDataConstImag[k];
pDataConstImag[k]=pDataConstImag[nIs];
pDataConstImag[nIs]=p;
}
if (pnJs[k]!=k)
{
for (i=0;i<=n-1;i++)
{
u=i*n+k;
v=i*n+pnJs[k];
p=pDataCoef[u];
pDataCoef[u]=pDataCoef[v];
pDataCoef[v]=p;
p=pDataCoefImag[u];
pDataCoefImag[u]=pDataCoefImag[v];
pDataCoefImag[v]=p;
}
}
v=k*n+k;
for (j=k+1;j<=n-1;j++)
{
u=k*n+j;
p=pDataCoef[u]*pDataCoef[v];
q=-pDataCoefImag[u]*pDataCoefImag[v];
s=(pDataCoef[v]-pDataCoefImag[v])*(pDataCoef[u]+pDataCoefImag[u]);
pDataCoef[u]=(p-q)/d;
pDataCoefImag[u]=(s-p-q)/d;
}
p=pDataConst[k]*pDataCoef[v];
q=-pDataConstImag[k]*pDataCoefImag[v];
s=(pDataCoef[v]-pDataCoefImag[v])*(pDataConst[k]+pDataConstImag[k]);
pDataConst[k]=(p-q)/d;
pDataConstImag[k]=(s-p-q)/d;
for (i=k+1;i<=n-1;i++)
{
u=i*n+k;
for (j=k+1;j<=n-1;j++)
{
v=k*n+j;
l=i*n+j;
p=pDataCoef[u]*pDataCoef[v];
q=pDataCoefImag[u]*pDataCoefImag[v];
s=(pDataCoef[u]+pDataCoefImag[u])*(pDataCoef[v]+pDataCoefImag[v]);
pDataCoef[l]=pDataCoef[l]-p+q;
pDataCoefImag[l]=pDataCoefImag[l]-s+p+q;
}
p=pDataCoef[u]*pDataConst[k];
q=pDataCoefImag[u]*pDataConstImag[k];
s=(pDataCoef[u]+pDataCoefImag[u])*(pDataConst[k]+pDataConstImag[k]);
pDataConst[i]=pDataConst[i]-p+q;
pDataConstImag[i]=pDataConstImag[i]-s+p+q;
}
}
u=(n-1)*n+n-1;
d=pDataCoef[u]*pDataCoef[u]+pDataCoefImag[u]*pDataCoefImag[u];
// 求解失败
if (d == 0.0)
{
return false;
}
// 求解
p=pDataCoef[u]*pDataConst[n-1]; q=-pDataCoefImag[u]*pDataConstImag[n-1];
s=(pDataCoef[u]-pDataCoefImag[u])*(pDataConst[n-1]+pDataConstImag[n-1]);
pDataConst[n-1]=(p-q)/d; pDataConstImag[n-1]=(s-p-q)/d;
for (i=n-2;i>=0;i--)
{
for (j=i+1;j<=n-1;j++)
{
u=i*n+j;
p=pDataCoef[u]*pDataConst[j];
q=pDataCoefImag[u]*pDataConstImag[j];
s=(pDataCoef[u]+pDataCoefImag[u])*(pDataConst[j]+pDataConstImag[j]);
pDataConst[i]=pDataConst[i]-p+q;
pDataConstImag[i]=pDataConstImag[i]-s+p+q;
}
}
// 调整位置
pnJs[n-1]=n-1;
for (k=n-1;k>=0;k--)
{
if (pnJs[k]!=k)
{
p=pDataConst[k];
pDataConst[k]=pDataConst[pnJs[k]];
pDataConst[pnJs[k]]=p;
p=pDataConstImag[k];
pDataConstImag[k]=pDataConstImag[pnJs[k]];
pDataConstImag[pnJs[k]]=p;
}
}
return true;
}
/**
* 复系数方程组的全选主元高斯－约当消去法
*
* @param mtxCoefImag - 系数矩阵的虚部矩阵
* @param mtxConstImag - 常数矩阵的虚部矩阵
* @param mtxResult - Matrix对象，返回方程组解矩阵的实部矩阵
* @param mtxResultImag - Matrix对象，返回方程组解矩阵的虚部矩阵
* @return boolean 型，方程组求解是否成功
*/
public boolean GetRootsetGaussJordan(Matrix mtxCoefImag, Matrix mtxConstImag, Matrix mtxResult, Matrix mtxResultImag)
{
int l,k,i,j,nIs=0,u,v;
double p,q,s,d;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -