帮看一个逆矩阵的程序~~~~~~~~~~

Question

public class Matrix
{
   private double[][] matrixData;  //矩阵的数据    public Matrix(double[][] date)
   {
        this.matrixData=this.cloneArray(date);
   } 
   public Matrix inverseMatrix()  //逆矩阵
   {
        Matrix tempM=this.appendUnitMatrix();
                    //现在右边加上一个单位矩阵，在进行初等变换，把左边部分变成单位矩阵
        double[][] tempData=tempM.getMatrixData();
        int tempRow=tempData.length;
        int tempCol=tempData[0].length;
        int line=0;        //对角线上数字为0时，用于交换的行号
        double bs=0;       //对角线上数字的大小
        double swap=0;     //临时变量，用于交换数字时坐中间结果
        for(int i=0;i<tempRow;i++)
        {
                         //將左边部分对角线上的数据等于0，与其他行进行交换
             if(tempData[i][i]==0)
             {
                  if(++line>=tempRow)
                  {
                      System.out.println("没有");
                      return null;
                  }
                  for(int j=0;j<tempCol;j++)
                  {
                      swap=tempData[i][j];
                      tempData[i][j]=tempData[line][j];
                      tempData[line][j]=swap;
                  }
                  i--;
                  continue;
             }
                         //將左边部分矩阵对角线上的数据变为1.0
             if(tempData[i][i]!=1)
             {
                  bs=tempData[i][i];
                  for(int j=tempCol-1;j>=0;j--)
                  {
                      tempData[i][j]/=bs;
                  }
                                    //將左边部分矩阵变成上对角矩阵
                  for(int iNow=i+1;i<tempRow;iNow++)
                  {
                      for(int j=tempCol-1;j>=i;j--)
                      {
                           tempData[iNow][j]-=tempData[i][j]*tempData[iNow][i];
                      }
                  }
             }
        }
                    //讲座便不分矩阵从上对角矩阵变为单位矩阵
        for(int i=0;i<tempRow-1;i++)
        {
            for(int iNow=i;iNow<tempRow-1;iNow++)
            {
                 for(int j=tempCol-1;j>=0;j--)
                 {
                     tempData[i][j]-=tempData[i][iNow+1]*tempData[iNow+1][j];
                                           //此处会显示有异常                  }
            }
        }
                    //右边部分就是他的逆矩阵
        Matrix c=null;
        int cRow=tempRow;
        int cColumn=tempCol/2;
        double[][] cData=new double[cRow][cColumn];
        for(int i=0;i<cRow;i++)
        {
            for(int j=0;j<cColumn;j++)
            {
                 cData[i][j]=tempData[i][cColumn+j];
            }
        }
        c=new Matrix(cData);
        return c;
   }
           /*返回matrixData的值*/
   public double[][] getMatrixData()
   {
   return cloneArray(this.matrixData);
   }
           /*设置矩阵的matrixData值*/
   public void setMatrixData(double[][] data)
   {
           this.matrixData=this.cloneArray(data);    
   }
           /*矩阵的字符串形式*/
   public String toString()
   {
   return this.arrayToString(this.matrixData);
   }
           /*以矩阵的形式输出*/
   public void display()
   {
   System.out.println(this.toString());
   }
           /*克隆一个矩阵*/
   public Object clone()
   {
   try {
  Matrix matrix=(Matrix)super.clone();
  matrix.setMatrixData(this.matrixData);
return matrix;
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
   }
           /*克隆一个二维数组*/
   private double[][] cloneArray(double[][] src)
   {
if(src==null)
{
return null;
}
return (double[][])src.clone();
   }
           /*给矩阵右边加上一个单位矩阵*/
   private Matrix appendUnitMatrix()
   {
   Matrix c=null;
   int cRow=this.matrixData.length;
   int cColumn=this.matrixData[0].length*2;
   double[][] cData=new double[cRow][cColumn];
   for(int i=0;i<cRow;i++)
   {
   for(int j=0;j<cColumn;j++)
   {
   if(j<this.matrixData[0].length)
   {
   cData[i][j]=this.matrixData[i][j];
   }
   else
   {
   if((j-i)==this.matrixData[0].length)
   {
   cData[i][j]=1.0;
   }
   else
   {
   cData[i][j]=0;
   }
   }
   }
   }
   c=new Matrix(cData);
   return c;
   }
           /*二维数组的字符串形式*/
   private String arrayToString(double[][] array)
   {
   DecimalFormat df=new DecimalFormat();
   StringBuffer sb=new StringBuffer("");
   for(int i=0;i<array.length;i++)
   {
   for(int j=0;j<array[0].length;j++)
   {
   sb.append(df.format(array[i][j])).append("");
   }
   sb.append("\n");
   }
   return sb.toString();
   }    public static void main(String[] args)
   {
        double[][] data1=new double[][]{{4.0,5.0,3.0},{4.0,5.0,6.0},{7.0,8.0,9.0}};         Matrix m1=new Matrix(data1);
        System.out.println("m1为:");
        m1.display();
        Matrix mTemp=m1.inverseMatrix();
        System.out.println("矩阵的逆矩阵为");
        mTemp.display();
   }
}
显示结果为
m1为:
453
456
789却没有把逆矩阵显示出来，请问这是为什么？
谢谢了~~~~~~代码红字处在调试的时候会说有个异常~~~~~~~java.lang.ArrayIndexOutOfBoundsException（是不是数据类型的原因？）

Answer 1

package cn.zzr.test;import java.text.DecimalFormat;public class Matrix {
private double[][] matrixData; // 矩阵的数据 public Matrix(double[][] date) {
this.matrixData = this.cloneArray(date);
} public Matrix inverseMatrix() // 逆矩阵
{
Matrix tempM = this.appendUnitMatrix();
// 现在右边加上一个单位矩阵，在进行初等变换，把左边部分变成单位矩阵
double[][] tempData = tempM.getMatrixData();
int tempRow = tempData.length;
int tempCol = tempData[0].length;
int line = 0; // 对角线上数字为0时，用于交换的行号
double bs = 0; // 对角线上数字的大小
double swap = 0; // 临时变量，用于交换数字时坐中间结果
for (int i = 0; i < tempRow; i++) {
// 將左边部分对角线上的数据等于0，与其他行进行交换
if (tempData[i][i] == 0) {
if (++line >= tempRow) {
System.out.println("没有");
break;
}
for (int j = 0; j < tempCol; j++) {
swap = tempData[i][j];
tempData[i][j] = tempData[line][j];
tempData[line][j] = swap;
}
i--;
continue;
}
// 將左边部分矩阵对角线上的数据变为1.0
if (tempData[i][i] != 1) {
bs = tempData[i][i];
for (int j = tempCol - 1; j >= 0; j--) {
tempData[i][j] /= bs;
}
// 將左边部分矩阵变成上对角矩阵
for (int iNow = i + 1; iNow < tempRow; iNow++) {
for (int j = tempCol - 1; j >= i; j--) {
tempData[iNow][j] -= tempData[i][j] * tempData[iNow][i];
}
}
}
}
// 讲座便不分矩阵从上对角矩阵变为单位矩阵
for (int i = 0; i < tempRow; i++) {
for (int iNow = i; iNow < tempRow - 1; iNow++) {
for (int j = tempCol - 1; j >= 0; j--) {
tempData[i][j] -= tempData[i][iNow + 1]
* tempData[iNow + 1][j];
}
// 此处会显示有异常 }
}
}
// 右边部分就是他的逆矩阵
int cRow = tempRow;
int cColumn = tempCol / 2;
double[][] cData = new double[cRow][cColumn];
for (int i1 = 0; i1 < cRow; i1++) {
for (int j = 0; j < cColumn; j++) {
cData[i1][j] = tempData[i1][cColumn + j];
}
}
return new Matrix(cData);
} /* 返回matrixData的值 */
public double[][] getMatrixData() {
return cloneArray(this.matrixData);
} /* 设置矩阵的matrixData值 */
public void setMatrixData(double[][] data) {
this.matrixData = this.cloneArray(data);
} /* 矩阵的字符串形式 */
public String toString() {
return arrayToString(this.matrixData);
} /* 以矩阵的形式输出 */
public void display() {
System.out.println(this.toString());
} /* 克隆一个矩阵 */
public Object clone() {
try {
Matrix matrix = (Matrix) super.clone();
matrix.setMatrixData(this.matrixData);
return matrix;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
} /* 克隆一个二维数组 */
private double[][] cloneArray(double[][] src) {
if (src == null) {
return null;
}
return (double[][]) src.clone();
} /* 给矩阵右边加上一个单位矩阵 */
private Matrix appendUnitMatrix() {
Matrix c = null;
int cRow = this.matrixData.length;
int cColumn = this.matrixData[0].length * 2;
double[][] cData = new double[cRow][cColumn];
for (int i = 0; i < cRow; i++) {
for (int j = 0; j < cColumn; j++) {
if (j < this.matrixData[0].length) {
cData[i][j] = this.matrixData[i][j];
} else {
if ((j - i) == this.matrixData[0].length) {
cData[i][j] = 1.0;
} else {
cData[i][j] = 0;
}
}
}
}
c = new Matrix(cData);
return c;
} /* 二维数组的字符串形式 */
private String arrayToString(double[][] array) {
DecimalFormat df = new DecimalFormat();
StringBuffer sb = new StringBuffer("");
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
sb.append(df.format(array[i][j]));
if (j != array[0].length - 1) {
sb.append("\t");
}
}
sb.append("\n");
}
return sb.toString();
} public static void main(String[] args) {
double[][] data1 = new double[][] { { 4.0, 5.0, 3.0 },
{ 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } }; Matrix m1 = new Matrix(data1);
System.out.println("m1为:");
m1.display();
Matrix mTemp = m1.inverseMatrix();
System.out.println(mTemp);
System.out.println("矩阵的逆矩阵为");
mTemp.display();
}
}

Answer 2

        System.out.println(mTemp);
        System.out.println("矩阵的逆矩阵为");
        mTemp.display();
这个地方去掉一下打印，昨天晚上头晕眼花的，没看清楚

Answer 3

再来请教~~~~~public Matrix multiply(Matrix b)  //矩阵的乘法
{
   if(b==null)
   {
        return null;
   }
   Matrix c=null;
   double[][] bData=b.getMatrixData();
   if(this.matrixData[0].length!=bData.length)
   {
        System.out.println("列数与行数相等");
        return c;
   }
   int cRow=this.matrixData.length;  //行
   int cColumn=bData[0].length;   //列
   double[][] cData=new double[cRow][cColumn];
   for(int i=0;i<cRow;i++)
   {
        for(int j=0;i<cColumn;j++)
        {
            cData[i][j]=0;        //这一行抛出异常
            for(int k=0;k<this.matrixData[0].length;k++)
            {
             cData[i][j]+=this.matrixData[i][k]*bData[k][j];
            }
        }
   }
   c=new Matrix(cData);
   return c;
}
public static void main(String[] args)       //修改过的main方法~~~~~~
{
   Matrix defaultM=new Matrix();
   System.out.println("默认矩阵: ");
   defaultM.display();
   double[][] data0=new double[3][3];
   for(int i=0;i<3;i++)
   {
        for(int j=0;j<3;j++)
        {
            data0[i][j]=i*3+j;
        }
   }
   Matrix m0=new Matrix(data0);
   System.out.println("矩阵为：");
   m0.display();
   double[][] data1=new double[][]{{4.0,5.0,3.0},{4.0,5.0,6.0},{7.0,8.0,9.0}};
   Matrix m1=new Matrix(data1);
   System.out.println("m1为:");
   m1.display();    Matrix mTemp=m0.multiply(m1);
   if(mTemp!=null)
   {
        mTemp.display();
   }
   else
   {
        System.out.println("错误");
   }
   System.out.println("矩阵的逆矩阵为");
   mTemp=m1.inverseMatrix();
   if(mTemp!=null)
   {
            mTemp.display();
            System.out.println("矩阵与他逆矩阵的乘积：");
        m1.multiply(mTemp).display();
   }
   else
   {
        System.out.println("错误");
   }
}这次又添加了一个矩阵的乘法，但是cData[i][j]=0;这一行又抛出了数组越界的异常（ArrayIndexOutOfBoundsException），第一次调试时变量cData[0][0]=09999999991，然后稍加修改后cData[0][0]=18.0，但结果还跑出了数组越界异常，而且离正确的值越来越远了（正确应该是1.0）请问这到底是怎么回事？应该怎么弄？谢谢~~~~~~

Answer 4

 for(int j=0;i<cColumn;j++)你对j进行自增，却在用i去判断，这个条件满足的时候，j会一路狂增，再大的数组都超界了。细心一点了，这种错就不会有了。