REX partition now like QS, exercises

Author: lee-naish

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'
@@ -54,7 +56,6 @@ const MSD_BOOKMARKS = {
   partition_right: 305,
   swap_condition: 309,
   swap: 310,
-  inc_dec: 'inc_dec',
   pre_sort_left: 400,
   sort_left: 401,
   pre_sort_right: 500,
@@ -160,13 +161,6 @@ export default {
       // where mid is undefined until after partition
       const finished_stack_frames = [];
       const real_stack = [];
-      // refreshStack does lots of work with highlighting etc but is
-      // called from other functions which are called from other
-      // function and somewhere along the line one of the functions is
-      // chunker.add. Often the arguments are not given explicitly -
-      // it's a mess. We assign the current bookmark to whereAreWe for
-      // now, to be used in refreshStack.  Maybe worth a re-write XXX.
-      let whereAreWe;
 
       // ----------------------------------------------------------------------------------------------------------------------------
       // Define helper functions
@@ -176,51 +170,53 @@ 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, whereAreWe, 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)
       }
 
-      // see comment above on whereAreWe
       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);
 
-        // XXX This was getting very messy - colors depends a
+        // 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 to
-        // simplify some things at least.
+        // 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
 
         // Show the binary representation for the current index
         // plus color appropriate element(s)
-        updateMask(vis, mask) // only needed for start of recursive function
-        if (maxIndex !== undefined) { // top level call to recursive fn
+        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 (whereAreWe === MSD_BOOKMARKS.partition_left) {
@@ -231,31 +227,17 @@ export default {
               vis.array.selectColor(cur_i, partRColor)
             else {
               vis.array.selectColor(cur_i, partLColor);
-              cur_i++; // show incremented i  XXX fix i_too_high
             }
           }
-/*
-          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)
-              vis.array.selectColor(cur_i, partRColor)
-          }
-          if (arr && cur_i !== undefined)
-            updateBinary(vis, arr[cur_i])
-*/
         } 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);
+            }
           }
         }
 
@@ -274,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);
         }
       };
 
@@ -351,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)
@@ -371,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()
@@ -393,35 +375,30 @@ 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
-          whereAreWe = MSD_BOOKMARKS.partition_left;
-          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
-          whereAreWe = MSD_BOOKMARKS.partition_right;
+          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) {
             partitionChunkerWrapper(MSD_BOOKMARKS.swap_condition)
             swapAction(MSD_BOOKMARKS.swap, i, j)
-            i++;
-            j--;
-            partitionChunkerWrapper(MSD_BOOKMARKS.inc_dec)
           } else {
             // about to return i from partition.  We update the "mid" of
             // the partition on the stack here so it is displayed at the

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

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?

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.
+

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.
+

src/algorithms/pseudocode/MSDRadixSort.js

@@ -70,10 +70,12 @@ 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 meet/cross, all the large elements at the left of
@@ -86,13 +88,13 @@ 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 meet/cross, we exit the loop.
@@ -102,7 +104,6 @@ while i < j \\B 303
         \\Expl{ Swap the larger element (A[i]) with the smaller
                 element (A[j]).
         \\Expl}
-        Increment i and decrement j \\B inc_dec
     \\In}
 \\In}
 \\Code}