From 69ffed748e53a643695f5d5c451794aea58847c2 Mon Sep 17 00:00:00 2001 From: mnordste Date: Tue, 1 Mar 2022 17:25:15 +0100 Subject: [PATCH 01/27] Added Operations file to put or refactors in. --- src/com/jwetherell/algorithms/mathematics/Operations.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 src/com/jwetherell/algorithms/mathematics/Operations.java diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java new file mode 100644 index 00000000..d522c7c8 --- /dev/null +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -0,0 +1,5 @@ +package com.jwetherell.algorithms.mathematics; + +public class Operations{ + +} \ No newline at end of file From 670921b5764b535c779b000fda9649785e168c15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Wed, 2 Mar 2022 06:01:27 +0100 Subject: [PATCH 02/27] Fixed #95. test: Added branch coverage in function Matrix.add, for different matrix types (Long/Double/...) --- .gitignore | 1 + .../data_structures/test/MatrixTests.java | 108 ++++++++++++++++++ 2 files changed, 109 insertions(+) diff --git a/.gitignore b/.gitignore index 23842834..45736ff0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /bin/ /build/ /dist/ +output.txt \ No newline at end of file diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index ca0014bf..0c680d88 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -1,6 +1,11 @@ package com.jwetherell.algorithms.data_structures.test; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Comparator; + import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; import static org.junit.Assert.assertArrayEquals; import org.junit.Test; @@ -111,4 +116,107 @@ public void testIdentityMethod1() { assertArrayEquals(expectedResult.getRow(0), matrix.getRow(0)); assertArrayEquals(expectedResult.getRow(1), matrix.getRow(1)); } + + @Test + public void testAddLong() { + Matrix matrix = new Matrix(2, 2); + matrix.set(0, 0, Long.valueOf(1)); + matrix.set(0, 1, Long.valueOf(2)); + matrix.set(1, 0, Long.valueOf(3)); + matrix.set(1, 1, Long.valueOf(4)); + + Matrix actualResult = matrix.add(matrix); + + Matrix expectedResult = new Matrix(2, 2); + expectedResult.set(0, 0, Long.valueOf(2)); + expectedResult.set(0, 1, Long.valueOf(4)); + expectedResult.set(1, 0, Long.valueOf(6)); + expectedResult.set(1, 1, Long.valueOf(8)); + + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); + assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); + } + + @Test + public void testAddBigInteger() { + Matrix matrix = new Matrix(2, 2); + matrix.set(0, 0, BigInteger.valueOf(1)); + matrix.set(0, 1, BigInteger.valueOf(2)); + matrix.set(1, 0, BigInteger.valueOf(3)); + matrix.set(1, 1, BigInteger.valueOf(4)); + + Matrix actualResult = matrix.add(matrix); + + Matrix expectedResult = new Matrix(2, 2); + expectedResult.set(0, 0, BigInteger.valueOf(2)); + expectedResult.set(0, 1, BigInteger.valueOf(4)); + expectedResult.set(1, 0, BigInteger.valueOf(6)); + expectedResult.set(1, 1, BigInteger.valueOf(8)); + + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); + assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); + } + + @Test + public void testAddFloat() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new Float(1.1)); + + Matrix actual = matrix.add(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Float(2.2)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Float(2.1)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Float(2.3)); + + assertTrue(Float.compare(actual.get(0, 0), expected.get(0, 0)) == 0); + assertTrue(Float.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Float.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + + @Test + public void testAddDouble() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new Double(1.1)); + + Matrix actual = matrix.add(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Double(2.2)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Double(2.1)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Double(2.3)); + + assertTrue(Double.compare(actual.get(0, 0), expected.get(0, 0)) == 0); + assertTrue(Double.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Double.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + + @Test + public void testAddBigDecimal() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new BigDecimal(1.1)); + + Matrix actual = matrix.add(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new BigDecimal(2.2)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new BigDecimal(2.1)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new BigDecimal(2.3)); + + assertTrue(actual.get(0, 0).compareTo(expected.get(0, 0)) == 0); + assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); + assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); + } } From b656c9424ed7329b937935fa6e3c2a1f90d5a71a Mon Sep 17 00:00:00 2001 From: Beatrice Berg <72010841+reversedpeach@users.noreply.github.com> Date: Wed, 2 Mar 2022 20:18:14 +0100 Subject: [PATCH 03/27] Fixed #97. test: Added branch coverage tests for all TODO-functions in FenwickTree.java (#102) --- .../test/FenwickTreeTests.java | 273 ++++++++++++++++++ 1 file changed, 273 insertions(+) diff --git a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java index e635398b..02de1474 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java @@ -1,5 +1,9 @@ package com.jwetherell.algorithms.data_structures.test; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Comparator; + import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; @@ -43,6 +47,7 @@ public void testRangeSumFenwickTree() { testRangeSumFenwickTree(segments); } + private void testRangeSumFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); @@ -136,4 +141,272 @@ private static final void assertTrue(String msg, Fe toString = "\n"+obj.toString(); Assert.assertTrue(msg+toString, isTrue); } + + // Requirement: + // When FenwickTree consists of data with BigDecimal numbers it should be able to sum them up correctly + @Test + public void testBigDecimalFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, (BigDecimal) new BigDecimal(1.1))); + segments.add(new FenwickTree.Data.RangeSumData(1, (BigDecimal) new BigDecimal(2.1))); + segments.add(new FenwickTree.Data.RangeSumData(2, (BigDecimal) new BigDecimal(6.1))); + segments.add(new FenwickTree.Data.RangeSumData(3, (BigDecimal) new BigDecimal(7.1))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testBigDecimalFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testBigDecimalFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testBigDecimalFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testBigDecimalFenwickTree(segments); + } + + private void testBigDecimalFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree.query(0, 3); + + query = tree.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new BigDecimal(6.1)) == 0); + + query = tree.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(new BigDecimal(1.1).add(new BigDecimal(2.1))) == 0); + } + + // Requirement: + // When FenwickTree consists of data with BigInteger numbers it should be able to sum them up correctly + @Test + public void testBigIntegerFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, (BigInteger) BigInteger.valueOf(1))); + segments.add(new FenwickTree.Data.RangeSumData(1, (BigInteger) BigInteger.valueOf(2))); + segments.add(new FenwickTree.Data.RangeSumData(2, (BigInteger) BigInteger.valueOf(6))); + segments.add(new FenwickTree.Data.RangeSumData(3, (BigInteger) BigInteger.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testBigIntegerFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testBigIntegerFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testBigIntegerFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testBigIntegerFenwickTree(segments); + } + + private void testBigIntegerFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree.query(0, 3); + + query = tree.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(6)) == 0); + + query = tree.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(BigInteger.valueOf(1).add(BigInteger.valueOf(2))) == 0); + } + + // Requirement: + // When FenwickTree consists of data with Long numbers it should be able to sum them up correctly + @Test + public void testLongFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, (Long) Long.valueOf(1))); + segments.add(new FenwickTree.Data.RangeSumData(1, (Long) Long.valueOf(2))); + segments.add(new FenwickTree.Data.RangeSumData(2, (Long) Long.valueOf(6))); + segments.add(new FenwickTree.Data.RangeSumData(3, (Long) Long.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testLongFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testLongFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testLongFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testLongFenwickTree(segments); + } + + private void testLongFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree.query(0, 3); + + query = tree.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(Long.valueOf(6)) == 0); + + query = tree.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(Long.sum(Long.valueOf(1), (Long.valueOf(2)))) == 0); + } + + // Requirement: + // When FenwickTree consists of data with Double numbers it should be able to sum them up correctly + @Test + public void testDoubleFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, (Double) new Double(1.11))); + segments.add(new FenwickTree.Data.RangeSumData(1, (Double) new Double(2.11))); + segments.add(new FenwickTree.Data.RangeSumData(2, (Double) new Double(6.11))); + segments.add(new FenwickTree.Data.RangeSumData(3, (Double) new Double(7.11))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testDoubleFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testDoubleFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testDoubleFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testDoubleFenwickTree(segments); + } + + private void testDoubleFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree.query(0, 3); + + query = tree.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new Double(6.11)) == 0); + + query = tree.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(Double.sum(new Double(1.11),(new Double(2.11)))) == 0); + } + + // Requirement: + // When FenwickTree consists of data with Float numbers it should be able to sum them up correctly + @Test + public void testFloatFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, (Float) new Float(1.11))); + segments.add(new FenwickTree.Data.RangeSumData(1, (Float) new Float(2.11))); + segments.add(new FenwickTree.Data.RangeSumData(2, (Float) new Float(6.11))); + segments.add(new FenwickTree.Data.RangeSumData(3, (Float) new Float(7.11))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testFloatFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testFloatFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testFloatFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testFloatFenwickTree(segments); + } + + private void testFloatFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree.query(0, 3); + + query = tree.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new Float(6.11)) == 0); + + query = tree.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(Float.sum(new Float(1.11),(new Float(2.11)))) == 0); + } + + + // Requirement: + // Added branch coverage for when an element is null when using the functions combined and separate for every case + // except the case in separate where "this.sum == null && data.sum != null" since it will not be possible to test as + // a separated number supposed to be null (this.sum) from a sum which is not null (data.sum) is equal to 0.0 and not null + // when separated + + @Test + public void testNullFenwickTree() { + List> segments = new ArrayList>(); + segments.add(new FenwickTree.Data.RangeSumData(0, null)); + segments.add(new FenwickTree.Data.RangeSumData(1, null)); + segments.add(new FenwickTree.Data.RangeSumData(2, new Float(6.11))); + segments.add(new FenwickTree.Data.RangeSumData(3, null)); + //segments.add(new FenwickTree.Data.RangeSumData(2, (Float) new Float(6.11))); + //segments.add(new FenwickTree.Data.RangeSumData(3, (Float) new Float(7.11))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testNullFenwickTree(segments); + + // Randomize it + Collections.shuffle(segments); + testNullFenwickTree(segments); + + // Try in order + Collections.sort(segments); + testNullFenwickTree(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testNullFenwickTree(segments); + } + + private void testNullFenwickTree(List> segments) { // Range Sum Segment tree + FenwickTree> tree1 = new FenwickTree>(segments); + + FenwickTree.Data.RangeSumData query = tree1.query(0, 3); + + query = tree1.query(1); + assertTrue("Segment tree query error. query=1 result="+query, tree1, query.sum == null); + + query = tree1.query(2); + assertTrue("Segment tree query error. query=2 result="+query, tree1, query.sum.compareTo(new Float(6.11)) == 0); + + query = tree1.query(3); + assertTrue("Segment tree query error. query=3 result="+query, tree1, query.sum == 0.0); + + query = tree1.query(0, 1); // stabbing + assertTrue("Segment tree query error. query=0->1 result="+ query, tree1, query.sum == null); + + query = tree1.query(0, 2); // stabbing + assertTrue("Segment tree query error. query=0->2 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); + + query = tree1.query(0, 3); // stabbing + assertTrue("Segment tree query error. query=0->3 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); + + query = tree1.query(2, 3); // stabbing + assertTrue("Segment tree query error. query=2->3 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); + + + } + + + + } From 002fa0e98364952ad2a7edebcf593873f68b3aa3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= <45148959+akerfel@users.noreply.github.com> Date: Thu, 3 Mar 2022 06:18:37 +0100 Subject: [PATCH 04/27] Fixed #103. test: Added branch coverage for Matrix.subtract, for different matrix types (Long/Double/...) (#106) --- .../data_structures/test/MatrixTests.java | 132 +++++++++++++++++- 1 file changed, 131 insertions(+), 1 deletion(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 0c680d88..6354ce28 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -219,4 +219,134 @@ public void testAddBigDecimal() { assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); } -} + + // Requirement: Matrix subtraction should work correctly with Long values. + @Test + public void testSubtractLong() { + Matrix matrix1 = new Matrix(2, 2); + matrix1.set(0, 0, Long.valueOf(1)); + matrix1.set(0, 1, Long.valueOf(2)); + matrix1.set(1, 0, Long.valueOf(3)); + matrix1.set(1, 1, Long.valueOf(4)); + + Matrix matrix2 = new Matrix(2, 2); + matrix2.set(0, 0, Long.valueOf(1*2)); + matrix2.set(0, 1, Long.valueOf(2*2)); + matrix2.set(1, 0, Long.valueOf(3*2)); + matrix2.set(1, 1, Long.valueOf(4*2)); + + Matrix actualResult = matrix1.subtract(matrix2); + + Matrix expectedResult = new Matrix(2, 2); + expectedResult.set(0, 0, Long.valueOf(-1)); + expectedResult.set(0, 1, Long.valueOf(-2)); + expectedResult.set(1, 0, Long.valueOf(-3)); + expectedResult.set(1, 1, Long.valueOf(-4)); + + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); + assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); + } + + // Requirement: Matrix subtraction should work correctly with BigInteger values. + @Test + public void testSubtractBigInteger() { + Matrix matrix1 = new Matrix(2, 2); + matrix1.set(0, 0, BigInteger.valueOf(1)); + matrix1.set(0, 1, BigInteger.valueOf(2)); + matrix1.set(1, 0, BigInteger.valueOf(3)); + matrix1.set(1, 1, BigInteger.valueOf(4)); + + Matrix matrix2 = new Matrix(2, 2); + matrix2.set(0, 0, BigInteger.valueOf(1*2)); + matrix2.set(0, 1, BigInteger.valueOf(2*2)); + matrix2.set(1, 0, BigInteger.valueOf(3*2)); + matrix2.set(1, 1, BigInteger.valueOf(4*2)); + + Matrix actualResult = matrix1.subtract(matrix2); + + Matrix expectedResult = new Matrix(2, 2); + expectedResult.set(0, 0, BigInteger.valueOf(-1)); + expectedResult.set(0, 1, BigInteger.valueOf(-2)); + expectedResult.set(1, 0, BigInteger.valueOf(-3)); + expectedResult.set(1, 1, BigInteger.valueOf(-4)); + + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); + assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); + } + + // Requirement: Matrix subtraction should work correctly with Float values. + @Test + public void testSubtractFloat() { + Matrix matrix1 = new Matrix(1, 1); + matrix1.set(0, 0, new Float(1.1)); + + Matrix matrix2 = new Matrix(1, 1); + matrix2.set(0, 0, new Float(1.1*2)); + + Matrix actual = matrix1.subtract(matrix2); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Float(-1.1)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Float(-1.05)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Float(1.15)); + + assertTrue(Math.abs(actual.get(0, 0) - expected.get(0, 0)) < 0.00001); + assertTrue(Float.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Float.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + + // Requirement: Matrix subtraction should work correctly with Double values. + @Test + public void testSubtractDouble() { + Matrix matrix1 = new Matrix(1, 1); + matrix1.set(0, 0, new Double(1.1)); + + Matrix matrix2 = new Matrix(1, 1); + matrix2.set(0, 0, new Double(1.1*2)); + + Matrix actual = matrix1.subtract(matrix2); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Double(-1.1)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Double(-1.05)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Double(1.15)); + + assertTrue(Math.abs(actual.get(0, 0) - expected.get(0, 0)) < 0.00001); + assertTrue(Double.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Double.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + + // Requirement: Matrix subtraction should work correctly with BigDecimal values. + @Test + public void testSubtractBigDecimal() { + Matrix matrix1 = new Matrix(1, 1); + matrix1.set(0, 0, new BigDecimal(1.1)); + + Matrix matrix2 = new Matrix(1, 1); + matrix2.set(0, 0, new BigDecimal(1.1*2)); + + Matrix actual = matrix1.subtract(matrix2); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new BigDecimal(-1.1)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new BigDecimal(-1.05)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new BigDecimal(1.15)); + + BigDecimal diff = actual.get(0, 0).subtract(expected.get(0, 0)).abs(); + assertTrue((diff.compareTo(new BigDecimal(0.00001)) < 0)); + assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); + assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); + } +} \ No newline at end of file From 0b4c224c36bc2cf5460eb2d9d3709494a6aef8f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= <45148959+akerfel@users.noreply.github.com> Date: Thu, 3 Mar 2022 06:22:46 +0100 Subject: [PATCH 05/27] Fixed #105. test: Added branch coverage for Matrix.multiply, for different matrix types (Long/Double/...) (#107) --- .../data_structures/test/MatrixTests.java | 252 +++++++++++++++++- 1 file changed, 250 insertions(+), 2 deletions(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 6354ce28..471f39fe 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -92,6 +92,166 @@ public void testMatrix() { Matrix matrix9 = matrix7.multiply(matrix8); assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); } + + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with Long values. + @Test + public void testMatrixLongOperations() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, Long.valueOf(14)); + matrix1.set(0, 1, Long.valueOf(9)); + matrix1.set(0, 2, Long.valueOf(3)); + matrix1.set(1, 0, Long.valueOf(2)); + matrix1.set(1, 1, Long.valueOf(11)); + matrix1.set(1, 2, Long.valueOf(15)); + matrix1.set(2, 0, Long.valueOf(0)); + matrix1.set(2, 1, Long.valueOf(12)); + matrix1.set(2, 2, Long.valueOf(17)); + matrix1.set(3, 0, Long.valueOf(5)); + matrix1.set(3, 1, Long.valueOf(2)); + matrix1.set(3, 2, Long.valueOf(3)); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, Long.valueOf(12)); + matrix2.set(0, 1, Long.valueOf(25)); + matrix2.set(1, 0, Long.valueOf(9)); + matrix2.set(1, 1, Long.valueOf(10)); + matrix2.set(2, 0, Long.valueOf(8)); + matrix2.set(2, 1, Long.valueOf(5)); + + // Result of multiplication + Long[][] array1 = new Long[][]{{Long.valueOf(273),Long.valueOf(455)}, + {Long.valueOf(243),Long.valueOf(235)}, + {Long.valueOf(244),Long.valueOf(205)}, + {Long.valueOf(102),Long.valueOf(160)}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, Long.valueOf(counter++)); + + // Result of subtraction + Long[][] array2 = new Long[][]{{Long.valueOf(0),Long.valueOf(0)}, + {Long.valueOf(0),Long.valueOf(0)}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + Long[][] array3 = new Long[][]{{Long.valueOf(0),Long.valueOf(2)}, + {Long.valueOf(4),Long.valueOf(6)}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, Long.valueOf(1)); + matrix7.set(0, 1, Long.valueOf(2)); + matrix7.set(1, 0, Long.valueOf(3)); + matrix7.set(1, 1, Long.valueOf(4)); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, Long.valueOf(1)); + matrix8.set(0, 1, Long.valueOf(2)); + matrix8.set(1, 0, Long.valueOf(3)); + matrix8.set(1, 1, Long.valueOf(4)); + + // Result of multiplication + Long[][] array4 = new Long[][]{{Long.valueOf(7),Long.valueOf(10)}, + {Long.valueOf(15),Long.valueOf(22)}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } + + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with BigInteger values. + @Test + public void testMatrixBigIntegerOperations() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, BigInteger.valueOf(14)); + matrix1.set(0, 1, BigInteger.valueOf(9)); + matrix1.set(0, 2, BigInteger.valueOf(3)); + matrix1.set(1, 0, BigInteger.valueOf(2)); + matrix1.set(1, 1, BigInteger.valueOf(11)); + matrix1.set(1, 2, BigInteger.valueOf(15)); + matrix1.set(2, 0, BigInteger.valueOf(0)); + matrix1.set(2, 1, BigInteger.valueOf(12)); + matrix1.set(2, 2, BigInteger.valueOf(17)); + matrix1.set(3, 0, BigInteger.valueOf(5)); + matrix1.set(3, 1, BigInteger.valueOf(2)); + matrix1.set(3, 2, BigInteger.valueOf(3)); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, BigInteger.valueOf(12)); + matrix2.set(0, 1, BigInteger.valueOf(25)); + matrix2.set(1, 0, BigInteger.valueOf(9)); + matrix2.set(1, 1, BigInteger.valueOf(10)); + matrix2.set(2, 0, BigInteger.valueOf(8)); + matrix2.set(2, 1, BigInteger.valueOf(5)); + + // Result of multiplication + BigInteger[][] array1 = new BigInteger[][]{{BigInteger.valueOf(273),BigInteger.valueOf(455)}, + {BigInteger.valueOf(243),BigInteger.valueOf(235)}, + {BigInteger.valueOf(244),BigInteger.valueOf(205)}, + {BigInteger.valueOf(102),BigInteger.valueOf(160)}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, BigInteger.valueOf(counter++)); + + // Result of subtraction + BigInteger[][] array2 = new BigInteger[][]{{BigInteger.valueOf(0),BigInteger.valueOf(0)}, + {BigInteger.valueOf(0),BigInteger.valueOf(0)}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + BigInteger[][] array3 = new BigInteger[][]{{BigInteger.valueOf(0),BigInteger.valueOf(2)}, + {BigInteger.valueOf(4),BigInteger.valueOf(6)}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, BigInteger.valueOf(1)); + matrix7.set(0, 1, BigInteger.valueOf(2)); + matrix7.set(1, 0, BigInteger.valueOf(3)); + matrix7.set(1, 1, BigInteger.valueOf(4)); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, BigInteger.valueOf(1)); + matrix8.set(0, 1, BigInteger.valueOf(2)); + matrix8.set(1, 0, BigInteger.valueOf(3)); + matrix8.set(1, 1, BigInteger.valueOf(4)); + + // Result of multiplication + BigInteger[][] array4 = new BigInteger[][]{{BigInteger.valueOf(7),BigInteger.valueOf(10)}, + {BigInteger.valueOf(15),BigInteger.valueOf(22)}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } @Test public void testIdentityMethod1() { @@ -117,6 +277,7 @@ public void testIdentityMethod1() { assertArrayEquals(expectedResult.getRow(1), matrix.getRow(1)); } + // Requirement: Matrix addition should work correctly with Long values. @Test public void testAddLong() { Matrix matrix = new Matrix(2, 2); @@ -137,6 +298,7 @@ public void testAddLong() { assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } + // Requirement: Matrix addition should work correctly with BigInteger values. @Test public void testAddBigInteger() { Matrix matrix = new Matrix(2, 2); @@ -157,6 +319,7 @@ public void testAddBigInteger() { assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } + // Requirement: Matrix addition should work correctly with Float values. @Test public void testAddFloat() { Matrix matrix = new Matrix(1, 1); @@ -178,6 +341,7 @@ public void testAddFloat() { assertTrue(Float.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); } + // Requirement: Matrix addition should work correctly with Double values. @Test public void testAddDouble() { Matrix matrix = new Matrix(1, 1); @@ -199,6 +363,7 @@ public void testAddDouble() { assertTrue(Double.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); } + // Requirement: Matrix addition should work correctly with BigDecimal values. @Test public void testAddBigDecimal() { Matrix matrix = new Matrix(1, 1); @@ -215,7 +380,8 @@ public void testAddBigDecimal() { Matrix wrong2 = new Matrix(1, 1); wrong2.set(0, 0, new BigDecimal(2.3)); - assertTrue(actual.get(0, 0).compareTo(expected.get(0, 0)) == 0); + BigDecimal diff = actual.get(0, 0).subtract(expected.get(0, 0)).abs(); + assertTrue((diff.compareTo(new BigDecimal(0.00001)) < 0)); assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); } @@ -349,4 +515,86 @@ public void testSubtractBigDecimal() { assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); } -} \ No newline at end of file + + // Requirement: Matrix multiplication should work correctly with Long values. + @Test + public void testMultiplyLong() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new Long(2)); + + Matrix actual = matrix.multiply(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Long(4)); + + Matrix wrong = new Matrix(1, 1); + wrong.set(0, 0, new Long(3)); + + assertTrue(Long.compare(actual.get(0, 0), expected.get(0, 0)) == 0); + assertTrue(Long.compare(actual.get(0, 0), wrong.get(0, 0)) != 0); + } + + // Requirement: Matrix multiplication should work correctly with BigInteger values. + @Test + public void testMultiplyBigInteger() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, BigInteger.valueOf(2)); + + Matrix actual = matrix.multiply(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, BigInteger.valueOf(4)); + + Matrix wrong = new Matrix(1, 1); + wrong.set(0, 0, BigInteger.valueOf(3)); + + assertTrue(actual.get(0, 0).compareTo(expected.get(0, 0)) == 0); + assertTrue(actual.get(0, 0).compareTo(wrong.get(0, 0)) != 0); + } + + // Requirement: Matrix multiplication should work correctly with Float values + @Test + public void testMultiplyFloat() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new Float(1.1)); + + Matrix actual = matrix.multiply(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Float(1.21)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Float(1.2)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Float(1.22)); + + assertTrue(Math.abs(actual.get(0, 0) - expected.get(0, 0)) < 0.00001); + assertTrue(Float.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Float.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + + // Requirement: Matrix multiplication should work correctly with BigDecimal values + @Test + public void testMultiplyBigDecimal() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new BigDecimal(1.1)); + + Matrix actual = matrix.multiply(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new BigDecimal(1.21)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new BigDecimal(1.2)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new BigDecimal(1.22)); + + BigDecimal diff = actual.get(0, 0).subtract(expected.get(0, 0)).abs(); + assertTrue((diff.compareTo(new BigDecimal(0.00001)) < 0)); + assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); + assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); + } + +} From d61840818297c3865d2c48ba82a6083f0e4bdb8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Thu, 3 Mar 2022 06:27:58 +0100 Subject: [PATCH 06/27] Fixed #108. Refactor: Removedunneeded imports from MatrixTests.java --- .../algorithms/data_structures/test/MatrixTests.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 471f39fe..27ffcd8c 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -2,10 +2,8 @@ import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Comparator; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; import static org.junit.Assert.assertArrayEquals; import org.junit.Test; @@ -596,5 +594,4 @@ public void testMultiplyBigDecimal() { assertTrue(actual.get(0, 0).compareTo(wrong1.get(0, 0)) != 0); assertTrue(actual.get(0, 0).compareTo(wrong2.get(0, 0)) != 0); } - } From a2d712407c0968f76a74e428b796dedf8e04469c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Thu, 3 Mar 2022 06:34:01 +0100 Subject: [PATCH 07/27] Fixed #109. test: Added branch coverage for Matrix.multiply, for Double matrix types --- .../data_structures/test/MatrixTests.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 27ffcd8c..11c4a04f 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -572,6 +572,28 @@ public void testMultiplyFloat() { assertTrue(Float.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); } + // Requirement: Matrix multiplication should work correctly with Double values + @Test + public void testMultiplyDouble() { + Matrix matrix = new Matrix(1, 1); + matrix.set(0, 0, new Double(1.1)); + + Matrix actual = matrix.multiply(matrix); + + Matrix expected = new Matrix(1, 1); + expected.set(0, 0, new Double(1.21)); + + Matrix wrong1 = new Matrix(1, 1); + wrong1.set(0, 0, new Double(1.2)); + + Matrix wrong2 = new Matrix(1, 1); + wrong2.set(0, 0, new Double(1.22)); + + assertTrue(Math.abs(actual.get(0, 0) - expected.get(0, 0)) < 0.00001); + assertTrue(Double.compare(actual.get(0, 0), wrong1.get(0, 0)) != 0); + assertTrue(Double.compare(actual.get(0, 0), wrong2.get(0, 0)) != 0); + } + // Requirement: Matrix multiplication should work correctly with BigDecimal values @Test public void testMultiplyBigDecimal() { From 6d0a6e69784b5d3ef13c933acb4fb2d8cd2fc9f1 Mon Sep 17 00:00:00 2001 From: Beatrice Berg <72010841+reversedpeach@users.noreply.github.com> Date: Thu, 3 Mar 2022 17:49:13 +0100 Subject: [PATCH 08/27] Fixed #100. feat: Added function rowMultiplication for different Number types to Operations.java (#110) --- .../algorithms/data_structures/Matrix.java | 67 ++----------------- .../algorithms/mathematics/Operations.java | 65 +++++++++++++++++- 2 files changed, 68 insertions(+), 64 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 0d814e18..6e5f16d7 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -4,6 +4,8 @@ import java.math.BigInteger; import java.util.Comparator; +import com.jwetherell.algorithms.mathematics.Operations; + /** * Matrx. This Matrix implementation is designed to be more efficient * in cache. A matrix is a rectangular array of numbers, symbols, or expressions. @@ -243,69 +245,7 @@ public Matrix multiply(Matrix input) { T[] row = getRow(r); T[] column = input.getColumn(c); T test = row[0]; - /* TODO: This is ugly and how to handle number overflow? */ - if (test instanceof BigDecimal) { - BigDecimal result = BigDecimal.ZERO; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - BigDecimal result2 = ((BigDecimal)m1).multiply(((BigDecimal)m2)); - result = result.add(result2); - } - output.set(r, c, (T)result); - } else if (test instanceof BigInteger) { - BigInteger result = BigInteger.ZERO; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - BigInteger result2 = ((BigInteger)m1).multiply(((BigInteger)m2)); - result = result.add(result2); - } - output.set(r, c, (T)result); - } else if (test instanceof Long) { - Long result = 0l; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - Long result2 = m1.longValue() * m2.longValue(); - result = result+result2; - } - output.set(r, c, (T)result); - } else if (test instanceof Double) { - Double result = 0d; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - Double result2 = m1.doubleValue() * m2.doubleValue(); - result = result+result2; - } - output.set(r, c, (T)result); - } else if (test instanceof Float) { - Float result = 0f; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - Float result2 = m1.floatValue() * m2.floatValue(); - result = result+result2; - } - output.set(r, c, (T)result); - } else { - // Integer - Integer result = 0; - for (int i = 0; i < cols; i++) { - T m1 = row[i]; - T m2 = column[i]; - - Integer result2 = m1.intValue() * m2.intValue(); - result = result+result2; - } - output.set(r, c, (T)result); - } + output.set(r, c, (T) Operations.rowMultiplication(test, row, column, cols)); } } return output; @@ -318,6 +258,7 @@ public void copy(Matrix m) { } } } + /** * {@inheritDoc} diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index d522c7c8..ebc8f390 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -1,5 +1,68 @@ package com.jwetherell.algorithms.mathematics; -public class Operations{ +import java.math.BigDecimal; +import java.math.BigInteger; +public class Operations { + + /* TODO: How to handle number overflow? */ + public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ + if (test instanceof BigDecimal) { + BigDecimal result = BigDecimal.ZERO; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + BigDecimal result2 = ((BigDecimal)m1).multiply(((BigDecimal)m2)); + result = result.add(result2); + } + return result; + } else if (test instanceof BigInteger) { + BigInteger result = BigInteger.ZERO; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + BigInteger result2 = ((BigInteger)m1).multiply(((BigInteger)m2)); + result = result.add(result2); + } + return result; + } else if (test instanceof Long) { + Long result = 0l; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + Long result2 = m1.longValue() * m2.longValue(); + result = result+result2; + } + return result; + } else if (test instanceof Double) { + Double result = 0d; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + Double result2 = m1.doubleValue() * m2.doubleValue(); + result = result+result2; + } + return result; + } else if (test instanceof Float) { + Float result = 0f; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + Float result2 = m1.floatValue() * m2.floatValue(); + result = result+result2; + } + return result; + } else { + // Integer + Integer result = 0; + for (int i = 0; i < cols; i++) { + Number m1 = row[i]; + Number m2 = column[i]; + Integer result2 = m1.intValue() * m2.intValue(); + result = result+result2; + } + return result; + } + } + } \ No newline at end of file From 4de254a88a0314deeaec71e31b71c9bf864eeb07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= <45148959+akerfel@users.noreply.github.com> Date: Fri, 4 Mar 2022 02:02:27 +0100 Subject: [PATCH 09/27] Fixed #99. feat: Made function which subtracts different Number types. (#113) --- .../data_structures/FenwickTree.java | 24 +++---------------- .../algorithms/data_structures/Matrix.java | 24 +------------------ .../data_structures/SegmentTree.java | 24 +++---------------- .../algorithms/mathematics/Operations.java | 19 ++++++++++++++- 4 files changed, 25 insertions(+), 66 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/FenwickTree.java b/src/com/jwetherell/algorithms/data_structures/FenwickTree.java index 60634d40..2c807c14 100644 --- a/src/com/jwetherell/algorithms/data_structures/FenwickTree.java +++ b/src/com/jwetherell/algorithms/data_structures/FenwickTree.java @@ -5,6 +5,8 @@ import java.util.ArrayList; import java.util.List; +import com.jwetherell.algorithms.mathematics.Operations; + /** * A Fenwick tree or binary indexed tree is a data structure providing efficient methods * for calculation and manipulation of the prefix sums of a table of values. Fenwick trees @@ -303,27 +305,7 @@ else if (this.sum != null && data.sum == null) else if (this.sum == null && data.sum != null) this.sum = data.sum; else { - /* TODO: This is ugly and how to handle number overflow? */ - if (this.sum instanceof BigDecimal || data.sum instanceof BigDecimal) { - BigDecimal result = ((BigDecimal)this.sum).add((BigDecimal)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof BigInteger || data.sum instanceof BigInteger) { - BigInteger result = ((BigInteger)this.sum).add((BigInteger)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof Long || data.sum instanceof Long) { - Long result = (this.sum.longValue() + data.sum.longValue()); - this.sum = (N)result; - } else if (this.sum instanceof Double || data.sum instanceof Double) { - Double result = (this.sum.doubleValue() + data.sum.doubleValue()); - this.sum = (N)result; - } else if (this.sum instanceof Float || data.sum instanceof Float) { - Float result = (this.sum.floatValue() + data.sum.floatValue()); - this.sum = (N)result; - } else { - // Integer - Integer result = (this.sum.intValue() + data.sum.intValue()); - this.sum = (N)result; - } + this.sum = (N) Operations.addNumbers(this.sum, data.sum); } } diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 6e5f16d7..2a25bcfb 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -167,29 +167,7 @@ public Matrix add(Matrix input) { for (int i = 0; i < cols; i++) { T m1 = this.get(r, c); T m2 = input.get(r, c); - T result; - /* TODO: This is ugly and how to handle number overflow? */ - if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { - BigDecimal result2 = ((BigDecimal)m1).add((BigDecimal)m2); - result = (T)result2; - } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { - BigInteger result2 = ((BigInteger)m1).add((BigInteger)m2); - result = (T)result2; - } else if (m1 instanceof Long || m2 instanceof Long) { - Long result2 = (m1.longValue() + m2.longValue()); - result = (T)result2; - } else if (m1 instanceof Double || m2 instanceof Double) { - Double result2 = (m1.doubleValue() + m2.doubleValue()); - result = (T)result2; - } else if (m1 instanceof Float || m2 instanceof Float) { - Float result2 = (m1.floatValue() + m2.floatValue()); - result = (T)result2; - } else { - // Integer - Integer result2 = (m1.intValue() + m2.intValue()); - result = (T)result2; - } - output.set(r, c, result); + output.set(r, c, (T) Operations.addNumbers(m1, m2)); } } } diff --git a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java index fb516d8e..f65b777e 100644 --- a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java +++ b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java @@ -12,6 +12,8 @@ import java.util.Set; import java.util.TreeSet; +import com.jwetherell.algorithms.mathematics.Operations; + /** * Segment tree using objects and pointers. A segment tree is a tree data * structure for storing intervals, or segments. It allows querying which of the @@ -603,27 +605,7 @@ else if (this.sum != null && data.sum == null) else if (this.sum == null && data.sum != null) this.sum = data.sum; else { - /* TODO: This is ugly and how to handle number overflow? */ - if (this.sum instanceof BigDecimal || data.sum instanceof BigDecimal) { - BigDecimal result = ((BigDecimal)this.sum).add((BigDecimal)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof BigInteger || data.sum instanceof BigInteger) { - BigInteger result = ((BigInteger)this.sum).add((BigInteger)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof Long || data.sum instanceof Long) { - Long result = (this.sum.longValue() + data.sum.longValue()); - this.sum = (N)result; - } else if (this.sum instanceof Double || data.sum instanceof Double) { - Double result = (this.sum.doubleValue() + data.sum.doubleValue()); - this.sum = (N)result; - } else if (this.sum instanceof Float || data.sum instanceof Float) { - Float result = (this.sum.floatValue() + data.sum.floatValue()); - this.sum = (N)result; - } else { - // Integer - Integer result = (this.sum.intValue() + data.sum.intValue()); - this.sum = (N)result; - } + this.sum = (N) Operations.addNumbers(this.sum, data.sum); } } diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index ebc8f390..ee325c30 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -64,5 +64,22 @@ public static Number rowMultiplication(Number test, Number[] row, Number[] colum return result; } } - + + /* TODO: How to handle number overflow? */ + public static Number addNumbers(Number m1, Number m2) { + if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { + return ((BigDecimal)m1).add((BigDecimal)m2); + } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { + return ((BigInteger)m1).add((BigInteger)m2); + } else if (m1 instanceof Long || m2 instanceof Long) { + return (m1.longValue() + m2.longValue()); + } else if (m1 instanceof Double || m2 instanceof Double) { + return (m1.doubleValue() + m2.doubleValue()); + } else if (m1 instanceof Float || m2 instanceof Float) { + return (m1.floatValue() + m2.floatValue()); + } else { + // Integer + return (m1.intValue() + m2.intValue()); + } + } } \ No newline at end of file From 271b37980593a8fd98ad52dda9815daa2a50c161 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= <45148959+akerfel@users.noreply.github.com> Date: Fri, 4 Mar 2022 02:10:42 +0100 Subject: [PATCH 10/27] Fixed #112. feat: Added function which subtracts different Number types. (#114) --- .../data_structures/FenwickTree.java | 22 +---------------- .../algorithms/data_structures/Matrix.java | 24 +------------------ .../algorithms/mathematics/Operations.java | 18 ++++++++++++++ 3 files changed, 20 insertions(+), 44 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/FenwickTree.java b/src/com/jwetherell/algorithms/data_structures/FenwickTree.java index 2c807c14..04af939e 100644 --- a/src/com/jwetherell/algorithms/data_structures/FenwickTree.java +++ b/src/com/jwetherell/algorithms/data_structures/FenwickTree.java @@ -323,27 +323,7 @@ else if (this.sum != null && data.sum == null) else if (this.sum == null && data.sum != null) this.sum = data.sum; else { - /* TODO: This is ugly and how to handle number overflow? */ - if (this.sum instanceof BigDecimal || data.sum instanceof BigDecimal) { - BigDecimal result = ((BigDecimal)this.sum).subtract((BigDecimal)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof BigInteger || data.sum instanceof BigInteger) { - BigInteger result = ((BigInteger)this.sum).subtract((BigInteger)data.sum); - this.sum = (N)result; - } else if (this.sum instanceof Long || data.sum instanceof Long) { - Long result = (this.sum.longValue() - data.sum.longValue()); - this.sum = (N)result; - } else if (this.sum instanceof Double || data.sum instanceof Double) { - Double result = (this.sum.doubleValue() - data.sum.doubleValue()); - this.sum = (N)result; - } else if (this.sum instanceof Float || data.sum instanceof Float) { - Float result = (this.sum.floatValue() - data.sum.floatValue()); - this.sum = (N)result; - } else { - // Integer - Integer result = (this.sum.intValue() - data.sum.intValue()); - this.sum = (N)result; - } + this.sum = (N) Operations.subtractNumbers(this.sum, data.sum); } } diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 2a25bcfb..1fe157d8 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -184,29 +184,7 @@ public Matrix subtract(Matrix input) { for (int i = 0; i < cols; i++) { T m1 = this.get(r, c); T m2 = input.get(r, c); - T result; - /* TODO: This is ugly and how to handle number overflow? */ - if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { - BigDecimal result2 = ((BigDecimal)m1).subtract((BigDecimal)m2); - result = (T)result2; - } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { - BigInteger result2 = ((BigInteger)m1).subtract((BigInteger)m2); - result = (T)result2; - } else if (m1 instanceof Long || m2 instanceof Long) { - Long result2 = (m1.longValue() - m2.longValue()); - result = (T)result2; - } else if (m1 instanceof Double || m2 instanceof Double) { - Double result2 = (m1.doubleValue() - m2.doubleValue()); - result = (T)result2; - } else if (m1 instanceof Float || m2 instanceof Float) { - Float result2 = (m1.floatValue() - m2.floatValue()); - result = (T)result2; - } else { - // Integer - Integer result2 = (m1.intValue() - m2.intValue()); - result = (T)result2; - } - output.set(r, c, result); + output.set(r, c, (T) Operations.subtractNumbers(m1, m2)); } } } diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index ee325c30..21dad0e8 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -82,4 +82,22 @@ public static Number addNumbers(Number m1, Number m2) { return (m1.intValue() + m2.intValue()); } } + + /* TODO: How to handle number overflow? */ + public static Number subtractNumbers(Number m1, Number m2) { + if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { + return ((BigDecimal)m1).subtract((BigDecimal)m2); + } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { + return ((BigInteger)m1).subtract((BigInteger)m2); + } else if (m1 instanceof Long || m2 instanceof Long) { + return (m1.longValue() - m2.longValue()); + } else if (m1 instanceof Double || m2 instanceof Double) { + return (m1.doubleValue() - m2.doubleValue()); + } else if (m1 instanceof Float || m2 instanceof Float) { + return (m1.floatValue() - m2.floatValue()); + } else { + // Integer + return (m1.intValue() - m2.intValue()); + } + } } \ No newline at end of file From 90d04ea3c81a7d5363f4cc874c5f53e23cc83cd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Fri, 4 Mar 2022 18:34:31 +0100 Subject: [PATCH 11/27] Fixed #115. fix: Removed unneded for loops in Matrix.add and Matrix.subtract. --- .../algorithms/data_structures/Matrix.java | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 1fe157d8..1bf5bb02 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -164,11 +164,9 @@ public Matrix add(Matrix input) { return output; for (int r = 0; r < output.rows; r++) { for (int c = 0; c < output.cols; c++) { - for (int i = 0; i < cols; i++) { - T m1 = this.get(r, c); - T m2 = input.get(r, c); - output.set(r, c, (T) Operations.addNumbers(m1, m2)); - } + T m1 = this.get(r, c); + T m2 = input.get(r, c); + output.set(r, c, (T) Operations.addNumbers(m1, m2)); } } return output; @@ -181,11 +179,9 @@ public Matrix subtract(Matrix input) { for (int r = 0; r < output.rows; r++) { for (int c = 0; c < output.cols; c++) { - for (int i = 0; i < cols; i++) { - T m1 = this.get(r, c); - T m2 = input.get(r, c); - output.set(r, c, (T) Operations.subtractNumbers(m1, m2)); - } + T m1 = this.get(r, c); + T m2 = input.get(r, c); + output.set(r, c, (T) Operations.subtractNumbers(m1, m2)); } } return output; From a9baefd8a13d36444d863a770d3c7333ff1025d7 Mon Sep 17 00:00:00 2001 From: Marcus Nordstedt <45561006+Snebie@users.noreply.github.com> Date: Mon, 7 Mar 2022 14:12:13 +0100 Subject: [PATCH 12/27] Fixed issue 101 (#117) * Fixed #101, feat: added compare function in operations and replaced ugly TODO code with calls to this function in Matrix and SegmentTree --- .../algorithms/data_structures/Matrix.java | 29 +------------ .../data_structures/SegmentTree.java | 42 ++----------------- .../algorithms/mathematics/Operations.java | 20 +++++++++ 3 files changed, 26 insertions(+), 65 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 1bf5bb02..bc084439 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -3,6 +3,7 @@ import java.math.BigDecimal; import java.math.BigInteger; import java.util.Comparator; +import com.jwetherell.algorithms.mathematics.Operations; import com.jwetherell.algorithms.mathematics.Operations; @@ -28,33 +29,7 @@ public class Matrix { @Override public int compare(T o1, T o2) { /* TODO: What if Java adds new numeric type? */ - int result = 0; - if (o1 instanceof BigDecimal || o2 instanceof BigDecimal) { - BigDecimal c1 = (BigDecimal)o1; - BigDecimal c2 = (BigDecimal)o2; - result = c1.compareTo(c2); - } else if (o1 instanceof BigInteger || o2 instanceof BigInteger) { - BigInteger c1 = (BigInteger)o1; - BigInteger c2 = (BigInteger)o2; - result = c1.compareTo(c2); - } else if (o1 instanceof Long || o2 instanceof Long) { - Long c1 = o1.longValue(); - Long c2 = o2.longValue(); - result = c1.compareTo(c2); - } else if (o1 instanceof Double || o2 instanceof Double) { - Double c1 = o1.doubleValue(); - Double c2 = o2.doubleValue(); - result = c1.compareTo(c2); - } else if (o1 instanceof Float || o2 instanceof Float) { - Float c1 = o1.floatValue(); - Float c2 = o2.floatValue(); - result = c1.compareTo(c2); - } else { - Integer c1 = o1.intValue(); - Integer c2 = o2.intValue(); - result = c1.compareTo(c2); - } - return result; + return Operations.compare(o1, o2); } }; diff --git a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java index f65b777e..cd7c18b9 100644 --- a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java +++ b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java @@ -343,25 +343,8 @@ else if (this.maximum == null && data.maximum != null) this.maximum = data.maximum; else { /* TODO: This is ugly */ - if (this.maximum instanceof BigDecimal || data.maximum instanceof BigDecimal) { - if (((BigDecimal)data.maximum).compareTo(((BigDecimal)this.maximum))==1) - this.maximum = data.maximum; - } else if (this.maximum instanceof BigInteger || data.maximum instanceof BigInteger) { - if (((BigInteger)data.maximum).compareTo(((BigInteger)this.maximum))==1) - this.maximum = data.maximum; - } else if (this.maximum instanceof Long || data.maximum instanceof Long) { - if (((Long)data.maximum).compareTo(((Long)this.maximum))==1) - this.maximum = data.maximum; - } else if (this.maximum instanceof Double || data.maximum instanceof Double) { - if (((Double)data.maximum).compareTo(((Double)this.maximum))==1) - this.maximum = data.maximum; - } else if (this.maximum instanceof Float || data.maximum instanceof Float) { - if (((Float)data.maximum).compareTo(((Float)this.maximum))==1) - this.maximum = data.maximum; - } else { - // Integer - if (((Integer)data.maximum).compareTo(((Integer)this.maximum))==1) - this.maximum = data.maximum; + if(Operations.compare(data.maximum, this.maximum) == 1){ + this.maximum = data.maximum; } } } @@ -474,25 +457,8 @@ else if (this.minimum == null && data.minimum != null) this.minimum = data.minimum; else { /* TODO: This is ugly */ - if (this.minimum instanceof BigDecimal || data.minimum instanceof BigDecimal) { - if (((BigDecimal)data.minimum).compareTo(((BigDecimal)this.minimum))==-1) - this.minimum = data.minimum; - } else if (this.minimum instanceof BigInteger || data.minimum instanceof BigInteger) { - if (((BigInteger)data.minimum).compareTo(((BigInteger)this.minimum))==-1) - this.minimum = data.minimum; - } else if (this.minimum instanceof Long || data.minimum instanceof Long) { - if (((Long)data.minimum).compareTo(((Long)this.minimum))==-1) - this.minimum = data.minimum; - } else if (this.minimum instanceof Double || data.minimum instanceof Double) { - if (((Double)data.minimum).compareTo(((Double)this.minimum))==-1) - this.minimum = data.minimum; - } else if (this.minimum instanceof Float || data.minimum instanceof Float) { - if (((Float)data.minimum).compareTo(((Float)this.minimum))==-1) - this.minimum = data.minimum; - } else { - // Integer - if (((Integer)data.minimum).compareTo(((Integer)this.minimum))==-1) - this.minimum = data.minimum; + if(Operations.compare(data.minimum, this.minimum) == -1){ + this.minimum = data.minimum; } } } diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index 21dad0e8..be0d3e39 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -4,6 +4,26 @@ import java.math.BigInteger; public class Operations { + + + public static int compare(Number a, Number b){ + if (a instanceof BigDecimal || b instanceof BigDecimal){ + return ((BigDecimal)a).compareTo((BigDecimal)b); + } + else if (a instanceof BigInteger || b instanceof BigInteger){ + return ((BigInteger)a).compareTo((BigInteger)b); + } + else if (a instanceof Long || b instanceof Long){ + return ((Long)a).compareTo((Long)b); + } + else if (a instanceof Double || b instanceof Double){ + return ((Double)a).compareTo((Double)b); + } + else if (a instanceof Float || b instanceof Float){ + return ((Float)a).compareTo((Float)b); + } + else{ + return ((Integer)a).compareTo((Integer)b); /* TODO: How to handle number overflow? */ public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ From 6301210a7d34c905ae3b110b35085fcc9c3a2d20 Mon Sep 17 00:00:00 2001 From: Marcus Nordstedt <45561006+Snebie@users.noreply.github.com> Date: Mon, 7 Mar 2022 14:13:09 +0100 Subject: [PATCH 13/27] Fixed Issue 98 (#116) * Fixed #98, tests: added tests for all datatypes (for number representation) to increase branch coverage for TODO functions in SegmentTree --- .../test/SegmentTreeTests.java | 908 +++++++++++++++++- 1 file changed, 888 insertions(+), 20 deletions(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java index d15d93f8..c3632d9e 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java @@ -15,6 +15,8 @@ import com.jwetherell.algorithms.data_structures.SegmentTree.DynamicSegmentTree; import com.jwetherell.algorithms.data_structures.SegmentTree.FlatSegmentTree; +import java.math.BigDecimal; +import java.math.BigInteger; public class SegmentTreeTests { @Test @@ -57,7 +59,7 @@ private void testQuadrantSegmentTree(java.util.List> segments = new ArrayList>(); segments.add(new SegmentTree.Data.RangeMaximumData(0, (Integer) 4)); segments.add(new SegmentTree.Data.RangeMaximumData(1, (Integer) 2)); @@ -72,22 +74,22 @@ public void testRangeMaxSegmentTree() { // No matter which order the data is given, all tests should pass // Initial order. - testRangeMaxSegmentTree(segments); + testRangeMaxSegmentTreeInteger(segments); // Randomize it Collections.shuffle(segments); - testRangeMaxSegmentTree(segments); + testRangeMaxSegmentTreeInteger(segments); // Try in order Collections.sort(segments); - testRangeMaxSegmentTree(segments); + testRangeMaxSegmentTreeInteger(segments); // Try reverse order Collections.sort(segments,REVERSE); - testRangeMaxSegmentTree(segments); + testRangeMaxSegmentTreeInteger(segments); } - private void testRangeMaxSegmentTree(java.util.List> segments) { // Range Maximum Segment tree + private void testRangeMaxSegmentTreeInteger(java.util.List> segments) { // Range Maximum Segment tree FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); @@ -116,7 +118,308 @@ private void testRangeMaxSegmentTree(java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, (BigInteger.valueOf(4)))); + segments.add(new SegmentTree.Data.RangeMaximumData(1, (BigInteger.valueOf(2)))); + segments.add(new SegmentTree.Data.RangeMaximumData(2, (BigInteger.valueOf(6)))); + segments.add(new SegmentTree.Data.RangeMaximumData(3, (BigInteger.valueOf(3)))); + segments.add(new SegmentTree.Data.RangeMaximumData(4, (BigInteger.valueOf(1)))); + segments.add(new SegmentTree.Data.RangeMaximumData(5, (BigInteger.valueOf(5)))); + segments.add(new SegmentTree.Data.RangeMaximumData(6, (BigInteger.valueOf(0)))); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, (BigInteger.valueOf(7)))); + segments.add(new SegmentTree.Data.RangeMaximumData(21, (BigInteger.valueOf(10)))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMaxSegmentTreeBigInteger(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMaxSegmentTreeBigInteger(segments); + + // Try in order + Collections.sort(segments); + testRangeMaxSegmentTreeBigInteger(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMaxSegmentTreeBigInteger(segments); + } + + private void testRangeMaxSegmentTreeBigInteger(java.util.List> segments) { // Range Maximum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.maximum==BigInteger.valueOf(7)); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, tree, query.maximum==BigInteger.valueOf(10)); + + // bounds checking + { + // max is first + query = tree.query(2, 4); + assertTrue("Segment tree query error. query=2->4 result="+query, tree, query.maximum==BigInteger.valueOf(6)); + + // max is middle + query = tree.query(4, 6); + assertTrue("Segment tree query error. query=4->6 result="+query, tree, query.maximum==BigInteger.valueOf(5)); + + // max is last + query = tree.query(5, 7); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.maximum==BigInteger.valueOf(7)); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.maximum==BigInteger.valueOf(7)); + } + + @Test + public void testRangeMaxSegmentTreeBigDecimal() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, BigDecimal.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMaximumData(1, BigDecimal.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMaximumData(2, BigDecimal.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMaximumData(3, BigDecimal.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMaximumData(4, BigDecimal.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMaximumData(5, BigDecimal.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMaximumData(6, BigDecimal.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, BigDecimal.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMaximumData(21, BigDecimal.valueOf(10))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMaxSegmentTreeBigDecimal(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMaxSegmentTreeBigDecimal(segments); + + // Try in order + Collections.sort(segments); + testRangeMaxSegmentTreeBigDecimal(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMaxSegmentTreeBigDecimal(segments); + } + + private void testRangeMaxSegmentTreeBigDecimal(java.util.List> segments) { // Range Maximum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.maximum==BigDecimal.valueOf(7)); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, tree, query.maximum==BigDecimal.valueOf(10)); + + // bounds checking + { + // max is first + query = tree.query(2, 4); + assertTrue("Segment tree query error. query=2->4 result="+query, tree, query.maximum==BigDecimal.valueOf(6)); + + // max is middle + query = tree.query(4, 6); + assertTrue("Segment tree query error. query=4->6 result="+query, tree, query.maximum==BigDecimal.valueOf(5)); + + // max is last + query = tree.query(5, 7); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.maximum==BigDecimal.valueOf(7)); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.maximum==BigDecimal.valueOf(7)); + } + + @Test + public void testRangeMaxSegmentTreeLong() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, Long.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMaximumData(1, Long.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMaximumData(2, Long.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMaximumData(3, Long.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMaximumData(4, Long.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMaximumData(5, Long.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMaximumData(6, Long.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, Long.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMaximumData(21, Long.valueOf(10))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMaxSegmentTreeLong(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMaxSegmentTreeLong(segments); + + // Try in order + Collections.sort(segments); + testRangeMaxSegmentTreeLong(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMaxSegmentTreeLong(segments); + } + + private void testRangeMaxSegmentTreeLong(java.util.List> segments) { // Range Maximum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.maximum==7); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, tree, query.maximum==10); + + // bounds checking + { + // max is first + query = tree.query(2, 4); + assertTrue("Segment tree query error. query=2->4 result="+query, tree, query.maximum==6); + + // max is middle + query = tree.query(4, 6); + assertTrue("Segment tree query error. query=4->6 result="+query, tree, query.maximum==5); + + // max is last + query = tree.query(5, 7); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.maximum==7); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.maximum==7); + } + + @Test + public void testRangeMaxSegmentTreeDouble() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, Double.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMaximumData(1, Double.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMaximumData(2, Double.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMaximumData(3, Double.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMaximumData(4, Double.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMaximumData(5, Double.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMaximumData(6, Double.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, Double.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMaximumData(21, Double.valueOf(10))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMaxSegmentTreeDouble(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMaxSegmentTreeDouble(segments); + + // Try in order + Collections.sort(segments); + testRangeMaxSegmentTreeDouble(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMaxSegmentTreeDouble(segments); + } + + private void testRangeMaxSegmentTreeDouble(java.util.List> segments) { // Range Maximum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.maximum==7); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, tree, query.maximum==10); + + // bounds checking + { + // max is first + query = tree.query(2, 4); + assertTrue("Segment tree query error. query=2->4 result="+query, tree, query.maximum==6); + + // max is middle + query = tree.query(4, 6); + assertTrue("Segment tree query error. query=4->6 result="+query, tree, query.maximum==5); + + // max is last + query = tree.query(5, 7); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.maximum==7); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.maximum==7); + } + + + @Test + public void testRangeMaxSegmentTreeFloat() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, Float.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMaximumData(1, Float.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMaximumData(2, Float.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMaximumData(3, Float.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMaximumData(4, Float.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMaximumData(5, Float.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMaximumData(6, Float.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, Float.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMaximumData(21, Float.valueOf(10))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMaxSegmentTreeFloat(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMaxSegmentTreeFloat(segments); + + // Try in order + Collections.sort(segments); + testRangeMaxSegmentTreeFloat(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMaxSegmentTreeFloat(segments); + } + + private void testRangeMaxSegmentTreeFloat(java.util.List> segments) { // Range Maximum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.maximum==7); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, tree, query.maximum==10); + + // bounds checking + { + // max is first + query = tree.query(2, 4); + assertTrue("Segment tree query error. query=2->4 result="+query, tree, query.maximum==6); + + // max is middle + query = tree.query(4, 6); + assertTrue("Segment tree query error. query=4->6 result="+query, tree, query.maximum==5); + + // max is last + query = tree.query(5, 7); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.maximum==7); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.maximum==7); + } + + + + + /*-------------------------*/ + + @Test + public void testRangeMinSegmentTreeInteger() { java.util.List> segments = new ArrayList>(); segments.add(new SegmentTree.Data.RangeMinimumData(0, (Integer) 4)); segments.add(new SegmentTree.Data.RangeMinimumData(1, (Integer) 2)); @@ -130,25 +433,267 @@ public void testRangeMinSegmentTree() { // No matter which order the data is given, all tests should pass // Initial order. - testRangeMinSegmentTree(segments); + testRangeMinSegmentTreeInteger(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMinSegmentTreeInteger(segments); + + // Try in order + Collections.sort(segments); + testRangeMinSegmentTreeInteger(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMinSegmentTreeInteger(segments); + } + + private void testRangeMinSegmentTreeInteger(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==0); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.minimum==0); + + // bounds checking + { + // min is first + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, tree, query.minimum==2); + + // min is middle + query = tree.query(3, 5); + assertTrue("Segment tree query error. query=3->5 result="+query, tree, query.minimum==1); + + // min is last + query = tree.query(1, 4); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.minimum==1); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.minimum==null); + } + + /* + Requirement: + + + */ + @Test + public void testRangeMinSegmentTreeBigInteger() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, BigInteger.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMinimumData(1, BigInteger.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMinimumData(2, BigInteger.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMinimumData(3, BigInteger.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMinimumData(4, BigInteger.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMinimumData(5, BigInteger.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMinimumData(6, BigInteger.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, BigInteger.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMinSegmentTreeBigInteger(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMinSegmentTreeBigInteger(segments); + + // Try in order + Collections.sort(segments); + testRangeMinSegmentTreeBigInteger(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMinSegmentTreeBigInteger(segments); + } + + private void testRangeMinSegmentTreeBigInteger(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==BigInteger.valueOf(0)); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.minimum==BigInteger.valueOf(0)); + + // bounds checking + { + // min is first + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, tree, query.minimum==BigInteger.valueOf(2)); + + // min is middle + query = tree.query(3, 5); + assertTrue("Segment tree query error. query=3->5 result="+query, tree, query.minimum==BigInteger.valueOf(1)); + + // min is last + query = tree.query(1, 4); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.minimum==BigInteger.valueOf(1)); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.minimum==null); + } + + /* + Requirement: + + + */ + @Test + public void testRangeMinSegmentTreeBigDecimal() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, BigDecimal.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMinimumData(1, BigDecimal.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMinimumData(2, BigDecimal.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMinimumData(3, BigDecimal.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMinimumData(4, BigDecimal.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMinimumData(5, BigDecimal.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMinimumData(6, BigDecimal.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, BigDecimal.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMinSegmentTreeBigDecimal(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMinSegmentTreeBigDecimal(segments); + + // Try in order + Collections.sort(segments); + testRangeMinSegmentTreeBigDecimal(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMinSegmentTreeBigDecimal(segments); + } + + private void testRangeMinSegmentTreeBigDecimal(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==BigDecimal.valueOf(0)); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.minimum==BigDecimal.valueOf(0)); + + // bounds checking + { + // min is first + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, tree, query.minimum==BigDecimal.valueOf(2)); + + // min is middle + query = tree.query(3, 5); + assertTrue("Segment tree query error. query=3->5 result="+query, tree, query.minimum==BigDecimal.valueOf(1)); + + // min is last + query = tree.query(1, 4); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.minimum==BigDecimal.valueOf(1)); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.minimum==null); + } + + @Test + public void testRangeMinSegmentTreeLong() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, Long.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMinimumData(1, Long.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMinimumData(2, Long.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMinimumData(3, Long.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMinimumData(4, Long.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMinimumData(5, Long.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMinimumData(6, Long.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Long.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMinSegmentTreeLong(segments); // Randomize it Collections.shuffle(segments); - testRangeMinSegmentTree(segments); + testRangeMinSegmentTreeLong(segments); // Try in order Collections.sort(segments); - testRangeMinSegmentTree(segments); + testRangeMinSegmentTreeLong(segments); // Try reverse order Collections.sort(segments,REVERSE); - testRangeMinSegmentTree(segments); + testRangeMinSegmentTreeLong(segments); } - private void testRangeMinSegmentTree(java.util.List> segments) { // Range Minimum Segment tree - FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + private void testRangeMinSegmentTreeLong(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); - SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==Long.valueOf(0)); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.minimum==Long.valueOf(0)); + + // bounds checking + { + // min is first + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, tree, query.minimum==Long.valueOf(2)); + + // min is middle + query = tree.query(3, 5); + assertTrue("Segment tree query error. query=3->5 result="+query, tree, query.minimum==Long.valueOf(1)); + + // min is last + query = tree.query(1, 4); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.minimum==Long.valueOf(1)); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.minimum==null); + } + + @Test + public void testRangeMinSegmentTreeDouble() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, Double.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMinimumData(1, Double.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMinimumData(2, Double.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMinimumData(3, Double.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMinimumData(4, Double.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMinimumData(5, Double.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMinimumData(6, Double.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Double.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMinSegmentTreeDouble(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMinSegmentTreeDouble(segments); + + // Try in order + Collections.sort(segments); + testRangeMinSegmentTreeDouble(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMinSegmentTreeDouble(segments); + } + + private void testRangeMinSegmentTreeDouble(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==0); query = tree.query(0, 17); @@ -174,7 +719,67 @@ private void testRangeMinSegmentTree(java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, Float.valueOf(4))); + segments.add(new SegmentTree.Data.RangeMinimumData(1, Float.valueOf(2))); + segments.add(new SegmentTree.Data.RangeMinimumData(2, Float.valueOf(6))); + segments.add(new SegmentTree.Data.RangeMinimumData(3, Float.valueOf(3))); + segments.add(new SegmentTree.Data.RangeMinimumData(4, Float.valueOf(1))); + segments.add(new SegmentTree.Data.RangeMinimumData(5, Float.valueOf(5))); + segments.add(new SegmentTree.Data.RangeMinimumData(6, Float.valueOf(0))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Float.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeMinSegmentTreeFloat(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeMinSegmentTreeFloat(segments); + + // Try in order + Collections.sort(segments); + testRangeMinSegmentTreeFloat(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeMinSegmentTreeFloat(segments); + } + + private void testRangeMinSegmentTreeFloat(java.util.List> segments) { // Range Minimum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, tree, query.minimum==0); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.minimum==0); + + // bounds checking + { + // min is first + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, tree, query.minimum== 2); + + // min is middle + query = tree.query(3, 5); + assertTrue("Segment tree query error. query=3->5 result="+query, tree, query.minimum== 1); + + // min is last + query = tree.query(1, 4); + assertTrue("Segment tree query error. query=5->7 result="+query, tree, query.minimum== 1); + } + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, tree, query.minimum==null); + } + + /* ----------------------------------------- */ + + @Test + public void testRangeSumSegmentTreeInteger() { java.util.List> segments = new ArrayList>(); segments.add(new SegmentTree.Data.RangeSumData(0, (Integer) 4)); segments.add(new SegmentTree.Data.RangeSumData(1, (Integer) 2)); @@ -188,22 +793,22 @@ public void testRangeSumSegmentTree() { // No matter which order the data is given, all tests should pass // Initial order. - testRangeSumSegmentTree(segments); + testRangeSumSegmentTreeInteger(segments); // Randomize it Collections.shuffle(segments); - testRangeSumSegmentTree(segments); + testRangeSumSegmentTreeInteger(segments); // Try in order Collections.sort(segments); - testRangeSumSegmentTree(segments); + testRangeSumSegmentTreeInteger(segments); // Try reverse order Collections.sort(segments,REVERSE); - testRangeSumSegmentTree(segments); + testRangeSumSegmentTreeInteger(segments); } - private void testRangeSumSegmentTree(java.util.List> segments) { // Range Sum Segment tree + private void testRangeSumSegmentTreeInteger(java.util.List> segments) { // Range Sum Segment tree FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); SegmentTree.Data.RangeSumData query = tree.query(0, 8); @@ -225,6 +830,269 @@ private void testRangeSumSegmentTree(java.util.List8 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(21)) ==0); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(28))==0); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(15))==0); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(7))==0); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, tree, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(7))==0); + } + + @Test + public void testRangeSumSegmentTreeBigDecimal() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeSumData(0, BigDecimal.valueOf(4))); + segments.add(new SegmentTree.Data.RangeSumData(1, BigDecimal.valueOf(2))); + segments.add(new SegmentTree.Data.RangeSumData(2, BigDecimal.valueOf(6))); + segments.add(new SegmentTree.Data.RangeSumData(3, BigDecimal.valueOf(3))); + segments.add(new SegmentTree.Data.RangeSumData(4, BigDecimal.valueOf(1))); + segments.add(new SegmentTree.Data.RangeSumData(5, BigDecimal.valueOf(5))); + segments.add(new SegmentTree.Data.RangeSumData(6, BigDecimal.valueOf(0))); + segments.add(new SegmentTree.Data.RangeSumData(17, BigDecimal.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeSumSegmentTreeBigDecimal(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeSumSegmentTreeBigDecimal(segments); + + // Try in order + Collections.sort(segments); + testRangeSumSegmentTreeBigDecimal(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeSumSegmentTreeBigDecimal(segments); + } + + private void testRangeSumSegmentTreeBigDecimal(java.util.List> segments) { // Range Sum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); + + SegmentTree.Data.RangeSumData query = tree.query(0, 8); + assertTrue("Segment tree query error. query=0->8 result="+query, tree, query.sum.compareTo(BigDecimal.valueOf(21))==0); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.sum.compareTo(BigDecimal.valueOf(28))==0); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, tree, query.sum.compareTo(BigDecimal.valueOf(15))==0); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, tree, query.sum.compareTo(BigDecimal.valueOf(7))==0); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, tree, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, tree, query.sum.compareTo(BigDecimal.valueOf(7))==0); + } + + @Test + public void testRangeSumSegmentTreeLong() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeSumData(0, Long.valueOf(4))); + segments.add(new SegmentTree.Data.RangeSumData(1, Long.valueOf(2))); + segments.add(new SegmentTree.Data.RangeSumData(2, Long.valueOf(6))); + segments.add(new SegmentTree.Data.RangeSumData(3, Long.valueOf(3))); + segments.add(new SegmentTree.Data.RangeSumData(4, Long.valueOf(1))); + segments.add(new SegmentTree.Data.RangeSumData(5, Long.valueOf(5))); + segments.add(new SegmentTree.Data.RangeSumData(6, Long.valueOf(0))); + segments.add(new SegmentTree.Data.RangeSumData(17, Long.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeSumSegmentTreeLong(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeSumSegmentTreeLong(segments); + + // Try in order + Collections.sort(segments); + testRangeSumSegmentTreeLong(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeSumSegmentTreeLong(segments); + } + + private void testRangeSumSegmentTreeLong(java.util.List> segments) { // Range Sum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); + + SegmentTree.Data.RangeSumData query = tree.query(0, 8); + assertTrue("Segment tree query error. query=0->8 result="+query, tree, query.sum==Long.valueOf(21)); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.sum==Long.valueOf(28)); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, tree, query.sum==Long.valueOf(15)); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, tree, query.sum==Long.valueOf(7)); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, tree, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, tree, query.sum==Long.valueOf(7)); + } + + @Test + public void testRangeSumSegmentTreeDouble() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeSumData(0, Double.valueOf(4))); + segments.add(new SegmentTree.Data.RangeSumData(1, Double.valueOf(2))); + segments.add(new SegmentTree.Data.RangeSumData(2, Double.valueOf(6))); + segments.add(new SegmentTree.Data.RangeSumData(3, Double.valueOf(3))); + segments.add(new SegmentTree.Data.RangeSumData(4, Double.valueOf(1))); + segments.add(new SegmentTree.Data.RangeSumData(5, Double.valueOf(5))); + segments.add(new SegmentTree.Data.RangeSumData(6, Double.valueOf(0))); + segments.add(new SegmentTree.Data.RangeSumData(17, Double.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeSumSegmentTreeDouble(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeSumSegmentTreeDouble(segments); + + // Try in order + Collections.sort(segments); + testRangeSumSegmentTreeDouble(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeSumSegmentTreeDouble(segments); + } + + private void testRangeSumSegmentTreeDouble(java.util.List> segments) { // Range Sum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); + + SegmentTree.Data.RangeSumData query = tree.query(0, 8); + assertTrue("Segment tree query error. query=0->8 result="+query, tree, query.sum==21); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.sum==28); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, tree, query.sum==15); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, tree, query.sum==7); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, tree, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, tree, query.sum==7); + } + + @Test + public void testRangeSumSegmentTreeBigFloat() { + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeSumData(0, Float.valueOf(4))); + segments.add(new SegmentTree.Data.RangeSumData(1, Float.valueOf(2))); + segments.add(new SegmentTree.Data.RangeSumData(2, Float.valueOf(6))); + segments.add(new SegmentTree.Data.RangeSumData(3, Float.valueOf(3))); + segments.add(new SegmentTree.Data.RangeSumData(4, Float.valueOf(1))); + segments.add(new SegmentTree.Data.RangeSumData(5, Float.valueOf(5))); + segments.add(new SegmentTree.Data.RangeSumData(6, Float.valueOf(0))); + segments.add(new SegmentTree.Data.RangeSumData(17, Float.valueOf(7))); + + // No matter which order the data is given, all tests should pass + + // Initial order. + testRangeSumSegmentTreeFloat(segments); + + // Randomize it + Collections.shuffle(segments); + testRangeSumSegmentTreeFloat(segments); + + // Try in order + Collections.sort(segments); + testRangeSumSegmentTreeFloat(segments); + + // Try reverse order + Collections.sort(segments,REVERSE); + testRangeSumSegmentTreeFloat(segments); + } + + private void testRangeSumSegmentTreeFloat(java.util.List> segments) { // Range Sum Segment tree + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); + + SegmentTree.Data.RangeSumData query = tree.query(0, 8); + assertTrue("Segment tree query error. query=0->8 result="+query, tree, query.sum==21); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, tree, query.sum==28); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, tree, query.sum==15); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, tree, query.sum==7); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, tree, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, tree, query.sum==7); + } + + + /*-----------------------------*/ + final String stravinsky = "Stravinsky"; final String schoenberg = "Schoenberg"; final String grieg = "Grieg"; From e97d3b7197805b82840442b4dc390936385eb4b6 Mon Sep 17 00:00:00 2001 From: Marcus Nordstedt <45561006+Snebie@users.noreply.github.com> Date: Mon, 7 Mar 2022 14:39:51 +0100 Subject: [PATCH 14/27] Issue 118 (#119) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * #Fixed #118, fix: fixed the bug for multiplyUsingLoopWithStringInput so it now can handle zero inputs, also modified the test to cover the case where there are several zeroes ('0000') in the input. Co-authored-by: Magnus Åkerfelt Co-authored-by: Beatrice Berg --- .../mathematics/Multiplication.java | 3 + .../data_structures/test/ListTests.java | 81 +++++++++++++++++++ .../algorithms/graph/test/Graphs.java | 69 ++++++++++++++++ .../mathematics/test/MathematicsTest.java | 38 ++++++++- .../algorithms/numbers/test/Numbers.java | 6 +- 5 files changed, 195 insertions(+), 2 deletions(-) diff --git a/src/com/jwetherell/algorithms/mathematics/Multiplication.java b/src/com/jwetherell/algorithms/mathematics/Multiplication.java index 98db58a7..7b965bf4 100644 --- a/src/com/jwetherell/algorithms/mathematics/Multiplication.java +++ b/src/com/jwetherell/algorithms/mathematics/Multiplication.java @@ -188,6 +188,9 @@ public static String multiplyUsingLoopWithStringInput(String a, String b) { zeroCheck = false; sb.append(s); } + if(sb.length()==0){ + return "0"; + } return sb.toString(); } diff --git a/test/com/jwetherell/algorithms/data_structures/test/ListTests.java b/test/com/jwetherell/algorithms/data_structures/test/ListTests.java index c8806877..a0c6b1c3 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/ListTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/ListTests.java @@ -181,4 +181,85 @@ public void testDoublyLinkedList() { assertTrue(JavaCollectionTest.testCollection(lCollection, Integer.class, lName, data.unsorted, data.sorted, data.invalid)); } + + /** + * Tests that the private function grow() in the ArrayList implementation + * in the file List.java works correctly. + * Requirement: If the size attribute exceeds the size of the underlying array, + * then the grow() function should be called, which should increase the size of said array. + */ + @Test + public void testGrowArrayList() { + List.ArrayList aList = new List.ArrayList(); + + // Add a large number (>1023) of elements to a list, + // so that the underlying array must be increased in size. + for (int i = 0; i < 100000; i++) { + aList.add(i); + } + + // Assert that the first and last elements are reachable, + // meaning that the size of the underlying array has been increased correctly. + assertTrue(aList.get(0) == 0); + assertTrue(aList.get(99999) == 99999); + + // Assert that the size attribute is correct + assertTrue(aList.size() == 100000); + } + + /** + * Tests that the private function shrink() in the ArrayList implementation + * in the file List.java works correctly. + * Requirement: If the size attribute becomes smaller than half the size of the underlying array, + * then the shrink() function should be called, which should decrease the size of said array. + */ + @Test + public void testShrinkArrayList() { + List.ArrayList aList = new List.ArrayList(); + + // Add 2000 elements, causing the underlying array go grow beyond the minimum size. + for (int i = 0; i < 2000; i++) { + aList.add(2); + } + + // Remove the first 1000 elements, so that the shrink() function is called + // from the remove function. + for (int i = 0; i < 1000; i++) { + aList.remove(i); + } + + // Assert that the size of the list is correct + assertTrue(aList.size() == 1000); + + // Assert that all elements in the list are reachable + for (int i = 0; i < 1000; i++) { + assertTrue(aList.get(i) == 2); + } + + // Assert that trying to reach an element outside the ArrayList returns null, + // meaning that the list has shrunk correctly. + assertTrue(aList.get(1000) == null); + } + + @Test + public void testRemoveInvalidIndex() { + List.ArrayList aList = new List.ArrayList(); + aList.add(2); + + // Requirement: If someone tries to remove an element at a negative (i.e. invalid) index + // in an ArrayList, then null should be returned. + assertTrue(aList.remove(-1) == null); + } + + @Test + public void testValidateListWithNullElement() { + List.ArrayList aList = new List.ArrayList(); + + // By adding a null value to the list, it should no longer be valid + aList.add(null); + + // Assert the following requirement: + // The validate() function should return false for lists with null elements. + assertTrue(!aList.validate()); + } } diff --git a/test/com/jwetherell/algorithms/graph/test/Graphs.java b/test/com/jwetherell/algorithms/graph/test/Graphs.java index 6a17dcd0..e0eb27cc 100644 --- a/test/com/jwetherell/algorithms/graph/test/Graphs.java +++ b/test/com/jwetherell/algorithms/graph/test/Graphs.java @@ -2,6 +2,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.*; import java.util.ArrayList; import java.util.HashMap; @@ -1006,4 +1007,72 @@ private static final Graph makeDirectedGraph(int N, int K, int[] values final Graph g = new Graph(TYPE.DIRECTED, vertices, edges); return g; } + + + @Test() + public void testFloydWarshallNull() throws Exception{ + Graph NullGraph = null; + + // Requirement: + // When graph is null an exception should be thrown + try{ + FloydWarshall.getAllPairsShortestPaths(NullGraph); + fail("Null graph should not be allowed"); + + } catch (NullPointerException e) { + // pass + } + + } + + @Test() + public void testBellmanFordNull() throws Exception{ + Graph NullGraph = null; + final Graph.Vertex start = null; + final Graph.Vertex end = null; + + // Requirement: + // When graph is null an exception should be thrown + try{ + BellmanFord.getShortestPath(NullGraph, start, end); + fail("Null graph should not be allowed"); + + } catch (NullPointerException e) { + // pass + } + + } + + @Test() + public void testKruskalNull() throws Exception{ + Graph NullGraph = null; + + // Requirement: + // When graph is null an exception should be thrown + try{ + Kruskal.getMinimumSpanningTree(NullGraph); + fail("Null graph should not be allowed"); + + } catch (NullPointerException e) { + // pass + } + } + + + @Test() + public void testKruskalDirected() throws Exception{ + final DirectedGraph directed = new DirectedGraph(); + + // Requirement: + // When graph is a directed graph an exception should be thrown + try{ + Kruskal.getMinimumSpanningTree(directed.graph); + fail("Directed graph should not be allowed"); + + } catch (IllegalArgumentException e) { + // pass + } + + } + } diff --git a/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java b/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java index c20381af..578d36eb 100644 --- a/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java +++ b/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java @@ -155,6 +155,33 @@ public void multiplication() { assertTrue("Multiplication using loop with int input. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); } } + @Test + public void testMultiplicationUsingFFTZero(){ + long result = Integer.parseInt(Multiplication.multiplyUsingFFT("0", "0")); + long expected = 0; + //Requirement: + //When multiplying two values where one or both is zero the result should be zero + assertTrue(result == expected); + } + + + // We think this test highlights a bug in the program, since the test fails. + // Therefore, we have commented out this test for now. + @Test + public void testMultiplyUsingLoopsWithStringInputZero(){ + long result = Integer.parseInt(Multiplication.multiplyUsingLoopWithStringInput("0", "0")); + long expected = 0; + //Requirement: + //When multiplying two values where one or both is zero the result should be zero + assertTrue(result ==expected); + + result = Integer.parseInt(Multiplication.multiplyUsingLoopWithStringInput("0000", "0000")); + expected = 0; + //Requirement: + //When multiplying two values where one or both is zero the result should be zero + assertTrue(result ==expected); + } + @Test public void division() { @@ -181,6 +208,16 @@ public void division() { assertTrue("Division using multiplication. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); } + @Test + public void testDivisionUsingLoopsNumeratorBiggerThanDenominator(){ + long result = Division.divisionUsingLoop(10, 5); + long expected = Division.division(10, 5); + //Requirement: + //previous tests did not include the case where the numerator is greater than the denominator, when this is the case a specific branch is supposed to be reached. + //But it is not represented as a requirement in some other way other than that the output should be the expected division result. + assertTrue(result == expected); + } + @Test public void knapsack() { int[] values = {7, 4, 8, 6, 2, 5}; @@ -309,4 +346,3 @@ public void millerRabin() { assertFalse("Miller-Rabin test error. " + composite, Primes.millerRabinTest(composite)); } } - diff --git a/test/com/jwetherell/algorithms/numbers/test/Numbers.java b/test/com/jwetherell/algorithms/numbers/test/Numbers.java index dcf087ab..3bc8cc72 100644 --- a/test/com/jwetherell/algorithms/numbers/test/Numbers.java +++ b/test/com/jwetherell/algorithms/numbers/test/Numbers.java @@ -38,6 +38,10 @@ public void testPowerOf2() { isPowOf2isNot = Integers.powerOfTwoUsingRecursion(isNot); assertTrue("Is power of 2 using recursion error", isPowOf2is); assertFalse("Is power of 2 using recursion error", isPowOf2isNot); + //Requirement: + // The function determines whether the input number is a power of 2, this should not be the case for input number = 0 + isPowOf2isNot = Integers.powerOfTwoUsingLoop(0); + assertFalse(isPowOf2isNot); } @Test @@ -75,7 +79,7 @@ public void testLongToBinaryString() { @Test public void testToEnglish() { - int a = -1001; + int a = -1001; String check = "negative one-thousand one"; String english = Integers.toEnglish(a); assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); From e44ceee5113452e7428f4bf7d1f9e5f0e1c73887 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Mon, 7 Mar 2022 15:56:34 +0100 Subject: [PATCH 15/27] Fixed merge conflict bug, added missing brackets --- src/com/jwetherell/algorithms/mathematics/Operations.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index be0d3e39..1ae607e7 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -22,8 +22,11 @@ else if (a instanceof Double || b instanceof Double){ else if (a instanceof Float || b instanceof Float){ return ((Float)a).compareTo((Float)b); } - else{ + else { return ((Integer)a).compareTo((Integer)b); + } + } + /* TODO: How to handle number overflow? */ public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ From 9a9a04283118edb0b2663e163abde783f1d498af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 15:05:19 +0100 Subject: [PATCH 16/27] Reverted change which removed unneeded for-loops. I have moved those changes to a separate branch, lab4removeForLoops, since it deals with a separate issue --- .../algorithms/data_structures/Matrix.java | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index bc084439..f71ccada 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -139,9 +139,11 @@ public Matrix add(Matrix input) { return output; for (int r = 0; r < output.rows; r++) { for (int c = 0; c < output.cols; c++) { - T m1 = this.get(r, c); - T m2 = input.get(r, c); - output.set(r, c, (T) Operations.addNumbers(m1, m2)); + for (int i = 0; i < cols; i++) { + T m1 = this.get(r, c); + T m2 = input.get(r, c); + output.set(r, c, (T) Operations.addNumbers(m1, m2)); + } } } return output; @@ -154,9 +156,11 @@ public Matrix subtract(Matrix input) { for (int r = 0; r < output.rows; r++) { for (int c = 0; c < output.cols; c++) { - T m1 = this.get(r, c); - T m2 = input.get(r, c); - output.set(r, c, (T) Operations.subtractNumbers(m1, m2)); + for (int i = 0; i < cols; i++) { + T m1 = this.get(r, c); + T m2 = input.get(r, c); + output.set(r, c, (T) Operations.subtractNumbers(m1, m2)); + } } } return output; From d09a9b8056ae38b66d58afed49473bdeeaf1da8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 15:14:10 +0100 Subject: [PATCH 17/27] Revert "Issue 118 (#119)" This reverts commit e97d3b7197805b82840442b4dc390936385eb4b6. This commit is reverted since it deals with a separate issue on the main-repo. We will move this commit to a separate branch, so we can make a separate pull request for this specific issue fix. --- .../mathematics/Multiplication.java | 3 - .../data_structures/test/ListTests.java | 81 ------------------- .../algorithms/graph/test/Graphs.java | 69 ---------------- .../mathematics/test/MathematicsTest.java | 38 +-------- .../algorithms/numbers/test/Numbers.java | 6 +- 5 files changed, 2 insertions(+), 195 deletions(-) diff --git a/src/com/jwetherell/algorithms/mathematics/Multiplication.java b/src/com/jwetherell/algorithms/mathematics/Multiplication.java index 7b965bf4..98db58a7 100644 --- a/src/com/jwetherell/algorithms/mathematics/Multiplication.java +++ b/src/com/jwetherell/algorithms/mathematics/Multiplication.java @@ -188,9 +188,6 @@ public static String multiplyUsingLoopWithStringInput(String a, String b) { zeroCheck = false; sb.append(s); } - if(sb.length()==0){ - return "0"; - } return sb.toString(); } diff --git a/test/com/jwetherell/algorithms/data_structures/test/ListTests.java b/test/com/jwetherell/algorithms/data_structures/test/ListTests.java index a0c6b1c3..c8806877 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/ListTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/ListTests.java @@ -181,85 +181,4 @@ public void testDoublyLinkedList() { assertTrue(JavaCollectionTest.testCollection(lCollection, Integer.class, lName, data.unsorted, data.sorted, data.invalid)); } - - /** - * Tests that the private function grow() in the ArrayList implementation - * in the file List.java works correctly. - * Requirement: If the size attribute exceeds the size of the underlying array, - * then the grow() function should be called, which should increase the size of said array. - */ - @Test - public void testGrowArrayList() { - List.ArrayList aList = new List.ArrayList(); - - // Add a large number (>1023) of elements to a list, - // so that the underlying array must be increased in size. - for (int i = 0; i < 100000; i++) { - aList.add(i); - } - - // Assert that the first and last elements are reachable, - // meaning that the size of the underlying array has been increased correctly. - assertTrue(aList.get(0) == 0); - assertTrue(aList.get(99999) == 99999); - - // Assert that the size attribute is correct - assertTrue(aList.size() == 100000); - } - - /** - * Tests that the private function shrink() in the ArrayList implementation - * in the file List.java works correctly. - * Requirement: If the size attribute becomes smaller than half the size of the underlying array, - * then the shrink() function should be called, which should decrease the size of said array. - */ - @Test - public void testShrinkArrayList() { - List.ArrayList aList = new List.ArrayList(); - - // Add 2000 elements, causing the underlying array go grow beyond the minimum size. - for (int i = 0; i < 2000; i++) { - aList.add(2); - } - - // Remove the first 1000 elements, so that the shrink() function is called - // from the remove function. - for (int i = 0; i < 1000; i++) { - aList.remove(i); - } - - // Assert that the size of the list is correct - assertTrue(aList.size() == 1000); - - // Assert that all elements in the list are reachable - for (int i = 0; i < 1000; i++) { - assertTrue(aList.get(i) == 2); - } - - // Assert that trying to reach an element outside the ArrayList returns null, - // meaning that the list has shrunk correctly. - assertTrue(aList.get(1000) == null); - } - - @Test - public void testRemoveInvalidIndex() { - List.ArrayList aList = new List.ArrayList(); - aList.add(2); - - // Requirement: If someone tries to remove an element at a negative (i.e. invalid) index - // in an ArrayList, then null should be returned. - assertTrue(aList.remove(-1) == null); - } - - @Test - public void testValidateListWithNullElement() { - List.ArrayList aList = new List.ArrayList(); - - // By adding a null value to the list, it should no longer be valid - aList.add(null); - - // Assert the following requirement: - // The validate() function should return false for lists with null elements. - assertTrue(!aList.validate()); - } } diff --git a/test/com/jwetherell/algorithms/graph/test/Graphs.java b/test/com/jwetherell/algorithms/graph/test/Graphs.java index e0eb27cc..6a17dcd0 100644 --- a/test/com/jwetherell/algorithms/graph/test/Graphs.java +++ b/test/com/jwetherell/algorithms/graph/test/Graphs.java @@ -2,7 +2,6 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.*; import java.util.ArrayList; import java.util.HashMap; @@ -1007,72 +1006,4 @@ private static final Graph makeDirectedGraph(int N, int K, int[] values final Graph g = new Graph(TYPE.DIRECTED, vertices, edges); return g; } - - - @Test() - public void testFloydWarshallNull() throws Exception{ - Graph NullGraph = null; - - // Requirement: - // When graph is null an exception should be thrown - try{ - FloydWarshall.getAllPairsShortestPaths(NullGraph); - fail("Null graph should not be allowed"); - - } catch (NullPointerException e) { - // pass - } - - } - - @Test() - public void testBellmanFordNull() throws Exception{ - Graph NullGraph = null; - final Graph.Vertex start = null; - final Graph.Vertex end = null; - - // Requirement: - // When graph is null an exception should be thrown - try{ - BellmanFord.getShortestPath(NullGraph, start, end); - fail("Null graph should not be allowed"); - - } catch (NullPointerException e) { - // pass - } - - } - - @Test() - public void testKruskalNull() throws Exception{ - Graph NullGraph = null; - - // Requirement: - // When graph is null an exception should be thrown - try{ - Kruskal.getMinimumSpanningTree(NullGraph); - fail("Null graph should not be allowed"); - - } catch (NullPointerException e) { - // pass - } - } - - - @Test() - public void testKruskalDirected() throws Exception{ - final DirectedGraph directed = new DirectedGraph(); - - // Requirement: - // When graph is a directed graph an exception should be thrown - try{ - Kruskal.getMinimumSpanningTree(directed.graph); - fail("Directed graph should not be allowed"); - - } catch (IllegalArgumentException e) { - // pass - } - - } - } diff --git a/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java b/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java index 578d36eb..c20381af 100644 --- a/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java +++ b/test/com/jwetherell/algorithms/mathematics/test/MathematicsTest.java @@ -155,33 +155,6 @@ public void multiplication() { assertTrue("Multiplication using loop with int input. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); } } - @Test - public void testMultiplicationUsingFFTZero(){ - long result = Integer.parseInt(Multiplication.multiplyUsingFFT("0", "0")); - long expected = 0; - //Requirement: - //When multiplying two values where one or both is zero the result should be zero - assertTrue(result == expected); - } - - - // We think this test highlights a bug in the program, since the test fails. - // Therefore, we have commented out this test for now. - @Test - public void testMultiplyUsingLoopsWithStringInputZero(){ - long result = Integer.parseInt(Multiplication.multiplyUsingLoopWithStringInput("0", "0")); - long expected = 0; - //Requirement: - //When multiplying two values where one or both is zero the result should be zero - assertTrue(result ==expected); - - result = Integer.parseInt(Multiplication.multiplyUsingLoopWithStringInput("0000", "0000")); - expected = 0; - //Requirement: - //When multiplying two values where one or both is zero the result should be zero - assertTrue(result ==expected); - } - @Test public void division() { @@ -208,16 +181,6 @@ public void division() { assertTrue("Division using multiplication. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); } - @Test - public void testDivisionUsingLoopsNumeratorBiggerThanDenominator(){ - long result = Division.divisionUsingLoop(10, 5); - long expected = Division.division(10, 5); - //Requirement: - //previous tests did not include the case where the numerator is greater than the denominator, when this is the case a specific branch is supposed to be reached. - //But it is not represented as a requirement in some other way other than that the output should be the expected division result. - assertTrue(result == expected); - } - @Test public void knapsack() { int[] values = {7, 4, 8, 6, 2, 5}; @@ -346,3 +309,4 @@ public void millerRabin() { assertFalse("Miller-Rabin test error. " + composite, Primes.millerRabinTest(composite)); } } + diff --git a/test/com/jwetherell/algorithms/numbers/test/Numbers.java b/test/com/jwetherell/algorithms/numbers/test/Numbers.java index 3bc8cc72..dcf087ab 100644 --- a/test/com/jwetherell/algorithms/numbers/test/Numbers.java +++ b/test/com/jwetherell/algorithms/numbers/test/Numbers.java @@ -38,10 +38,6 @@ public void testPowerOf2() { isPowOf2isNot = Integers.powerOfTwoUsingRecursion(isNot); assertTrue("Is power of 2 using recursion error", isPowOf2is); assertFalse("Is power of 2 using recursion error", isPowOf2isNot); - //Requirement: - // The function determines whether the input number is a power of 2, this should not be the case for input number = 0 - isPowOf2isNot = Integers.powerOfTwoUsingLoop(0); - assertFalse(isPowOf2isNot); } @Test @@ -79,7 +75,7 @@ public void testLongToBinaryString() { @Test public void testToEnglish() { - int a = -1001; + int a = -1001; String check = "negative one-thousand one"; String english = Integers.toEnglish(a); assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); From c586d458243d0550541e8e3cbba5109fca3578d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 15:38:11 +0100 Subject: [PATCH 18/27] Fixed #122. Added test coverage for Matrix.compare. --- .../data_structures/test/MatrixTests.java | 254 +++++++++++++++++- 1 file changed, 247 insertions(+), 7 deletions(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 11c4a04f..33c5f4f9 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -171,6 +171,246 @@ public void testMatrixLongOperations() { assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); } + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with Float values. + @Test + public void testMatrixFloatOperations() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, Float.valueOf(14)); + matrix1.set(0, 1, Float.valueOf(9)); + matrix1.set(0, 2, Float.valueOf(3)); + matrix1.set(1, 0, Float.valueOf(2)); + matrix1.set(1, 1, Float.valueOf(11)); + matrix1.set(1, 2, Float.valueOf(15)); + matrix1.set(2, 0, Float.valueOf(0)); + matrix1.set(2, 1, Float.valueOf(12)); + matrix1.set(2, 2, Float.valueOf(17)); + matrix1.set(3, 0, Float.valueOf(5)); + matrix1.set(3, 1, Float.valueOf(2)); + matrix1.set(3, 2, Float.valueOf(3)); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, Float.valueOf(12)); + matrix2.set(0, 1, Float.valueOf(25)); + matrix2.set(1, 0, Float.valueOf(9)); + matrix2.set(1, 1, Float.valueOf(10)); + matrix2.set(2, 0, Float.valueOf(8)); + matrix2.set(2, 1, Float.valueOf(5)); + + // Result of multiplication + Float[][] array1 = new Float[][]{{Float.valueOf(273),Float.valueOf(455)}, + {Float.valueOf(243),Float.valueOf(235)}, + {Float.valueOf(244),Float.valueOf(205)}, + {Float.valueOf(102),Float.valueOf(160)}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, Float.valueOf(counter++)); + + // Result of subtraction + Float[][] array2 = new Float[][]{{Float.valueOf(0),Float.valueOf(0)}, + {Float.valueOf(0),Float.valueOf(0)}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + Float[][] array3 = new Float[][]{{Float.valueOf(0),Float.valueOf(2)}, + {Float.valueOf(4),Float.valueOf(6)}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, Float.valueOf(1)); + matrix7.set(0, 1, Float.valueOf(2)); + matrix7.set(1, 0, Float.valueOf(3)); + matrix7.set(1, 1, Float.valueOf(4)); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, Float.valueOf(1)); + matrix8.set(0, 1, Float.valueOf(2)); + matrix8.set(1, 0, Float.valueOf(3)); + matrix8.set(1, 1, Float.valueOf(4)); + + // Result of multiplication + Float[][] array4 = new Float[][]{{Float.valueOf(7),Float.valueOf(10)}, + {Float.valueOf(15),Float.valueOf(22)}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } + + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with Double values. + @Test + public void testMatrixDoubleOperations() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, Double.valueOf(14)); + matrix1.set(0, 1, Double.valueOf(9)); + matrix1.set(0, 2, Double.valueOf(3)); + matrix1.set(1, 0, Double.valueOf(2)); + matrix1.set(1, 1, Double.valueOf(11)); + matrix1.set(1, 2, Double.valueOf(15)); + matrix1.set(2, 0, Double.valueOf(0)); + matrix1.set(2, 1, Double.valueOf(12)); + matrix1.set(2, 2, Double.valueOf(17)); + matrix1.set(3, 0, Double.valueOf(5)); + matrix1.set(3, 1, Double.valueOf(2)); + matrix1.set(3, 2, Double.valueOf(3)); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, Double.valueOf(12)); + matrix2.set(0, 1, Double.valueOf(25)); + matrix2.set(1, 0, Double.valueOf(9)); + matrix2.set(1, 1, Double.valueOf(10)); + matrix2.set(2, 0, Double.valueOf(8)); + matrix2.set(2, 1, Double.valueOf(5)); + + // Result of multiplication + Double[][] array1 = new Double[][]{{Double.valueOf(273),Double.valueOf(455)}, + {Double.valueOf(243),Double.valueOf(235)}, + {Double.valueOf(244),Double.valueOf(205)}, + {Double.valueOf(102),Double.valueOf(160)}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, Double.valueOf(counter++)); + + // Result of subtraction + Double[][] array2 = new Double[][]{{Double.valueOf(0),Double.valueOf(0)}, + {Double.valueOf(0),Double.valueOf(0)}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + Double[][] array3 = new Double[][]{{Double.valueOf(0),Double.valueOf(2)}, + {Double.valueOf(4),Double.valueOf(6)}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, Double.valueOf(1)); + matrix7.set(0, 1, Double.valueOf(2)); + matrix7.set(1, 0, Double.valueOf(3)); + matrix7.set(1, 1, Double.valueOf(4)); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, Double.valueOf(1)); + matrix8.set(0, 1, Double.valueOf(2)); + matrix8.set(1, 0, Double.valueOf(3)); + matrix8.set(1, 1, Double.valueOf(4)); + + // Result of multiplication + Double[][] array4 = new Double[][]{{Double.valueOf(7),Double.valueOf(10)}, + {Double.valueOf(15),Double.valueOf(22)}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } + + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with BigDecimal values. + @Test + public void testMatrixBigDecimalOperations() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, BigDecimal.valueOf(14)); + matrix1.set(0, 1, BigDecimal.valueOf(9)); + matrix1.set(0, 2, BigDecimal.valueOf(3)); + matrix1.set(1, 0, BigDecimal.valueOf(2)); + matrix1.set(1, 1, BigDecimal.valueOf(11)); + matrix1.set(1, 2, BigDecimal.valueOf(15)); + matrix1.set(2, 0, BigDecimal.valueOf(0)); + matrix1.set(2, 1, BigDecimal.valueOf(12)); + matrix1.set(2, 2, BigDecimal.valueOf(17)); + matrix1.set(3, 0, BigDecimal.valueOf(5)); + matrix1.set(3, 1, BigDecimal.valueOf(2)); + matrix1.set(3, 2, BigDecimal.valueOf(3)); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, BigDecimal.valueOf(12)); + matrix2.set(0, 1, BigDecimal.valueOf(25)); + matrix2.set(1, 0, BigDecimal.valueOf(9)); + matrix2.set(1, 1, BigDecimal.valueOf(10)); + matrix2.set(2, 0, BigDecimal.valueOf(8)); + matrix2.set(2, 1, BigDecimal.valueOf(5)); + + // Result of multiplication + BigDecimal[][] array1 = new BigDecimal[][]{{BigDecimal.valueOf(273),BigDecimal.valueOf(455)}, + {BigDecimal.valueOf(243),BigDecimal.valueOf(235)}, + {BigDecimal.valueOf(244),BigDecimal.valueOf(205)}, + {BigDecimal.valueOf(102),BigDecimal.valueOf(160)}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, BigDecimal.valueOf(counter++)); + + // Result of subtraction + BigDecimal[][] array2 = new BigDecimal[][]{{BigDecimal.valueOf(0),BigDecimal.valueOf(0)}, + {BigDecimal.valueOf(0),BigDecimal.valueOf(0)}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + BigDecimal[][] array3 = new BigDecimal[][]{{BigDecimal.valueOf(0),BigDecimal.valueOf(2)}, + {BigDecimal.valueOf(4),BigDecimal.valueOf(6)}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, BigDecimal.valueOf(1)); + matrix7.set(0, 1, BigDecimal.valueOf(2)); + matrix7.set(1, 0, BigDecimal.valueOf(3)); + matrix7.set(1, 1, BigDecimal.valueOf(4)); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, BigDecimal.valueOf(1)); + matrix8.set(0, 1, BigDecimal.valueOf(2)); + matrix8.set(1, 0, BigDecimal.valueOf(3)); + matrix8.set(1, 1, BigDecimal.valueOf(4)); + + // Result of multiplication + BigDecimal[][] array4 = new BigDecimal[][]{{BigDecimal.valueOf(7),BigDecimal.valueOf(10)}, + {BigDecimal.valueOf(15),BigDecimal.valueOf(22)}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } + // Requirement: Matrix addition, subtraction, and multiplication should work correctly with BigInteger values. @Test public void testMatrixBigIntegerOperations() { @@ -198,9 +438,9 @@ public void testMatrixBigIntegerOperations() { // Result of multiplication BigInteger[][] array1 = new BigInteger[][]{{BigInteger.valueOf(273),BigInteger.valueOf(455)}, - {BigInteger.valueOf(243),BigInteger.valueOf(235)}, - {BigInteger.valueOf(244),BigInteger.valueOf(205)}, - {BigInteger.valueOf(102),BigInteger.valueOf(160)}}; + {BigInteger.valueOf(243),BigInteger.valueOf(235)}, + {BigInteger.valueOf(244),BigInteger.valueOf(205)}, + {BigInteger.valueOf(102),BigInteger.valueOf(160)}}; Matrix result1 = new Matrix(4,2,array1); Matrix matrix3 = matrix1.multiply(matrix2); @@ -216,7 +456,7 @@ public void testMatrixBigIntegerOperations() { // Result of subtraction BigInteger[][] array2 = new BigInteger[][]{{BigInteger.valueOf(0),BigInteger.valueOf(0)}, - {BigInteger.valueOf(0),BigInteger.valueOf(0)}}; + {BigInteger.valueOf(0),BigInteger.valueOf(0)}}; Matrix result2 = new Matrix(2,2,array2); Matrix matrix5 = matrix4.subtract(matrix4); @@ -224,7 +464,7 @@ public void testMatrixBigIntegerOperations() { // Result of addition BigInteger[][] array3 = new BigInteger[][]{{BigInteger.valueOf(0),BigInteger.valueOf(2)}, - {BigInteger.valueOf(4),BigInteger.valueOf(6)}}; + {BigInteger.valueOf(4),BigInteger.valueOf(6)}}; Matrix result3 = new Matrix(2,2,array3); Matrix matrix6 = matrix4.add(matrix4); @@ -244,13 +484,13 @@ public void testMatrixBigIntegerOperations() { // Result of multiplication BigInteger[][] array4 = new BigInteger[][]{{BigInteger.valueOf(7),BigInteger.valueOf(10)}, - {BigInteger.valueOf(15),BigInteger.valueOf(22)}}; + {BigInteger.valueOf(15),BigInteger.valueOf(22)}}; Matrix result4 = new Matrix(2,2,array4); Matrix matrix9 = matrix7.multiply(matrix8); assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); } - + @Test public void testIdentityMethod1() { Matrix matrix = new Matrix(2, 2); From f0ac979fb113960572d758997e9064ea5ad45c1f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 16:06:30 +0100 Subject: [PATCH 19/27] Fixed #123. Removed unnecessary whitespace. --- .gitignore | 3 +-- .../algorithms/data_structures/Matrix.java | 1 - .../test/FenwickTreeTests.java | 12 ++--------- .../test/SegmentTreeTests.java | 20 ------------------- 4 files changed, 3 insertions(+), 33 deletions(-) diff --git a/.gitignore b/.gitignore index 45736ff0..2b9a78be 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ /bin/ /build/ -/dist/ -output.txt \ No newline at end of file +/dist/ \ No newline at end of file diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index f71ccada..860bb101 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -189,7 +189,6 @@ public void copy(Matrix m) { } } } - /** * {@inheritDoc} diff --git a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java index 02de1474..fe5f3ce8 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java @@ -47,7 +47,6 @@ public void testRangeSumFenwickTree() { testRangeSumFenwickTree(segments); } - private void testRangeSumFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); @@ -330,7 +329,7 @@ public void testFloatFenwickTree() { testFloatFenwickTree(segments); } - private void testFloatFenwickTree(List> segments) { // Range Sum Segment tree + private void testFloatFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); @@ -348,7 +347,6 @@ private void testFloatFenwickTree(List> seg // except the case in separate where "this.sum == null && data.sum != null" since it will not be possible to test as // a separated number supposed to be null (this.sum) from a sum which is not null (data.sum) is equal to 0.0 and not null // when separated - @Test public void testNullFenwickTree() { List> segments = new ArrayList>(); @@ -377,7 +375,7 @@ public void testNullFenwickTree() { testNullFenwickTree(segments); } - private void testNullFenwickTree(List> segments) { // Range Sum Segment tree + private void testNullFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree1 = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree1.query(0, 3); @@ -402,11 +400,5 @@ private void testNullFenwickTree(List> segm query = tree1.query(2, 3); // stabbing assertTrue("Segment tree query error. query=2->3 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); - - } - - - - } diff --git a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java index c3632d9e..fda7d89d 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java @@ -413,11 +413,6 @@ private void testRangeMaxSegmentTreeFloat(java.util.List Date: Tue, 8 Mar 2022 16:08:48 +0100 Subject: [PATCH 20/27] Removed whitespaces changes to .gitignore --- .gitignore | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 2b9a78be..f4d30d4c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,2 @@ /bin/ -/build/ -/dist/ \ No newline at end of file +/build/ \ No newline at end of file From 8780d103ac7a31604fb92ea7b7d0dee4471c73df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 16:09:52 +0100 Subject: [PATCH 21/27] Second try: Removed whitespaces changes to .gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index f4d30d4c..2b9a78be 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ /bin/ -/build/ \ No newline at end of file +/build/ +/dist/ \ No newline at end of file From 8de810274624d5afbd7981335d771f3b7825357f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 16:10:49 +0100 Subject: [PATCH 22/27] Added back newline at end of .gitignore --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 2b9a78be..23842834 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ /bin/ /build/ -/dist/ \ No newline at end of file +/dist/ From 37dc12c2c8d5e943b472f87451c2bba73c98810c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Tue, 8 Mar 2022 16:15:51 +0100 Subject: [PATCH 23/27] Removed duplicate import and unneeded whitespace --- src/com/jwetherell/algorithms/data_structures/Matrix.java | 2 -- src/com/jwetherell/algorithms/mathematics/Operations.java | 3 --- .../algorithms/data_structures/test/FenwickTreeTests.java | 8 ++++---- 3 files changed, 4 insertions(+), 9 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 860bb101..180d2e13 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -5,8 +5,6 @@ import java.util.Comparator; import com.jwetherell.algorithms.mathematics.Operations; -import com.jwetherell.algorithms.mathematics.Operations; - /** * Matrx. This Matrix implementation is designed to be more efficient * in cache. A matrix is a rectangular array of numbers, symbols, or expressions. diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index 1ae607e7..36543685 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -4,8 +4,6 @@ import java.math.BigInteger; public class Operations { - - public static int compare(Number a, Number b){ if (a instanceof BigDecimal || b instanceof BigDecimal){ return ((BigDecimal)a).compareTo((BigDecimal)b); @@ -27,7 +25,6 @@ else if (a instanceof Float || b instanceof Float){ } } - /* TODO: How to handle number overflow? */ public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ if (test instanceof BigDecimal) { diff --git a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java index fe5f3ce8..f298802d 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java @@ -143,7 +143,7 @@ private static final void assertTrue(String msg, Fe // Requirement: // When FenwickTree consists of data with BigDecimal numbers it should be able to sum them up correctly - @Test + @Test public void testBigDecimalFenwickTree() { List> segments = new ArrayList>(); segments.add(new FenwickTree.Data.RangeSumData(0, (BigDecimal) new BigDecimal(1.1))); @@ -169,7 +169,7 @@ public void testBigDecimalFenwickTree() { testBigDecimalFenwickTree(segments); } - private void testBigDecimalFenwickTree(List> segments) { // Range Sum Segment tree + private void testBigDecimalFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); @@ -209,7 +209,7 @@ public void testBigIntegerFenwickTree() { testBigIntegerFenwickTree(segments); } - private void testBigIntegerFenwickTree(List> segments) { // Range Sum Segment tree + private void testBigIntegerFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); @@ -249,7 +249,7 @@ public void testLongFenwickTree() { testLongFenwickTree(segments); } - private void testLongFenwickTree(List> segments) { // Range Sum Segment tree + private void testLongFenwickTree(List> segments) { // Range Sum Segment tree FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); From 24679e00bd151accea3a2132422aff5561496e27 Mon Sep 17 00:00:00 2001 From: Beatrice Berg <72010841+reversedpeach@users.noreply.github.com> Date: Tue, 8 Mar 2022 18:54:05 +0100 Subject: [PATCH 24/27] Fixed #120. feat: Added documentation to Operations.java (#124) --- .../algorithms/mathematics/Operations.java | 28 +++++++++++++++++-- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index 36543685..e4ff3561 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -3,7 +3,17 @@ import java.math.BigDecimal; import java.math.BigInteger; +/** + * Mathematical operations adapted to support input of the different numeric types + * Integer, Float, Double, Long, BigDecimal and BigInteger. + */ public class Operations { + + /* + * Compares two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger + * + * TODO: How to handle number overflow? + */ public static int compare(Number a, Number b){ if (a instanceof BigDecimal || b instanceof BigDecimal){ return ((BigDecimal)a).compareTo((BigDecimal)b); @@ -25,7 +35,11 @@ else if (a instanceof Float || b instanceof Float){ } } - /* TODO: How to handle number overflow? */ + /* + * Multiplies two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger in a row + * + * TODO: How to handle number overflow? + */ public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ if (test instanceof BigDecimal) { BigDecimal result = BigDecimal.ZERO; @@ -85,7 +99,11 @@ public static Number rowMultiplication(Number test, Number[] row, Number[] colum } } - /* TODO: How to handle number overflow? */ + /* + * Adds two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger + * + * TODO: How to handle number overflow? + */ public static Number addNumbers(Number m1, Number m2) { if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { return ((BigDecimal)m1).add((BigDecimal)m2); @@ -103,7 +121,11 @@ public static Number addNumbers(Number m1, Number m2) { } } - /* TODO: How to handle number overflow? */ + /* + * Subtracts one number from another of the type Integer, Float, Double, Long, BigDecimal or BigInteger + * + * TODO: How to handle number overflow? + */ public static Number subtractNumbers(Number m1, Number m2) { if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { return ((BigDecimal)m1).subtract((BigDecimal)m2); From f9dc7495fa838112335fee8882ac96f39dc79eac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Wed, 9 Mar 2022 02:54:01 +0100 Subject: [PATCH 25/27] Removed 'This is ugly' comments, since we refactored those functions --- src/com/jwetherell/algorithms/data_structures/SegmentTree.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java index cd7c18b9..8a223d73 100644 --- a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java +++ b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java @@ -342,7 +342,6 @@ else if (this.maximum != null && data.maximum == null) else if (this.maximum == null && data.maximum != null) this.maximum = data.maximum; else { - /* TODO: This is ugly */ if(Operations.compare(data.maximum, this.maximum) == 1){ this.maximum = data.maximum; } @@ -456,7 +455,6 @@ else if (this.minimum != null && data.minimum == null) else if (this.minimum == null && data.minimum != null) this.minimum = data.minimum; else { - /* TODO: This is ugly */ if(Operations.compare(data.minimum, this.minimum) == -1){ this.minimum = data.minimum; } From 72c4c9ef31e33b20f3199b614bf9d1ee4524d933 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Wed, 9 Mar 2022 03:46:06 +0100 Subject: [PATCH 26/27] Removed unnecessary whitespace. --- .../algorithms/data_structures/Matrix.java | 2 +- .../algorithms/mathematics/Operations.java | 18 ++++---- .../test/FenwickTreeTests.java | 28 ++++++------ .../data_structures/test/MatrixTests.java | 44 +++++++++---------- .../test/SegmentTreeTests.java | 22 +++++----- 5 files changed, 57 insertions(+), 57 deletions(-) diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 180d2e13..270ee532 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -27,7 +27,7 @@ public class Matrix { @Override public int compare(T o1, T o2) { /* TODO: What if Java adds new numeric type? */ - return Operations.compare(o1, o2); + return Operations.compare(o1, o2); } }; diff --git a/src/com/jwetherell/algorithms/mathematics/Operations.java b/src/com/jwetherell/algorithms/mathematics/Operations.java index e4ff3561..ac477310 100644 --- a/src/com/jwetherell/algorithms/mathematics/Operations.java +++ b/src/com/jwetherell/algorithms/mathematics/Operations.java @@ -12,21 +12,21 @@ public class Operations { /* * Compares two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger * - * TODO: How to handle number overflow? + * TODO: How to handle number overflow? */ public static int compare(Number a, Number b){ if (a instanceof BigDecimal || b instanceof BigDecimal){ return ((BigDecimal)a).compareTo((BigDecimal)b); - } + } else if (a instanceof BigInteger || b instanceof BigInteger){ return ((BigInteger)a).compareTo((BigInteger)b); - } + } else if (a instanceof Long || b instanceof Long){ return ((Long)a).compareTo((Long)b); - } + } else if (a instanceof Double || b instanceof Double){ return ((Double)a).compareTo((Double)b); - } + } else if (a instanceof Float || b instanceof Float){ return ((Float)a).compareTo((Float)b); } @@ -34,11 +34,11 @@ else if (a instanceof Float || b instanceof Float){ return ((Integer)a).compareTo((Integer)b); } } - + /* * Multiplies two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger in a row * - * TODO: How to handle number overflow? + * TODO: How to handle number overflow? */ public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){ if (test instanceof BigDecimal) { @@ -102,7 +102,7 @@ public static Number rowMultiplication(Number test, Number[] row, Number[] colum /* * Adds two number of the type Integer, Float, Double, Long, BigDecimal or BigInteger * - * TODO: How to handle number overflow? + * TODO: How to handle number overflow? */ public static Number addNumbers(Number m1, Number m2) { if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { @@ -124,7 +124,7 @@ public static Number addNumbers(Number m1, Number m2) { /* * Subtracts one number from another of the type Integer, Float, Double, Long, BigDecimal or BigInteger * - * TODO: How to handle number overflow? + * TODO: How to handle number overflow? */ public static Number subtractNumbers(Number m1, Number m2) { if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { diff --git a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java index f298802d..efa5e4e1 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java @@ -141,7 +141,7 @@ private static final void assertTrue(String msg, Fe Assert.assertTrue(msg+toString, isTrue); } - // Requirement: + // Requirement: // When FenwickTree consists of data with BigDecimal numbers it should be able to sum them up correctly @Test public void testBigDecimalFenwickTree() { @@ -173,7 +173,7 @@ private void testBigDecimalFenwickTree(List> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); - + query = tree.query(2); assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new BigDecimal(6.1)) == 0); @@ -181,7 +181,7 @@ private void testBigDecimalFenwickTree(List1 result="+ query, tree, query.sum.compareTo(new BigDecimal(1.1).add(new BigDecimal(2.1))) == 0); } - // Requirement: + // Requirement: // When FenwickTree consists of data with BigInteger numbers it should be able to sum them up correctly @Test public void testBigIntegerFenwickTree() { @@ -213,7 +213,7 @@ private void testBigIntegerFenwickTree(List> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); - + query = tree.query(2); assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(BigInteger.valueOf(6)) == 0); @@ -221,7 +221,7 @@ private void testBigIntegerFenwickTree(List1 result="+ query, tree, query.sum.compareTo(BigInteger.valueOf(1).add(BigInteger.valueOf(2))) == 0); } - // Requirement: + // Requirement: // When FenwickTree consists of data with Long numbers it should be able to sum them up correctly @Test public void testLongFenwickTree() { @@ -253,7 +253,7 @@ private void testLongFenwickTree(List> segme FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); - + query = tree.query(2); assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(Long.valueOf(6)) == 0); @@ -261,7 +261,7 @@ private void testLongFenwickTree(List> segme assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(Long.sum(Long.valueOf(1), (Long.valueOf(2)))) == 0); } - // Requirement: + // Requirement: // When FenwickTree consists of data with Double numbers it should be able to sum them up correctly @Test public void testDoubleFenwickTree() { @@ -301,7 +301,7 @@ private void testDoubleFenwickTree(List> s assertTrue("Segment tree query error. query=0->1 result="+ query, tree, query.sum.compareTo(Double.sum(new Double(1.11),(new Double(2.11)))) == 0); } - // Requirement: + // Requirement: // When FenwickTree consists of data with Float numbers it should be able to sum them up correctly @Test public void testFloatFenwickTree() { @@ -333,7 +333,7 @@ private void testFloatFenwickTree(List> seg FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); - + query = tree.query(2); assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new Float(6.11)) == 0); @@ -342,10 +342,10 @@ private void testFloatFenwickTree(List> seg } - // Requirement: - // Added branch coverage for when an element is null when using the functions combined and separate for every case - // except the case in separate where "this.sum == null && data.sum != null" since it will not be possible to test as - // a separated number supposed to be null (this.sum) from a sum which is not null (data.sum) is equal to 0.0 and not null + // Requirement: + // Added branch coverage for when an element is null when using the functions combined and separate for every case + // except the case in separate where "this.sum == null && data.sum != null" since it will not be possible to test as + // a separated number supposed to be null (this.sum) from a sum which is not null (data.sum) is equal to 0.0 and not null // when separated @Test public void testNullFenwickTree() { @@ -397,7 +397,7 @@ private void testNullFenwickTree(List> segm query = tree1.query(0, 3); // stabbing assertTrue("Segment tree query error. query=0->3 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); - + query = tree1.query(2, 3); // stabbing assertTrue("Segment tree query error. query=2->3 result="+ query, tree1, query.sum.compareTo(new Float(6.11)) == 0); } diff --git a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java index 33c5f4f9..84fcd51c 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -524,14 +524,14 @@ public void testAddLong() { matrix.set(1, 0, Long.valueOf(3)); matrix.set(1, 1, Long.valueOf(4)); - Matrix actualResult = matrix.add(matrix); + Matrix actualResult = matrix.add(matrix); Matrix expectedResult = new Matrix(2, 2); expectedResult.set(0, 0, Long.valueOf(2)); expectedResult.set(0, 1, Long.valueOf(4)); expectedResult.set(1, 0, Long.valueOf(6)); expectedResult.set(1, 1, Long.valueOf(8)); - + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } @@ -545,14 +545,14 @@ public void testAddBigInteger() { matrix.set(1, 0, BigInteger.valueOf(3)); matrix.set(1, 1, BigInteger.valueOf(4)); - Matrix actualResult = matrix.add(matrix); + Matrix actualResult = matrix.add(matrix); Matrix expectedResult = new Matrix(2, 2); expectedResult.set(0, 0, BigInteger.valueOf(2)); expectedResult.set(0, 1, BigInteger.valueOf(4)); expectedResult.set(1, 0, BigInteger.valueOf(6)); expectedResult.set(1, 1, BigInteger.valueOf(8)); - + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } @@ -563,7 +563,7 @@ public void testAddFloat() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new Float(1.1)); - Matrix actual = matrix.add(matrix); + Matrix actual = matrix.add(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Float(2.2)); @@ -585,7 +585,7 @@ public void testAddDouble() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new Double(1.1)); - Matrix actual = matrix.add(matrix); + Matrix actual = matrix.add(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Double(2.2)); @@ -607,7 +607,7 @@ public void testAddBigDecimal() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new BigDecimal(1.1)); - Matrix actual = matrix.add(matrix); + Matrix actual = matrix.add(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new BigDecimal(2.2)); @@ -639,14 +639,14 @@ public void testSubtractLong() { matrix2.set(1, 0, Long.valueOf(3*2)); matrix2.set(1, 1, Long.valueOf(4*2)); - Matrix actualResult = matrix1.subtract(matrix2); + Matrix actualResult = matrix1.subtract(matrix2); Matrix expectedResult = new Matrix(2, 2); expectedResult.set(0, 0, Long.valueOf(-1)); expectedResult.set(0, 1, Long.valueOf(-2)); expectedResult.set(1, 0, Long.valueOf(-3)); expectedResult.set(1, 1, Long.valueOf(-4)); - + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } @@ -659,21 +659,21 @@ public void testSubtractBigInteger() { matrix1.set(0, 1, BigInteger.valueOf(2)); matrix1.set(1, 0, BigInteger.valueOf(3)); matrix1.set(1, 1, BigInteger.valueOf(4)); - + Matrix matrix2 = new Matrix(2, 2); matrix2.set(0, 0, BigInteger.valueOf(1*2)); matrix2.set(0, 1, BigInteger.valueOf(2*2)); matrix2.set(1, 0, BigInteger.valueOf(3*2)); matrix2.set(1, 1, BigInteger.valueOf(4*2)); - - Matrix actualResult = matrix1.subtract(matrix2); - + + Matrix actualResult = matrix1.subtract(matrix2); + Matrix expectedResult = new Matrix(2, 2); expectedResult.set(0, 0, BigInteger.valueOf(-1)); expectedResult.set(0, 1, BigInteger.valueOf(-2)); expectedResult.set(1, 0, BigInteger.valueOf(-3)); expectedResult.set(1, 1, BigInteger.valueOf(-4)); - + assertArrayEquals(expectedResult.getRow(0), actualResult.getRow(0)); assertArrayEquals(expectedResult.getRow(1), actualResult.getRow(1)); } @@ -687,7 +687,7 @@ public void testSubtractFloat() { Matrix matrix2 = new Matrix(1, 1); matrix2.set(0, 0, new Float(1.1*2)); - Matrix actual = matrix1.subtract(matrix2); + Matrix actual = matrix1.subtract(matrix2); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Float(-1.1)); @@ -712,7 +712,7 @@ public void testSubtractDouble() { Matrix matrix2 = new Matrix(1, 1); matrix2.set(0, 0, new Double(1.1*2)); - Matrix actual = matrix1.subtract(matrix2); + Matrix actual = matrix1.subtract(matrix2); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Double(-1.1)); @@ -737,7 +737,7 @@ public void testSubtractBigDecimal() { Matrix matrix2 = new Matrix(1, 1); matrix2.set(0, 0, new BigDecimal(1.1*2)); - Matrix actual = matrix1.subtract(matrix2); + Matrix actual = matrix1.subtract(matrix2); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new BigDecimal(-1.1)); @@ -760,7 +760,7 @@ public void testMultiplyLong() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new Long(2)); - Matrix actual = matrix.multiply(matrix); + Matrix actual = matrix.multiply(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Long(4)); @@ -778,7 +778,7 @@ public void testMultiplyBigInteger() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, BigInteger.valueOf(2)); - Matrix actual = matrix.multiply(matrix); + Matrix actual = matrix.multiply(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, BigInteger.valueOf(4)); @@ -796,7 +796,7 @@ public void testMultiplyFloat() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new Float(1.1)); - Matrix actual = matrix.multiply(matrix); + Matrix actual = matrix.multiply(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Float(1.21)); @@ -818,7 +818,7 @@ public void testMultiplyDouble() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new Double(1.1)); - Matrix actual = matrix.multiply(matrix); + Matrix actual = matrix.multiply(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new Double(1.21)); @@ -840,7 +840,7 @@ public void testMultiplyBigDecimal() { Matrix matrix = new Matrix(1, 1); matrix.set(0, 0, new BigDecimal(1.1)); - Matrix actual = matrix.multiply(matrix); + Matrix actual = matrix.multiply(matrix); Matrix expected = new Matrix(1, 1); expected.set(0, 0, new BigDecimal(1.21)); diff --git a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java index fda7d89d..2187d415 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java @@ -481,7 +481,7 @@ public void testRangeMinSegmentTreeBigInteger() { segments.add(new SegmentTree.Data.RangeMinimumData(4, BigInteger.valueOf(1))); segments.add(new SegmentTree.Data.RangeMinimumData(5, BigInteger.valueOf(5))); segments.add(new SegmentTree.Data.RangeMinimumData(6, BigInteger.valueOf(0))); - segments.add(new SegmentTree.Data.RangeMinimumData(17, BigInteger.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, BigInteger.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -539,7 +539,7 @@ public void testRangeMinSegmentTreeBigDecimal() { segments.add(new SegmentTree.Data.RangeMinimumData(4, BigDecimal.valueOf(1))); segments.add(new SegmentTree.Data.RangeMinimumData(5, BigDecimal.valueOf(5))); segments.add(new SegmentTree.Data.RangeMinimumData(6, BigDecimal.valueOf(0))); - segments.add(new SegmentTree.Data.RangeMinimumData(17, BigDecimal.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, BigDecimal.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -597,7 +597,7 @@ public void testRangeMinSegmentTreeLong() { segments.add(new SegmentTree.Data.RangeMinimumData(4, Long.valueOf(1))); segments.add(new SegmentTree.Data.RangeMinimumData(5, Long.valueOf(5))); segments.add(new SegmentTree.Data.RangeMinimumData(6, Long.valueOf(0))); - segments.add(new SegmentTree.Data.RangeMinimumData(17, Long.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Long.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -655,7 +655,7 @@ public void testRangeMinSegmentTreeDouble() { segments.add(new SegmentTree.Data.RangeMinimumData(4, Double.valueOf(1))); segments.add(new SegmentTree.Data.RangeMinimumData(5, Double.valueOf(5))); segments.add(new SegmentTree.Data.RangeMinimumData(6, Double.valueOf(0))); - segments.add(new SegmentTree.Data.RangeMinimumData(17, Double.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Double.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -713,7 +713,7 @@ public void testRangeMinSegmentTreeFloat() { segments.add(new SegmentTree.Data.RangeMinimumData(4, Float.valueOf(1))); segments.add(new SegmentTree.Data.RangeMinimumData(5, Float.valueOf(5))); segments.add(new SegmentTree.Data.RangeMinimumData(6, Float.valueOf(0))); - segments.add(new SegmentTree.Data.RangeMinimumData(17, Float.valueOf(7))); + segments.add(new SegmentTree.Data.RangeMinimumData(17, Float.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -771,7 +771,7 @@ public void testRangeSumSegmentTreeInteger() { segments.add(new SegmentTree.Data.RangeSumData(4, (Integer) 1)); segments.add(new SegmentTree.Data.RangeSumData(5, (Integer) 5)); segments.add(new SegmentTree.Data.RangeSumData(6, (Integer) 0)); - segments.add(new SegmentTree.Data.RangeSumData(17, (Integer) 7)); + segments.add(new SegmentTree.Data.RangeSumData(17, (Integer) 7)); // No matter which order the data is given, all tests should pass @@ -823,7 +823,7 @@ public void testRangeSumSegmentTreeBigInteger() { segments.add(new SegmentTree.Data.RangeSumData(4, BigInteger.valueOf(1))); segments.add(new SegmentTree.Data.RangeSumData(5, BigInteger.valueOf(5))); segments.add(new SegmentTree.Data.RangeSumData(6, BigInteger.valueOf(0))); - segments.add(new SegmentTree.Data.RangeSumData(17, BigInteger.valueOf(7))); + segments.add(new SegmentTree.Data.RangeSumData(17, BigInteger.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -875,7 +875,7 @@ public void testRangeSumSegmentTreeBigDecimal() { segments.add(new SegmentTree.Data.RangeSumData(4, BigDecimal.valueOf(1))); segments.add(new SegmentTree.Data.RangeSumData(5, BigDecimal.valueOf(5))); segments.add(new SegmentTree.Data.RangeSumData(6, BigDecimal.valueOf(0))); - segments.add(new SegmentTree.Data.RangeSumData(17, BigDecimal.valueOf(7))); + segments.add(new SegmentTree.Data.RangeSumData(17, BigDecimal.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -927,7 +927,7 @@ public void testRangeSumSegmentTreeLong() { segments.add(new SegmentTree.Data.RangeSumData(4, Long.valueOf(1))); segments.add(new SegmentTree.Data.RangeSumData(5, Long.valueOf(5))); segments.add(new SegmentTree.Data.RangeSumData(6, Long.valueOf(0))); - segments.add(new SegmentTree.Data.RangeSumData(17, Long.valueOf(7))); + segments.add(new SegmentTree.Data.RangeSumData(17, Long.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -979,7 +979,7 @@ public void testRangeSumSegmentTreeDouble() { segments.add(new SegmentTree.Data.RangeSumData(4, Double.valueOf(1))); segments.add(new SegmentTree.Data.RangeSumData(5, Double.valueOf(5))); segments.add(new SegmentTree.Data.RangeSumData(6, Double.valueOf(0))); - segments.add(new SegmentTree.Data.RangeSumData(17, Double.valueOf(7))); + segments.add(new SegmentTree.Data.RangeSumData(17, Double.valueOf(7))); // No matter which order the data is given, all tests should pass @@ -1031,7 +1031,7 @@ public void testRangeSumSegmentTreeBigFloat() { segments.add(new SegmentTree.Data.RangeSumData(4, Float.valueOf(1))); segments.add(new SegmentTree.Data.RangeSumData(5, Float.valueOf(5))); segments.add(new SegmentTree.Data.RangeSumData(6, Float.valueOf(0))); - segments.add(new SegmentTree.Data.RangeSumData(17, Float.valueOf(7))); + segments.add(new SegmentTree.Data.RangeSumData(17, Float.valueOf(7))); // No matter which order the data is given, all tests should pass From fa45cbf41228e2d344389a262f86b51e997036ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20=C3=85kerfeldt?= Date: Wed, 9 Mar 2022 03:48:05 +0100 Subject: [PATCH 27/27] Removed unnecessary whitespace. --- .../algorithms/data_structures/test/FenwickTreeTests.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java index efa5e4e1..e842984a 100644 --- a/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java +++ b/test/com/jwetherell/algorithms/data_structures/test/FenwickTreeTests.java @@ -293,7 +293,7 @@ private void testDoubleFenwickTree(List> s FenwickTree> tree = new FenwickTree>(segments); FenwickTree.Data.RangeSumData query = tree.query(0, 3); - + query = tree.query(2); assertTrue("Segment tree query error. query=2 result="+query, tree, query.sum.compareTo(new Double(6.11)) == 0);