矩阵常用操作的JAVA实现以及算法分析（向量点乘、矩阵乘矩阵、矩阵的转置、矩阵乘向量、向量乘矩阵）

public class Matrix {
	
	//向量点乘
    public static double Dot(double[] a, double[] b){
        /*
         * 点乘
         * a = [a1,a2,...,an]  b = [b1, b2, ..., bn]
         * a .* b = a1b1 + a2b2 + ... + anbn
         * 注意：一维向量 a b 列数相同
         * */

        double product = 0;
        //检测ab列数是否相同（数组长度）
        if(a.length == b.length){                   //数组名.length计算的是数组获取空间的大小，与元素个数无关
            for (int i = 0; i < a.length; i++) {
                product += a[i] * b[i];
            }
            return product;
        }
        else{
            System.out.println("两个向量列数不一致，无法计算。");
        }
        return product;
    }

	//矩阵乘矩阵
    public static double[][] Mult(double A[][],double B[][]){
        /*
         * 矩阵之积
         * 设 A 为 m * p 的矩阵，B 为 p * n 的矩阵，那么称 m * n 的矩阵C
         * 为矩阵 A 与矩阵 B 的乘积。记作 C = AB
         *
         * A =  a11, a12, a13   B = b11, b12
         *      a21, a22, a23       b21, b22
         *                          b31, b32
         *
         * C = a11b11 + a12b21 +a13b31, a11b12 + a12b22 + a13b32
         *     a21b11 + a22b21 + a23b31, a21b12 + a22b22 + a23b32
         *
         * 注意：当矩阵 A 的列数等于矩阵 B 的行数时，A 与 B 可以相乘
         * */

        double[][] C = new double[A.length][B[0].length];

        if(A[0].length == B.length){ //判断 A 的列数是否等于 B 的行数
            /*
            * 最后 3 层循环嵌套分析，我是一个个试的。根据 C 的下标反推 AB ij 的值
            * 推完之后发现 A行 = C 行 B列 = C 列，其余填 k 就行。与注意中的相同。            *
            * */
            for (int i = 0; i < C.length; i++) {
                for (int j = 0; j < C[i].length; j++) {
                    for (int k = 0; k < B.length; k++) {
                        C[i][j] += A[i][k]*B[k][j];
                    }

                }
            }

        }else{
            System.out.println("A 的列数不等于 B 的行数");
        }
        return C;
    }
	
	矩阵的转置
    public static double[][] Transpose(double A[][]){
        /*
        * 将矩阵的行列互换得到的新矩阵称为转置矩阵
        * 测试的时候我简直就是个傻逼。居然用
        * 1 0
        * 0 1
        * 来测试转置矩阵。
        * */
        double[][] B = new double[A.length][A[0].length];

        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                B[i][j] = A[j][i];
            }
        }
        return B;
    }

	//矩阵乘向量
    public static double[] Mult(double A[][], double b[]){
        /*
        * 需要满足的条件是矩阵的列数等于向量的大小
        * */
        double[] c = new double[A.length];

        if(A[0].length == b.length){
            for (int i = 0; i < A.length; i++) {
                for (int j = 0; j < b.length; j++) {
                    c[i] += A[i][j] * b[j];
                }
            }

        }else{
            System.out.println("矩阵的列数不等于向量的大小");
        }

        return c;
    }

	//向量乘矩阵
    public static double[] Mult(double b[], double A[][]){
        /*
        * 向量大小等于矩阵行数
        * */
        double[] c = new double[A[0].length];

        if(b.length == A.length){
            for (int i = 0; i < A.length; i++) {
                for (int j = 0; j < A[0].length; j++) {
                    c[j] = b[i]*A[i][j];
                }
            }

        }else{
            System.out.println("向量大小不等于矩阵行数");
        }

        return c;
    }
    private int age;


}