Merge branch 'REXpartition' into dev

lee-naish · lee-naish · commit acaee7674372 · 2025-04-11T19:11:40.000+10:00
diff --git a/src/algorithms/controllers/MSDRadixSort.js b/src/algorithms/controllers/MSDRadixSort.js
@@ -34,8 +34,10 @@ const STACK_FRAME_COLOR = {
 const VIS_VARIABLE_STRINGS = {
   i_left_index: 'i',
   j_right_index: 'j',
+  i_eq_0: 'i==0',
   i_gt_n: 'i==n+1',
   j_eq_0: 'j==0',
+  j_gt_n: 'j==n+1',
   left: 'left',
   right: 'right',
   right_eq_0: 'right==0'
@@ -159,7 +161,6 @@ export default {
       // where mid is undefined until after partition
       const finished_stack_frames = [];
       const real_stack = [];
-      let leftCheck = false
 
       // ----------------------------------------------------------------------------------------------------------------------------
       // Define helper functions
@@ -169,83 +170,81 @@ export default {
       // This function is the only way information is cached and incremented properly in the while loop
       const partitionChunker = (bookmark, i, j, prev_i, prev_j, left, right, depth, arr, mask) => {
         assert(bookmark !== undefined); // helps catch bugs early, and trace them in stack
-        const args_array = [real_stack, finished_stack_frames, i, j, prev_i, prev_j, left, right, depth, leftCheck, maxIndex, arr, mask]
+        const args_array = [real_stack, finished_stack_frames, i, j, prev_i, prev_j, left, right, depth, bookmark, maxIndex, arr, mask]
         chunker.add(bookmark, refreshStack, args_array, depth)
       }
 
-      // we use a global flag in case we scan through the whole partition 
-      // and stop at the end without finding the mask bit we are looking
-      // for
-      const refreshStack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, prev_i, prev_j, left, right, cur_depth, checkingLeft, maxIndex, arr, mask) => {
+      const refreshStack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, prev_i, prev_j, left, right, cur_depth, whereAreWe, maxIndex, arr, mask) => {
         // If we fall off the start/end of the array we just use the
         // first/last element and give the actual value of j/i
+        let cur_i_too_low;
         let cur_i_too_high;
         let cur_j_too_low;
+        let cur_j_too_high;
         let tmp_j = cur_j; // used to determine context later
         if (cur_i === A.length) {
           cur_i = undefined;
           cur_i_too_high = A.length - 1;
-        } else {
-          cur_i_too_high = undefined;
+        } else if (cur_i === -1) {
+          cur_i = undefined;
+          cur_i_too_low = 0;
         }
-        if (cur_j === -1) {
+        if (cur_j === A.length) {
+          cur_j = undefined;
+          cur_j_too_high = A.length - 1;
+        } else if (cur_j === -1) {
           cur_j = undefined;
           cur_j_too_low = 0;
-        } else {
-          cur_j_too_low = undefined;
         }
 
         assert(vis.array);
         assert(cur_real_stack && cur_finished_stack_frames);
 
-        vis.array.setStackDepth(cur_real_stack.length);
-        vis.array.setStack(
-          deriveStack(cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_depth)
-        );
+        // This was getting very messy - colors depends a
+        // lot on where we are and we had a bunch of tricky testing of
+        // various vars to determine that.  Now we use whereAreWe
+        // (current bookmark) simplify some things at least.
+        // XXX prev_i and prev_j are no longer used so could be deleted
+        // as parameters and elsewhere
 
-        // XXX This is getting very messy - (un)highlighting depends a
-        // lot on where we are and we have a bunch of tricky testing of
-        // various vars to determine that.  Could pass in bookmark to
-        // simplify some things at least??
         // Show the binary representation for the current index
-        // plus (un)highlight appropriate element(s)
-        updateMask(vis, mask) // only needed for start of recursive function
-        if (maxIndex !== undefined) { // top level call to recursive fn
+        // plus color appropriate element(s)
+        updateMask(vis, mask) // needed at call/return of recursive function
+        if (whereAreWe === MSD_BOOKMARKS.rec_function) {
+          // top level call to recursive fn
           unhighlight(vis, maxIndex)
           updateBinary(vis, 0)
 	}
-        if (cur_i !== undefined && tmp_j === undefined && prev_i !== undefined) {
+        if (whereAreWe === MSD_BOOKMARKS.pre_sort_left) {
           // just before first recursive call
-          if (i <= right)
-            vis.array.selectColor(prev_i, partRColor)
-          if (prev_j >= left) // might have fallen off array
-            vis.array.selectColor(prev_j, partLColor)
           for (let k = cur_i; k <= right; k++)
             vis.array.deselect(k);
-        } else if (checkingLeft) {
+        } else if (whereAreWe === MSD_BOOKMARKS.partition_left) {
           // note i can fall off RHS of array...
-          if (prev_i !== undefined && prev_i !== cur_j) {
-            let real_i = cur_i;
-            if (cur_i === undefined)
-              real_i = right + 1;
-            for (let k = prev_i; k < real_i && k <= right; k++)
-              vis.array.selectColor(k, partLColor)
-            if (cur_i !== undefined && cur_i <= right && (arr[cur_i] >> mask & 1) === 1)
+          if (cur_i !== undefined && cur_i <= right ) {
+            updateBinary(vis, arr[cur_i]);
+            if ((arr[cur_i] >> mask & 1) === 1)
               vis.array.selectColor(cur_i, partRColor)
+            else {
+              vis.array.selectColor(cur_i, partLColor);
+            }
           }
-          if (arr && cur_i !== undefined)
-            updateBinary(vis, arr[cur_i])
-        } else {
+        } else if (whereAreWe === MSD_BOOKMARKS.partition_right) {
           // note j can fall off LHS of array...
-          if (prev_j !== undefined && prev_j !== cur_i)
-            for (let k = prev_j; k >= cur_j && k >= cur_i; k--)
-              vis.array.selectColor(k, partRColor)
-          if (prev_j !== undefined && cur_j !== undefined && cur_j > cur_i) {
-            vis.array.selectColor(cur_j, partLColor);
-            // XXX probably best avoid updateBinary at swap
-            updateBinary(vis, arr[cur_j])
+          if (cur_j !== undefined && cur_j >= left ) {
+            updateBinary(vis, arr[cur_j]);
+            if ((arr[cur_j] >> mask & 1) === 0)
+              vis.array.selectColor(cur_j, partLColor)
+            else {
+              vis.array.selectColor(cur_j, partRColor);
+            }
           }
         }
+
+        vis.array.setStackDepth(cur_real_stack.length);
+        vis.array.setStack(
+          deriveStack(cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_depth)
+        );
         if (left < A.length) // shouldn't happen with initial mask choice
           assignVariable(vis, VIS_VARIABLE_STRINGS.left, left);
         if (right >= 0) {
@@ -257,11 +256,13 @@ export default {
         }
         if (isPartitionExpanded() || isRecursionExpanded()) {
           assignVariable(vis, VIS_VARIABLE_STRINGS.i_left_index, cur_i);
+          assignVariable(vis, VIS_VARIABLE_STRINGS.i_eq_0, cur_i_too_low);
           assignVariable(vis, VIS_VARIABLE_STRINGS.i_gt_n, cur_i_too_high);
 	}
         if (isPartitionExpanded()) {
           assignVariable(vis, VIS_VARIABLE_STRINGS.j_right_index, cur_j);
           assignVariable(vis, VIS_VARIABLE_STRINGS.j_eq_0, cur_j_too_low);
+          assignVariable(vis, VIS_VARIABLE_STRINGS.j_gt_n, cur_j_too_high);
         }
       };
 
@@ -334,8 +335,8 @@ export default {
       let DELAY_POPPER_SWAP = 700;
 
       const partition = (arr, left, right, mask, depth) => {
-        i = left
-        j = right
+        i = left-1
+        j = right+1
 
         const partitionChunkerWrapper = (bookmark) => {
           partitionChunker(bookmark, i, j, prev_i, prev_j, left, right, depth, arr, mask)
@@ -354,8 +355,6 @@ cur_i, cur_j, cur_depth, A) => {
 
               vis.array.swapElements(_n1, _n2);
               refreshStack(vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, prev_i, prev_j, left, right, cur_depth, false, undefined, A, mask)
-              vis.array.selectColor(_n1, partLColor);
-              vis.array.selectColor(_n2, partRColor);
               // redo poppers: swapping the elements keeps the
               // contents of the poppers correct but the position needs
               // to change. The documentation suggests update()
@@ -376,25 +375,25 @@ arr],
           depth);
         }
 
-        partitionChunkerWrapper(MSD_BOOKMARKS.set_i)
+        partitionChunkerWrapper(MSD_BOOKMARKS.set_i);
         // partitionChunkerWrapper(MSD_BOOKMARKS.set_j)
         while (i < j) {
           prev_i = i; // save prev value for unhighlighting
           prev_j = j;
           // Build the left group until it reaches the mask (find the big element)
-          leftCheck = true
-          while (i <= j && (arr[i] >> mask & 1) === 0) {
-            // partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
+          i++;
+          partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
+          while (i < j && (arr[i] >> mask & 1) === 0) {
             i++
+            partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
           }
-          partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
           // Build the right group until it fails the mask (find the small element)
-          leftCheck = false
+          j--;
+          partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
           while (j > i && (arr[j] >> mask & 1) === 1) {
-            // partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
             j--
+            partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
           }
-          partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
 
           // Swap if the bigger element is not in the right place
           if (i < j) {
diff --git a/src/algorithms/explanations/MSDRadixSortExp.md b/src/algorithms/explanations/MSDRadixSortExp.md
@@ -34,14 +34,16 @@ mask bit are put at the right (similar to partition in quicksort).
 indices for the sub-arrays boundaries and and the mask shifted one bit
 position to the right.
 
-### 3. Partitioning Based on Current Bit
-* The indices ```i``` and ```j```, are set at the left and right of the array segment.
-* These indices move towards each other, adjusting positions based on the
-mask bit of each key:
+### 3. Partitioning Based on Current Mask Bit
+* The indices ```i``` and ```j```, are set at the left and right of the
+  array segment, respectively.
+* These indices scan towards each other, adjusting positions based on the mask bit of each key:
     * Increment ```i``` until an element with a 1 as the mask bit is reached
     * Decrement ```j``` until an element with a 0 as the mask bit is reached
 
-* If the two indices have not met/crossed, perform a swap to ensure that 0s are placed on the left and 1s on the right.
+* If the two indices have met/crossed, stop. Otherwise, swap the
+  elements (so the 0 element is on the left and the 1 element is on the
+  right) and continue scanning as described above.
 
 ## Complexity
 ### Time Complexity
diff --git a/src/algorithms/extra-info/MSDRadixSortInfo.md b/src/algorithms/extra-info/MSDRadixSortInfo.md
@@ -20,4 +20,8 @@ Sort)
 
 [G4GLink]: https://www.geeksforgeeks.org/msd-most-significant-digit-radix-sort/
 
+## Exercises/Exploration
 
+The coding of partition used in AIA is based on the coding in quicksort.
+Compare and contrast the two.  What other approaches to coding partition
+could be used?
diff --git a/src/algorithms/extra-info/QSInfo.md b/src/algorithms/extra-info/QSInfo.md
@@ -20,3 +20,17 @@ Geeks for Geeks Link: [**Quicksort**][G4GLink]
 
 [G4GLink]: https://www.geeksforgeeks.org/quick-sort/
 
+## Exercises/Exploration
+
+Look into some of the history of quicksort.  The basic idea is relatively
+simple and was invented long ago. However, it has had a *huge* amount
+of work done on it over the years to refine it in many ways - far more
+than any other relatively simple algorithm.
+
+The coding of partition used in AIA goes back to some early versions of
+quicksort where in order to maximize efficiency, the "inner loop(s)" of
+the algorithm (incrementing or decrementing the array index and testing
+an array element) was written so as to minimise the number of instructions
+executed by the hardware. Hardware has changed a lot since then! Look
+into some more recent efficient ways of coding partition.
+
diff --git a/src/algorithms/extra-info/QSM3Info.md b/src/algorithms/extra-info/QSM3Info.md
@@ -20,3 +20,18 @@ Geeks for Geeks Link: [**Quick Sort - Median of Three**][G4GLink]
 
 [G4GLink]: https://www.geeksforgeeks.org/quick-sort/
 
+## Exercises/Exploration
+
+Look into some of the history of quicksort.  The basic idea is relatively
+simple and was invented long ago. However, it has had a *huge* amount
+of work done on it over the years to refine it in many ways (median
+of three partitioning is just one of these) - far more than any other
+relatively simple algorithm. What are some of the other refinements?
+
+The coding of partition used in AIA goes back to some early versions of
+quicksort where in order to maximize efficiency, the "inner loop(s)" of
+the algorithm (incrementing or decrementing the array index and testing
+an array element) was written so as to minimise the number of instructions
+executed by the hardware. Hardware has changed a lot since then! Look
+into some more recent efficient ways of coding partition.
+
diff --git a/src/algorithms/pseudocode/MSDRadixSort.js b/src/algorithms/pseudocode/MSDRadixSort.js
@@ -70,13 +70,15 @@ RexsortRecursive(A, i, right, mask/2) \\B 501
 
 \\Code{
 Partition
-i,j <- left,right \\B 301
+i,j <- left-1,right+1 \\B 301
 \\Expl{ i scans from left to right stopping at "large" elements
 (with "1" as the mask bit) and j scans from right to left
 stopping at "small" elements (with "0" as the mask bit).
+The scanning does a pre-increment of i (and pre-decrement of j) before
+testing the array element.
 \\Expl}
 while i < j \\B 303
-\\Expl{ When the indices cross, all the large elements at the left of
+\\Expl{ When the indices meet/cross, all the large elements at the left of
         the array segment have been swapped with small elements from the
         right of the array segment. The coding here can be simplified
         if we use "break" or similar to exit from this loop.
@@ -86,16 +88,16 @@ while i < j \\B 303
     \\Expl{ Scan right looking for a "large" element that is out of
         place (mask bit is one). Bitwise "and" between A[i] and mask can be used to
         extract the desired bit.
-        Note we do the tests before incrementing i.
+        Note we do the tests after incrementing i at each step.
     \\Expl}
     Decrement j until the mask bit of A[j] = 0 or j <= i \\B 305
     \\Expl{ Scan left looking for a "small" element that is out of
         place (mask bit is zero). Bitwise "and" between A[i] and mask can be used to
         extract the desired bit.
-        Note we do the tests before decrementing j.
+        Note we do the tests after decrementing j at each step.
     \\Expl}
     if i < j \\B 309
-    \\Expl{ If the indices cross, we exit the loop.
+    \\Expl{ If the indices meet/cross, we exit the loop.
     \\Expl}
     \\In{
         swap(A[i], A[j]) \\B 310
