Merge pull request #7156 from dupirefr/bael-2996

dupirefr/dupire.francois+pro@gmail.com [BAEL-2996] Matrices Multiplication in Java

libraries-2/pom.xml

@@ -50,6 +50,26 @@
 			<artifactId>picocli</artifactId>
 			<version>${picocli.version}</version>
 		</dependency>
+        <dependency>
+            <groupId>org.ejml</groupId>
+            <artifactId>ejml-all</artifactId>
+            <version>${ejml.version}</version>
+        </dependency>
+		<dependency>
+			<groupId>org.nd4j</groupId>
+			<artifactId>nd4j-native</artifactId>
+			<version>${nd4j.version}</version>
+		</dependency>
+        <dependency>
+            <groupId>org.la4j</groupId>
+            <artifactId>la4j</artifactId>
+            <version>${la4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>colt</groupId>
+            <artifactId>colt</artifactId>
+            <version>${colt.version}</version>
+        </dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter</artifactId>
@@ -93,10 +113,22 @@
 			<scope>test</scope>
 		</dependency>
 
-                <dependency>
+        <dependency>
-                    <groupId>edu.uci.ics</groupId>
+            <groupId>edu.uci.ics</groupId>
-                    <artifactId>crawler4j</artifactId>
+            <artifactId>crawler4j</artifactId>
-                    <version>${crawler4j.version}</version>
+            <version>${crawler4j.version}</version>
+		</dependency>
+
+		<!-- Benchmarking -->
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-core</artifactId>
+			<version>${jmh.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-generator-annprocess</artifactId>
+			<version>${jmh.version}</version>
 		</dependency>
           
 	</dependencies>
@@ -109,5 +141,10 @@
 		<chronicle.map.version>3.17.2</chronicle.map.version>
         <crawler4j.version>4.4.0</crawler4j.version>
 		<spring-boot-starter.version>2.1.4.RELEASE</spring-boot-starter.version>
+		<ejml.version>0.38</ejml.version>
+		<nd4j.version>1.0.0-beta4</nd4j.version>
+		<colt.version>1.2.0</colt.version>
+		<la4j.version>0.6.0</la4j.version>
+		<jmh.version>1.19</jmh.version>
 	</properties>
 </project>

libraries-2/src/test/java/com/baeldung/matrices/MatrixMultiplicationBenchmarking.java

@@ -0,0 +1,9 @@
+package com.baeldung.matrices;
+
+public class MatrixMultiplicationBenchmarking {
+
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+}

libraries-2/src/test/java/com/baeldung/matrices/apache/RealMatrixUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.matrices.apache;
+
+import org.apache.commons.math3.linear.Array2DRowRealMatrix;
+import org.apache.commons.math3.linear.RealMatrix;
+import org.junit.jupiter.api.Test;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class RealMatrixUnitTest {
+
+    @Test
+    @Benchmark
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        RealMatrix firstMatrix = new Array2DRowRealMatrix(
+          new double[][] {
+            new double[] {1d, 5d},
+            new double[] {2d, 3d},
+            new double[] {1d ,7d}
+          }
+        );
+
+        RealMatrix secondMatrix = new Array2DRowRealMatrix(
+          new double[][] {
+            new double[] {1d, 2d, 3d, 7d},
+            new double[] {5d, 2d, 8d, 1d}
+          }
+        );
+
+        RealMatrix expected = new Array2DRowRealMatrix(
+          new double[][] {
+            new double[] {26d, 12d, 43d, 12d},
+            new double[] {17d, 10d, 30d, 17d},
+            new double[] {36d, 16d, 59d, 14d}
+          }
+        );
+
+        RealMatrix actual = firstMatrix.multiply(secondMatrix);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+
+}

libraries-2/src/test/java/com/baeldung/matrices/colt/DoubleMatrix2DUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.matrices.colt;
+
+import cern.colt.matrix.DoubleFactory2D;
+import cern.colt.matrix.DoubleMatrix2D;
+import cern.colt.matrix.linalg.Algebra;
+import org.junit.jupiter.api.Test;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class DoubleMatrix2DUnitTest {
+
+    @Test
+    @Benchmark
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        DoubleFactory2D doubleFactory2D = DoubleFactory2D.dense;
+
+        DoubleMatrix2D firstMatrix = doubleFactory2D.make(
+          new double[][] {
+            new double[] {1d, 5d},
+            new double[] {2d, 3d},
+            new double[] {1d ,7d}
+          }
+        );
+
+        DoubleMatrix2D secondMatrix = doubleFactory2D.make(
+          new double[][] {
+            new double[] {1d, 2d, 3d, 7d},
+            new double[] {5d, 2d, 8d, 1d}
+          }
+        );
+
+        DoubleMatrix2D expected = doubleFactory2D.make(
+          new double[][] {
+            new double[] {26d, 12d, 43d, 12d},
+            new double[] {17d, 10d, 30d, 17d},
+            new double[] {36d, 16d, 59d, 14d}
+          }
+        );
+
+        Algebra algebra = new Algebra();
+        DoubleMatrix2D actual = algebra.mult(firstMatrix, secondMatrix);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+
+}

libraries-2/src/test/java/com/baeldung/matrices/ejml/SimpleMatrixUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.matrices.ejml;
+
+import org.ejml.simple.SimpleMatrix;
+import org.junit.jupiter.api.Test;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class SimpleMatrixUnitTest {
+
+    @Test
+    @Benchmark
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        SimpleMatrix firstMatrix = new SimpleMatrix(
+          new double[][] {
+            new double[] {1d, 5d},
+            new double[] {2d, 3d},
+            new double[] {1d ,7d}
+          }
+        );
+
+        SimpleMatrix secondMatrix = new SimpleMatrix(
+          new double[][] {
+            new double[] {1d, 2d, 3d, 7d},
+            new double[] {5d, 2d, 8d, 1d}
+          }
+        );
+
+        SimpleMatrix expected = new SimpleMatrix(
+          new double[][] {
+            new double[] {26d, 12d, 43d, 12d},
+            new double[] {17d, 10d, 30d, 17d},
+            new double[] {36d, 16d, 59d, 14d}
+          }
+        );
+
+        SimpleMatrix actual = firstMatrix.mult(secondMatrix);
+
+        assertThat(actual).matches(m -> m.isIdentical(expected, 0d));
+    }
+
+}

libraries-2/src/test/java/com/baeldung/matrices/homemade/HomemadeMatrixUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.matrices.homemade;
+
+import org.junit.jupiter.api.Test;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class HomemadeMatrixUnitTest {
+
+    @Test
+    @Benchmark
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        double[][] firstMatrix = {
+          new double[]{1d, 5d},
+          new double[]{2d, 3d},
+          new double[]{1d, 7d}
+        };
+
+        double[][] secondMatrix = {
+          new double[]{1d, 2d, 3d, 7d},
+          new double[]{5d, 2d, 8d, 1d}
+        };
+
+        double[][] expected = {
+          new double[]{26d, 12d, 43d, 12d},
+          new double[]{17d, 10d, 30d, 17d},
+          new double[]{36d, 16d, 59d, 14d}
+        };
+
+        double[][] actual = multiplyMatrices(firstMatrix, secondMatrix);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    private double[][] multiplyMatrices(double[][] firstMatrix, double[][] secondMatrix) {
+        double[][] result = new double[firstMatrix.length][secondMatrix[0].length];
+
+        for (int row = 0; row < result.length; row++) {
+            for (int col = 0; col < result[row].length; col++) {
+                result[row][col] = multiplyMatricesCell(firstMatrix, secondMatrix, row, col);
+            }
+        }
+
+        return result;
+    }
+
+    private double multiplyMatricesCell(double[][] firstMatrix, double[][] secondMatrix, int row, int col) {
+        double cell = 0;
+        for (int i = 0; i < secondMatrix.length; i++) {
+            cell += firstMatrix[row][i] * secondMatrix[i][col];
+        }
+        return cell;
+    }
+}

libraries-2/src/test/java/com/baeldung/matrices/la4j/Basic2DMatrixUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.matrices.la4j;
+
+import org.junit.jupiter.api.Test;
+import org.la4j.Matrix;
+import org.la4j.matrix.dense.Basic2DMatrix;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class Basic2DMatrixUnitTest {
+
+    @Test
+    @Benchmark
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        Matrix firstMatrix = new Basic2DMatrix(
+          new double[][]{
+            new double[]{1d, 5d},
+            new double[]{2d, 3d},
+            new double[]{1d, 7d}
+          }
+        );
+
+        Matrix secondMatrix = new Basic2DMatrix(
+          new double[][]{
+            new double[]{1d, 2d, 3d, 7d},
+            new double[]{5d, 2d, 8d, 1d}
+          }
+        );
+
+        Matrix expected = new Basic2DMatrix(
+          new double[][]{
+            new double[]{26d, 12d, 43d, 12d},
+            new double[]{17d, 10d, 30d, 17d},
+            new double[]{36d, 16d, 59d, 14d}
+          }
+        );
+
+        Matrix actual = firstMatrix.multiply(secondMatrix);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+
+}

libraries-2/src/test/java/com/baeldung/matrices/nd4j/INDArrayUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.matrices.nd4j;
+
+import org.junit.jupiter.api.Test;
+import org.nd4j.linalg.api.ndarray.INDArray;
+import org.nd4j.linalg.factory.Nd4j;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(value = 2)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+public class INDArrayUnitTest {
+
+    @Test
+    public void givenTwoMatrices_whenMultiply_thenMultiplicatedMatrix() {
+        INDArray firstMatrix = Nd4j.create(
+          new double[][]{
+            new double[]{1d, 5d},
+            new double[]{2d, 3d},
+            new double[]{1d, 7d}
+          }
+        );
+
+        INDArray secondMatrix = Nd4j.create(
+          new double[][] {
+            new double[] {1d, 2d, 3d, 7d},
+            new double[] {5d, 2d, 8d, 1d}
+          }
+        );
+
+        INDArray expected = Nd4j.create(
+          new double[][] {
+            new double[] {26d, 12d, 43d, 12d},
+            new double[] {17d, 10d, 30d, 17d},
+            new double[] {36d, 16d, 59d, 14d}
+          }
+        );
+
+        INDArray actual = firstMatrix.mmul(secondMatrix);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+
+}