From fcfd80355f03036b77a9184b9038bbec830d00ea Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 09:08:12 +0530 Subject: [PATCH 01/24] MatrixMultiplication.java created and updated. --- .../matrix/MatrixMultiplication.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java new file mode 100644 index 000000000000..cc36f9a5d6bc --- /dev/null +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -0,0 +1,40 @@ +package com.thealgorithms.matrix; + +public class MatrixMultiplication { + private MatrixMultiplication() { + } + + /** + * Multiplies two matrices. + * + * @param matrixA the first matrix rowsA x colsA + * @param matrixB the second matrix rowsB x colsB + * @return the product of the two matrices rowsA x colsB + * @throws IllegalArgumentException if the matrices cannot be multiplied + */ + public static double[][] multiply(double[][] matrixA, double[][] matrixB) { + + if (matrixA == null || matrixB == null) { + throw new IllegalArgumentException("Input matrices cannot be null"); + } + + if (matrixA[0].length != matrixB.length) { + throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); + } + + int rowsA = matrixA.length; + int colsA = matrixA[0].length; + int colsB = matrixB[0].length; + + double[][] result = new double[rowsA][colsB]; + + for (int i = 0; i < rowsA; i++) { + for (int j = 0; j < colsB; j++) { + for (int k = 0; k < colsA; k++) { + result[i][j] += matrixA[i][k] * matrixB[k][j]; + } + } + } + return result; + } +} From c9f57d0d347d4fefff4b629bfab092be8a0d5d8b Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 09:11:21 +0530 Subject: [PATCH 02/24] Add necessary comment to MatrixMultiplication.java --- .../java/com/thealgorithms/matrix/MatrixMultiplication.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index cc36f9a5d6bc..8fe80a695c99 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -13,11 +13,12 @@ private MatrixMultiplication() { * @throws IllegalArgumentException if the matrices cannot be multiplied */ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { - + // Check the input matrices are not null if (matrixA == null || matrixB == null) { throw new IllegalArgumentException("Input matrices cannot be null"); } + // Validate the matrix dimensions if (matrixA[0].length != matrixB.length) { throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); } @@ -26,8 +27,10 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { int colsA = matrixA[0].length; int colsB = matrixB[0].length; + // Initialize the result matrix with zeros double[][] result = new double[rowsA][colsB]; + // Perform matrix multiplication for (int i = 0; i < rowsA; i++) { for (int j = 0; j < colsB; j++) { for (int k = 0; k < colsA; k++) { From 16c9897249f93ab7d1d988a38d42d3d79f6cb618 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 09:12:59 +0530 Subject: [PATCH 03/24] Create MatrixMultiplicationTest.java --- .../com/thealgorithms/matrix/MatrixMultiplicationTest.java | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java new file mode 100644 index 000000000000..18dfe9acbbc3 --- /dev/null +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -0,0 +1,4 @@ +package com.thealgorithms.matrix; + +public class MatrixMultiplicationTest { +} From 1ff92f53e93a0aefd1c1d6fc921be68c5e12f88a Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:01:06 +0530 Subject: [PATCH 04/24] method for 2 by 2 matrix multiplication is created --- .../matrix/MatrixMultiplicationTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 18dfe9acbbc3..a973443d1874 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -1,4 +1,19 @@ package com.thealgorithms.matrix; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + + public class MatrixMultiplicationTest { + @Test + void testMultiply2by2(){ + double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; + double[][] matrixB = {{5.0,6.0},{7.0,8.0}}; + double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); + } + } From 855d20f4bb1d2c080ab6732232c42ddb434736db Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:04:20 +0530 Subject: [PATCH 05/24] Use assertMatrixEquals(), otherwise there can be error due to floating point arithmetic errors --- .../java/com/thealgorithms/matrix/MatrixMultiplicationTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index a973443d1874..26bfdf226709 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -13,7 +13,7 @@ void testMultiply2by2(){ double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); + assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals } } From 05064a54709c6663541dff5931a401f97cc2a53e Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:11:55 +0530 Subject: [PATCH 06/24] assertMatrixEquals method created and updated --- .../matrix/MatrixMultiplicationTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 26bfdf226709..5393b3e67e7a 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -6,6 +6,10 @@ public class MatrixMultiplicationTest { + + private static final double EPSILON = 1e-9; // for floating point comparison + + @Test void testMultiply2by2(){ double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; @@ -16,4 +20,15 @@ void testMultiply2by2(){ assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals } + private void assertMatrixEquals(double[][] expected, double[][] actual) { + assertEquals(expected.length, actual.length, "Row count mismatch"); + for (int i = 0; i < expected.length; i++) { + assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); // Check if the number of columns in each row matches + for (int j = 0; j < expected[i].length; j++) { + assertEquals(expected[i][j], actual[i][j], EPSILON, + "Mismatch at (" + i + "," + j + ")"); + } + } + } + } From 4e4625ce5970281255df164121efa459df7270c6 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:14:51 +0530 Subject: [PATCH 07/24] method created for 3by2 matrix multiply with 2by1 matrix --- .../matrix/MatrixMultiplicationTest.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 5393b3e67e7a..25344f7ad23c 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -20,6 +20,17 @@ void testMultiply2by2(){ assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals } + @Test + void testMultiply3by2and1(){ + double[][] matrixA = {{1.0,2.0},{3.0,4.0},{5.0,6.0}}; + double[][] matrixB = {{7.0},{8.0}}; + double[][] expected = {{23.0}, {53.0}, {83.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals + } + + private void assertMatrixEquals(double[][] expected, double[][] actual) { assertEquals(expected.length, actual.length, "Row count mismatch"); for (int i = 0; i < expected.length; i++) { From f661455081bf773006b278093e2be7d7e274cd36 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:18:40 +0530 Subject: [PATCH 08/24] method created for null matrix multiplication --- .../matrix/MatrixMultiplicationTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 25344f7ad23c..fb59302497e7 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -30,6 +30,21 @@ void testMultiply3by2and1(){ assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals } + @Test + void testMultiplyNull(){ + double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; + double[][] matrixB = null; + + Exception exception = assertThrows(IllegalArgumentException.class, () -> { + MatrixMultiplication.multiply(matrixA, matrixB); + }); + + String expectedMessage = "Input matrices cannot be null"; + String actualMessage = exception.getMessage(); + + assertTrue(actualMessage.contains(expectedMessage)); + } + private void assertMatrixEquals(double[][] expected, double[][] actual) { assertEquals(expected.length, actual.length, "Row count mismatch"); From a9438d20b05f03f5992ccb0f175181640171f4bf Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:21:08 +0530 Subject: [PATCH 09/24] method for test matrix dimension error --- .../matrix/MatrixMultiplicationTest.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index fb59302497e7..a0675f38796a 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -46,6 +46,18 @@ void testMultiplyNull(){ } + @Test + void testIncompatibleDimensions() { + double[][] A = { + {1.0, 2.0} + }; + double[][] B = { + {1.0, 2.0} + }; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B)); + } + + private void assertMatrixEquals(double[][] expected, double[][] actual) { assertEquals(expected.length, actual.length, "Row count mismatch"); for (int i = 0; i < expected.length; i++) { From 4bf395bbc5404fd904ca0e2d31e4287e8942ea48 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:25:34 +0530 Subject: [PATCH 10/24] method for test empty matrix input --- .../com/thealgorithms/matrix/MatrixMultiplicationTest.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index a0675f38796a..2981758e3020 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -57,6 +57,13 @@ void testIncompatibleDimensions() { assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B)); } + @Test + void testEmptyMatrices() { + double[][] A = new double[0][0]; + double[][] B = new double[0][0]; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B)); + } + private void assertMatrixEquals(double[][] expected, double[][] actual) { assertEquals(expected.length, actual.length, "Row count mismatch"); From 64a97dbfc50ebd595b703d0519f20997bbf3eb07 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 10:34:46 +0530 Subject: [PATCH 11/24] testMultiply3by2and2by1 test case updated --- .../com/thealgorithms/matrix/MatrixMultiplicationTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 2981758e3020..daeb67c6f1f3 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -21,13 +21,13 @@ void testMultiply2by2(){ } @Test - void testMultiply3by2and1(){ + void testMultiply3by2and2by1(){ double[][] matrixA = {{1.0,2.0},{3.0,4.0},{5.0,6.0}}; double[][] matrixB = {{7.0},{8.0}}; double[][] expected = {{23.0}, {53.0}, {83.0}}; double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals + assertMatrixEquals(expected, result); } @Test From 6d16a542b3c9d36829e071e443097775cad60762 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 16:27:31 +0530 Subject: [PATCH 12/24] Check for empty matrices part updated --- .../java/com/thealgorithms/matrix/MatrixMultiplication.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index 8fe80a695c99..a56341570d8a 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -18,6 +18,12 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { throw new IllegalArgumentException("Input matrices cannot be null"); } + // Check for empty matrices + if (matrixA.length == 0 || matrixB.length == 0 || + matrixA[0].length == 0 || matrixB[0].length == 0) { + throw new IllegalArgumentException("Input matrices must not be empty"); + } + // Validate the matrix dimensions if (matrixA[0].length != matrixB.length) { throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); From 65927d84fa7446348e55615fdeaba6f0969d6ba2 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 16:38:03 +0530 Subject: [PATCH 13/24] Updated Unit test coverage --- .../matrix/MatrixMultiplicationTest.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index daeb67c6f1f3..29cf8d1665f7 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -30,6 +30,19 @@ void testMultiply3by2and2by1(){ assertMatrixEquals(expected, result); } + @Test + void testNullMatrixA() { + double[][] B = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, B)); + } + + @Test + void testNullMatrixB() { + double[][] A = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, null)); + } + + @Test void testMultiplyNull(){ double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; From 1a58232e26e2bb9c5ad285c4229d425beaa28e92 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 16:44:27 +0530 Subject: [PATCH 14/24] files updated --- .../java/com/thealgorithms/matrix/MatrixMultiplication.java | 2 +- .../com/thealgorithms/matrix/MatrixMultiplicationTest.java | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index a56341570d8a..d6ed54ad107e 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -1,6 +1,6 @@ package com.thealgorithms.matrix; -public class MatrixMultiplication { +public final class MatrixMultiplication { private MatrixMultiplication() { } diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 29cf8d1665f7..172ec9f885ad 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -1,6 +1,9 @@ package com.thealgorithms.matrix; import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.*; From 414200eaf855c7a492fac06f5375e1bbea2bc43b Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 16:51:36 +0530 Subject: [PATCH 15/24] clean the code --- .../matrix/MatrixMultiplication.java | 12 ++-- .../matrix/MatrixMultiplicationTest.java | 62 +++++++------------ 2 files changed, 31 insertions(+), 43 deletions(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index d6ed54ad107e..d6067012eb33 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -7,9 +7,9 @@ private MatrixMultiplication() { /** * Multiplies two matrices. * - * @param matrixA the first matrix rowsA x colsA - * @param matrixB the second matrix rowsB x colsB - * @return the product of the two matrices rowsA x colsB + * @param matrixA the first matrix rowsA x colsA + * @param matrixB the second matrix rowsB x colsB + * @return the product of the two matrices rowsA x colsB * @throws IllegalArgumentException if the matrices cannot be multiplied */ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { @@ -19,8 +19,10 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { } // Check for empty matrices - if (matrixA.length == 0 || matrixB.length == 0 || - matrixA[0].length == 0 || matrixB[0].length == 0) { + if (matrixA.length == 0 + || matrixB.length == 0 + || matrixA[0].length == 0 + || matrixB[0].length == 0) { throw new IllegalArgumentException("Input matrices must not be empty"); } diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 172ec9f885ad..2357f4196da2 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -2,31 +2,27 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; - -import static org.junit.jupiter.api.Assertions.*; - +import static org.junit.jupiter.api.Assertions.assertTrue; public class MatrixMultiplicationTest { private static final double EPSILON = 1e-9; // for floating point comparison - @Test - void testMultiply2by2(){ - double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; - double[][] matrixB = {{5.0,6.0},{7.0,8.0}}; + void testMultiply2by2() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; + double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}}; double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals + assertMatrixEquals(expected, result); // Use custom method due to floating point issues } @Test - void testMultiply3by2and2by1(){ - double[][] matrixA = {{1.0,2.0},{3.0,4.0},{5.0,6.0}}; - double[][] matrixB = {{7.0},{8.0}}; + void testMultiply3by2and2by1() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}}; + double[][] matrixB = {{7.0}, {8.0}}; double[][] expected = {{23.0}, {53.0}, {83.0}}; double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); @@ -35,25 +31,23 @@ void testMultiply3by2and2by1(){ @Test void testNullMatrixA() { - double[][] B = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, B)); + double[][] b = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b)); } @Test void testNullMatrixB() { - double[][] A = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, null)); + double[][] a = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null)); } - @Test - void testMultiplyNull(){ - double[][] matrixA = {{1.0,2.0},{3.0,4.0}}; + void testMultiplyNull() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; double[][] matrixB = null; - Exception exception = assertThrows(IllegalArgumentException.class, () -> { - MatrixMultiplication.multiply(matrixA, matrixB); - }); + Exception exception = assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(matrixA, matrixB)); String expectedMessage = "Input matrices cannot be null"; String actualMessage = exception.getMessage(); @@ -61,35 +55,27 @@ void testMultiplyNull(){ assertTrue(actualMessage.contains(expectedMessage)); } - @Test void testIncompatibleDimensions() { - double[][] A = { - {1.0, 2.0} - }; - double[][] B = { - {1.0, 2.0} - }; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B)); + double[][] a = {{1.0, 2.0}}; + double[][] b = {{1.0, 2.0}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); } @Test void testEmptyMatrices() { - double[][] A = new double[0][0]; - double[][] B = new double[0][0]; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B)); + double[][] a = new double[0][0]; + double[][] b = new double[0][0]; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); } - private void assertMatrixEquals(double[][] expected, double[][] actual) { assertEquals(expected.length, actual.length, "Row count mismatch"); for (int i = 0; i < expected.length; i++) { - assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); // Check if the number of columns in each row matches + assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); for (int j = 0; j < expected[i].length; j++) { - assertEquals(expected[i][j], actual[i][j], EPSILON, - "Mismatch at (" + i + "," + j + ")"); + assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")"); } } } - } From d150bb2e77083fa79f95a6c2acd479b359934259 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 16:59:25 +0530 Subject: [PATCH 16/24] clean the code --- .../matrix/MatrixMultiplicationTest.java | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 2357f4196da2..1288c3814c42 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -32,13 +32,15 @@ void testMultiply3by2and2by1() { @Test void testNullMatrixA() { double[][] b = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b)); + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(null, b)); } @Test void testNullMatrixB() { double[][] a = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null)); + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, null)); } @Test @@ -59,14 +61,16 @@ void testMultiplyNull() { void testIncompatibleDimensions() { double[][] a = {{1.0, 2.0}}; double[][] b = {{1.0, 2.0}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, b)); } @Test void testEmptyMatrices() { double[][] a = new double[0][0]; double[][] b = new double[0][0]; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, b)); } private void assertMatrixEquals(double[][] expected, double[][] actual) { From 1858c69ebd220ba477a6c9f85bcf85549b189db7 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 17:20:44 +0530 Subject: [PATCH 17/24] Updated files with google-java-format --- .../matrix/MatrixMultiplication.java | 77 +++++----- .../matrix/MatrixMultiplicationTest.java | 145 +++++++++--------- 2 files changed, 109 insertions(+), 113 deletions(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index d6067012eb33..93b9030b83d7 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -1,51 +1,50 @@ package com.thealgorithms.matrix; public final class MatrixMultiplication { - private MatrixMultiplication() { - } + private MatrixMultiplication() {} - /** - * Multiplies two matrices. - * - * @param matrixA the first matrix rowsA x colsA - * @param matrixB the second matrix rowsB x colsB - * @return the product of the two matrices rowsA x colsB - * @throws IllegalArgumentException if the matrices cannot be multiplied - */ - public static double[][] multiply(double[][] matrixA, double[][] matrixB) { - // Check the input matrices are not null - if (matrixA == null || matrixB == null) { - throw new IllegalArgumentException("Input matrices cannot be null"); - } + /** + * Multiplies two matrices. + * + * @param matrixA the first matrix rowsA x colsA + * @param matrixB the second matrix rowsB x colsB + * @return the product of the two matrices rowsA x colsB + * @throws IllegalArgumentException if the matrices cannot be multiplied + */ + public static double[][] multiply(double[][] matrixA, double[][] matrixB) { + // Check the input matrices are not null + if (matrixA == null || matrixB == null) { + throw new IllegalArgumentException("Input matrices cannot be null"); + } - // Check for empty matrices - if (matrixA.length == 0 - || matrixB.length == 0 - || matrixA[0].length == 0 - || matrixB[0].length == 0) { - throw new IllegalArgumentException("Input matrices must not be empty"); - } + // Check for empty matrices + if (matrixA.length == 0 + || matrixB.length == 0 + || matrixA[0].length == 0 + || matrixB[0].length == 0) { + throw new IllegalArgumentException("Input matrices must not be empty"); + } - // Validate the matrix dimensions - if (matrixA[0].length != matrixB.length) { - throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); - } + // Validate the matrix dimensions + if (matrixA[0].length != matrixB.length) { + throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); + } - int rowsA = matrixA.length; - int colsA = matrixA[0].length; - int colsB = matrixB[0].length; + int rowsA = matrixA.length; + int colsA = matrixA[0].length; + int colsB = matrixB[0].length; - // Initialize the result matrix with zeros - double[][] result = new double[rowsA][colsB]; + // Initialize the result matrix with zeros + double[][] result = new double[rowsA][colsB]; - // Perform matrix multiplication - for (int i = 0; i < rowsA; i++) { - for (int j = 0; j < colsB; j++) { - for (int k = 0; k < colsA; k++) { - result[i][j] += matrixA[i][k] * matrixB[k][j]; - } - } + // Perform matrix multiplication + for (int i = 0; i < rowsA; i++) { + for (int j = 0; j < colsB; j++) { + for (int k = 0; k < colsA; k++) { + result[i][j] += matrixA[i][k] * matrixB[k][j]; } - return result; + } } + return result; + } } diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 1288c3814c42..7c754eef5df0 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -7,79 +7,76 @@ public class MatrixMultiplicationTest { - private static final double EPSILON = 1e-9; // for floating point comparison - - @Test - void testMultiply2by2() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; - double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}}; - double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; - - double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); // Use custom method due to floating point issues - } - - @Test - void testMultiply3by2and2by1() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}}; - double[][] matrixB = {{7.0}, {8.0}}; - double[][] expected = {{23.0}, {53.0}, {83.0}}; - - double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); - } - - @Test - void testNullMatrixA() { - double[][] b = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(null, b)); - } - - @Test - void testNullMatrixB() { - double[][] a = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, null)); - } - - @Test - void testMultiplyNull() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; - double[][] matrixB = null; - - Exception exception = assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(matrixA, matrixB)); - - String expectedMessage = "Input matrices cannot be null"; - String actualMessage = exception.getMessage(); - - assertTrue(actualMessage.contains(expectedMessage)); - } - - @Test - void testIncompatibleDimensions() { - double[][] a = {{1.0, 2.0}}; - double[][] b = {{1.0, 2.0}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, b)); - } - - @Test - void testEmptyMatrices() { - double[][] a = new double[0][0]; - double[][] b = new double[0][0]; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, b)); - } - - private void assertMatrixEquals(double[][] expected, double[][] actual) { - assertEquals(expected.length, actual.length, "Row count mismatch"); - for (int i = 0; i < expected.length; i++) { - assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); - for (int j = 0; j < expected[i].length; j++) { - assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")"); - } - } + private static final double EPSILON = 1e-9; // for floating point comparison + + @Test + void testMultiply2by2() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; + double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}}; + double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); // Use custom method due to floating point issues + } + + @Test + void testMultiply3by2and2by1() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}}; + double[][] matrixB = {{7.0}, {8.0}}; + double[][] expected = {{23.0}, {53.0}, {83.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); + } + + @Test + void testNullMatrixA() { + double[][] b = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b)); + } + + @Test + void testNullMatrixB() { + double[][] a = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null)); + } + + @Test + void testMultiplyNull() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; + double[][] matrixB = null; + + Exception exception = + assertThrows( + IllegalArgumentException.class, () -> MatrixMultiplication.multiply(matrixA, matrixB)); + + String expectedMessage = "Input matrices cannot be null"; + String actualMessage = exception.getMessage(); + + assertTrue(actualMessage.contains(expectedMessage)); + } + + @Test + void testIncompatibleDimensions() { + double[][] a = {{1.0, 2.0}}; + double[][] b = {{1.0, 2.0}}; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); + } + + @Test + void testEmptyMatrices() { + double[][] a = new double[0][0]; + double[][] b = new double[0][0]; + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); + } + + private void assertMatrixEquals(double[][] expected, double[][] actual) { + assertEquals(expected.length, actual.length, "Row count mismatch"); + for (int i = 0; i < expected.length; i++) { + assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); + for (int j = 0; j < expected[i].length; j++) { + assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")"); + } } + } } From 56baf841ef1333689d72e15a4ed4fed385bba01f Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 17:23:02 +0530 Subject: [PATCH 18/24] Updated files --- .../matrix/MatrixMultiplication.java | 77 +++++----- .../matrix/MatrixMultiplicationTest.java | 145 +++++++++--------- 2 files changed, 113 insertions(+), 109 deletions(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index 93b9030b83d7..d6067012eb33 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -1,50 +1,51 @@ package com.thealgorithms.matrix; public final class MatrixMultiplication { - private MatrixMultiplication() {} - - /** - * Multiplies two matrices. - * - * @param matrixA the first matrix rowsA x colsA - * @param matrixB the second matrix rowsB x colsB - * @return the product of the two matrices rowsA x colsB - * @throws IllegalArgumentException if the matrices cannot be multiplied - */ - public static double[][] multiply(double[][] matrixA, double[][] matrixB) { - // Check the input matrices are not null - if (matrixA == null || matrixB == null) { - throw new IllegalArgumentException("Input matrices cannot be null"); + private MatrixMultiplication() { } - // Check for empty matrices - if (matrixA.length == 0 - || matrixB.length == 0 - || matrixA[0].length == 0 - || matrixB[0].length == 0) { - throw new IllegalArgumentException("Input matrices must not be empty"); - } + /** + * Multiplies two matrices. + * + * @param matrixA the first matrix rowsA x colsA + * @param matrixB the second matrix rowsB x colsB + * @return the product of the two matrices rowsA x colsB + * @throws IllegalArgumentException if the matrices cannot be multiplied + */ + public static double[][] multiply(double[][] matrixA, double[][] matrixB) { + // Check the input matrices are not null + if (matrixA == null || matrixB == null) { + throw new IllegalArgumentException("Input matrices cannot be null"); + } - // Validate the matrix dimensions - if (matrixA[0].length != matrixB.length) { - throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); - } + // Check for empty matrices + if (matrixA.length == 0 + || matrixB.length == 0 + || matrixA[0].length == 0 + || matrixB[0].length == 0) { + throw new IllegalArgumentException("Input matrices must not be empty"); + } + + // Validate the matrix dimensions + if (matrixA[0].length != matrixB.length) { + throw new IllegalArgumentException("Matrices cannot be multiplied: incompatible dimensions."); + } - int rowsA = matrixA.length; - int colsA = matrixA[0].length; - int colsB = matrixB[0].length; + int rowsA = matrixA.length; + int colsA = matrixA[0].length; + int colsB = matrixB[0].length; - // Initialize the result matrix with zeros - double[][] result = new double[rowsA][colsB]; + // Initialize the result matrix with zeros + double[][] result = new double[rowsA][colsB]; - // Perform matrix multiplication - for (int i = 0; i < rowsA; i++) { - for (int j = 0; j < colsB; j++) { - for (int k = 0; k < colsA; k++) { - result[i][j] += matrixA[i][k] * matrixB[k][j]; + // Perform matrix multiplication + for (int i = 0; i < rowsA; i++) { + for (int j = 0; j < colsB; j++) { + for (int k = 0; k < colsA; k++) { + result[i][j] += matrixA[i][k] * matrixB[k][j]; + } + } } - } + return result; } - return result; - } } diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 7c754eef5df0..1288c3814c42 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -7,76 +7,79 @@ public class MatrixMultiplicationTest { - private static final double EPSILON = 1e-9; // for floating point comparison - - @Test - void testMultiply2by2() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; - double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}}; - double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; - - double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); // Use custom method due to floating point issues - } - - @Test - void testMultiply3by2and2by1() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}}; - double[][] matrixB = {{7.0}, {8.0}}; - double[][] expected = {{23.0}, {53.0}, {83.0}}; - - double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); - assertMatrixEquals(expected, result); - } - - @Test - void testNullMatrixA() { - double[][] b = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b)); - } - - @Test - void testNullMatrixB() { - double[][] a = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null)); - } - - @Test - void testMultiplyNull() { - double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; - double[][] matrixB = null; - - Exception exception = - assertThrows( - IllegalArgumentException.class, () -> MatrixMultiplication.multiply(matrixA, matrixB)); - - String expectedMessage = "Input matrices cannot be null"; - String actualMessage = exception.getMessage(); - - assertTrue(actualMessage.contains(expectedMessage)); - } - - @Test - void testIncompatibleDimensions() { - double[][] a = {{1.0, 2.0}}; - double[][] b = {{1.0, 2.0}}; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); - } - - @Test - void testEmptyMatrices() { - double[][] a = new double[0][0]; - double[][] b = new double[0][0]; - assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); - } - - private void assertMatrixEquals(double[][] expected, double[][] actual) { - assertEquals(expected.length, actual.length, "Row count mismatch"); - for (int i = 0; i < expected.length; i++) { - assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); - for (int j = 0; j < expected[i].length; j++) { - assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")"); - } + private static final double EPSILON = 1e-9; // for floating point comparison + + @Test + void testMultiply2by2() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; + double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}}; + double[][] expected = {{19.0, 22.0}, {43.0, 50.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); // Use custom method due to floating point issues + } + + @Test + void testMultiply3by2and2by1() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}}; + double[][] matrixB = {{7.0}, {8.0}}; + double[][] expected = {{23.0}, {53.0}, {83.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); + } + + @Test + void testNullMatrixA() { + double[][] b = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(null, b)); + } + + @Test + void testNullMatrixB() { + double[][] a = {{1, 2}, {3, 4}}; + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, null)); + } + + @Test + void testMultiplyNull() { + double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; + double[][] matrixB = null; + + Exception exception = assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(matrixA, matrixB)); + + String expectedMessage = "Input matrices cannot be null"; + String actualMessage = exception.getMessage(); + + assertTrue(actualMessage.contains(expectedMessage)); + } + + @Test + void testIncompatibleDimensions() { + double[][] a = {{1.0, 2.0}}; + double[][] b = {{1.0, 2.0}}; + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, b)); + } + + @Test + void testEmptyMatrices() { + double[][] a = new double[0][0]; + double[][] b = new double[0][0]; + assertThrows(IllegalArgumentException.class, + () -> MatrixMultiplication.multiply(a, b)); + } + + private void assertMatrixEquals(double[][] expected, double[][] actual) { + assertEquals(expected.length, actual.length, "Row count mismatch"); + for (int i = 0; i < expected.length; i++) { + assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i); + for (int j = 0; j < expected[i].length; j++) { + assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")"); + } + } } - } } From ca40a2b1d2e1d8e0a120d74889aeec34a8c27c7c Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 17:52:33 +0530 Subject: [PATCH 19/24] Updated files --- .../matrix/MatrixMultiplication.java | 7 ++----- .../matrix/MatrixMultiplicationTest.java | 21 ++++++++----------- 2 files changed, 11 insertions(+), 17 deletions(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index d6067012eb33..6fd08484ce7b 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -19,12 +19,9 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { } // Check for empty matrices - if (matrixA.length == 0 - || matrixB.length == 0 - || matrixA[0].length == 0 - || matrixB[0].length == 0) { + if (matrixA.length == 0 || matrixB.length == 0 || matrixA[0].length == 0 || matrixB[0].length == 0) { throw new IllegalArgumentException("Input matrices must not be empty"); - } + } // Validate the matrix dimensions if (matrixA[0].length != matrixB.length) { diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 1288c3814c42..bd3dc3a64150 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -1,10 +1,12 @@ package com.thealgorithms.matrix; -import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; + + public class MatrixMultiplicationTest { private static final double EPSILON = 1e-9; // for floating point comparison @@ -32,15 +34,13 @@ void testMultiply3by2and2by1() { @Test void testNullMatrixA() { double[][] b = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(null, b)); + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b)); } @Test void testNullMatrixB() { double[][] a = {{1, 2}, {3, 4}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, null)); + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null)); } @Test @@ -48,8 +48,7 @@ void testMultiplyNull() { double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; double[][] matrixB = null; - Exception exception = assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(matrixA, matrixB)); + Exception exception = assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(matrixA, matrixB)); String expectedMessage = "Input matrices cannot be null"; String actualMessage = exception.getMessage(); @@ -61,16 +60,14 @@ void testMultiplyNull() { void testIncompatibleDimensions() { double[][] a = {{1.0, 2.0}}; double[][] b = {{1.0, 2.0}}; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, b)); + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); } @Test void testEmptyMatrices() { double[][] a = new double[0][0]; double[][] b = new double[0][0]; - assertThrows(IllegalArgumentException.class, - () -> MatrixMultiplication.multiply(a, b)); + assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b)); } private void assertMatrixEquals(double[][] expected, double[][] actual) { From d633a3eb4b6f75f311f43a2395ca1b6c4fcd79ff Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 17:56:41 +0530 Subject: [PATCH 20/24] Updated files --- .../java/com/thealgorithms/matrix/MatrixMultiplication.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index 6fd08484ce7b..bd3f111efa88 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -21,7 +21,7 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) { // Check for empty matrices if (matrixA.length == 0 || matrixB.length == 0 || matrixA[0].length == 0 || matrixB[0].length == 0) { throw new IllegalArgumentException("Input matrices must not be empty"); - } + } // Validate the matrix dimensions if (matrixA[0].length != matrixB.length) { From 4257686415e395e56c4aad7065332903eb501abd Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 17:58:55 +0530 Subject: [PATCH 21/24] Updated files --- .../java/com/thealgorithms/matrix/MatrixMultiplicationTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index bd3dc3a64150..f6192d7f3d63 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -6,7 +6,6 @@ import org.junit.jupiter.api.Test; - public class MatrixMultiplicationTest { private static final double EPSILON = 1e-9; // for floating point comparison From dcec0543f8f6aacf23cf09cc1cd6010846340f0d Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 20:30:57 +0530 Subject: [PATCH 22/24] Add reference links and complexities --- .../matrix/MatrixMultiplication.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java index bd3f111efa88..6467a438577b 100644 --- a/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java +++ b/src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java @@ -1,5 +1,26 @@ package com.thealgorithms.matrix; +/** + * This class provides a method to perform matrix multiplication. + * + *

Matrix multiplication takes two 2D arrays (matrices) as input and + * produces their product, following the mathematical definition of + * matrix multiplication. + * + *

For more details: + * https://www.geeksforgeeks.org/java/java-program-to-multiply-two-matrices-of-any-size/ + * https://en.wikipedia.org/wiki/Matrix_multiplication + * + *

Time Complexity: O(n^3) – where n is the dimension of the matrices + * (assuming square matrices for simplicity). + * + *

Space Complexity: O(n^2) – for storing the result matrix. + * + * + * @author Nishitha Wihala Pitigala + * + */ + public final class MatrixMultiplication { private MatrixMultiplication() { } From c243140027901e7552da05bc78b1d81360fe2b29 Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 20:33:19 +0530 Subject: [PATCH 23/24] Add test cases for 1by1 matrix and non-rectangular matrix --- .../matrix/MatrixMultiplicationTest.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index f6192d7f3d63..8acccc391a1c 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -10,6 +10,16 @@ public class MatrixMultiplicationTest { private static final double EPSILON = 1e-9; // for floating point comparison + @Test + void testMultiply1by1(){ + double[][] matrixA = {{1.0}}; + double[][] matrixB = {{2.0}}; + double[][] expected = {{2.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); + } + @Test void testMultiply2by2() { double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}}; @@ -30,6 +40,16 @@ void testMultiply3by2and2by1() { assertMatrixEquals(expected, result); } + @Test + void testMultiplyNonRectangularMatrices() { + double[][] matrixA = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}}; + double[][] matrixB = {{7.0, 8.0}, {9.0, 10.0}, {11.0, 12.0}}; + double[][] expected = {{58.0, 64.0}, {139.0, 154.0}}; + + double[][] result = MatrixMultiplication.multiply(matrixA, matrixB); + assertMatrixEquals(expected, result); + } + @Test void testNullMatrixA() { double[][] b = {{1, 2}, {3, 4}}; From 49d7f984b72149bc203f95ff2969d32ef5e7734e Mon Sep 17 00:00:00 2001 From: Nishitha0730 Date: Sat, 19 Jul 2025 20:39:36 +0530 Subject: [PATCH 24/24] Add reference links and complexities --- .../java/com/thealgorithms/matrix/MatrixMultiplicationTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java index 8acccc391a1c..9463d33a18cb 100644 --- a/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java +++ b/src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java @@ -11,7 +11,7 @@ public class MatrixMultiplicationTest { private static final double EPSILON = 1e-9; // for floating point comparison @Test - void testMultiply1by1(){ + void testMultiply1by1() { double[][] matrixA = {{1.0}}; double[][] matrixB = {{2.0}}; double[][] expected = {{2.0}};