compsci 0.3.0.1 → 0.3.1.1

data/examples/heap.rb

@@ -1,11 +1,11 @@
 require 'compsci/heap'
-require 'compsci/timer'
 
 include CompSci
 
 puts <<EOF
+
 #
-# display the results of TernaryHeap push and pop
+# display the results of ternary Heap push and pop
 #
 
 EOF
@@ -38,3 +38,41 @@ puts "array: #{h.array.inspect}"
 puts "heap: #{h.heap?}"
 puts h
 puts
+
+
+puts <<EOF
+
+#
+# display the results of binary Heap push and pop
+#
+
+EOF
+
+h = Heap.new(child_slots: 2)
+
+puts "push: %s" % Array.new(30) { rand(99).tap { |i| h.push i } }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "pop: %i" % h.pop
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "pop: %s" % Array.new(9) { h.pop }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "push: %s" % Array.new(30) { rand(99).tap { |i| h.push i } }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts

data/examples/heap_push.rb

@@ -6,12 +6,18 @@ include CompSci
 runtime = (ARGV.shift || "3").to_i
 
 puts <<EOF
+
 #
-# 3 seconds worth of pushes
+# #{runtime} seconds worth of Heap pushes
 #
 
 EOF
 
+
+# pregenerate a sequence of random numbers
+# every NUMBERWANGth request, shift the sequence and push a new random
+# this should mitigate random number generation from interfering with timing
+# while also mitigating any chance of cyclic behavior
 RANDMAX = 1_000
 NUMBERWANG = 1_000
 NUMS = (0..(RANDMAX - 1)).to_a.shuffle

data/examples/ternary_search_tree.rb

@@ -0,0 +1,30 @@
+require 'compsci/node'
+require 'compsci/names'
+
+include CompSci
+
+randmax = (ARGV.shift || 50).to_i
+
+puts <<EOF
+
+#
+# Insert #{randmax} nodes into a ternary search tree (random keys)
+#
+
+EOF
+
+root = KeyNode.new(rand(randmax), key: rand(randmax), children: 3)
+randmax.times { puts root.insert(rand(randmax), rand(randmax)) }
+puts root.display
+
+puts <<EOF
+
+#
+# Search for #{randmax} keys in order
+#
+
+EOF
+
+randmax.times { |key|
+  puts "search #{key}: #{root.search(key).map { |n| n.value }.join(' ')}"
+}

data/examples/tree.rb

@@ -1,42 +1,44 @@
 require 'compsci/node'
-require 'compsci/tree'
-require 'compsci/timer'
 
 include CompSci
 
 puts <<EOF
+
 #
-# Try out Binary-, Ternary-, and QuaternaryTree
+# Fill up and display some trees
 #
 
 EOF
 
 vals = Array.new(30) { rand 99 }
+puts "vals: #{vals.inspect}"
 
-[BinaryTree, TernaryTree, QuaternaryTree].each { |tree_class|
-  # start with the same vals for each class
+[2, 3, 4].each { |children|
   my_vals = vals.dup
-  p my_vals
-  tree = tree_class.new(ChildFlexNode, my_vals.shift)
-  tree.push my_vals.shift until my_vals.empty?
-  p tree
-  puts tree.display(width: 80)
-  puts
-  visited = []
-  tree.df_search { |n|
-    visited << n
-    false # or n.value > 90
-  }
-  puts "df_search visited: %s" % visited.join(' ')
-  puts
-  puts
 
-  # push different vals for each class
-  my_vals = Array.new(30) { rand 99 }
-  puts "push: #{my_vals.inspect}"
-  tree.push my_vals.shift until my_vals.empty?
-  puts
-  puts tree.display(width: 80)
+  puts <<EOF
+
+#
+# Children: #{children}
+#
+
+EOF
+
+
+  root = Node.new my_vals.shift, children: children
+  nodes = [root]
+  until my_vals.empty?
+    new_nodes = []
+    nodes.each { |node|
+      children.times { |i|
+        node[i] = Node.new my_vals.shift, children: children
+      }
+      new_nodes += node.children
+    }
+    nodes = new_nodes
+  end
+  p root
   puts
+  puts root.display(width: 80)
   puts
 }

data/lib/compsci.rb

@@ -1 +1,10 @@
-module CompSci; end
+module CompSci
+  # thanks apeiros
+  # https://gist.github.com/rickhull/d0b579aa08c85430b0dc82a791ff12d6
+  def self.power_of?(num, base)
+    return false if base <= 1
+    mod = 0
+    num, mod = num.divmod(base) until num == 1 || mod > 0
+    mod == 0
+  end
+end

data/lib/compsci/complete_tree.rb

@@ -1,10 +1,8 @@
 module CompSci
-  # A CompleteNaryTree can very efficiently use an array for storage using
+  # A CompleteTree can very efficiently use an array for storage using
   # simple arithmetic to determine parent child relationships.
   #
-  # It is kept separate from compsci/tree as it does not require compsci/node
-  #
-  class CompleteNaryTree
+  class CompleteTree
     # integer math maps several children to one parent
     def self.parent_idx(idx, n)
       (idx-1) / n
@@ -67,6 +65,7 @@ module CompSci
       puts "not yet"
     end
 
+    # TODO: fixme
     def display(width: 80)
       str = ''
       old_level = 0
@@ -89,19 +88,19 @@ module CompSci
     alias_method :to_s, :display
   end
 
-  class CompleteBinaryTree < CompleteNaryTree
+  class CompleteBinaryTree < CompleteTree
     def initialize(array: [])
       super(array: array, child_slots: 2)
     end
   end
 
-  class CompleteTernaryTree < CompleteNaryTree
+  class CompleteTernaryTree < CompleteTree
     def initialize(array: [])
       super(array: array, child_slots: 3)
     end
   end
 
-  class CompleteQuaternaryTree < CompleteNaryTree
+  class CompleteQuaternaryTree < CompleteTree
     def initialize(array: [])
       super(array: array, child_slots: 4)
     end

data/lib/compsci/flex_node.rb

@@ -0,0 +1,90 @@
+require 'compsci/node'
+
+module CompSci
+  #
+  # FlexNodes accumulate children; no child gaps
+  #
+
+  # FlexNode API is #add_child, #add_parent, #new_child
+
+  class FlexNode < Node
+    def initialize(value, metadata: {})
+      @value = value
+      @children = []
+      @metadata = metadata
+    end
+
+    def add_child(node)
+      @children << node
+    end
+
+    def new_child(value)
+      self.add_child self.class.new(value)
+    end
+
+    def add_parent(node)
+      node.add_child(self)
+    end
+
+    def df_search(&blk)
+      return self if yield self
+      stop_node = nil
+      @children.each { |child|
+        stop_node = child.df_search(&blk)
+        break if stop_node
+      }
+      stop_node
+    end
+
+    def bf_search(&blk)
+      destinations = [self]
+      while !destinations.empty?
+        node = destinations.shift
+        return node if yield node
+        destinations += node.children
+      end
+      nil
+    end
+
+    def open_parent?(child_slots)
+      @children.size < child_slots
+    end
+
+    def open_parent(child_slots)
+      self.bf_search { |n| n.open_parent?(child_slots) }
+    end
+
+    def push(value, child_slots)
+      self.open_parent(child_slots).new_child value
+    end
+  end
+
+  class ChildFlexNode < FlexNode
+    attr_accessor :parent
+
+    def initialize(value, metadata: {})
+      super(value, metadata: metadata)
+      @parent = nil
+    end
+
+    # O(log n) recursive
+    def gen
+      @parent ? @parent.gen + 1 : 0
+    end
+
+    def siblings
+      @parent ? @parent.children : []
+    end
+
+    def add_child(node)
+      node.parent ||= self
+      raise "node has a parent: #{node.parent}" if node.parent != self
+      @children << node
+    end
+
+    def add_parent(node)
+      @parent = node
+      @parent.add_child(self)
+    end
+  end
+end

data/lib/compsci/heap.rb

@@ -18,7 +18,7 @@ require 'compsci/complete_tree'
 #   swap nodes at each layer of the tree, and there are log(n, base b) layers
 #   to the tree.
 #
-class CompSci::Heap < CompSci::CompleteNaryTree
+class CompSci::Heap < CompSci::CompleteTree
   # * defaults to a MaxHeap, with the largest node at the root
   # * specify a minheap with minheap: true or cmp_val: -1
   #
@@ -65,7 +65,6 @@ class CompSci::Heap < CompSci::CompleteNaryTree
   #
   def sift_up(idx)
     return self if idx <= 0
-    # print '.'
     pidx = self.class.parent_idx(idx, @child_slots)
     if !self.heapish?(pidx, idx)
       @array[idx], @array[pidx] = @array[pidx], @array[idx]   # swap

data/lib/compsci/names/pokemon.rb

@@ -0,0 +1,62 @@
+require 'compsci/names'
+
+module CompSci::Names::Pokemon
+  DATAFILE = File.join(__dir__, 'pokemon.txt')
+
+  def self.array
+    @@array ||= self.read_file
+    @@array
+  end
+
+  def self.hash
+    @@hash ||= self.read_hash
+    @@hash
+  end
+
+  # an array of all the names
+  def self.read_file(path: DATAFILE)
+    File.readlines(path).map { |n| n.chomp }
+  end
+
+  # return an array, possibly empty, if all: true
+  # return a string, possibly nil, if all: false
+  def self.grep(rgx, path: DATAFILE, all: false)
+    ary = []
+    File.open(path).each_line { |l|
+      if l.match rgx
+        ary << l.chomp
+        break unless all
+      end
+    }
+    all ? ary : ary.first
+  end
+
+  # a hash of all the names, keyed by the first letter
+  def self.read_hash(path: DATAFILE)
+    hsh = Hash.new { |h, k| h[k] = [] }
+    File.open(path).each_line { |l|
+      hsh[l[0]] << l.chomp
+    }
+    hsh
+  end
+
+  # convert 0-25 to a lowercase alpha
+  def self.key(val)
+    if val.is_a?(String)
+      if val.match(/^[0-9]/)
+        val = val[0..1].to_i
+      elsif val.match(/^[a-z]/i)
+        return val.downcase[0]
+      else
+        raise(ArgumentError, "can't handle #{val}")
+      end
+    end
+    CompSci::Names::ENGLISH_LOWER[val.to_i]
+  end
+
+  # return a pokemon sampled from those keyed by val
+  def self.sample(val)
+    ary = self.hash[self.key(val)]
+    ary.sample if ary
+  end
+end

data/lib/compsci/node.rb

@@ -1,67 +1,141 @@
 module CompSci
   # has a value and an array of children; allows child gaps
   class Node
-    attr_accessor :value
+    def self.display_line(nodes: [], width: 80)
+      block_width = [width / nodes.size, 1].max
+      nodes.map { |node|
+        str = node ? node.to_s : '_'
+        space = [(block_width + str.size) / 2, str.size + 1].max
+        str.ljust(space, ' ').rjust(block_width, ' ')
+      }.join
+    end
+
+    attr_accessor :value, :metadata
     attr_reader :children
 
-    def initialize(value, children: [])
+    def initialize(value, children: 2, metadata: {})
       @value = value
-      if children.is_a?(Integer)
-        @children = Array.new(children)
-      else
-        @children = children
-      end
-      # @metadata = {}
+      @children = Array.new(children)
+      @metadata = metadata
     end
 
-    def to_s
-      @value.to_s
+    def [](idx)
+      @children[idx]
     end
 
-    # This could be done directly with self.children, but #set_child is part
-    # of the Node API.
-    def set_child(idx, node)
+    def []=(idx, node)
       @children[idx] = node
     end
 
+    def to_s
+      @value.to_s
+    end
+
     def inspect
       "#<%s:0x%0xi @value=%s @children=[%s]>" %
-        [self.class,
-         self.object_id,
-         self.to_s,
-         @children.map(&:to_s).join(', ')]
+        [self.class, self.object_id, self, @children.join(', ')]
+    end
+
+    def display(width: 80)
+      lines = [self.class.display_line(nodes: [self], width: width)]
+      nodes = @children
+      while nodes.any? { |n| !n.nil? }
+        lines << self.class.display_line(nodes: nodes, width: width)
+        if nodes.size > 3**7
+          lines << "nodes.size = #{nodes.size}; abort render"
+          break
+        end
+        nodes = nodes.reduce([]) { |memo, n|
+          memo + Array.new(@children.size) { |i| n and n.children[i] }
+        }
+      end
+      lines.join("\n")
     end
   end
 
+  # TODO: implement key with @metadata !?!?!?!?
+
   # adds a key to Node; often the key is used to place the node in the
   # tree, independent of the value; e.g. key=priority, value=process_id
   class KeyNode < Node
-    attr_accessor :key
+    class DuplicateKey < RuntimeError; end
+    class SearchError < RuntimeError; end
+
+    attr_reader :key, :duplicates
+
+    def self.key_cmp_idx(new_key, key, child_slots: 2, duplicates: false)
+      if child_slots < 2
+        raise(ArgumentError, "child_slots: #{child_slots} too small")
+      elsif child_slots == 2
+        raise(DuplicateKey, "#{new_key}") if new_key == key and !duplicates
+        new_key < key ? 0 : 1
+      elsif child_slots == 3
+        (new_key <=> key) + 1
+      else
+        raise(ArgumentError: "child_slots: #{child_slots} too big")
+      end
+    end
 
-    def initialize(val, key: nil, children: [])
-      @key = key
+    def initialize(val, key: nil, children: 2, duplicates: false)
       super(val, children: children)
+      @key, @duplicates = key, duplicates
     end
 
     def to_s
-      [key, value].join(':')
+      [@key, @value].join(':')
+    end
+
+    # which child idx should handle key?
+    def cidx(key)
+      self.class.key_cmp_idx(key, @key,
+                             child_slots: @children.size,
+                             duplicates: @duplicates)
     end
-  end
 
-  # accumulate children; no child gaps
-  class FlexNode < Node
-    # These methods look like convenience methods, but they provide the
-    # FlexNode interface also used by ChildFlexNode
-    def add_child(node)
-      @children << node
+    # works for 2 or 3 children
+    def insert(key, val)
+      idx = self.cidx(key)
+      if @children[idx]
+        @children[idx].insert(key, val)
+      else
+        @children[idx] = self.class.new(val, key: key,
+                                        children: @children.size,
+                                        duplicates: @duplicates)
+      end
     end
 
-    def new_child(value)
-      self.add_child self.class.new(value)
+    # returns a single node for binary search
+    # returns multiple nodes for ternary search
+    def search(key)
+      if @children.size == 2
+        self.search2(key)
+      elsif @children.size == 3
+        self.search3(key)
+      else
+        raise(SearchError, "can't search for @children.size children")
+      end
     end
 
-    def add_parent(node)
-      node.add_child(self)
+    # returns a single node or nil
+    def search2(key)
+      return self if key == @key
+      child = @children[self.cidx(key)]
+      child.search(key) if child
+    end
+
+    # returns an array of nodes, possibly empty
+    def search3(key)
+      if key == @key
+        nodes = [self]
+        node = @children[1]
+        while node
+          nodes << node
+          node = node.children[1]
+        end
+        return nodes
+      end
+      child = @children[self.cidx(key)]
+      child ? child.search(key) : []
     end
   end
 
@@ -69,7 +143,7 @@ module CompSci
   class ChildNode < Node
     attr_accessor :parent
 
-    def initialize(value, children: [])
+    def initialize(value, children: 2)
       @parent = nil
       super(value, children: children)
     end
@@ -83,35 +157,11 @@ module CompSci
       @parent ? @parent.children : []
     end
 
-    def set_child(idx, node)
+    # update both sides of the relationship
+    def []=(idx, node)
       node.parent ||= self
       raise "node has a parent: #{node.parent}" if node.parent != self
       @children[idx] = node
     end
-
-    def set_parent(idx, node)
-      @parent = node
-      @parent.set_child(idx, self)
-    end
-  end
-
-  # ChildNode which accumulates children with no gaps
-  # It meets the FlexNode API but does not inherit from FlexNode since it
-  # needs to reimplement each method; instead get parent stuff from ChildNode
-  class ChildFlexNode < ChildNode
-    def add_child(node)
-      node.parent ||= self
-      raise "node has a parent: #{node.parent}" if node.parent != self
-      @children << node
-    end
-
-    def new_child(value)
-      self.add_child self.class.new(value)
-    end
-
-    def add_parent(node)
-      @parent = node
-      @parent.add_child(self)
-    end
   end
 end