算法系列-----矩阵（四）-------------矩阵的乘法

最新推荐文章于 2022-03-31 16:59:25 发布

wust小吴

最新推荐文章于 2022-03-31 16:59:25 发布

阅读量1.3k

点赞数

分类专栏：算法系列-----矩阵文章标签：算法矩阵

算法系列-----矩阵专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了矩阵运算中的多种操作，包括矩阵乘数、行向量与列向量的乘法、列向量与行向量的乘法、二维矩阵与一维矩阵的乘法以及矩阵相乘，并提供了具体的实现代码与测试示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

乘数矩阵：也可以叫矩阵的乘数就是说这个乘数是表示缩放这个矩阵 Xn[]

	/**
	 * 矩阵乘数的函数
	 * 
	 * @param args
	 *            参数a是个浮点型（double）的一维数组，b是浮点数；
	 * @return 返回值是一个浮点型一维数组（列向量a乘以数b的结果）
	 */
	public static double[] multi(double[] a, double b) {
		int hang = a.length;
		double[] result = new double[hang];
		for (int i = 0; i < hang; i++) {
			result[i] = a[i] * b;
		}
		return result;
	}

行向量乘以列向量：

他们的结果作为向量乘法结果矩阵的某一个元素

	/**
	 * 行向量乘以列向量的函数
	 * 
	 * @param args
	 *            参数a，b是两个浮点型（double）的一维数组
	 * @return 返回值是一个浮点型数值
	 */
	public static double multi_data(double[] a, double[] b) {
		int lie = a.length;
		double result = 0;
		for (int i = 0; i < lie; i++) {
			result += a[i] * b[i];

		}
		return result;
	}

如果单从该函数去看，需要添加判断条件：

a.length==b.length

而如果该函数被下面调用了，已经判断了a的长度和b的长度是相等的，所以这里只是单独的抽出来而已

列向量乘以行向量：

</pre><pre name="code" class="java">	/**
	 * 列向量乘以行向量的函数
	 * 
	 * @param args
	 *            参数a，b是两个浮点型（double）的一维数组
	 * @return 返回值是一个浮点型二维矩阵
	 */
	public static double[][] multi_mat(double[] a, double[] b) {
		int hang = a.length;
		int lie = b.length;
		double[][] result = new double[hang][lie];
		for (int i = 0; i < hang; i++) {
			for (int j = 0; j < lie; j++) {
				result[i][j] = a[i] * b[j];
			}
		}
		return result;
	}

矩阵相乘：

	/**
	 * 矩阵相乘的函数
	 * 
	 * @param args
	 *            参数a，b是两个浮点型（double）的二维数组
	 * @return 返回值是一个浮点型二维数组（矩阵的乘积）
	 */
	public static double[][] multi(double[][] a, double[][] b) {
		int hang = a.length;
		int lie = b[0].length;
		double sum;
		double[][] result = new double[hang][lie];
		for (int i = 0; i < hang; i++) {
			for (int j = 0; j < lie; j++) {
				sum = 0;
				for (int k = 0; k < b.length; k++) {
					sum += a[i][k] * b[k][j];
				}
				result[i][j] = sum;
			}
		}
		return result;
	}

二维矩阵和一维矩阵的相乘：

	/**
	 * 矩阵相乘的函数
	 * 
	 * @param args
	 *            参数a是个浮点型（double）的二维数组，a是一维数组
	 * @return 返回值是一个浮点型二维数组（矩阵的乘积）
	 */
	public static double[] multi(double[][] a, double[] b) {
		int hang = a.length;

		double sum;
		double[] result = new double[hang];
		for (int i = 0; i < hang; i++) {
			sum = 0;
			for (int k = 0; k < b.length; k++) {
				sum += a[i][k] * b[k];
			}
			result[i] = sum;
		}

		return result;
	}

他有个条件就是一维的长度不能大于列数

测试代码：

</pre><pre name="code" class="java">	public static void main(String[] args) {
		double[] a = { 3, 2, 1, 4};
		double[] b = { 5, 6, 9, 8};
		double[] c = {1,2};	
		
		double[][] d_a = new double[][]{{1,2},{3,4}};
		double[][] d_b = new double[][]{{7, 8}, {6, 5}};
		double[][] d_c = new double[][]{{7, 8}, {6, 5},{2,4}};
		double[][] d_testa = multi(d_a,3);
		double[][] d_testb = zjz_qh(d_b,1);
		double[][] d_testc = zjz(d_c,0,0);
		double[] s_test = multi(d_c,c);
		double result = multi_data(a,b);
		double[][] result2 = multi_mat(a,b);
		System.out.println("乘数矩阵");
		System.out.println("--------------------------------");
		print(d_testa);
		System.out.println("行向量乘以列向量");
		System.out.println("--------------------------------");
		System.out.println(result);

		System.out.println("列向量乘以行向量");
		System.out.println("--------------------------------");
		print(result2);
		System.out.println("二维矩阵和一维矩阵相乘");
		System.out.println("--------------------------------");
		print_array(s_test);
	}

输出结果：

乘数矩阵
--------------------------------
3.0 6.0
9.0 12.0
行向量乘以列向量
--------------------------------
68.0
列向量乘以行向量
--------------------------------
15.0 18.027.0 24.0
10.0 12.018.0 16.0
5.0 6.09.0 8.0
20.0 24.036.0 32.0
二维矩阵和一维矩阵相乘
--------------------------------
23.0 16.010.0

矩阵相乘有个麻烦的事就是可能会遇到参数类型的影响，需要重载多次，各位还是自己写把，我这里把参数类型都写为double类型