= vs == vs <- clean up

Author: lee-naish

src/algorithms/controllers/msort_arr_td.js

@@ -5,7 +5,7 @@
 // Uses simple stack display like DFSrec; stack vanishes inside
 // merge+copy because screen real-estate is limited and details of merge
 // are independent of stack details anyway (may cause some surprise
-// though)
+// though) XXX would be nice to add QS/REX style stack display instead
 
 import { msort_arr_td } from '../explanations';
 import {colors} from '../../components/DataStructures/colors';
@@ -268,9 +268,9 @@ export function run_msort() {
 
     const refresh_stack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_pivot_index, cur_depth) => {
 
-      // XXX
+      // XXX left over from quicksort...
       // We can't render the -1 index in the array
-      // For now we display i==0/j==0 at left of array if appropriate
+      // For now we display i=0/j=0 at left of array if appropriate
       let cur_i_too_low;
       let cur_j_too_low;
       if (cur_i === -1) {

src/algorithms/controllers/quickSort_shared.js

@@ -281,7 +281,7 @@ cur_i, cur_j, cur_pivot_index, cur_left, cur_right, cur_depth) {
     const refresh_stack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_pivot_index, cur_left, cur_right, cur_depth) => {
 
       // We can't render the -1 index in the array
-      // For now we display i==0/j==0 at left of array if appropriate
+      // For now we display i=0/j=0 at left of array if appropriate
       let cur_i_too_low;
       let cur_j_too_low;
       if (cur_i === -1) {

src/algorithms/pseudocode/DFSrec.js

@@ -63,7 +63,7 @@ DFS1(G, n, p) // Search from node n using parent node p. This visits all \\B dfs
         // nodes connected to n, ignoring nodes with parents already
         // assigned (as if these nodes have been removed from G).
 \\In{
-    if Parent[n] == null // Ignore n if Parent[n] has been assigned \\B check_parent
+    if Parent[n] = null // Ignore n if Parent[n] has been assigned \\B check_parent
     \\In{
         Parent[n] <- p \\B assign_parent
         \\Expl{ Node n is now finalised.

src/algorithms/pseudocode/HashingInsertion.js

@@ -1,15 +1,13 @@
 import parse from '../../pseudocode/parse';
 
 
-// XXX Best skip NullTable and HashInit function completely - just start
+// We now skip NullTable and HashInit function completely - just start
 // animation with initialised table
-// XXX: if dynamic tables are not implemented, both CheckTableFullness
-// and CheckTableFullnessDel should be removed (if they are added the
-// bookmarks withing them should be different, and maybe
-// explanations)
-// NOTE: code now no longer explicitly keeps track of number of
-// insertions and CheckTableFullness is modified so some bookmarks (eg,
-// 4, 19, 20) no longer exist and controller code will have to change
+// If dynamic tables are not implemented, both CheckTableFullness
+// and CheckTableFullnessDel should be removed.
+// Currently dynamic tables are supported for open addressing but not
+// chaining.  The latter still has "Check how full the table is" that
+// doesn't expand but has an explanation. XXX could be added some time.
 
 const main = `
 
@@ -135,7 +133,7 @@ const main = `
                         there will be no duplicate elements.
                     \\Expl}
                     \\In{
-                        OldT = T;  // save T so we can extract the keys
+                        OldT <- T;  // save T so we can extract the keys
                         T <- new empty table \\B 30
                         \\Expl{ Without deleted elements, it is best for
                             the table size to approximately double.  If there are many deleted slots

src/algorithms/pseudocode/TTFTreeSearch.js

@@ -31,15 +31,15 @@ export default parse(`
     // Return node t if it contains key k
     if t is a two-node \\B if t is a two-node: Return_if_key_in_node
     \\In{
-        if t.key1 == k return t \\B if t.key1 == k return t
+        if t.key1 = k return t \\B if t.key1 == k return t
     \\In}
     else if t is a three-node \\B if t is a three-node: Return_if_key_in_node
     \\In{
-        if t.key1 == k or t.key2 == k return t \\B if t.key1 == k or t.key2 == k return t
+        if t.key1 = k or t.key2 = k return t \\B if t.key1 == k or t.key2 == k return t
     \\In}
     else // t is a four-node \\B else: Return_if_key_in_node
     \\In{
-        if t.key1 == k or t.key2 == k or t.key3 == k return t \\B if t.key1 == k or t.key2 == k or t.key3 == k return t
+        if t.key1 = k or t.key2 = k or t.key3 = k return t \\B if t.key1 == k or t.key2 == k or t.key3 == k return t
     \\In}
     \\Code}
     
@@ -96,4 +96,4 @@ export default parse(`
     \\In}
     \\Code}
     
-`);
+`);

src/algorithms/pseudocode/msort_list_td.js

@@ -138,7 +138,7 @@ CopySmaller
 
 \\Code{
 CopyRest
-    if L == Null
+    if L = Null
     \\In{
         tail(E) <- R // append extra R elements to M \\B appendR
     \\In}

src/algorithms/pseudocode/msort_lista_td.js

@@ -47,7 +47,7 @@ scan
     Mid <- L \\B Mid
     \\Expl{ Start at first element of L
     \\Expl}
-    for i = 1 to len/2 - 1 // while not at middle
+    for i <- 1 to len/2 - 1 // while not at middle
     \\In{
         Mid <- Mid.tail \\B MidNext
         \\Expl{ Skip to next element

src/algorithms/pseudocode/straightRadixSort.js

@@ -98,12 +98,12 @@ for num in A \\B 13
 
 \\Code{
 CumSum
-for i = 1 to maximum digit value \\B 14
+for i <- 1 to maximum digit value \\B 14
 \\Expl{ We must scan left to right. The count for digit 0 remains
   unchanged.
 \\Expl}
 \\In{
-    Count[i] = Count[i-1] + Count[i] \\B 15
+    Count[i] <- Count[i-1] + Count[i] \\B 15
 \\In}
 \\Code}
 
@@ -127,8 +127,8 @@ for each num in A in reverse order \\B 8
       highlighted, and the digit value 0-3 (maybe the latter can be done
       by just highlighting B[digit] instead).
     \\Note}
-    Count[digit] = Count[digit]-1 \\B 18
-    B[Count[digit]] = num \\B 9
+    Count[digit] <- Count[digit] - 1 \\B 18
+    B[Count[digit]] <- num \\B 9
 \\In}
 \\Code}
 

src/algorithms/pseudocode/unionFindUnion.js

@@ -87,12 +87,12 @@ Union(n, m) // merge/union the subsets containing n and m, respectively \\B Unio
 \\In{
     n <- Find(n) \\B n <- Find(n)
     m <- Find(m) \\B m <- Find(m)
-    if n == m // in same subset already - nothing to do \\B if n == m
+    if n = m // in same subset already - nothing to do \\B if n == m
         \\In{
         return \\B return
         \\In}
     swap n and m if needed to ensure m is the "taller" subtree \\Ref Maybe_swap
-    parent[n] = m // add the shorter subtree (n) to the taller one (m) \\B parent[n] = m
+    parent[n] <- m // add the shorter subtree (n) to the taller one (m) \\B parent[n] = m
     \\Expl{ This sometimes increases the height of the resulting tree but
             if we added the taller to the shorter the height would always
             increase.
@@ -147,7 +147,7 @@ still use n
 
 \\Code{
     Adjust_rank
-        if rank[n] == rank[m] \\B if rank[n] == rank[m]
+        if rank[n] = rank[m] \\B if rank[n] == rank[m]
             \\Expl{  If we are adding a strictly shorter subtree to m the height
                     doesn't change, but if the heights were equal the new height
             \\Expl}
@@ -163,7 +163,7 @@ Initialise
     \\Note{ No need to animate this?? We just have this as the initial
         state of the animation.
     \\Note}
-      parent[i] = i and rank[i] = 0 for all elements i in the set \\B parent[i] = i and rank[i] = 0 for all elements i in the set
+      parent[i] <- i and rank[i] <- 0 for all elements i in the set \\B parent[i] = i and rank[i] = 0 for all elements i in the set
     \\Expl{ Initially, each element i is in its own singleton subset. If
             the array has free space, extra elements can be added and
             initialised in the same way.