From 93845890c1ed069ee0707943ea6989d2e5a69358 Mon Sep 17 00:00:00 2001 From: MrLetsplay Date: Tue, 21 Nov 2023 23:54:44 +0100 Subject: [PATCH] Add more decimal calculations --- .../shareclientcore/document/Util.java | 41 +++++++++++++++++- .../shareclientcore/DecimalTest.java | 42 +++++++++++++++++-- 2 files changed, 79 insertions(+), 4 deletions(-) diff --git a/src/main/java/me/mrletsplay/shareclientcore/document/Util.java b/src/main/java/me/mrletsplay/shareclientcore/document/Util.java index 4c92a70..01d8e5e 100644 --- a/src/main/java/me/mrletsplay/shareclientcore/document/Util.java +++ b/src/main/java/me/mrletsplay/shareclientcore/document/Util.java @@ -44,7 +44,27 @@ public class Util { return null; } - public static void getIncrement(Identifier[] i1, Identifier[] i2, int offset) { + public static int[] getIncremented(Identifier[] i1, Identifier[] i2, int offset) { + // TODO: can potentially be optimized by just calculating the index of the first non-zero digit (e.g. don't return array and discard it -> just return the index) + int[] delta = subtract(i2, i1, offset); + int firstNonZero = 0; + for(int i = 0; i < delta.length; i++) { + if(delta[i] != 0) { + firstNonZero = i; + break; + } + } + + // Because of math, (firstNonZero + 1) >= i1.length (I think) + // then make the array 1 longer so we have space for the increment (which is one order of magnitude smaller) + int[] incremented = new int[firstNonZero + 2]; + for(int i = 0; i < incremented.length; i++) { + incremented[i] = i <= i1.length ? i1[i].digit() : 0; + } + + add1AtIndex(incremented, firstNonZero + 1); // last digit might be zero, which is ambigious, inc again + if(incremented[incremented.length - 1] == 0) add1AtIndex(incremented, firstNonZero + 1); + return incremented; } /** @@ -67,7 +87,26 @@ public class Util { } } + if(carry == 1) throw new RuntimeException("Can't subtract numbers (are you sure a > b?)"); + return diff; } + public static void add1AtIndex(int[] a, int index) { + // Technically, some of the overflow preventions are probably overkill since the biggest carry we can get is 1 (we're only adding a 1 somewhere after all) + + int carry = 0; + for(int i = a.length - 1; i >= 0; i--) { + int dA = a[i]; + int dB = (index == i ? 1 : 0) + carry; + + carry = dB - (BASE - dA) + 1; // Calculate carry and be overflow-safe + if(carry < 0) carry = 0; + + a[i] = carry != 0 ? -BASE + dA + dB : dA + dB; // Calculate sum of digits and be overflow-safe + } + + if(carry == 1) throw new RuntimeException("Can't add numbers: Too large"); + } + } diff --git a/src/test/java/me/mrletsplay/shareclientcore/DecimalTest.java b/src/test/java/me/mrletsplay/shareclientcore/DecimalTest.java index ddccb31..4bcd748 100644 --- a/src/test/java/me/mrletsplay/shareclientcore/DecimalTest.java +++ b/src/test/java/me/mrletsplay/shareclientcore/DecimalTest.java @@ -1,6 +1,7 @@ package me.mrletsplay.shareclientcore; import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import org.junit.jupiter.api.Test; @@ -13,21 +14,56 @@ public class DecimalTest { public void testSimpleSubtraction() { Identifier[] a = new Identifier[] { new Identifier(1, 0), new Identifier(2, 0), new Identifier(3, 0) }; Identifier[] b = new Identifier[] { new Identifier(1, 0), new Identifier(1, 0), new Identifier(3, 0) }; - assertArrayEquals(Util.subtract(a, b, 0), new int[] { 0, 1, 0 }); + assertArrayEquals(new int[] { 0, 1, 0 }, Util.subtract(a, b, 0)); } @Test public void testCarrySubtraction() { Identifier[] a = new Identifier[] { new Identifier(2, 0), new Identifier(0, 0), new Identifier(4, 0) }; Identifier[] b = new Identifier[] { new Identifier(1, 0), new Identifier(0, 0), new Identifier(5, 0) }; - assertArrayEquals(Util.subtract(a, b, 0), new int[] { 0, 9, 9 }); + assertArrayEquals(new int[] { 0, Util.BASE - 1, Util.BASE - 1 }, Util.subtract(a, b, 0)); } @Test public void testOffsetSubtraction() { Identifier[] a = new Identifier[] { new Identifier(1, 0), new Identifier(0, 0), new Identifier(5, 0) }; Identifier[] b = new Identifier[] { new Identifier(1, 0), new Identifier(0, 0), new Identifier(4, 0) }; - assertArrayEquals(Util.subtract(a, b, 1), new int[] { 0, 1 }); + assertArrayEquals(new int[] { 0, 1 }, Util.subtract(a, b, 1)); + } + + @Test + public void testReversedInputFails() { + Identifier[] a = new Identifier[] { new Identifier(1, 0), new Identifier(1, 0), new Identifier(3, 0) }; + Identifier[] b = new Identifier[] { new Identifier(1, 0), new Identifier(2, 0), new Identifier(3, 0) }; + assertThrows(RuntimeException.class, () -> Util.subtract(a, b, 0)); + } + + @Test + public void testSimpleAdd1() { + int[] a = new int[] { 0, 0 }; + Util.add1AtIndex(a, 1); + assertArrayEquals(new int[] { 0, 1 }, a); + } + + @Test + public void testCarryAdd1() { + int[] a = new int[] { 0, Util.BASE - 1 }; + Util.add1AtIndex(a, 1); + assertArrayEquals(new int[] { 1, 0 }, a); + } + + @Test + public void testCarryAdd1_2() { + int[] a = new int[] { 0, Util.BASE - 1, Util.BASE - 1 }; + Util.add1AtIndex(a, 2); + assertArrayEquals(new int[] { 1, 0, 0 }, a); + } + + @Test + public void testCarryAdd1_3() { + int[] a = new int[] { 0, Util.BASE - 1, Util.BASE - 1 }; + Util.add1AtIndex(a, 1); + assertArrayEquals(new int[] { 1, 0, Util.BASE - 1 }, a); } }