在Java中乘以两个矩阵

我目前正在开发一个类来表示矩阵，它代表任何一般的mxn矩阵。我已经完成了加法和标量乘法，但我正在努力开发两个矩阵的乘法。矩阵的数据保存在一个二维数组中。在Java中乘以两个矩阵

的方法看起来有点像这样：

public Matrix multiply(Matrix A) { 
      ////code 
    }

它将返回产品矩阵。这是右边的乘法。所以，如果我叫A.multiply（B），那么它会返回矩阵AB，B在右边。

我还不需要担心检查乘法是否在给定矩阵的定义，我认为我将得到正确的尺寸的矩阵。

有谁知道一个简单的算法，甚至可能在伪码进行乘法处理？

在此先感谢。

来源

2013-03-31 Jarred Morris

你尝试过什么吗？或者你问过叔叔谷歌？ – ogzd

我试过Google，但找不到任何我熟悉的东西。我并不关心效率，只是一些很容易编程的东西。我自己尝试在for循环中使用for循环，但没有成功。我真的有点麻烦了。我认为这很疲倦，我最终会到达那里：p但是网上的一些提示总是有帮助的。 –

数学矩阵A（LXM）和B（MXN）的产品被定义为矩阵C（LXN）由元素：

 m 
c_i_j = ∑ a_i_k * b_k_j 
     k=1

所以，如果你不是太多了速度你可能会很乐意与直线前进为O（n^3）执行：

for (int i=0; i<l; ++i) 
    for (int j=0; j<n; ++j) 
     for (int k=0; k<m; ++k) 
     c[i][j] += a[i][k] * b[k][j]

相反，如果你弥补的速度，你可能想看看像施特拉森算法其他替代品（见：Strassen的算法）。

但被警告 - 特别是如果你在现代的处理器架构乘以小矩阵的速度在很大程度上取决于排列的方式，使最佳利用高速缓存行矩阵数据和乘法的顺序。

我强烈怀疑会有任何机会从withing一个VM影响这一因素，所以我不知道这是要考虑的。

来源

2013-03-31 20:05:43 mikyra

非常感谢你:)这个作品。效率并不重要，所以O（n^3）的复杂性就很好。我所需要的只是让算法正确执行这个过程，不管它需要多长时间，这都是好事。再次感谢：） –

的Java。矩阵乘法。

这里是“代码进行乘法处理”。用不同尺寸的基质进行测试。

public class Matrix { 

/** 
* Matrix multiplication method. 
* @param m1 Multiplicand 
* @param m2 Multiplier 
* @return Product 
*/ 
    public static double[][] multiplyByMatrix(double[][] m1, double[][] m2) { 
     int m1ColLength = m1[0].length; // m1 columns length 
     int m2RowLength = m2.length; // m2 rows length 
     if(m1ColLength != m2RowLength) return null; // matrix multiplication is not possible 
     int mRRowLength = m1.length; // m result rows length 
     int mRColLength = m2[0].length; // m result columns length 
     double[][] mResult = new double[mRRowLength][mRColLength]; 
     for(int i = 0; i < mRRowLength; i++) {   // rows from m1 
      for(int j = 0; j < mRColLength; j++) {  // columns from m2 
       for(int k = 0; k < m1ColLength; k++) { // columns from m1 
        mResult[i][j] += m1[i][k] * m2[k][j]; 
       } 
      } 
     } 
     return mResult; 
    } 

    public static String toString(double[][] m) { 
     String result = ""; 
     for(int i = 0; i < m.length; i++) { 
      for(int j = 0; j < m[i].length; j++) { 
       result += String.format("%11.2f", m[i][j]); 
      } 
      result += "\n"; 
     } 
     return result; 
    } 

    public static void main(String[] args) { 
     // #1 
     double[][] multiplicand = new double[][] { 
       {3, -1, 2}, 
       {2, 0, 1}, 
       {1, 2, 1} 
     }; 
     double[][] multiplier = new double[][] { 
       {2, -1, 1}, 
       {0, -2, 3}, 
       {3, 0, 1} 
     }; 
     System.out.println("#1\n" + toString(multiplyByMatrix(multiplicand, multiplier))); 
     // #2 
     multiplicand = new double[][] { 
       {1, 2, 0}, 
       {-1, 3, 1}, 
       {2, -2, 1} 
     }; 
     multiplier = new double[][] { 
       {2}, 
       {-1}, 
       {1} 
     }; 
     System.out.println("#2\n" + toString(multiplyByMatrix(multiplicand, multiplier))); 
     // #3 
     multiplicand = new double[][] { 
       {1, 2, -1}, 
       {0, 1, 0} 
     }; 
     multiplier = new double[][] { 
       {1, 1, 0, 0}, 
       {0, 2, 1, 1}, 
       {1, 1, 2, 2} 
     }; 
     System.out.println("#3\n" + toString(multiplyByMatrix(multiplicand, multiplier))); 
    } 
}

输出：

#1 
     12.00  -1.00  2.00 
     7.00  -2.00  3.00 
     5.00  -5.00  8.00 

#2 
     0.00 
     -4.00 
     7.00 

#3 
     0.00  4.00  0.00  0.00 
     0.00  2.00  1.00  1.00

来源

2014-05-22 21:27:19

在Java中乘以两个矩阵

回答

相关问题