Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

java-math/src/test/java/com/baeldung/algorithms/combination/CombinationUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.algorithms.combination;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+
+import org.junit.Test;
+
+public class CombinationUnitTest {
+
+    private static final int N = 5;
+    private static final int R = 3;
+    private static final int nCr = 10;
+      
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingSetRecursiveAlgorithm_thenExpectedCount() {
+        SetRecursiveCombinationGenerator generator = new SetRecursiveCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingSelectionRecursiveAlgorithm_thenExpectedCount() {
+        SelectionRecursiveCombinationGenerator generator = new SelectionRecursiveCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+    
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingIterativeAlgorithm_thenExpectedCount() {
+        IterativeCombinationGenerator generator = new IterativeCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/distancebetweenpoints/DistanceBetweenPointsServiceUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.distancebetweenpoints;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class DistanceBetweenPointsServiceUnitTest {
+
+    private DistanceBetweenPointsService service = new DistanceBetweenPointsService();
+
+    @Test
+    public void givenTwoPoints_whenCalculateDistanceByFormula_thenCorrect() {
+
+        double x1 = 3;
+        double y1 = 4;
+        double x2 = 7;
+        double y2 = 1;
+
+        double distance = service.calculateDistanceBetweenPoints(x1, y1, x2, y2);
+
+        assertEquals(distance, 5, 0.001);
+
+    }
+
+    @Test
+    public void givenTwoPoints_whenCalculateDistanceWithHypot_thenCorrect() {
+
+        double x1 = 3;
+        double y1 = 4;
+        double x2 = 7;
+        double y2 = 1;
+
+        double distance = service.calculateDistanceBetweenPointsWithHypot(x1, y1, x2, y2);
+
+        assertEquals(distance, 5, 0.001);
+
+    }
+
+    @Test
+    public void givenTwoPoints_whenCalculateDistanceWithPoint2D_thenCorrect() {
+
+        double x1 = 3;
+        double y1 = 4;
+        double x2 = 7;
+        double y2 = 1;
+
+        double distance = service.calculateDistanceBetweenPointsWithPoint2D(x1, y1, x2, y2);
+
+        assertEquals(distance, 5, 0.001);
+
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/factorial/FactorialUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.algorithms.factorial;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigInteger;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class FactorialUnitTest {
+
+    Factorial factorial;
+
+    @Before
+    public void setup() {
+        factorial = new Factorial();
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingForLoop_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingForLoop(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingStreams_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingStreams(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingRecursion_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingRecursion(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingMemoize_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(120);
+
+        n = 6;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(720);
+    }
+
+    @Test
+    public void whenCalculatingFactorialHavingLargeResult_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialHavingLargeResult(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingApacheCommons_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingApacheCommons(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingGuava_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialUsingGuava(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+}

java-math/src/test/java/com/baeldung/algorithms/gcd/GCDImplementationUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.algorithms.gcd;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class GCDImplementationUnitTest {
+
+    @Test
+    public void whenCalculatingGCDByBruteForceMethod_thenCorrect() {
+        int n1 = 60;
+        int n2 = 90;
+        int gcd = GCDImplementation.gcdByBruteForce(n1, n2);
+        assertThat(gcd).isEqualTo(30);
+    }
+
+    @Test
+    public void whenCalculatingGCDByEuclidsAlgorithm_thenCorrect() {
+        int n1 = 60;
+        int n2 = 90;
+        int gcd = GCDImplementation.gcdByEuclidsAlgorithm(n1, n2);
+        assertThat(gcd).isEqualTo(30);
+    }
+
+    @Test
+    public void whenCalculatingGCDBySteinsAlgorithm_thenCorrect() {
+        int n1 = 60;
+        int n2 = 90;
+        int gcd = GCDImplementation.gcdBySteinsAlgorithm(n1, n2);
+        assertThat(gcd).isEqualTo(30);
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/linesintersection/LinesIntersectionServiceUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.linesintersection;
+
+import java.awt.Point;
+import java.util.Optional;
+
+import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertEquals;
+
+public class LinesIntersectionServiceUnitTest {
+    private LinesIntersectionService service = new LinesIntersectionService();
+
+    @Test
+    public void givenNotParallelLines_whenCalculatePoint_thenPresent() {
+
+        double m1 = 0;
+        double b1 = 0;
+        double m2 = 1;
+        double b2 = -1;
+
+        Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2);
+
+        assertTrue(point.isPresent());
+        assertEquals(point.get().getX(), 1, 0.001);
+        assertEquals(point.get().getY(), 0, 0.001);
+    }
+
+    @Test
+    public void givenParallelLines_whenCalculatePoint_thenEmpty() {
+        double m1 = 1;
+        double b1 = 0;
+        double m2 = 1;
+        double b2 = -1;
+
+        Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2);
+
+        assertFalse(point.isPresent());
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/logarithm/LogarithmUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.algorithms.logarithm;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.Test;
+
+public class LogarithmUnitTest {
+
+    @Test
+    public void givenLog10_shouldReturnValidResults() {
+        assertEquals(Math.log10(100), 2);
+        assertEquals(Math.log10(1000), 3);
+    }
+
+    @Test
+    public void givenLogE_shouldReturnValidResults() {
+        assertEquals(Math.log(Math.E), 1);
+        assertEquals(Math.log(10), 2.30258, 0.00001);
+    }
+
+    @Test
+    public void givenCustomLog_shouldReturnValidResults() {
+        assertEquals(customLog(2, 256), 8);
+        assertEquals(customLog(10, 100), 2);
+    }
+
+    private static double customLog(double base, double logNumber) {
+        return Math.log(logNumber) / Math.log(base);
+    }
+
+}

java-math/src/test/java/com/baeldung/algorithms/mercator/EllipticalMercatorUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.mercator;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+
+public class EllipticalMercatorUnitTest {
+
+    @Test
+    public void giventThatTheInputIs22_whenXAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new EllipticalMercator();
+        double result = mercator.xAxisProjection(22);
+        Assert.assertEquals(result, 2449028.7974520186, 0.0);
+    }
+
+    @Test
+    public void giventThatTheInputIs44_whenYAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new EllipticalMercator();
+        double result = mercator.yAxisProjection(44);
+        Assert.assertEquals(result, 5435749.887511954, 0.0);
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/mercator/SphericalMercatorUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.mercator;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SphericalMercatorUnitTest {
+
+    @Test
+    public void giventThatTheInputIs22_whenXAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new SphericalMercator();
+        double result = mercator.xAxisProjection(22);
+        Assert.assertEquals(result, 2449028.7974520186, 0.0);
+    }
+
+    @Test
+    public void giventThatTheInputIs44_whenYAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new SphericalMercator();
+        double result = mercator.yAxisProjection(44);
+        Assert.assertEquals(result, 5465442.183322753, 0.0);
+    }
+}

java-math/src/test/java/com/baeldung/algorithms/percentage/PercentageCalculatorUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.percentage;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PercentageCalculatorUnitTest {
+    private PercentageCalculator pc = new PercentageCalculator();
+
+    @Test
+    public void whenPass2Integers_thenShouldCalculatePercentage(){
+        Assert.assertEquals("Result not as expected",
+                50.0,pc.calculatePercentage(50,100),0.1);
+    }
+
+    @Test
+    public void whenPassObtainedMarksAsDouble_thenShouldCalculatePercentage(){
+        Assert.assertEquals("Result not as expected",5.05,
+                pc.calculatePercentage(50.5,1000),0.1);
+    }
+
+    @Test
+    public void whenPassTotalMarksAsDouble_thenShouldCalculatePercentage(){
+        Assert.assertEquals("Result not as expected",19.6,
+                pc.calculatePercentage(5,25.5),0.1);
+    }
+
+    @Test
+    public void whenPass2DoubleNumbers_thenShouldCalculatePercentage(){
+        Assert.assertEquals("Result not as expected",20,
+                pc.calculatePercentage(5.5,27.5),0.1);
+    }
+
+}

java-math/src/test/java/com/baeldung/algorithms/rectanglesoverlap/RectangleUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import org.junit.Test;
+
+public class RectangleUnitTest {
+
+    @Test
+    public void givenTwoOverlappingRectangles_whenisOverlappingCalled_shouldReturnTrue() {
+        Rectangle rectangle1 = new Rectangle(new Point(2, 1), new Point(4, 3));
+        Rectangle rectangle2 = new Rectangle(new Point(1, 1), new Point(6, 4));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, -2), new Point(2, 3));
+        rectangle2 = new Rectangle(new Point(-2, -1), new Point(5, 2));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, 1), new Point(2, 4));
+        rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, 5));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+    }
+
+    @Test
+    public void givenTwoNonOverlappingRectangles_whenisOverlappingCalled_shouldReturnFalse() {
+        Rectangle rectangle1 = new Rectangle(new Point(-5, 1), new Point(-3, 4));
+        Rectangle rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, 5));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, 1), new Point(3, 4));
+        rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, -1));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-2, 1), new Point(0, 3));
+        rectangle2 = new Rectangle(new Point(3, 1), new Point(5, 4));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+    }
+
+}

java-math/src/test/java/com/baeldung/algorithms/roundedup/RoundUpToHundredUnitTest.java

@@ -0,0 +1,14 @@
+package com.baeldung.algorithms.roundedup;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class RoundUpToHundredUnitTest {
+    @Test
+    public void givenInput_whenRound_thenRoundUpToTheNearestHundred() {
+        assertEquals("Rounded up to hundred", 100, RoundUpToHundred.round(99));
+        assertEquals("Rounded up to three hundred ", 300, RoundUpToHundred.round(200.2));
+        assertEquals("Returns same rounded value", 400, RoundUpToHundred.round(400));
+    }
+}

java-math/src/test/java/com/baeldung/matrices/MatrixMultiplicationBenchmarking.java

@@ -0,0 +1,84 @@
+package com.baeldung.matrices;
+
+import cern.colt.matrix.DoubleFactory2D;
+import cern.colt.matrix.DoubleMatrix2D;
+import cern.colt.matrix.linalg.Algebra;
+import org.apache.commons.math3.linear.Array2DRowRealMatrix;
+import org.apache.commons.math3.linear.RealMatrix;
+import org.ejml.simple.SimpleMatrix;
+import org.la4j.Matrix;
+import org.la4j.matrix.dense.Basic2DMatrix;
+import org.nd4j.linalg.api.ndarray.INDArray;
+import org.nd4j.linalg.factory.Nd4j;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.TimeUnit;
+
+public class MatrixMultiplicationBenchmarking {
+
+    public static void main(String[] args) throws Exception {
+        Options opt = new OptionsBuilder()
+          .include(MatrixMultiplicationBenchmarking.class.getSimpleName())
+          .mode(Mode.AverageTime)
+          .forks(2)
+          .warmupIterations(5)
+          .measurementIterations(10)
+          .timeUnit(TimeUnit.MICROSECONDS)
+          .build();
+
+        new Runner(opt).run();
+    }
+
+    @Benchmark
+    public Object homemadeMatrixMultiplication(MatrixProvider matrixProvider) {
+        return HomemadeMatrix.multiplyMatrices(matrixProvider.getFirstMatrix(), matrixProvider.getSecondMatrix());
+    }
+
+    @Benchmark
+    public Object ejmlMatrixMultiplication(MatrixProvider matrixProvider) {
+        SimpleMatrix firstMatrix = new SimpleMatrix(matrixProvider.getFirstMatrix());
+        SimpleMatrix secondMatrix = new SimpleMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.mult(secondMatrix);
+    }
+
+    @Benchmark
+    public Object apacheCommonsMatrixMultiplication(MatrixProvider matrixProvider) {
+        RealMatrix firstMatrix = new Array2DRowRealMatrix(matrixProvider.getFirstMatrix());
+        RealMatrix secondMatrix = new Array2DRowRealMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.multiply(secondMatrix);
+    }
+
+    @Benchmark
+    public Object la4jMatrixMultiplication(MatrixProvider matrixProvider) {
+        Matrix firstMatrix = new Basic2DMatrix(matrixProvider.getFirstMatrix());
+        Matrix secondMatrix = new Basic2DMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.multiply(secondMatrix);
+    }
+
+    @Benchmark
+    public Object nd4jMatrixMultiplication(MatrixProvider matrixProvider) {
+        INDArray firstMatrix = Nd4j.create(matrixProvider.getFirstMatrix());
+        INDArray secondMatrix = Nd4j.create(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.mmul(secondMatrix);
+    }
+
+    @Benchmark
+    public Object coltMatrixMultiplication(MatrixProvider matrixProvider) {
+        DoubleFactory2D doubleFactory2D = DoubleFactory2D.dense;
+
+        DoubleMatrix2D firstMatrix = doubleFactory2D.make(matrixProvider.getFirstMatrix());
+        DoubleMatrix2D secondMatrix = doubleFactory2D.make(matrixProvider.getSecondMatrix());
+
+        Algebra algebra = new Algebra();
+        return algebra.mult(firstMatrix, secondMatrix);
+    }
+
+}

java-math/src/test/java/com/baeldung/matrices/MatrixProvider.java

@@ -0,0 +1,33 @@
+package com.baeldung.matrices;
+
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+@State(Scope.Benchmark)
+public class MatrixProvider {
+    private double[][] firstMatrix;
+    private double[][] secondMatrix;
+
+    public MatrixProvider() {
+        firstMatrix =
+          new double[][] {
+            new double[] {1d, 5d},
+            new double[] {2d, 3d},
+            new double[] {1d ,7d}
+          };
+
+        secondMatrix =
+          new double[][] {
+            new double[] {1d, 2d, 3d, 7d},
+            new double[] {5d, 2d, 8d, 1d}
+          };
+    }
+
+    public double[][] getFirstMatrix() {
+        return firstMatrix;
+    }
+
+    public double[][] getSecondMatrix() {
+        return secondMatrix;
+    }
+}

java-math/src/test/java/com/baeldung/matrices/apache/RealMatrixUnitTest.java

@@ -0,0 +1,41 @@
+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;
+
+class RealMatrixUnitTest {
+
+    @Test
+    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);
+    }
+}

java-math/src/test/java/com/baeldung/matrices/colt/DoubleMatrix2DUnitTest.java

@@ -0,0 +1,46 @@
+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;
+
+class DoubleMatrix2DUnitTest {
+
+    @Test
+    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);
+    }
+
+}

java-math/src/test/java/com/baeldung/matrices/ejml/SimpleMatrixUnitTest.java

@@ -0,0 +1,41 @@
+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;
+
+class SimpleMatrixUnitTest {
+
+    @Test
+    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));
+    }
+
+}

java-math/src/test/java/com/baeldung/matrices/homemade/HomemadeMatrixUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.matrices.homemade;
+
+import org.junit.jupiter.api.Test;
+import org.openjdk.jmh.annotations.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class HomemadeMatrixUnitTest {
+
+    @Test
+    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;
+    }
+
+}

java-math/src/test/java/com/baeldung/matrices/la4j/Basic2DMatrixUnitTest.java

@@ -0,0 +1,42 @@
+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;
+
+class Basic2DMatrixUnitTest {
+
+    @Test
+    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);
+    }
+
+}

java-math/src/test/java/com/baeldung/matrices/nd4j/INDArrayUnitTest.java

@@ -0,0 +1,42 @@
+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;
+
+class INDArrayUnitTest {
+
+    @Test
+    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);
+    }
+
+}