compsci 0.0.3.1 → 0.1.0.1

data/lib/compsci/names.rb

@@ -0,0 +1,132 @@
+# coding: utf-8
+module CompSci
+  module Names
+    WW1 = [:apples, :butter, :charlie, :duff, :edward, :freddy, :george,
+           :harry, :ink, :johnnie, :king, :london, :monkey, :nuts, :orange,
+           :pudding, :queenie, :robert, :sugar, :tommy, :uncle, :vinegar,
+           :willie, :xerxes, :yellow, :zebra]
+    WW2 = [:able, :baker, :charlie, :dog, :easy, :fox, :george, :how, :item,
+           :jig, :king, :love, :mike, :nan, :oboe, :peter, :queen, :roger,
+           :sugar, :tare, :uncle, :victor, :william, :xray, :yoke, :zebra]
+    NATO = [:alfa, :bravo, :charlie, :delta, :echo, :foxtrot, :golf, :hotel,
+            :india, :juliett, :kilo, :lima, :mike, :november, :oscar, :papa,
+            :quebec, :romeo, :sierra, :tango, :uniform, :victor, :whiskey,
+            :xray, :yankee, :zulu]
+    CRYPTO = [:alice, :bob, :charlie, :david, :eve, :frank, :grace, :heidi,
+              :judy, :mallory, :olivia, :peggy, :sybil, :trudy, :victor,
+              :wendy]
+    ENGLISH_UPPER = [*'A'..'Z']
+    ENGLISH_LOWER = [*'a'..'z']
+
+    PLANETS = [:mercury, :venus, :earth, :mars, :jupiter, :saturn, :uranus,
+               :neptune, :pluto]
+
+    SOLAR = [:mercury, :venus, :earth, :mars, :asteroid_belt, :jupiter,
+             :saturn, :uranus, :neptune, :kuiper_belt, :scattered_disk,
+             :heliosphere]
+
+    # map val to [0..names.length]
+    def self.assign(val, names)
+      case val
+      when String
+        if val.match %r{\A\d+\z}
+          pos = val.to_i
+        else
+          case names.size
+          when (1..26)
+            pos = val[0].upcase.ord - 'A'.ord
+          when (27..99)
+            pos = val[0].ord - 'A'.ord
+            pos -= 6 if pos > 26
+          else
+            raise "unexpected names.size: #{names.size}"
+          end
+        end
+      when Integer
+        pos = val
+      else
+        raise "unexpected val: #{val} (#{val.class})"
+      end
+
+      if pos < 0 or pos >= names.size
+        raise "val #{val} pos #{pos} outside of names range (#{names.size})"
+      end
+      names[pos]
+    end
+
+    module Greek
+      UPPER = [*'Α'..'Ρ', *'Σ'..'Ω']
+      LOWER = [*('α'..'ρ'), *('σ'..'ω')]
+      SYMBOLS = [:alpha, :beta, :gamma, :delta, :epsilon, :zeta, :eta, :theta,
+                 :iota, :kappa, :lambda, :mu, :nu, :xi, :omicron, :pi, :rho,
+                 :sigma, :tau, :upsilon, :phi, :chi, :psi, :omega]
+
+      # e.g. { alpha: ['Α', 'α'] ...
+      CHAR_MAP = {}
+      SYMBOLS.each_with_index { |sym, i| CHAR_MAP[sym] = [UPPER[i], LOWER[i]] }
+
+      LATIN_SYMBOLS = {
+        a: :alpha,
+        b: :beta,
+        c: :gamma,
+        d: :delta,
+        e: :epsilon,
+        f: :zeta,
+        g: :eta,
+        h: :theta,
+        i: :iota,
+        j: :xi,      # use for j, q and w
+        k: :kappa,
+        l: :lambda,
+        m: :mu,
+        n: :nu,
+        # nonesuch: => :xi,
+        o: :omicron,
+        p: :pi,
+        q: :xi,      # use for j, q and w
+        r: :rho,
+        s: :sigma,
+        t: :tau,
+        u: :upsilon,
+        v: :phi,
+        w: :xi,      # use for j, q and w
+        x: :chi,
+        y: :psi,
+        z: :omega,
+      }
+      SYMBOLS26 = LATIN_SYMBOLS.values
+
+      def self.upper(latin_str)
+        CHAR_MAP.fetch(self.sym(latin_str)).first
+      end
+
+      def self.lower(latin_str)
+        CHAR_MAP.fetch(self.sym(latin_str)).last
+      end
+
+      def self.sym(val)
+        case val
+        when String
+          if val.match %r{\A\d+\z}
+            val = val.to_i
+            if val >= 0 and val < SYMBOLS.size
+              SYMBOLS[val]
+            else
+              raise "val #{val} not in range (#{SYMBOLS.size})"
+            end
+          else
+            LATIN_SYMBOLS.fetch val[0].downcase.to_sym
+          end
+        when Integer
+          if val >= 0 and val < SYMBOLS.size
+            SYMBOLS[val]
+          else
+            raise "val #{val} not in range (#{SYMBOLS.size})"
+          end
+        else
+          raise "unexpected val #{val} (#{val.class})"
+        end
+      end
+    end
+  end
+end

data/lib/compsci/node.rb

@@ -0,0 +1,67 @@
+module CompSci
+  # has a value and an array of children
+  class Node
+    attr_accessor :value
+    attr_reader :children
+
+    def initialize(value)
+      @value = value
+      @children = []
+      # @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 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(', ')]
+    end
+  end
+
+  # like Node but with a reference to its parent
+  class ChildNode < Node
+    attr_accessor :parent
+
+    def initialize(value)
+      @parent = nil
+      super(value)
+    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
+      super(node)
+    end
+
+    def add_parent(node)
+      @parent = node
+      super(node)
+    end
+  end
+end

data/lib/compsci/timer.rb

@@ -1,36 +1,37 @@
-require 'compsci'
+module CompSci
 
-module CompSci::Timer
-  # lifted from seattlerb/minitest
-  if defined? Process::CLOCK_MONOTONIC
-    def self.now
-      Process.clock_gettime Process::CLOCK_MONOTONIC
+  module Timer
+    # lifted from seattlerb/minitest
+    if defined? Process::CLOCK_MONOTONIC
+      def self.now
+        Process.clock_gettime Process::CLOCK_MONOTONIC
+      end
+    else
+      def self.now
+        Time.now
+      end
     end
-  else
-    def self.now
-      Time.now
-    end
-  end
 
-  def self.since(t)
-    self.now - t
-  end
+    def self.since(t)
+      self.now - t
+    end
 
-  def self.elapsed(&work)
-    t = self.now
-    return yield, self.since(t)
-  end
+    def self.elapsed(&work)
+      t = self.now
+      return yield, self.since(t)
+    end
 
-  def self.loop_avg(count: 999, seconds: 1, &work)
-    i = 0
-    start = self.now
-    val = nil
-    loop {
-      val = yield
-      i += 1
-      break if i >= count
-      break if self.since(start) > seconds
-    }
-    return val, self.since(start) / i.to_f
+    def self.loop_avg(count: 999, seconds: 1, &work)
+      i = 0
+      start = self.now
+      val = nil
+      loop {
+        val = yield
+        i += 1
+        break if i >= count
+        break if self.since(start) > seconds
+      }
+      return val, self.since(start) / i.to_f
+    end
   end
 end

data/lib/compsci/tree.rb

@@ -1,67 +1,11 @@
-require 'compsci'
+require 'compsci/node'
 
 module CompSci
-  class Node
-    attr_accessor :value
-    attr_reader :children
-
-    def initialize(value)
-      @value = value
-      @children = []
-      # @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 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(', ')]
-    end
-  end
-
-  # like Node but with a reference to its parent
-  class ChildNode < Node
-    attr_accessor :parent
-
-    def initialize(value)
-      @parent = nil
-      super(value)
-    end
-
-    def add_child(node)
-      node.parent ||= self
-      raise "node has a parent: #{node.parent}" if node.parent != self
-      super(node)
-    end
-
-    def add_parent(node)
-      @parent = node
-      super(node)
-    end
-  end
-
   class Tree
     attr_reader :root
 
-    def initialize(klass, val)
-      @root = klass.new val
+    def initialize(node_class, val)
+      @root = node_class.new val
     end
 
     def df_search(node: nil, &blk)
@@ -96,9 +40,8 @@ module CompSci
   class NaryTree < Tree
     attr_reader :child_slots
 
-    def initialize(klass, val, child_slots:)
-      super(klass, val)
-      raise "#{klass}#parent required" unless @root.respond_to? :parent
+    def initialize(node_class, val, child_slots:)
+      super(node_class, val)
       @child_slots = child_slots
     end
 
@@ -106,35 +49,58 @@ module CompSci
       node.children.size < @child_slots
     end
 
+    def open_sibling
+      # try siblings first, only possible with Node#parent
+      if @open_parent.respond_to?(:siblings)
+        @open_parent.siblings.find { |s| self.open_parent?(s) }
+      end
+    end
+
     def open_parent
       @open_parent ||= @root
       return @open_parent if self.open_parent?(@open_parent)
-
-      # TODO: ugh, there must be a better way, this is O(n)
-
-      # try siblings first
-      if @open_parent.parent
-        @open_parent.parent.children.each { |c|
-          return @open_parent = c if self.open_parent?(c)
-        }
-      end
+      open_sibling = self.open_sibling
+      return @open_parent = open_sibling if open_sibling
       @open_parent = self.bf_search { |n| self.open_parent?(n) }
     end
 
     def push(value)
       self.open_parent.new_child value
     end
+
+    def display(width: nil)
+      str = ''
+      old_level = 0
+      width ||= @child_slots * 40
+      self.bf_search { |node|
+        raise "#{node.class} not yet supported" unless node.respond_to? :gen
+        level = node.gen
+        if old_level != level
+          str += "\n"
+          old_level = level
+        end
+        # center in block_width
+        slots = @child_slots**level
+        block_width = width / slots
+        val = node.to_s
+        space = [(block_width + val.size) / 2, val.size + 1].max
+        str += val.ljust(space, ' ').rjust(block_width, ' ')
+        false
+      }
+      str
+    end
+    alias_method :to_s, :display
   end
 
   class BinaryTree < NaryTree
-    def initialize(klass, val)
-      super(klass, val, child_slots: 2)
+    def initialize(node_class, val)
+      super(node_class, val, child_slots: 2)
     end
 
-    def to_s(node: nil, width: 80)
+    def display(width: 80)
       count = 0
       str = ''
-      self.bf_search(node: node) { |n|
+      self.bf_search { |n|
         count += 1
         level = Math.log(count, 2).floor
         block_width = width / (2**level)
@@ -144,74 +110,18 @@ module CompSci
       }
       str
     end
+    alias_method :to_s, :display
   end
 
-  # A CompleteBinaryTree can very efficiently use an array for storage using
-  # simple arithmetic to determine parent child relationships.
-  #
-  # Likewise, we should be able to use an array for N children
-  #
-  class CompleteNaryTree
-    def self.parent_idx(idx, n)
-      (idx-1) / n
-    end
-
-    def self.children_idx(idx, n)
-      Array.new(n) { |i| n*idx + i + 1 }
-    end
-
-    attr_reader :store
-
-    def initialize(store: [], child_slots: 2)
-      @store = store
-      @child_slots = child_slots
-    end
-
-    def push node
-      @store.push node
-    end
-
-    def pop
-      @store.pop
-    end
-
-    def size
-      @store.size
-    end
-
-    def last_idx
-      @store.size - 1 unless @store.empty?
+  class TernaryTree < NaryTree
+    def initialize(node_class, val)
+      super(node_class, val, child_slots: 3)
     end
   end
 
-  # Heap still expects CompleteBinaryTree
-  #
-  class CompleteBinaryTree < CompleteNaryTree
-    # integer math says idx 2 and idx 1 both have parent at idx 0
-    def self.parent_idx(idx)
-      (idx-1) / 2
-    end
-
-    def self.children_idx(idx)
-      [2*idx + 1, 2*idx + 2]
-    end
-
-    attr_reader :store
-
-    def initialize(store: [])
-      super(store: store, child_slots: 2)
-    end
-
-    # TODO: generalize for N != 2
-    def to_s(node: nil, width: 80)
-      str = ''
-      @store.each_with_index { |n, i|
-        level = Math.log(i+1, 2).floor
-        block_width = width / (2**level)
-        str += "\n" if 2**level == i+1 and i > 0
-        str += n.to_s.ljust(block_width / 2, ' ').rjust(block_width, ' ')
-      }
-      str
+  class QuaternaryTree < NaryTree
+    def initialize(node_class, val)
+      super(node_class, val, child_slots: 4)
     end
   end
 end