JAVA-626 : Added new module, replacement for the retired java-math

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/ApacheCommonsCombinationGenerator.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+import org.apache.commons.math3.util.CombinatoricsUtils;
+
+public class ApacheCommonsCombinationGenerator {
+
+    private static final int N = 6;
+    private static final int R = 3;
+
+    /** 
+     * Print all combinations of r elements from a set
+     * @param n - number of elements in set
+     * @param r - number of elements in selection
+     */
+    public static void generate(int n, int r) {
+        Iterator<int[]> iterator = CombinatoricsUtils.combinationsIterator(n, r);
+        while (iterator.hasNext()) {
+            final int[] combination = iterator.next();
+            System.out.println(Arrays.toString(combination));
+        }
+    }
+
+    public static void main(String[] args) {
+        generate(N, R);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/CombinatoricsLibCombinationGenerator.java

@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.combination;
+
+import org.paukov.combinatorics3.Generator;
+
+public class CombinatoricsLibCombinationGenerator {
+
+    public static void main(String[] args) {
+        Generator.combination(0, 1, 2, 3, 4, 5)
+            .simple(3)
+            .stream()
+            .forEach(System.out::println);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/GuavaCombinationsGenerator.java

@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.Arrays;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
+public class GuavaCombinationsGenerator {
+
+    public static void main(String[] args) {
+
+        Set<Set<Integer>> combinations = Sets.combinations(ImmutableSet.of(0, 1, 2, 3, 4, 5), 3);
+        System.out.println(combinations.size());
+        System.out.println(Arrays.toString(combinations.toArray()));
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/IterativeCombinationGenerator.java

@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class IterativeCombinationGenerator {
+
+    private static final int N = 5;
+    private static final int R = 2;
+
+    /**
+     * Generate all combinations of r elements from a set
+     * @param n the number of elements in input set
+     * @param r the number of elements in a combination
+     * @return the list containing all combinations
+     */
+    public List<int[]> generate(int n, int r) {
+        List<int[]> combinations = new ArrayList<>();
+        int[] combination = new int[r];
+
+        // initialize with lowest lexicographic combination
+        for (int i = 0; i < r; i++) {
+            combination[i] = i;
+        }
+
+        while (combination[r - 1] < n) {
+            combinations.add(combination.clone());
+
+            // generate next combination in lexicographic order
+            int t = r - 1;
+            while (t != 0 && combination[t] == n - r + t) {
+                t--;
+            }
+            combination[t]++;
+            for (int i = t + 1; i < r; i++) {
+                combination[i] = combination[i - 1] + 1;
+            }
+        }
+
+        return combinations;
+    }
+
+    public static void main(String[] args) {
+        IterativeCombinationGenerator generator = new IterativeCombinationGenerator();
+        List<int[]> combinations = generator.generate(N, R);
+        System.out.println(combinations.size());
+        for (int[] combination : combinations) {
+            System.out.println(Arrays.toString(combination));
+        }
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/SelectionRecursiveCombinationGenerator.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SelectionRecursiveCombinationGenerator {
+
+    private static final int N = 6;
+    private static final int R = 3;
+
+    /** 
+     * Generate all combinations of r elements from a set
+     * @param n - number of elements in input set
+     * @param r - number of elements to be chosen
+     * @return the list containing all combinations
+     */
+    public List<int[]> generate(int n, int r) {
+        List<int[]> combinations = new ArrayList<>();
+        helper(combinations, new int[r], 0, n - 1, 0);
+        return combinations;
+    }
+
+    /** 
+     * Choose elements from set by recursing over elements selected
+     * @param combinations - List to store generated combinations
+     * @param data - current combination
+     * @param start - starting element of remaining set
+     * @param end - last element of remaining set
+     * @param index - number of elements chosen so far.
+     */
+    private void helper(List<int[]> combinations, int data[], int start, int end, int index) {
+        if (index == data.length) {
+            int[] combination = data.clone();
+            combinations.add(combination);
+        } else {
+            int max = Math.min(end, end + 1 - data.length + index);
+            for (int i = start; i <= max; i++) {
+                data[index] = i;
+                helper(combinations, data, i + 1, end, index + 1);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        SelectionRecursiveCombinationGenerator generator = new SelectionRecursiveCombinationGenerator();
+        List<int[]> combinations = generator.generate(N, R);
+        for (int[] combination : combinations) {
+            System.out.println(Arrays.toString(combination));
+        }
+        System.out.printf("generated %d combinations of %d items from %d ", combinations.size(), R, N);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/combination/SetRecursiveCombinationGenerator.java

@@ -0,0 +1,50 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SetRecursiveCombinationGenerator {
+
+    private static final int N = 5;
+    private static final int R = 2;
+
+    /** 
+     * Generate all combinations of r elements from a set
+     * @param n - number of elements in set
+     * @param r - number of elements in selection
+     * @return the list containing all combinations
+     */
+    public List<int[]> generate(int n, int r) {
+        List<int[]> combinations = new ArrayList<>();
+        helper(combinations, new int[r], 0, n-1, 0);
+        return combinations;
+    }
+
+    /**
+     * @param combinations - List to contain the generated combinations
+     * @param data - List of elements in the selection
+     * @param start - index of the starting element in the remaining set
+     * @param end - index of the last element in the set  
+     * @param index - number of elements selected so far
+     */
+    private void helper(List<int[]> combinations, int data[], int start, int end, int index) {
+        if (index == data.length) {
+            int[] combination = data.clone();
+            combinations.add(combination);
+        } else if (start <= end) {
+            data[index] = start;
+            helper(combinations, data, start + 1, end, index + 1);
+            helper(combinations, data, start + 1, end, index);
+        }
+    }
+
+    public static void main(String[] args) {
+        SetRecursiveCombinationGenerator generator = new SetRecursiveCombinationGenerator();
+        List<int[]> combinations = generator.generate(N, R);
+        for (int[] combination : combinations) {
+            System.out.println(Arrays.toString(combination));
+        }
+        System.out.printf("generated %d combinations of %d items from %d ", combinations.size(), R, N);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/distancebetweenpoints/DistanceBetweenPointsService.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.distancebetweenpoints;
+
+import java.awt.geom.Point2D;
+
+public class DistanceBetweenPointsService {
+
+    public double calculateDistanceBetweenPoints(
+        double x1, 
+        double y1, 
+        double x2, 
+        double y2) {
+        
+        return Math.sqrt((y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1));
+    }
+
+    public double calculateDistanceBetweenPointsWithHypot(
+        double x1, 
+        double y1, 
+        double x2, 
+        double y2) {
+        
+        double ac = Math.abs(y2 - y1);
+        double cb = Math.abs(x2 - x1);
+        
+        return Math.hypot(ac, cb);
+    }
+
+    public double calculateDistanceBetweenPointsWithPoint2D( 
+        double x1, 
+        double y1, 
+        double x2, 
+        double y2) {
+        
+        return Point2D.distance(x1, y1, x2, y2);
+
+    }
+
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/factorial/Factorial.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.factorial;
+
+import java.math.BigInteger;
+import java.util.stream.LongStream;
+
+import org.apache.commons.math3.util.CombinatoricsUtils;
+
+import com.google.common.math.BigIntegerMath;
+
+public class Factorial {
+
+    public long factorialUsingForLoop(int n) {
+        long fact = 1;
+        for (int i = 2; i <= n; i++) {
+            fact = fact * i;
+        }
+        return fact;
+    }
+
+    public long factorialUsingStreams(int n) {
+        return LongStream.rangeClosed(1, n)
+            .reduce(1, (long x, long y) -> x * y);
+    }
+
+    public long factorialUsingRecursion(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        return n * factorialUsingRecursion(n - 1);
+    }
+
+    private Long[] factorials = new Long[20];
+
+    public long factorialUsingMemoize(int n) {
+
+        if (factorials[n] != null) {
+            return factorials[n];
+        }
+
+        if (n <= 2) {
+            return n;
+        }
+        long nthValue = n * factorialUsingMemoize(n - 1);
+        factorials[n] = nthValue;
+        return nthValue;
+    }
+
+    public BigInteger factorialHavingLargeResult(int n) {
+        BigInteger result = BigInteger.ONE;
+        for (int i = 2; i <= n; i++)
+            result = result.multiply(BigInteger.valueOf(i));
+        return result;
+    }
+
+    public long factorialUsingApacheCommons(int n) {
+        return CombinatoricsUtils.factorial(n);
+    }
+
+    public BigInteger factorialUsingGuava(int n) {
+        return BigIntegerMath.factorial(n);
+    }
+
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/linesintersection/LinesIntersectionService.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linesintersection;
+
+import java.awt.Point;
+import java.util.Optional;
+
+public class LinesIntersectionService {
+
+    public Optional<Point> calculateIntersectionPoint(double m1, double b1, double m2, double b2) {
+
+        if (m1 == m2) {
+            return Optional.empty();
+        }
+
+        double x = (b2 - b1) / (m1 - m2);
+        double y = m1 * x + b1;
+
+        Point point = new Point();
+        point.setLocation(x, y);
+        return Optional.of(point);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/mercator/EllipticalMercator.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.mercator;
+
+class EllipticalMercator extends Mercator {
+
+    @Override
+    double yAxisProjection(double input) {
+
+        input = Math.min(Math.max(input, -89.5), 89.5);
+        double earthDimensionalRateNormalized = 1.0 - Math.pow(RADIUS_MINOR / RADIUS_MAJOR, 2);
+
+        double inputOnEarthProj = Math.sqrt(earthDimensionalRateNormalized) *  Math.sin( Math.toRadians(input));
+
+        inputOnEarthProj = Math.pow(((1.0 - inputOnEarthProj)/(1.0+inputOnEarthProj)), 0.5 * Math.sqrt(earthDimensionalRateNormalized));
+        double inputOnEarthProjNormalized = Math.tan(0.5 * ((Math.PI*0.5) -  Math.toRadians(input)))/inputOnEarthProj;
+        return (-1) * RADIUS_MAJOR * Math.log(inputOnEarthProjNormalized);
+    }
+
+    @Override
+    double xAxisProjection(double input) {
+        return RADIUS_MAJOR * Math.toRadians(input);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/mercator/Mercator.java

@@ -0,0 +1,10 @@
+package com.baeldung.algorithms.mercator;
+
+abstract class Mercator {
+    final static double RADIUS_MAJOR = 6378137.0;
+    final static double RADIUS_MINOR = 6356752.3142;
+
+    abstract double yAxisProjection(double input);
+
+    abstract double xAxisProjection(double input);
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/mercator/SphericalMercator.java

@@ -0,0 +1,14 @@
+package com.baeldung.algorithms.mercator;
+
+public class SphericalMercator extends  Mercator {
+
+    @Override
+    double xAxisProjection(double input) {
+        return Math.toRadians(input) * RADIUS_MAJOR;
+    }
+
+    @Override
+    double yAxisProjection(double input) {
+        return Math.log(Math.tan(Math.PI / 4 + Math.toRadians(input) / 2)) * RADIUS_MAJOR;
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/rectanglesoverlap/Point.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+public class Point {
+
+    private int x;
+    private int y;
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/rectanglesoverlap/Rectangle.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+public class Rectangle {
+
+    private Point bottomLeft;
+    private Point topRight;
+
+    public Rectangle(Point bottomLeft, Point topRight) {
+        this.bottomLeft = bottomLeft;
+        this.topRight = topRight;
+    }
+
+    public Point getBottomLeft() {
+        return bottomLeft;
+    }
+
+    public void setBottomLeft(Point bottomLeft) {
+        this.bottomLeft = bottomLeft;
+    }
+
+    public Point getTopRight() {
+        return topRight;
+    }
+
+    public void setTopRight(Point topRight) {
+        this.topRight = topRight;
+    }
+
+    public boolean isOverlapping(Rectangle other) {
+        // one rectangle is to the top of the other
+        if (this.topRight.getY() < other.bottomLeft.getY() || this.bottomLeft.getY() > other.topRight.getY()) {
+            return false;
+        }
+        // one rectangle is to the left of the other
+        if (this.topRight.getX() < other.bottomLeft.getX() || this.bottomLeft.getX() > other.topRight.getX()) {
+            return false;
+        }
+        return true;
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/algorithms/roundedup/RoundUpToHundred.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.roundedup;
+
+import java.util.Scanner;
+
+public class RoundUpToHundred {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        double input = scanner.nextDouble();
+        scanner.close();
+
+        RoundUpToHundred.round(input);
+    }
+
+    static long round(double input) {
+        long i = (long) Math.ceil(input);
+        return ((i + 99) / 100) * 100;
+    };
+
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/matrices/HomemadeMatrix.java

@@ -0,0 +1,23 @@
+package com.baeldung.matrices;
+
+public class HomemadeMatrix {
+    public static 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 static 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;
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/matrices/benchmark/BigMatrixMultiplicationBenchmarking.java

@@ -0,0 +1,121 @@
+package com.baeldung.matrices.benchmark;
+
+import cern.colt.matrix.DoubleFactory2D;
+import cern.colt.matrix.DoubleMatrix2D;
+import cern.colt.matrix.linalg.Algebra;
+import com.baeldung.matrices.HomemadeMatrix;
+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.ChainedOptionsBuilder;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+public class BigMatrixMultiplicationBenchmarking {
+    private static final int DEFAULT_FORKS = 2;
+    private static final int DEFAULT_WARMUP_ITERATIONS = 5;
+    private static final int DEFAULT_MEASUREMENT_ITERATIONS = 10;
+
+    public static void main(String[] args) throws Exception {
+        Map<String, String> parameters = parseParameters(args);
+
+        ChainedOptionsBuilder builder = new OptionsBuilder()
+          .include(BigMatrixMultiplicationBenchmarking.class.getSimpleName())
+          .mode(Mode.AverageTime)
+          .forks(forks(parameters))
+          .warmupIterations(warmupIterations(parameters))
+          .measurementIterations(measurementIterations(parameters))
+          .timeUnit(TimeUnit.SECONDS);
+
+        parameters.forEach(builder::param);
+
+        new Runner(builder.build()).run();
+    }
+
+    private static Map<String, String> parseParameters(String[] args) {
+        return Arrays.stream(args)
+          .map(arg -> arg.split("="))
+          .collect(Collectors.toMap(
+            arg -> arg[0],
+            arg -> arg[1]
+          ));
+    }
+
+    private static int forks(Map<String, String> parameters) {
+        String forks = parameters.remove("forks");
+        return parseOrDefault(forks, DEFAULT_FORKS);
+    }
+
+    private static int warmupIterations(Map<String, String> parameters) {
+        String warmups = parameters.remove("warmupIterations");
+        return parseOrDefault(warmups, DEFAULT_WARMUP_ITERATIONS);
+    }
+
+    private static int measurementIterations(Map<String, String> parameters) {
+        String measurements = parameters.remove("measurementIterations");
+        return parseOrDefault(measurements, DEFAULT_MEASUREMENT_ITERATIONS);
+    }
+
+    private static int parseOrDefault(String parameter, int defaultValue) {
+        return parameter != null ? Integer.parseInt(parameter) : defaultValue;
+    }
+
+    @Benchmark
+    public Object homemadeMatrixMultiplication(BigMatrixProvider matrixProvider) {
+        return HomemadeMatrix.multiplyMatrices(matrixProvider.getFirstMatrix(), matrixProvider.getSecondMatrix());
+    }
+
+    @Benchmark
+    public Object ejmlMatrixMultiplication(BigMatrixProvider matrixProvider) {
+        SimpleMatrix firstMatrix = new SimpleMatrix(matrixProvider.getFirstMatrix());
+        SimpleMatrix secondMatrix = new SimpleMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.mult(secondMatrix);
+    }
+
+    @Benchmark
+    public Object apacheCommonsMatrixMultiplication(BigMatrixProvider matrixProvider) {
+        RealMatrix firstMatrix = new Array2DRowRealMatrix(matrixProvider.getFirstMatrix());
+        RealMatrix secondMatrix = new Array2DRowRealMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.multiply(secondMatrix);
+    }
+
+    @Benchmark
+    public Object la4jMatrixMultiplication(BigMatrixProvider matrixProvider) {
+        Matrix firstMatrix = new Basic2DMatrix(matrixProvider.getFirstMatrix());
+        Matrix secondMatrix = new Basic2DMatrix(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.multiply(secondMatrix);
+    }
+
+    @Benchmark
+    public Object nd4jMatrixMultiplication(BigMatrixProvider matrixProvider) {
+        INDArray firstMatrix = Nd4j.create(matrixProvider.getFirstMatrix());
+        INDArray secondMatrix = Nd4j.create(matrixProvider.getSecondMatrix());
+
+        return firstMatrix.mmul(secondMatrix);
+    }
+
+    @Benchmark
+    public Object coltMatrixMultiplication(BigMatrixProvider 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);
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/matrices/benchmark/BigMatrixProvider.java

@@ -0,0 +1,46 @@
+package com.baeldung.matrices.benchmark;
+
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.infra.BenchmarkParams;
+
+import java.util.Random;
+import java.util.stream.DoubleStream;
+
+@State(Scope.Benchmark)
+public class BigMatrixProvider {
+    @Param({})
+    private int matrixSize;
+    private double[][] firstMatrix;
+    private double[][] secondMatrix;
+
+    public BigMatrixProvider() {}
+
+    @Setup
+    public void setup(BenchmarkParams parameters) {
+        firstMatrix = createMatrix(matrixSize);
+        secondMatrix = createMatrix(matrixSize);
+    }
+
+    private double[][] createMatrix(int matrixSize) {
+        Random random = new Random();
+
+        double[][] result = new double[matrixSize][matrixSize];
+        for (int row = 0; row < result.length; row++) {
+            for (int col = 0; col < result[row].length; col++) {
+                result[row][col] = random.nextDouble();
+            }
+        }
+        return result;
+    }
+
+    public double[][] getFirstMatrix() {
+        return firstMatrix;
+    }
+
+    public double[][] getSecondMatrix() {
+        return secondMatrix;
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/matrices/benchmark/MatrixMultiplicationBenchmarking.java

@@ -0,0 +1,86 @@
+package com.baeldung.matrices.benchmark;
+
+import cern.colt.matrix.DoubleFactory2D;
+import cern.colt.matrix.DoubleMatrix2D;
+import cern.colt.matrix.linalg.Algebra;
+import com.baeldung.matrices.HomemadeMatrix;
+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())
+          .exclude(BigMatrixMultiplicationBenchmarking.class.getSimpleName())
+          .mode(Mode.AverageTime)
+          .forks(2)
+          .warmupIterations(10)
+          .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);
+    }
+
+}

core-java-modules/core-java-lang-math-2/src/main/java/com/baeldung/matrices/benchmark/MatrixProvider.java

@@ -0,0 +1,33 @@
+package com.baeldung.matrices.benchmark;
+
+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;
+    }
+}

core-java-modules/core-java-lang-math-2/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>