compsci 0.0.3.1 → 0.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc2eff6c2450cd9807ab097dd86eebb37420a7b7
-  data.tar.gz: 470311b19fc70c7ab1a5d405c3aba939f57464e7
+  metadata.gz: 3df760b020e177135c9d73e20f455635ca82250c
+  data.tar.gz: '0850e990c79b14fa39533e0990d707cb3f1fe7cc'
 SHA512:
-  metadata.gz: 37214ed2f4c2fd3f8837f1908fc78b07be79e624ba7f387f40c68aec49f93b1b866589fab0b863e02e6add2d6dcbfe4508c9ae1bdf1864269427dce25fdb15b4
-  data.tar.gz: 52dc0115e1f44a769da4dc3f1e721624e3963cef0111d098af6ad6beb72728b120905aaaeb45161950c79455810bbf8caab5426fb22aee716f5e7e92f84244a4
+  metadata.gz: 8997da4e5f98d35b1250d8feab97d9e46d7a193aec42a89b74e720bfff50608624b054e7e3bb85709230d2a038557919c3a2ce0d6f9f4dc22ddf88e8357d6c8c
+  data.tar.gz: 90069e7be2f383c80e0edd09c41ca566ba8481b3659c4aca90c7b23000027c3eaa1139cf980ba74737ca9ba4d20e99bd0591623be7b5872d9d7cb06ac99ce2ad

data/README.md

@@ -1,28 +1,70 @@
 [![Build Status](https://travis-ci.org/rickhull/compsci.svg?branch=master)](https://travis-ci.org/rickhull/compsci)
 
-# Introduction
+# CompSci
 
 Provided are some toy implementations for some basic computer science problems.
 
-## [`Tree`](/lib/compsci/tree.rb) data structures
-
-* `Node`       - references children nodes only
-* `ChildNode`  - references parent and children nodes
-* `Tree`       - tracks the `root` node; provides `df_search` and `bf_search`
-* `NaryTree`   - enforces number of children per node via `child_slots`
-* `BinaryTree` - `NaryTree` with `child_slots` == 2; provides `to_s`
-* `CompleteBinaryTree` - efficient Array implementation
+## [`Node`](lib/compsci/node.rb) data structure
+
+* `Node`
+  - `@value`
+  - `@children`
+* `ChildNode` adds
+  - `@parent`
+  - `#gen`
+  - `#siblings`
+
+## [`Tree`](lib/compsci/tree.rb) data structures
+
+* `Tree`
+  - `@root`
+  - `#df_search`
+  - `#bf_search`
+* `NaryTree`
+  - `@child_slots` (number of children per node)
+  - `#open_parent` O(n) to find a node with open child slots
+  - `#push` append `#open_parent.children`
+  - `#display` if initialized with `ChildNode`
+* `BinaryTree`
+  - `NaryTree.new(child_slots: 2)`
+  - `#display` for `Node` and `ChildNode`
+* `TernaryTree`
+  - `NaryTree.new(child_slots: 3)`
+* `QuaternaryTree`
+  - `NaryTree.new(child_slots: 4)`
+
+## [`CompleteNaryTree`](lib/compsci/complete_tree.rb) data structure
+
+Efficient Array implementation of a complete tree.
+
+* `CompleteNaryTree`
+  - `CompleteNaryTree.parent_idx`
+  - `CompleteNaryTree.children_idx`
+  - `CompleteNaryTree.gen`
+  - `@array`
+  - `@child_slots`
+  - `#push`
+  - `#pop`
+  - `#size`
+  - `#last_idx`
+  - `#display` (alias `#to_s`)
+* `CompleteBinaryTree`
+  - `CompleteNaryTree.new(child_slots: 2)`
+* `CompleteTernaryTree`
+  - `CompleteNaryTree.new(child_slots: 3)`
+* `CompleteQuaternaryTree`
+  - `CompleteNaryTree.new(child_slots: 4)`
 
 ## [`Heap`](lib/compsci/heap.rb) data structure
 
-Implemented with a `CompleteBinaryTree` for storage using simple arithmetic to
-determine array indices for parent and children.  See the
+`CompleteNaryTree` implementation.  Both minheaps and maxheaps are supported.
+Any number of children may be provided via `child_slots`.  The primary
+operations are `Heap#push` and `Heap#pop`. See the
 [heap example](examples/heap.rb) which can be executed (among other examples)
 via `rake examples`.
 
-Both minheaps and maxheaps are supported.  The primary operations are
-`Heap#push` and `Heap#pop`.  My basic Vagrant VM gets around 500k pushes per
-second, constant up past 1M pushes.
+My basic Vagrant VM gets around 500k pushes per second, constant up past 1M
+pushes.
 
 ## [`Fibonacci`](lib/compsci/fibonacci.rb) functions
 
@@ -93,3 +135,10 @@ cumulative: 0.828
 * `Fit.linear` - fits `y = a + bx`; returns a, b, r^2
 * `Fit.exponential` fits `y = ae^(bx)`; returns a, b, r^2
 * `Fit.power` fits `y = ax^b`; returns a, b, r^2
+
+## [`Names`](lib/compsci/names.rb) functions
+
+* `Names.assign`
+* `Names::Greek.upper`
+* `Names::Greek.lower`
+* `Names::Greek.symbol`

data/VERSION

@@ -1 +1 @@
-0.0.3.1
+0.1.0.1

data/compsci.gemspec

@@ -10,28 +10,11 @@ Gem::Specification.new do |s|
 
   s.version = File.read(File.join(__dir__, 'VERSION')).chomp
 
-  s.files = %w[
-    compsci.gemspec
-    VERSION
-    README.md
-    Rakefile
-    lib/compsci.rb
-    lib/compsci/fibonacci.rb
-    lib/compsci/fit.rb
-    lib/compsci/heap.rb
-    lib/compsci/timer.rb
-    lib/compsci/tree.rb
-    examples/binary_tree.rb
-    examples/heap.rb
-    test/fibonacci.rb
-    test/fit.rb
-    test/heap.rb
-    test/timer.rb
-    test/tree.rb
-    test/bench/fibonacci.rb
-    test/bench/heap.rb
-    test/bench/tree.rb
-  ]
+  s.files = %w[compsci.gemspec VERSION README.md Rakefile]
+  s.files += Dir['lib/**/*.rb']
+  s.files += Dir['test/**/*.rb']
+  s.files += Dir['examples/**/*.rb']
 
   s.add_development_dependency "minitest", "~> 5.0"
+  s.add_development_dependency "rake", "~> 0"
 end

data/examples/binary_tree.rb

@@ -13,7 +13,7 @@ EOF
 count = 0
 start = Timer.now
 start_1k = Timer.now
-tree = BinaryTree.new(ChildNode, rand(99))
+tree = NaryTree.new(ChildNode, rand(99), child_slots: 2)
 
 loop {
   count += 1
@@ -47,20 +47,25 @@ puts <<EOF
 
 EOF
 
-vals = []
-30.times { vals << rand(99) }
+vals = Array.new(30) { rand 99 }
 p vals
 
-tree = BinaryTree.new(ChildNode, vals.shift)
+tree = NaryTree.new(ChildNode, vals.shift, child_slots: 2)
 tree.push vals.shift until vals.empty?
-
 puts tree
 
+p tree
+puts
+
 tree.df_search { |n|
   puts "visited #{n}"
   false # or n.value > 90
 }
 puts
 
-p tree
+vals = Array.new(30) { rand 99 }
+puts "push: #{vals.inspect}"
+
+tree.push vals.shift until vals.empty?
+puts tree
 puts

data/examples/complete_tree.rb

@@ -0,0 +1,47 @@
+require 'compsci/complete_tree'
+require 'compsci/timer'
+
+include CompSci
+
+puts <<EOF
+#
+# Print CompleteBinary-, Ternary-, and QuaternaryTree
+#
+
+EOF
+
+vals = Array.new(30) { rand 99 }
+
+[CompleteBinaryTree,
+ CompleteTernaryTree,
+ CompleteQuaternaryTree,
+].each { |tree_class|
+  # start with the same vals for each class
+  my_vals = vals.dup
+  p my_vals
+  tree = tree_class.new
+  tree.push my_vals.shift until my_vals.empty?
+  p tree
+  puts tree.display(width: 80)
+  puts
+  puts
+  puts
+
+
+  # TODO: add CompleteTree#df_search
+  # tree.df_search { |n|
+  #   puts "visited #{n}"
+  #   false # or n.value > 90
+  # }
+  # 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 tree.display(width: 80)
+  puts
+  puts
+  puts
+}

data/examples/heap.rb

@@ -13,7 +13,7 @@ EOF
 count = 0
 start = Timer.now
 start_100k = Timer.now
-h = BinaryHeap.new
+h = Heap.new
 
 loop {
   count += 1
@@ -47,24 +47,36 @@ puts
 
 puts <<EOF
 #
-# 99 inserts; display the internal array
+# display the results of TernaryHeap push and pop
 #
 
 EOF
 
-h = Heap.new
+h = Heap.new(child_slots: 3)
 
-puts "push: %s" % Array.new(99) { rand(99).tap { |i| h.push i } }.join(' ')
-puts "heap store: #{h.store.inspect}"
+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 "heap store: #{h.store.inspect}"
+puts "array: #{h.array.inspect}"
 puts "heap: #{h.heap?}"
+puts h
+puts
 puts
 
 puts "pop: %s" % Array.new(9) { h.pop }.join(' ')
-puts "heap store: #{h.store.inspect}"
+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/tree.rb

@@ -0,0 +1,41 @@
+require 'compsci/tree'
+require 'compsci/timer'
+
+include CompSci
+
+puts <<EOF
+#
+# Try out Binary-, Ternary-, and QuaternaryTree
+#
+
+EOF
+
+vals = Array.new(30) { rand 99 }
+
+[BinaryTree, TernaryTree, QuaternaryTree].each { |tree_class|
+  # start with the same vals for each class
+  my_vals = vals.dup
+  p my_vals
+  tree = tree_class.new(ChildNode, 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
+  puts
+}

data/lib/compsci.rb

@@ -1,2 +1 @@
-module CompSci
-end
+module CompSci; end

data/lib/compsci/complete_tree.rb

@@ -0,0 +1,109 @@
+module CompSci
+  # A CompleteNaryTree 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
+    # integer math maps several children to one parent
+    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
+
+    def self.gen(idx, n)
+      count = 0
+      loop {
+        pidx = self.parent_idx(idx, n)
+        break if pidx < 0
+        count += 1
+        idx = pidx
+      }
+      count
+    end
+
+    attr_reader :array
+
+    def initialize(array: [], child_slots: 2)
+      @array = array
+      @child_slots = child_slots
+    end
+
+    def push val
+      @array.push val
+    end
+
+    def pop
+      @array.pop
+    end
+
+    def size
+      @array.size
+    end
+
+    def last_idx
+      @array.size - 1 unless @array.empty?
+    end
+
+    # or, ya know, just iterate @array
+    def bf_search(&blk)
+      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)
+      puts "not yet"
+    end
+
+    def display(width: 80)
+      str = ''
+      old_level = 0
+      @array.each_with_index { |val, i|
+        val = val.to_s
+        level = self.class.gen(i, @child_slots)
+        if old_level != level
+          str += "\n"
+          old_level = level
+        end
+
+        # 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, ' ')
+      }
+      str
+    end
+    alias_method :to_s, :display
+  end
+
+  class CompleteBinaryTree < CompleteNaryTree
+    def initialize(array: [])
+      super(array: array, child_slots: 2)
+    end
+  end
+
+  class CompleteTernaryTree < CompleteNaryTree
+    def initialize(array: [])
+      super(array: array, child_slots: 3)
+    end
+  end
+
+  class CompleteQuaternaryTree < CompleteNaryTree
+    def initialize(array: [])
+      super(array: array, child_slots: 4)
+    end
+  end
+end

data/lib/compsci/fibonacci.rb

@@ -1,39 +1,40 @@
-require 'compsci'
 autoload :Matrix, 'matrix'
 
-module CompSci::Fibonacci
-  def self.classic(n)
-    n < 2 ? n : classic(n-1) + classic(n-2)
-  end
+module CompSci
+  class Fibonacci
+    def self.classic(n)
+      n < 2 ? n : classic(n-1) + classic(n-2)
+    end
 
-  def self.cache_recursive(n, cache = {})
-    return n if n < 2
-    cache[n] ||= cache_recursive(n-1, cache) + cache_recursive(n-2, cache)
-  end
+    def self.cache_recursive(n, cache = {})
+      return n if n < 2
+      cache[n] ||= cache_recursive(n-1, cache) + cache_recursive(n-2, cache)
+    end
 
-  def self.cache_iterative(n)
-    cache = [0, 1]
-    2.upto(n) { |i| cache[i] = cache[i-1] + cache[i-2] }
-    cache[n]
-  end
+    def self.cache_iterative(n)
+      cache = [0, 1]
+      2.upto(n) { |i| cache[i] = cache[i-1] + cache[i-2] }
+      cache[n]
+    end
 
-  # traditional
-  def self.dynamic(n)
-    a, b = 0, 1
-    n.times { a, b = b, a+b }
-    a
-  end
+    # traditional
+    def self.dynamic(n)
+      a, b = 0, 1
+      n.times { a, b = b, a+b }
+      a
+    end
 
-  # fails for n == 0
-  def self.dynamic_fast(n)
-    a, b = 0, 1
-    (n-1).times { a, b = b, a+b }
-    b
-  end
+    # fails for n == 0
+    def self.dynamic_fast(n)
+      a, b = 0, 1
+      (n-1).times { a, b = b, a+b }
+      b
+    end
 
-  # https://gist.github.com/havenwood/02cf291b809327d96a3f
-  # slower than dynamic until around n == 500
-  def self.matrix(n)
-    (Matrix[[0, 1], [1, 1]] ** n.pred)[1, 1].to_i
+    # https://gist.github.com/havenwood/02cf291b809327d96a3f
+    # slower than dynamic until around n == 500
+    def self.matrix(n)
+      (Matrix[[0, 1], [1, 1]] ** n.pred)[1, 1].to_i
+    end
   end
 end