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}}; pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy