compsci 0.3.0.1 → 0.3.2.1

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/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/fit.rb

@@ -153,5 +153,22 @@ module CompSci
 
       return Math.exp(a), b, self.error(xys) { |x| (Math.exp(a) * (x ** b)) }
     end
+
+    def self.predict(model, a, b, x)
+      case model
+      when :constant
+        a
+      when :logarithmic
+        a + b * Math.log(x)
+      when :linear
+        a + b * x
+      when :exponential
+        a * Math::E ** (b * x)
+      when :power
+        a * x ** b
+      else
+        raise("unknown model: #{model}")
+      end
+    end
   end
 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 { |line|
+      hsh[line.chr] << line.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

data/lib/compsci/simplex/parse.rb

@@ -82,18 +82,22 @@ class CompSci::Simplex
     end
   end
 
-  def self.problem(maximize: nil, constraints: [], **kwargs)
+  def self.problem(**kwargs)
+    self.new(*self.get_params(**kwargs))
+  end
+
+  def self.get_params(maximize: nil, constraints: [], **kwargs)
     if maximize
-      obj, maximize = maximize, true
+      expr, maximize = maximize, true
     elsif kwargs[:minimize]
-      obj, maximize = kwargs[:minimize], false
+      expr, maximize = kwargs[:minimize], false
     else
       raise(ArgumentError, "one of maximize/minimize expected")
     end
-    unless obj.is_a?(String)
+    unless expr.is_a?(String)
       raise(ArgumentError, "bad expr: #{expr} (#{expr.class})")
     end
-    obj_cof = Parse.expression(obj)
+    obj_cof = Parse.expression(expr)
 
     c = [] # coefficients of objective expression
     a = [] # array (per constraint) of the inequality's lhs coefficients
@@ -116,7 +120,7 @@ class CompSci::Simplex
       a.push cofs
       b.push rhs
     }
-    self.new(c, a, b)
+    [c, a, b]
   end
 
   def self.maximize(expression, *ineqs)

data/lib/compsci/simplex.rb

@@ -1,9 +1,9 @@
-require 'compsci'
-
 # note, this work is based on https://github.com/rickhull/simplex
 # which was forked in 2017 from https://github.com/danlucraft/simplex
 # which had its last commit in 2013
 
+module CompSci; end
+
 class CompSci::Simplex
   DEFAULT_MAX_PIVOTS = 10_000
 
@@ -26,35 +26,36 @@ class CompSci::Simplex
     @max_pivots = DEFAULT_MAX_PIVOTS
 
     # Problem dimensions; these never change
-    @num_non_slack_vars = num_vars
-    @num_constraints    = num_inequalities
-    @num_vars           = @num_non_slack_vars + @num_constraints
+    @num_free_vars   = num_vars
+    @num_basic_vars = num_inequalities
+    @total_vars      = @num_free_vars + @num_basic_vars
 
     # Set up initial matrix A and vectors b, c
-    @c = c.map { |flt| -1 * flt } + Array.new(@num_constraints, 0)
+    # store all input values as Rational (via #rationalize)
+    @c = c.map { |flt| -1 * flt.rationalize } + Array.new(@num_basic_vars, 0)
     @a = a.map.with_index { |ary, i|
-      if ary.size != @num_non_slack_vars
+      if ary.size != @num_free_vars
         raise ArgumentError, "a is inconsistent"
       end
-      # set diagonal to 1 (identity matrix?)
-      ary + Array.new(@num_constraints) { |ci| ci == i ? 1 : 0 }
+      # add identity matrix
+      ary.map { |flt| flt.rationalize } +
+        Array.new(@num_basic_vars) { |ci| ci == i ? 1 : 0 }
     }
-    @b = b
+    @b = b.map { |flt| flt.rationalize }
 
-    # set initial solution: all non-slack variables = 0
-    @basic_vars = (@num_non_slack_vars...@num_vars).to_a
+    @basic_vars = (@num_free_vars...@total_vars).to_a
     self.update_solution
   end
 
   # does not modify vector / matrix
   def update_solution
-    @x = Array.new(@num_vars, 0)
+    @x = Array.new(@total_vars, 0)
 
     @basic_vars.each { |basic_var|
       idx = nil
-      @num_constraints.times { |i|
+      @num_basic_vars.times { |i|
         if @a[i][basic_var] == 1
-          idx =i
+          idx = i
           break
         end
       }
@@ -78,7 +79,7 @@ class CompSci::Simplex
   end
 
   def current_solution
-    @x[0...@num_non_slack_vars]
+    @x[0...@num_free_vars]
   end
 
   def can_improve?
@@ -121,7 +122,7 @@ class CompSci::Simplex
     }
 
     # update A and B
-    @num_constraints.times { |i|
+    @num_basic_vars.times { |i|
       next if i == pivot_row
       r = @a[i][pivot_column]
       @a[i] = @a[i].map.with_index { |val, j| val - r * @a[pivot_row][j] }
@@ -134,7 +135,7 @@ class CompSci::Simplex
   def pivot_row(column_ix)
     min_ratio = nil
     idx = nil
-    @num_constraints.times { |i|
+    @num_basic_vars.times { |i|
       a, b = @a[i][column_ix], @b[i]
       next if a == 0 or (b < 0) ^ (a < 0)
       ratio = Rational(b, a)
@@ -168,6 +169,4 @@ class CompSci::Simplex
     lines.insert(1, "-"*max_line_length)
     lines.join("\n")
   end
-
-
 end