compsci 0.0.1.1 → 0.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc7af3ec0bc93ea91b485b329e66033cca137597
-  data.tar.gz: f62c24c3171a6534e92fa8f53dba942e009442c3
+  metadata.gz: 4ee20715906280e4a366f493195ae4decf079cf1
+  data.tar.gz: '0088708c15ca4dae9cdc58ef35d1f85dd60203cc'
 SHA512:
-  metadata.gz: fe64178808bef0a929882318ed08941de2179940bc332ee42ca9f48f0430e566ae6299f628aa4ad11573787c59fe9746cd8a23b5309fa1ecd92117fd1c0daf16
-  data.tar.gz: 0ce9187b7eb0d17add238c6344452e344685e00126927359f2d2d54f6e3fbc8ce5a389d153027c7f626b8039f86e8b7409d1950f2d14afbd5619ec8dd878ff4c
+  metadata.gz: 38071308dbc5a6e1988abf8671166c10b793f4baa9bb7371c1fe65c3d2570f1a38caaf61042fa247d58a0451b8711b1ec0eb0ea98e67bfe9fab8bbd8c0652318
+  data.tar.gz: 11a04a2484e15b29a049c1d6c48c373e2360c98b24f02d4bc874353aa29917acbf53acc1932b1d3629796afd5956c91048a14ff8c46b54904f457d1588e7aa45

data/README.md

@@ -6,36 +6,39 @@ Provided are some toy implementations for some basic computer science problems.
 
 ## [`Tree`](/lib/compsci/tree.rb) data structures
 
-* `Tree`       - enforces number of children per node
-* `Tree::Node` - references parent and children nodes
-* `BinaryTree` - subclass of `Tree`; child_slots == 2
+* `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
 
 ## [`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
-[heap example](https://github.com/rickhull/compsci/blob/master/eamples/heap.rb)
-which can be executed (among other examples) via `rake examples`.
+[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 over 350k pushes per
+`Heap#push` and `Heap#pop`.  My basic Vagrant VM gets around 500k pushes per
 second, constant up past 1M pushes.
 
-## [`Fibonacci`](lib/compsci/fib.rb) functions
+## [`Fibonacci`](lib/compsci/fibonacci.rb) functions
 
 * `Fibonacci.classic(n)`         - naive, recursive
 * `Fibonacci.cache_recursive(n)` - as above, caching already computed results
 * `Fibonacci.cache_iterative(n)` - as above but iterative
 * `Fibonacci.dynamic(n)`         - as above but without a cache structure
+* `Fibonacci.matrix(n)`          - matrix is magic; beats dynamic around n=500
 
 ## [`Timer`](/lib/compsci/timer.rb) functions
 
 * `Timer.now`          - uses `Process::CLOCK_MONOTONIC` if available
+* `Timer.since`        - provides the elapsed time since a prior time
 * `Timer.elapsed`      - provides the elapsed time to run a block
 * `Timer.loop_average` - runs a block repeatedly and provides the mean elapsed
                          time
-* `Timer.since`        - provides the elapsed time since a prior time
 
 ## [`Fit`](lib/compsci/fit.rb) functions
 

data/Rakefile

@@ -5,14 +5,14 @@ Rake::TestTask.new :test do |t|
   t.warning = true
 end
 
-Rake::TestTask.new bench: :test do |t|
+Rake::TestTask.new bench: [:test, :loadavg] do |t|
   t.pattern = "test/bench/*.rb"
   t.warning = true
   t.description = "Run benchmarks"
 end
 
 desc "Run example scripts"
-task examples: :test do
+task examples: [:test, :loadavg] do
   Dir['examples/**/*.rb'].each { |filepath|
     puts
     sh "ruby -Ilib #{filepath}"
@@ -31,7 +31,7 @@ metrics_tasks = []
 begin
   require 'flog_task'
   FlogTask.new do |t|
-    t.threshold = 420
+    t.threshold = 450
     t.dirs = ['lib']
     t.verbose = true
   end
@@ -68,7 +68,7 @@ task code_metrics: metrics_tasks
 
 desc "Show current system load"
 task "loadavg" do
-  puts File.read "/proc/loadavg"
+  puts "/proc/loadavg %s" % (File.read("/proc/loadavg") rescue "Unavailable")
 end
 
 def lib_sh(cmd)

data/VERSION

@@ -1 +1 @@
-0.0.1.1
+0.0.2.1

data/compsci.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
     README.md
     Rakefile
     lib/compsci.rb
-    lib/compsci/fib.rb
+    lib/compsci/fibonacci.rb
     lib/compsci/fit.rb
     lib/compsci/heap.rb
     lib/compsci/timer.rb
@@ -24,12 +24,12 @@ Gem::Specification.new do |s|
     examples/binary_tree.rb
     examples/heap.rb
     examples/timer.rb
-    test/fib.rb
+    test/fibonacci.rb
     test/fit.rb
     test/heap.rb
     test/timer.rb
     test/tree.rb
-    test/bench/fib.rb
+    test/bench/fibonacci.rb
     test/bench/heap.rb
     test/bench/tree.rb
   ]

data/examples/binary_tree.rb

@@ -1,16 +1,60 @@
 require 'compsci/tree'
+require 'compsci/timer'
 
 include CompSci
 
+puts <<EOF
+#
+# 3 seconds worth of pushes
+#
+
+EOF
+
+count = 0
+start = Timer.now
+start_1k = Timer.now
+tree = BinaryTree.new(ChildNode, rand(99))
+
+loop {
+  count += 1
+
+  if count % 100 == 0
+    _ans, push_elapsed = Timer.elapsed { tree.push rand 99 }
+    puts "%ith push: %0.8f s" % [count, push_elapsed]
+
+    if count % 1000 == 0
+      push_1k_elapsed = Timer.since start_1k
+      puts "-----------"
+      puts "    1k push: %0.4f s (%i push / s)" %
+           [push_1k_elapsed, 1000.to_f / push_1k_elapsed]
+      puts
+      start_1k = Timer.now
+    end
+  else
+    tree.push rand 99
+  end
+
+  break if Timer.since(start) > 3
+}
+
+puts "pushed %i items in %0.1f s" % [count, Timer.since(start)]
+puts
+
+puts <<EOF
+#
+# 30 inserts, puts, df_search
+#
+
+EOF
+
 vals = []
 30.times { vals << rand(99) }
 p vals
 
-root_node = Tree::Node.new vals.shift
-tree = BinaryTree.new(root_node)
+tree = BinaryTree.new(ChildNode, vals.shift)
 tree.push vals.shift until vals.empty?
 
-tree.bf_print
+puts tree
 
 tree.df_search { |n|
   puts "visited #{n}"
@@ -19,3 +63,4 @@ tree.df_search { |n|
 puts
 
 p tree
+puts

data/examples/heap.rb

@@ -5,34 +5,39 @@ include CompSci
 
 puts <<EOF
 #
-# 3 seconds worth of inserts
+# 3 seconds worth of pushes
 #
 
 EOF
 
 count = 0
 start = Timer.now
+start_100k = Timer.now
 h = Heap.new
-elapsed = 0
 
-while elapsed < 3
-  _answer, push_elapsed = Timer.elapsed { h.push rand 99999 }
+loop {
   count += 1
-  puts "%ith push: %0.8f s" % [count, push_elapsed] if count % 10000 == 0
 
-  if count % 100000 == 0
-    start_100k ||= start
-    push_100k_elapsed = Timer.now - start_100k
-    puts "-------------"
-    puts "    100k push: %0.8f s (%ik push / s)" %
-         [push_100k_elapsed, 100.to_f / push_100k_elapsed]
-    puts
-    start_100k = Timer.now
+  if count % 10000 == 0
+    _answer, push_elapsed = Timer.elapsed { h.push rand 99999 }
+    puts "%ith push: %0.8f s" % [count, push_elapsed]
+    if count % 100000 == 0
+      h.push rand 99999
+      push_100k_elapsed = Timer.since start_100k
+      puts "-------------"
+      puts "    100k push: %0.8f s (%ik push / s)" %
+           [push_100k_elapsed, 100.to_f / push_100k_elapsed]
+      puts
+      start_100k = Timer.now
+    end
+  else
+    h.push rand 99999
   end
-  elapsed = Timer.now - start
-end
 
-puts "pushed %i items in %0.1f s" % [count, elapsed]
+  break if Timer.since(start) > 3
+}
+
+puts "pushed %i items in %0.1f s" % [count, Timer.since(start)]
 puts
 
 print "still a heap with #{h.size} items? "

data/examples/timer.rb

@@ -18,8 +18,8 @@ puts
 
 
 start = Timer.now
-print "running sleep 0.02 (0.5 s): "
-_answer, each_et = Timer.loop_average(seconds: 0.5) {
+print "running sleep 0.02 (0.3 s): "
+_answer, each_et = Timer.loop_average(seconds: 0.3) {
   print '.'
   sleep 0.02
 }
@@ -28,15 +28,3 @@ puts "each: %0.3f" % each_et
 puts "elapsed: %0.3f" % Timer.since(start)
 puts "cumulative: %0.3f" % Timer.since(overall_start)
 puts
-
-
-start = Timer.now
-print "running sleep 2 (1 s): "
-_answer, each_et = Timer.loop_average(seconds: 1) {
-  print '.'
-  sleep 2
-}
-puts
-puts "each: %0.3f" % each_et
-puts "elapsed: %0.3f" % Timer.since(start)
-puts "cumulative: %0.3f" % Timer.since(overall_start)

data/lib/compsci/{fib.rb → fibonacci.rb}

@@ -1,4 +1,5 @@
 require 'compsci'
+autoload :Matrix, 'matrix'
 
 module CompSci::Fibonacci
   def self.classic(n)
@@ -16,9 +17,23 @@ module CompSci::Fibonacci
     cache[n]
   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
+
+  # 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

data/lib/compsci/heap.rb

@@ -36,13 +36,16 @@ class CompSci::Heap < CompSci::CompleteBinaryTree
     end
   end
 
-  # append to the array; sift_up
+  # append to the array
+  # sift_up -- O(log n) on heap size
   def push(node)
     @store << node
     self.sift_up(@store.size - 1)
   end
 
-  # remove from the front of the array; move last node to root; sift_down
+  # remove from the front of the array
+  # move last node to root
+  # sift_down -- O(log n) on heap size
   def pop
     node = @store.shift
     replacement = @store.pop
@@ -56,25 +59,29 @@ class CompSci::Heap < CompSci::CompleteBinaryTree
     @store.first
   end
 
-  # called recursively; idx represents the node suspected to violate the heap
+  # called recursively
+  # idx represents the node suspected to violate the heap
+  # intended to be O(log n) on heap size
   def sift_up(idx)
     return self if idx <= 0
     pidx = self.class.parent_idx(idx)
     if !self.heapish?(pidx, idx)
-      @store[idx], @store[pidx] = @store[pidx], @store[idx] # swap
+      @store[idx], @store[pidx] = @store[pidx], @store[idx]   # swap
       self.sift_up(pidx)
     end
     self
   end
 
-  # called recursively; idx represents the node suspected to violate the heap
+  # called recursively
+  # idx represents the node suspected to violate the heap
+  # intended to be O(log n) on heap size
   def sift_down(idx)
     return self if idx >= @store.size
     lidx, ridx = self.class.children_idx(idx)
-    # take the child most likely to be a good parent
+    # promote the heapiest child
     cidx = self.heapish?(lidx, ridx) ? lidx : ridx
     if !self.heapish?(idx, cidx)
-      @store[idx], @store[cidx] = @store[cidx], @store[idx] # swap
+      @store[idx], @store[cidx] = @store[cidx], @store[idx]   # swap
       self.sift_down(cidx)
     end
     self
@@ -85,10 +92,13 @@ class CompSci::Heap < CompSci::CompleteBinaryTree
     (@store[pidx] <=> @store[cidx]) != (@cmp_val * -1)
   end
 
-  # not used internally; checks that every node satisfies the heap property
+  # not used internally
+  # checks that every node satisfies the heap property
+  # calls heapish? on idx's children and then heap? on them recursively
   def heap?(idx: 0)
     check_children = []
     self.class.children_idx(idx).each { |cidx|
+      # cidx is arithmetically produced; the corresponding child may not exist
       if cidx < @store.size
         return false unless self.heapish?(idx, cidx)
         check_children << cidx

data/lib/compsci/tree.rb

@@ -1,26 +1,67 @@
 require 'compsci'
 
 module CompSci
-  class Tree
-    attr_reader :root, :child_slots
+  class Node
+    attr_accessor :value
+    attr_reader :children
+
+    def initialize(value)
+      @value = value
+      @children = []
+      # @metadata = {}
+    end
 
-    def initialize(root_node, child_slots: 2)
-      @root = root_node
-      @child_slots = child_slots
-      @open_parent = @root
+    def add_child(node)
+      @children << node
     end
 
-    def push(value)
-      self.open_parent.new_child value
+    def new_child(value)
+      self.add_child self.class.new(value)
     end
 
-    def open_parent?(node)
-      node.children.size < @child_slots
+    def add_parent(node)
+      node.add_child(self)
     end
 
-    def open_parent
-      return @open_parent if self.open_parent?(@open_parent)
-      @open_parent = self.bf_search { |n| self.open_parent?(n) }
+    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
     end
 
     def df_search(node: nil, &blk)
@@ -33,13 +74,6 @@ module CompSci
       nil
     end
 
-    def df_search_generic(node: nil, &blk)
-      # Perform pre-order operation
-      # children.each { Perform in-order operation }
-      # Perform post-order operation
-      puts "not defined yet"
-    end
-
     def bf_search(node: nil, &blk)
       node ||= @root
       destinations = [node]
@@ -51,61 +85,64 @@ module CompSci
       nil
     end
 
-    class Node
-      attr_accessor :value, :parent
-      attr_reader :children
+    def df_search_generic(node: nil, &blk)
+      # Perform pre-order operation
+      # children.each { Perform in-order operation }
+      # Perform post-order operation
+      puts "not defined yet"
+    end
+  end
 
-      def initialize(value)
-        @value = value
-        @parent = nil
-        @children = []
-        # @metadata = {}
-      end
+  class NaryTree < Tree
+    attr_reader :child_slots
 
-      def add_child(node)
-        node.parent ||= self
-        raise "node has a parent: #{node.parent}" if node.parent != self
-        @children << node
-      end
+    def initialize(klass, val, child_slots:)
+      super(klass, val)
+      raise "#{klass}#parent required" unless @root.respond_to? :parent
+      @child_slots = child_slots
+    end
 
-      def new_child(value)
-        self.add_child self.class.new(value)
-      end
+    def open_parent?(node)
+      node.children.size < @child_slots
+    end
 
-      def add_parent(node)
-        @parent = node
-        node.add_child(self)
-      end
+    def open_parent
+      @open_parent ||= @root
+      return @open_parent if self.open_parent?(@open_parent)
 
-      def to_s
-        @value.to_s
-      end
+      # TODO: ugh, there must be a better way, this is O(n)
 
-      def inspect
-        "#<%s:0x%0xi @value=%s @children=[%s]>" %
-          [self.class,
-           self.object_id,
-           self.to_s,
-           @children.map(&:to_s).join(', ')]
+      # try siblings first
+      if @open_parent.parent
+        @open_parent.parent.children.each { |c|
+          return @open_parent = c if self.open_parent?(c)
+        }
       end
+      @open_parent = self.bf_search { |n| self.open_parent?(n) }
+    end
+
+    def push(value)
+      self.open_parent.new_child value
     end
   end
 
-  class BinaryTree < Tree
-    def initialize(root_node)
-      super(root_node, child_slots: 2)
+  class BinaryTree < NaryTree
+    def initialize(klass, val)
+      super(klass, val, child_slots: 2)
     end
 
-    def bf_print(node: nil, width: 80)
+    def to_s(node: nil, width: 80)
       count = 0
+      str = ''
       self.bf_search(node: node) { |n|
         count += 1
         level = Math.log(count, 2).floor
         block_width = width / (2**level)
-        puts if 2**level == count and count > 1
-        print n.to_s.ljust(block_width / 2, ' ').rjust(block_width, ' ')
+        str += "\n" if 2**level == count and count > 1
+        str += n.to_s.ljust(block_width / 2, ' ').rjust(block_width, ' ')
+        false # keep searching to visit every node
       }
-      puts
+      str
     end
   end
 

data/test/bench/{fib.rb → fibonacci.rb}

@@ -1,4 +1,4 @@
-require 'compsci/fib'
+require 'compsci/fibonacci'
 require 'minitest/autorun'
 require 'minitest/benchmark'
 
@@ -14,13 +14,14 @@ CACHE_RANGE = [100, 1000, 10000, 100000]
 # this causes churn at the process level and impacts other benchmarks
 # DYNAMIC_RANGE = [100, 1000, 10000, 100000, 200000, 500000]
 DYNAMIC_RANGE = [100, 1000, 10000, 100000]
+MATRIX_RANGE = [100, 1000, 10000, 100000]
 
 #SPEC_BENCHMARK = true
-#CLASS_BENCHMARK = false
-#BENCHMARK_IPS = true
+#CLASS_BENCHMARK = true
+BENCHMARK_IPS = true
 SPEC_BENCHMARK = false
-CLASS_BENCHMARK = true
-BENCHMARK_IPS = false
+CLASS_BENCHMARK = false
+#BENCHMARK_IPS = false
 
 
 if SPEC_BENCHMARK
@@ -67,6 +68,17 @@ if SPEC_BENCHMARK
       Fibonacci.dynamic(n)
     end
   end
+
+  describe "Fibonacci.matrix Benchmark" do
+    bench_range do
+      MATRIX_RANGE
+    end
+
+    fd = ["Fibonacci.matrix (linear, 0.99)", 0.99]
+    bench_performance_linear(*fd) do |n|
+      Fibonacci.matrix(n)
+    end
+  end
 end
 
 if CLASS_BENCHMARK
@@ -89,6 +101,7 @@ end
 if BENCHMARK_IPS
   require 'benchmark/ips'
 
+  # recursive benchmarks with low N; iterative for comparison
   Benchmark.ips do |b|
     b.config time: 3, warmup: 0.5
     num = 25
@@ -105,10 +118,30 @@ if BENCHMARK_IPS
       Fibonacci.cache_iterative(num)
     }
 
+    b.compare!
+  end
+
+  # nonrecursive benchmarks with high N
+  Benchmark.ips do |b|
+    b.config time: 3, warmup: 0.5
+    num = 500
+
+    b.report("Fibonacci.cache_iterative(#{num})") {
+      Fibonacci.cache_iterative(num)
+    }
+
     b.report("Fibonacci.dynamic(#{num})") {
       Fibonacci.dynamic(num)
     }
 
+    b.report("Fibonacci.dynamic_fast(#{num})") {
+      Fibonacci.dynamic_fast(num)
+    }
+
+    b.report("Fibonacci.matrix(#{num})") {
+      Fibonacci.matrix(num)
+    }
+
     b.compare!
   end
 end

data/test/bench/tree.rb

@@ -4,7 +4,7 @@ require 'minitest/benchmark'
 
 include CompSci
 
-describe "Tree#push Benchmark" do
+describe "BinaryTree#push Benchmark" do
   bench_range do
     # note, 5000 takes way too long and is definitely not constant time
     # TODO: BUG?
@@ -12,8 +12,15 @@ describe "Tree#push Benchmark" do
     [10, 100, 1000, 2000]
   end
 
-  bench_performance_constant "Tree#push (constant)" do |n|
-    tree = Tree.new Tree::Node.new 42
+  bench_performance_constant "BinaryTree#push (constant)" do |n|
+    tree = BinaryTree.new(ChildNode, 42)
+    n.times { tree.push rand 99 }
+  end
+
+  bench_performance_linear "BinaryTree#push (linear)" do |n|
+    skip "this fails with r^2 around 0.91"
+
+    tree = BinaryTree.new ChildNode.new 42
     n.times { tree.push rand 99 }
   end
 end

data/test/fibonacci.rb

@@ -0,0 +1,20 @@
+require 'compsci/fibonacci'
+require 'minitest/autorun'
+
+include CompSci
+
+describe Fibonacci do
+  before do
+    @answers = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+  end
+
+  it "must calculate fib(0..10)" do
+    @answers.each_with_index { |ans, i|
+      Fibonacci.classic(i).must_equal ans
+      Fibonacci.cache_recursive(i).must_equal ans
+      Fibonacci.cache_iterative(i).must_equal ans
+      Fibonacci.dynamic(i).must_equal ans
+      Fibonacci.matrix(i).must_equal ans
+    }
+  end
+end

data/test/fit.rb

@@ -3,19 +3,23 @@ require 'minitest/autorun'
 
 include CompSci
 
+def noise # range: -0.5 to 0.5
+  rand - 0.5
+end
+
 describe Fit do
   before do
     @xs = [1, 2, 5, 10, 20, 50, 100, 200, 500]
   end
 
-  describe "sigma" do
+  describe "Fit.sigma" do
     it "must answer correctly" do
       Fit.sigma([1, 2, 3]).must_equal 6
       Fit.sigma([1, 2, 3]) { |n| n ** 2 }.must_equal 14
     end
   end
 
-  describe "error" do
+  describe "Fit.error" do
     it "must calculate r^2" do
       Fit.error([[1, 1], [2, 2], [3, 3]]) { |x| x }.must_equal 1.0
       Fit.error([[1, 1], [2, 2], [3, 4]]) { |x| x }.must_be_close_to 0.785
@@ -23,22 +27,28 @@ describe Fit do
   end
 
   # y = a
-  describe "constant" do
+  describe "Fit.constant" do
+    it "must accept constant data" do
+      [0, 1, 10, 100, 1000, 9999].each { |a|
+        y_bar, variance = Fit.constant(@xs, @xs.map { |x| a })
+        y_bar.must_equal a
+        variance.must_equal 0
+      }
+    end
+
     # note, this test can possibly fail depending on the uniformity of
     # rand's output for our sample
-    it "must accept constant data" do
+    it "must accept noisy constant data" do
       [0, 1, 10, 100, 1000, 9999].each { |a|
-        ys = @xs.map { |x| a + (rand - 0.5) }
-        y_bar, variance = Fit.constant(@xs, ys)
-        var_val = variance / ys.size
+        y_bar, variance = Fit.constant(@xs, @xs.map { |x| a + noise() })
         y_bar.must_be_close_to a, 0.3
-        var_val.must_be_close_to 0.1, 0.09
+        (variance / @xs.size).must_be_close_to 0.1, 0.09
       }
     end
   end
 
   # y = a + b*ln(x)
-  describe "logarithmic" do
+  describe "Fit.logarithmic" do
     it "must accept logarithmic data" do
       [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |a|
         [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |b|
@@ -52,7 +62,7 @@ describe Fit do
   end
 
   # y = a + bx
-  describe "linear" do
+  describe "Fit.linear" do
     it "must accept linear data" do
       [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |a|
         [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |b|
@@ -64,21 +74,22 @@ describe Fit do
       }
     end
 
-    # test that b is near 0; (1 - b) is similar magnitude to r2 in terms of
-    # threshold
-    # here's the deal: r2 is usually pretty low, but sometimes it is up over
-    # 0.5, if rand() is being less than uniform in our sample
-    # so, accept a wide range for r2
-    # and let's check against 1 - b
-    #
+    it "must accept constant data" do
+      [0, 1, 10, 100, 1000, 9999].each { |a|
+        ary = Fit.linear(@xs, @xs.map { |x| a })
+        ary[0].must_equal a
+        ary[1].must_equal 0
+        ary[2].nan?.must_equal true
+      }
+    end
+
     # note, this test can possibly fail depending on the uniformity of
     # rand's output for our sample
     #
-    it "must accept constant data" do
+    it "must accept noisy constant data" do
       r2s = []
       [0, 1, 10, 100, 1000, 9999].each { |a|
-        ys = @xs.map { |x| a + (rand - 0.5) }
-        ary = Fit.linear(@xs, ys)
+        ary = Fit.linear(@xs, @xs.map { |x| a + noise() })
         ary[0].must_be_close_to a, 0.4
         ary[1].must_be_close_to 0, 0.05
         r2s << ary[2]
@@ -87,52 +98,23 @@ describe Fit do
       mean_r2.must_be_close_to 0.15, 0.15
     end
 
-    it "must reject nonlinear data" do
-      skip "investigate further"
-      # this should be quite un-linear; expect r2 below 0.8
-      #
-      # ACTUALLY
-      #
-      # the r2 for fit_linear is mostly about the relative fit of a sloped
-      # line compared to zero slope (i.e. y_bar)
-      #
-      # this is why a linear r2 close to 1.0 is the wrong test for fit_constant
-      # because the relative fit of the sloped line (slope near 0) doesn't
-      # "explain" much relative to y_bar
-      #
-      # in the case where y = x^3, a linear fit may still have a high r2,
-      # because the error for the y_bar predictor is astronomical.  A super
-      # steep slope fits (relative to the zero slope mean) pretty well.
-
-      # this calls into question how useful r2 is, as we need it to be a
-      # threshold value due to noise, yet even a terrible fit like trying to
-      # match x^3 is hard to distinguish from noise
-      #
+    it "must reject x^2" do
+      skip "it does not reject x^2 at r^2 < 0.99"
+      xs = [1, 10, 100, 1000]
+      _a, _b, r2 = Fit.linear(xs, xs.map { |x| x**2 })
+      r2.must_be :<, 0.99
+    end
 
-      a = -50
-      b = 1.3
-      ys = @xs.map { |x| a + b * x**2 + x**3 }
-      ary = Fit.linear(@xs, ys)
-      if ary[2] > 0.85
-        puts
-        puts "fit_linear: #{ary.inspect}"
-        puts "y = %0.2f + %0.2f(x) (r2 = %0.3f)" % ary
-        puts
-        col1, col2 = 5, 15
-        puts "x".ljust(col1, ' ') + "y".ljust(col2, ' ') + "predicted"
-        puts '---'.ljust(col1, ' ') + '---'.ljust(col2, ' ') + '---'
-        @xs.zip(ys).each { |(x,y)|
-          puts x.to_s.ljust(col1, ' ') + y.to_s.ljust(col2, ' ') +
-               "%0.2f" % (ary[0] + ary[1] * x)
-        }
-        # ary[2].must_be :<, 0.8
-        ary[2].must_be :<, 0.9
-      end
+    it "must reject x^3" do
+      skip "it does not reject x^3 at r^2 < 0.99"
+      xs = [1, 10, 100, 1000]
+      _a, _b, r2 = Fit.linear(xs, xs.map { |x| x**3 })
+      r2.must_be :<, 0.99
     end
   end
 
   # y = ae^(bx)
-  describe "exponential" do
+  describe "Fit.exponential" do
     it "must accept exponential data" do
       [0.001, 7.5, 500, 1000, 5000, 9999].each { |a|
         [-1.4, -1.1, -0.1, 0.01, 0.5, 0.75].each { |b|
@@ -146,7 +128,7 @@ describe Fit do
   end
 
   # y = ax^b
-  describe "power" do
+  describe "Fit.power" do
     it "must accept power data" do
       [0.01, 7.5, 500, 1000, 5000, 9999].each { |a|
         [-114, -100, -10, -0.5, -0.1, 0.1, 0.75, 10, 50, 60].each { |b|

data/test/timer.rb

@@ -23,26 +23,27 @@ describe Timer do
   describe "loop_average" do
     it "return the block value and a positive number" do
       start = Timer.now
-      answer, avg_et = Timer.loop_average(seconds: 0.25) {
+      answer, avg_et = Timer.loop_average(seconds: 0.1) {
         sleep 0.01
         :foo
       }
       answer.must_equal :foo
       avg_et.must_be_close_to 0.01, 0.005
-      Timer.since(start).must_be_close_to 0.3, 0.05
+      Timer.since(start).must_be_close_to 0.15, 0.05
     end
 
     it "must repeat short loops and stop on time" do
+      # see above, Timer.since(start)
       true.must_equal true
     end
 
     it "must not interrupt long loops" do
       start = Timer.now
-      _answer, avg_et = Timer.loop_average(seconds: 0.1) {
-        sleep 0.25
+      _answer, avg_et = Timer.loop_average(seconds: 0.01) {
+        sleep 0.1
       }
       Timer.since(start).must_be_close_to avg_et, 0.05
-      avg_et.must_be_close_to 0.3, 0.05
+      avg_et.must_be_close_to 0.15, 0.05
     end
   end
 end

data/test/tree.rb

@@ -3,14 +3,135 @@ require 'minitest/autorun'
 
 include CompSci
 
+describe Node do
+  before do
+    @martin_sheen = Node.new 'martin'
+    @charlie_sheen = Node.new 'charlie'
+    @emilio_estevez = Node.new 'emilio'
+  end
+
+  it "must start with no children" do
+    [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
+      n.children.must_be_empty
+    }
+  end
+
+  it "must track children" do
+    @charlie_sheen.add_parent(@martin_sheen)
+    @martin_sheen.children.must_include @charlie_sheen
+
+    @martin_sheen.children.wont_include @emilio_estevez
+    @martin_sheen.add_child @emilio_estevez
+    @martin_sheen.children.must_include @emilio_estevez
+  end
+
+  it "must create children from scalars" do
+    @martin_sheen.new_child 'fake_emilio'
+    @martin_sheen.children.size.must_equal 1
+    @martin_sheen.children.first.value.must_equal 'fake_emilio'
+    @martin_sheen.children.wont_include @emilio_estevez
+  end
+end
+
+describe ChildNode do
+  before do
+    @martin_sheen = ChildNode.new 'martin'
+    @charlie_sheen = ChildNode.new 'charlie'
+    @emilio_estevez = ChildNode.new 'emilio'
+  end
+
+  it "must start with neither parent nor children" do
+    [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
+      n.parent.nil?.must_equal true
+      n.children.must_be_empty
+    }
+  end
+
+  it "must track parent and children" do
+    @charlie_sheen.add_parent(@martin_sheen)
+    @charlie_sheen.parent.must_equal @martin_sheen
+    @martin_sheen.children.must_include @charlie_sheen
+
+    @martin_sheen.children.wont_include @emilio_estevez
+    @martin_sheen.add_child @emilio_estevez
+    @martin_sheen.children.must_include @emilio_estevez
+    @emilio_estevez.parent.must_equal @martin_sheen
+  end
+
+  it "must create children from scalars" do
+    @martin_sheen.new_child 'fake_emilio'
+    @martin_sheen.children.size.must_equal 1
+    @martin_sheen.children.first.value.must_equal 'fake_emilio'
+    @martin_sheen.children.wont_include @emilio_estevez
+  end
+end
+
 describe Tree do
   before do
-    @node = Tree::Node.new 42
-    @tree = Tree.new(@node, child_slots: 3)
+    @tree = Tree.new(Node, 42)
+    @vals = Array.new(99) { rand 99 }
+  end
+
+  it "is populated via the root node" do
+    @vals.each { |v| @tree.root.new_child v }
+    @tree.root.children.size.must_equal @vals.size
+  end
+
+  it "does depth_first search" do
+    vals = (0..30).to_a
+    tree = Tree.new(Node, vals.shift)
+    tree.root.new_child vals.shift
+    tree.root.new_child vals.shift
+    tree.root.children.each { |c|
+      c.new_child vals.shift
+      c.new_child vals.shift
+
+      c.children.each { |cc|
+        cc.new_child vals.shift
+        cc.new_child vals.shift
+      }
+    }
+
+    visited = []
+    tree.df_search { |n|
+      visited << n.value
+      false
+    }
+    visited.wont_be_empty
+    visited.must_equal [0, 1, 3, 5, 6, 4, 7, 8, 2, 9, 11, 12, 10, 13, 14]
+  end
+
+  it "does breadth_first search" do
+    vals = (0..30).to_a
+    tree = Tree.new(Node, vals.shift)
+    tree.root.new_child vals.shift
+    tree.root.new_child vals.shift
+    tree.root.children.each { |c|
+      c.new_child vals.shift
+      c.new_child vals.shift
+
+      c.children.each { |cc|
+        cc.new_child vals.shift
+        cc.new_child vals.shift
+      }
+    }
+
+    visited = []
+    tree.bf_search { |n|
+      visited << n.value
+      false
+    }
+    visited.wont_be_empty
+    visited.must_equal [0, 1, 2, 3, 4, 9, 10, 5, 6, 7, 8, 11, 12, 13, 14]
+  end
+end
+
+describe NaryTree do
+  before do
+    @tree = NaryTree.new(ChildNode, 42, child_slots: 3)
   end
 
   it "must have an open parent" do
-    @tree.open_parent?(@node).must_equal true
     @tree.open_parent?(@tree.root).must_equal true
     @tree.open_parent?(@tree.open_parent).must_equal true
   end
@@ -24,7 +145,7 @@ describe Tree do
 
   describe "searching" do
     before do
-      @tree = Tree.new(Tree::Node.new 42)
+      @tree = NaryTree.new(ChildNode, 42, child_slots: 2)
       99.times { |i| @tree.push i }
     end
 
@@ -76,59 +197,24 @@ describe Tree do
       count.must_equal 83
     end
   end
-
-  describe Tree::Node do
-    before do
-      @martin_sheen = Tree::Node.new 'martin'
-      @charlie_sheen = Tree::Node.new 'charlie'
-      @emilio_estevez = Tree::Node.new 'emilio'
-    end
-
-    it "must start with no relations" do
-      [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
-        n.parent.nil?.must_equal true
-        n.children.must_be_empty
-      }
-    end
-
-    it "must allow relations" do
-      @charlie_sheen.add_parent(@martin_sheen)
-      @charlie_sheen.parent.must_equal @martin_sheen
-      @martin_sheen.children.must_include @charlie_sheen
-
-      @martin_sheen.children.wont_include @emilio_estevez
-      @martin_sheen.add_child @emilio_estevez
-      @martin_sheen.children.must_include @emilio_estevez
-      @emilio_estevez.parent.must_equal @martin_sheen
-    end
-
-    it "must create children from scalars" do
-      @martin_sheen.new_child 'fake_emilio'
-      @martin_sheen.children.size.must_equal 1
-      @martin_sheen.children.first.value.must_equal 'fake_emilio'
-      @martin_sheen.children.wont_include @emilio_estevez
-    end
-  end
 end
 
 describe BinaryTree do
   before do
-    @tree = BinaryTree.new(Tree::Node.new 42)
+    @tree = BinaryTree.new(ChildNode, 42)
   end
 
   it "must have 2 child_slots" do
     @tree.child_slots.must_equal 2
   end
 
-  it "must bf_print" do
-    31.times { @tree.push rand 99 }
-    out, err = capture_io do
-      @tree.bf_print
-    end
-    line_count = out.split("\n").size
-    line_count.must_be :>, 4
-    line_count.must_be :<, 7
-    err.must_be_empty
+  it "must to_s" do
+    item_count = 31
+    # tree already has a root node
+    (item_count - 1).times { @tree.push rand 99 }
+    str = @tree.to_s
+    line_count = str.split("\n").size
+    line_count.must_equal Math.log(item_count + 1, 2).ceil
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compsci
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
+  version: 0.0.2.1
 platform: ruby
 authors:
 - Rick Hull
@@ -38,15 +38,15 @@ files:
 - examples/heap.rb
 - examples/timer.rb
 - lib/compsci.rb
-- lib/compsci/fib.rb
+- lib/compsci/fibonacci.rb
 - lib/compsci/fit.rb
 - lib/compsci/heap.rb
 - lib/compsci/timer.rb
 - lib/compsci/tree.rb
-- test/bench/fib.rb
+- test/bench/fibonacci.rb
 - test/bench/heap.rb
 - test/bench/tree.rb
-- test/fib.rb
+- test/fibonacci.rb
 - test/fit.rb
 - test/heap.rb
 - test/timer.rb

data/test/fib.rb

@@ -1,13 +0,0 @@
-require 'compsci/fib'
-require 'minitest/autorun'
-
-include CompSci
-
-describe Fibonacci do
-  it "must calculate fib(10) == 55" do
-    Fibonacci.classic(10).must_equal 55
-    Fibonacci.cache_recursive(10).must_equal 55
-    Fibonacci.cache_iterative(10).must_equal 55
-    Fibonacci.dynamic(10).must_equal 55
-  end
-end