矩阵的运算

public class Main{
	public static void main(String[]  args){
		double[][] a={{1,2,-1},{3,1,0},{-1,-1,-2}};
        double[][] b={{2,3,5},{4,6,8},{-2,-4,-1}};
        Matrix.printMatrix(Matrix.matrixAdd(a,b)); //两矩阵相加
        Matrix.printMatrix(Matrix.matrixSubstract(a,b));//两矩阵相减
        Matrix.printMatrix(Matrix.matrixTranspose(a));//矩阵a的转置
        Matrix.printMatrix(Matrix.matrixInverse(a)); //矩阵a的逆矩阵
	}
}

public class Matrix {
//实现两矩阵的相加
    public static double[][] matrixAdd(double[][] a, double[][] b) {
        if (a.length != b.length || a[0].length!=b[0].length) {  //a.length、b.length代表行数，a[0].length、b[0].length代表列数,判断两矩阵是否同型
            return null;
        }
        double[][] c = new double[a.length][a[0].length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                    c[i][j] = a[i][j]+b[i][j];  //对应位置的元素相加
                }
            }
        return c;
    }
//实现两矩阵的相减(具体实现与矩阵相加类似)
    public static double[][] matrixSubtract(double[][] a, double[][] b) {
        if (a.length != b.length || a[0].length!=b[0].length) {  //a.length、b.length代表行数，a[0].length、b[0].length代表列数
            return null;
        }
        double[][] c = new double[a.length][a[0].length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                    c[i][j] = a[i][j]-b[i][j];
                }
            }
        return c;
    }
//实现矩阵的转置
    public static double[][] matrixTranspose(double[][] a) {
        double[][] c = new double[a[0].length][a.length];
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[0].length;j++){
                c[j][i]=a[i][j];   //通过坐标之间的关系，将矩阵a一行上的元素转移到矩阵c的对应列上
            }
        }
        return c;
    }
//实现求矩阵的逆矩阵(这里利用伴随矩阵法，初等变换法做数学题是容易使用，但在编程方面不太容易操作)
    public static double[][] matrixInverse(double[][] a){
        int rlen=a.length,clen=a[0].length;
        if(rlen!=clen){   //矩阵不是方阵，不存在逆矩阵
            return null;
        }
        double[][] c=new double[a.length][a[0].length];
        double A=CalculateDet.calDet(a);   //求出矩阵a的行列式，若行列式为0，则不存在逆矩阵(这里由于使用的double型，并不能准确判断是否等于0)
        /*if(A>-0.00000000001 && A< 0.00000000001){
            return null;
        }*/
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[0].length;j++){
                if((i+j)%2==0){
                    c[i][j]=CalculateDet.calDet(MatrixSon.matrixSon(a,i,j))/A;  //求对应位置的代数余子式(i+j为奇数则是余子式的相反数，偶数则等于余子式)
                }
                else{
                    c[i][j]=-(CalculateDet.calDet(MatrixSon.matrixSon(a,i,j))/A);
            }
        }
    }
         return matrixTranspose(c);
 }
        
//输出矩阵内容

    public static void printMatrix(double[][] c) {
        if (c != null) {
            for (int i = 0; i < c.length; i++) {
                for (int j = 0; j < c[0].length; j++) {
                    System.out.printf("  %6.4f",c[i][j]);//输出为右对齐，保留四位小数
                }
                System.out.println();
            }
        } else {
            System.out.println("无效，矩阵无法进行对应运算!");
        }
        System.out.println();
    }
}

public class MatrixSon {
    
    public static double[][] matrixSon(double[][] a, int r, int c) {
        double[][] b = new double[a.length - 1][a[0].length - 1];
        int i,j;
        for (i = 0; i < a.length - 1; i++) {
            if (i < r) {
                for (j = 0; j < a[0].length - 1; j++) {
                    if (j < c) {
                        b[i][j] = a[i][j];
                    } else {
                        b[i][j] = a[i][j + 1];
                    }
                }
                if (a[0].length - 1 != c) {
                    b[i][a[0].length - 2] = a[i][a[0].length - 1];
                }
            } else {
                for (j = 0; j < a[0].length - 1; j++) {
                    if (j < c) {
                        b[i][j] = a[i + 1][j];
                    } else {
                        b[i][j] = a[i + 1][j + 1];
                    }
                }
                if (a[0].length - 1 != c) {
                    b[i][a[0].length - 2] = a[i + 1][a[0].length - 1];
                }
            }
        }
        if (a.length - 1 != r) {
                for (j = 0; j < a[0].length - 1; j++) {
                    if (j < c) {
                        b[a.length - 2][j] = a[a.length-1][j];
                    } else {
                        b[a.length - 2][j] = a[a.length - 1][j + 1];
                    }
                }
                if (a[0].length - 1 != c) {
                    b[a.length - 2][a[0].length - 2] = a[a.length - 1][a[0].length - 1];
                }
            }
        return b;
    }
}

public class CalculateDet {
    public static double calDet(double[][] a) {
        if (a.length == a[0].length && a.length == 1) {
            return a[0][0];
        }
        if (a.length == 2) {    //二阶行列式的对角线运算法则
            return a[0][0] * a[1][1] - a[1][0] * a[0][1];
        }
        double result = 0;
        double[] ans=new double[a[0].length];
        for (int i = 0; i < a[0].length; i++) {
            if (i % 2 == 0) {
                ans[i]= a[0][i]*calDet(matrixSon(a,0,i));  
            }
            else{
                ans[i]=-a[0][i]*calDet(matrixSon(a,0,i));
            }
        }
        for(int i=0;i<a[0].length;i++){
            result+=ans[i];
        }
        return result;
    }
}