major cleanup

- remove CompleteBinary / Ternary / QuaternaryTree classes
- rework how generations are calculated (and cached)

Author: rickhull

README.md

@@ -69,12 +69,6 @@ determine parent/child relationships.
   - `#size`
   - `#last_idx`
   - `#display` - alias `#to_s`
-* `CompleteBinaryTree < CompleteTree`
-  - `@child_slots = 2`
-* `CompleteTernaryTree < CompleteTree`
-  - `@child_slots = 3`
-* `CompleteQuaternaryTree < CompleteTree`
-  - `@child_slots = 4`
 
 * [examples/complete_tree.rb](examples/complete_tree.rb)
 * [test/complete_tree.rb](test/complete_tree.rb)

examples/complete_tree.rb

@@ -3,24 +3,18 @@
 include CompSci
 
 vals = Array.new(30) { rand 99 }
+puts "initial vals: #{vals.inspect}"
 
-[CompleteBinaryTree,
- CompleteTernaryTree,
- CompleteQuaternaryTree].each { |tree_class|
-
+[2, 3, 4].each { |child_slots|
   puts <<EOF
 
 #
-# Print #{tree_class} filled with static vals
+# Print CompleteTree(#{child_slots}) filled with static vals
 #
 
 EOF
 
-  my_vals = vals.dup
-  puts "initial vals: #{my_vals.inspect}"
-  tree = tree_class.new
-  tree.push my_vals.shift until my_vals.empty?
-
+  tree = CompleteTree.new(array: vals, child_slots: child_slots)
   p tree
   puts
   puts tree.display(width: 80)
@@ -36,7 +30,7 @@
 EOF
 
   my_vals = Array.new(30) { rand 99 }
-  puts "new vals: #{my_vals.inspect}"
+  puts "added vals: #{my_vals.inspect}"
 
   tree.push my_vals.shift until my_vals.empty?
   puts

lib/compsci/complete_tree.rb

@@ -3,28 +3,45 @@
 module CompSci
   # A CompleteTree can very efficiently use an array for storage using
   # simple arithmetic to determine parent child relationships.
+  # Any type of value may be stored in the array / tree at any location.
   #
   class CompleteTree
     class WIP < RuntimeError; end
 
-    # integer math maps several children to one parent
+    # given a child index and child count (e.g. 2 for a binary tree)
+    # integer math maps several children to one parent index
     def self.parent_idx(idx, n)
       (idx-1) / n
     end
 
+    # given a parent index and child count
+    # integer math maps several children to one parent index
     def self.children_idx(idx, n)
       Array.new(n) { |i| n*idx + i + 1 }
     end
 
+    GEN = {}
+    [2, 3, 4, 5, 6].each { |n|
+      cursor = -1
+      GEN[n] = Array.new(10) { |i| cursor += n**i }
+    }
+
+    def self.gen_lookup(idx, n)
+      return nil unless GEN[n]
+      return nil unless idx <= GEN[n].last
+      GEN[n].each.with_index { |max, level| return level if idx <= max }
+      nil
+    end
+
     def self.gen(idx, n)
-      count = 0
-      loop {
-        pidx = self.parent_idx(idx, n)
-        break if pidx < 0
-        count += 1
-        idx = pidx
-      }
-      count
+      return 0 if idx <= 0
+      gen_lookup(idx, n) or gen(self.parent_idx(idx, n), n) + 1
+    end
+
+    # return generation level and sibling count at that level
+    def self.generation(idx, n)
+      level = gen(idx, n)
+      [level, n ** level]
     end
 
     attr_reader :array
@@ -50,65 +67,21 @@ def last_idx
       @array.size - 1 unless @array.empty?
     end
 
-    # or, ya know, just iterate @array
-    def bf_search(&blk)
-      raise(WIP)
-      destinations = [0]
-      while !destinations.empty?
-        idx = destinations.shift
-        return idx if yield @array[idx]
-
-        # idx has a val and the block is false
-        # add existent children to destinations
-        self.class.children_idx(idx, @child_slots).each { |cidx|
-          destinations.push(cidx) if cidx < @array.size
-        }
-      end
-    end
-
-    def df_search(&blk)
-      raise(WIP)
-    end
-
-    # TODO: fixme
     def display(width: 80)
-      raise(WIP)
-      str = ''
-      old_level = 0
+      result = []
+      level = 0
       @array.each_with_index { |val, i|
         val = val.to_s
-        level = self.class.gen(i, @child_slots)
-        if old_level != level
-          str += NEWLINE
-          old_level = level
-        end
+        level, slots = self.class.generation(i, @child_slots)
+        block_width = width / slots
 
         # center in block_width
-        slots = @child_slots**level
-        block_width = width / slots
         space = [(block_width + val.size) / 2, val.size + 1].max
-        str += val.ljust(space, ' ').rjust(block_width, ' ')
+        result[level] ||= ''
+        result[level] += val.ljust(space, ' ').rjust(block_width, ' ')
       }
-      str
+      result
     end
     alias_method :to_s, :display
   end
-
-  class CompleteBinaryTree < CompleteTree
-    def initialize(array: [])
-      super(array: array, child_slots: 2)
-    end
-  end
-
-  class CompleteTernaryTree < CompleteTree
-    def initialize(array: [])
-      super(array: array, child_slots: 3)
-    end
-  end
-
-  class CompleteQuaternaryTree < CompleteTree
-    def initialize(array: [])
-      super(array: array, child_slots: 4)
-    end
-  end
 end

sig/complete_tree.rbs

@@ -3,40 +3,24 @@ module CompSci
   # simple arithmetic to determine parent child relationships.
   #
   class CompleteTree
-    @array: Array[Integer]
+    @array: Array[untyped]
     @child_slots: Integer
 
     def self.parent_idx: (Integer idx, Integer n) -> Integer
     def self.children_idx: (Integer idx, Integer n) -> Array[Integer]
+    def self.gen_lookup: (Integer idx, Integer n) -> Integer
     def self.gen: (Integer idx, Integer n) -> Integer
+    def self.generation: (Integer idx, Integer n) -> [Integer, Integer]
 
-    attr_reader array: Array[Integer]
+    attr_reader array: Array[untyped]
 
-    def initialize: (?array: Array[Integer], ?child_slots: Integer) -> void
+    def initialize: (?array: Array[untyped], ?child_slots: Integer) -> void
 
     def push: (untyped val) -> untyped
     def pop: () -> untyped
     def size: () -> Integer
     def last_idx: () -> (Integer | nil)
-    def bf_search: () { (untyped) -> untyped } -> untyped
-
-    def df_search: () { (?) -> untyped } -> untyped
-
-    # TODO: fixme
-    def display: (?width: ::Integer) -> untyped
-
+    def display: (?width: Integer) -> Array[String]
     alias to_s display
   end
-
-  class CompleteBinaryTree < CompleteTree
-    def initialize: (?array: untyped) -> void
-  end
-
-  class CompleteTernaryTree < CompleteTree
-    def initialize: (?array: untyped) -> void
-  end
-
-  class CompleteQuaternaryTree < CompleteTree
-    def initialize: (?array: untyped) -> void
-  end
 end

test/complete_tree.rb

@@ -117,7 +117,7 @@
     before do
       @array = (0..99).sort_by { rand }
       @empty = CompleteTree.new(child_slots: 5)
-      @nonempty = CompleteQuaternaryTree.new(array: @array)
+      @nonempty = CompleteTree.new(array: @array, child_slots: 4)
     end
 
     it "must have a size" do