compsci 0.1.1.1 → 0.2.0.1

data/lib/compsci/tree.rb

@@ -1,6 +1,8 @@
-require 'compsci/node'
+# require 'compsci/node'
 
 module CompSci
+  # for now at least, this assumes children simply stack up
+  # children like: [nil, child1, child2] are not supported
   class Tree
     attr_reader :root
 
@@ -8,6 +10,7 @@ module CompSci
       @root = node_class.new val
     end
 
+    # does not support children gaps
     def df_search(node: nil, &blk)
       node ||= @root
       return node if yield node
@@ -18,6 +21,7 @@ module CompSci
       nil
     end
 
+    # does not support children gaps
     def bf_search(node: nil, &blk)
       node ||= @root
       destinations = [node]
@@ -38,6 +42,15 @@ module CompSci
   end
 
   class NaryTree < Tree
+    # 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
+
     attr_reader :child_slots
 
     def initialize(node_class, val, child_slots:)

data/test/bench/complete_tree.rb

@@ -0,0 +1,59 @@
+require 'compsci/complete_tree'
+require 'compsci/timer'
+require 'compsci/fit'
+
+include CompSci
+
+timing = {}
+ns = [10, 100, 1000, 10_000, 100_000]
+
+# Note, CompleteTree is a very thin wrapper around Array, so we are just
+# testing ruby's inherent Array performance here.
+# Append / push / insert is constant for ruby Arrays.
+
+puts <<EOF
+
+#
+# timing CompleteTree(N)#push where N is the size of the tree
+#
+
+EOF
+
+ns.each { |n|
+  h = CompleteBinaryTree.new
+  n.times { h.push rand }
+  _val, secs = Timer.loop_avg {
+    h.push rand
+  }
+  puts "CompleteTree(%i) push: %0.8f" % [n, secs]
+  timing[n] = secs
+  break if secs > 1
+}
+
+a, b, r2, fn = Fit.best timing.keys, timing.values
+
+puts "best fit: #{fn} (%0.3f); a = %0.6f, b = %0.6f" % [r2, a, b]
+
+
+
+puts <<EOF
+
+#
+# timing CompleteTree#push where N is the count of pushes
+#
+
+EOF
+
+ns.each { |n|
+  h = CompleteBinaryTree.new
+  _val, secs = Timer.loop_avg {
+    n.times { h.push rand }
+  }
+  puts "%ix CompleteTree#push: %0.8f" % [n, secs]
+  timing[n] = secs
+  break if secs > 1
+}
+
+a, b, r2, fn = Fit.best timing.keys, timing.values
+
+puts "best fit: #{fn} (%0.3f); a = %0.6f, b = %0.6f" % [r2, a, b]

data/test/bench/fibonacci.rb

@@ -134,10 +134,6 @@ if BENCHMARK_IPS
       Fibonacci.dynamic(num)
     }
 
-    b.report("Fibonacci.dynamic_fast(#{num})") {
-      Fibonacci.dynamic_fast(num)
-    }
-
     b.report("Fibonacci.matrix(#{num})") {
       Fibonacci.matrix(num)
     }

data/test/bench/simplex.rb

@@ -0,0 +1,141 @@
+require 'compsci/simplex'
+
+include CompSci
+
+BENCH_IPS = true
+BENCH_OBJECT_SPACE = true
+
+SIMPLEX_PARAMS = [
+  # 1 (index 0)
+  [[1, 1],
+   [[2,  1],
+    [1,  2]],
+   [4, 3]],
+
+  [[3, 4],
+   [[1, 1],
+    [2, 1]],
+   [4, 5]],
+
+  [[2, -1],
+   [[1, 2],
+    [3, 2],],
+   [6, 12]],
+
+  [[60, 90, 300],
+   [[1, 1, 1],
+    [1, 3, 0],
+    [2, 0, 1]],
+   [600, 600, 900]],
+
+  # 5
+  [[70, 210, 140],
+   [[1, 1, 1],
+    [5, 4, 4],
+    [40, 20, 30]],
+   [100, 480, 3200]],
+
+  [[2, -1, 2],
+   [[2, 1, 0],
+    [1, 2, -2],
+    [0, 1, 2]],
+   [10, 20, 5]],
+
+  [[11, 16, 15],
+   [[1, 2, Rational(3, 2)],
+    [Rational(2, 3), Rational(2, 3), 1],
+    [Rational(1, 2), Rational(1, 3), Rational(1, 2)]],
+   [12_000, 4_600, 2_400]],
+
+  [[5, 4, 3],
+   [[2, 3, 1],
+    [4, 1, 2],
+    [3, 4, 2]],
+   [5, 11, 8]],
+
+  [[3, 2, -4],
+   [[1, 4, 0],
+    [2, 4,-2],
+    [1, 1,-2]],
+   [5, 6, 2]],
+
+  # 10
+  [[2, -1, 8],
+   [[2, -4, 6],
+    [-1, 3, 4],
+    [0, 0, 2]],
+   [3, 2, 1]],
+
+  [[100_000, 40_000, 18_000],
+   [[20, 6, 3],
+    [0, 1, 0],
+    [-1,-1, 1],
+    [-9, 1, 1]],
+   [182, 10, 0, 0]],
+
+  [[1, 2, 1, 2],
+   [[1, 0, 1, 0],
+    [0, 1, 0, 1],
+    [1, 1, 0, 0],
+    [0, 0, 1, 1]],
+   [1, 4, 2, 2]],
+
+  [[10, -57, -9, -24],
+   [[0.5, -5.5, -2.5, 9],
+    [0.5, -1.5, -0.5, 1],
+    [ 1,    0,    0, 0]],
+   [0, 0, 1]],
+
+  # 14 (index 13)
+  [[25, 20],
+   [[20, 12],
+    [1, 1]],
+   [1800, 8*15]],
+]
+
+def new_simplices
+  SIMPLEX_PARAMS.map { |c, a, b| Simplex.new(c, a, b) }
+end
+
+if BENCH_IPS
+  require 'benchmark/ips'
+
+  Benchmark.ips do |b|
+    b.config time: 3, warmup: 0.5
+
+    b.report("Simplex init") {
+      new_simplices
+    }
+
+    b.report("init, solve") {
+      new_simplices.each { |s| s.solution }
+    }
+
+    #b.report("Simplex Matrix") {
+    #}
+
+    b.compare!
+  end
+end
+
+if BENCH_OBJECT_SPACE
+  require 'compsci/timer'
+  require 'objspace'
+
+  def disp_memsize(var, label = '')
+    "memsize(%s): %i" % [label, ObjectSpace.memsize_of(var)]
+  end
+
+  simplices = SIMPLEX_PARAMS.map { |c, a, b|
+    Simplex.new(c, a, b)
+  }
+
+  puts "SIMPLEX_PARAMS.size = #{SIMPLEX_PARAMS.size}"
+  puts "simplices.size = #{simplices.size}"
+
+  puts disp_memsize SIMPLEX_PARAMS, 'SIMPLEX_PARAMS'
+  puts disp_memsize simplices, 'simplices'
+  results = simplices.map { |s| s.solution }
+  puts disp_memsize simplices, 'simplices after solving'
+  puts disp_memsize results, 'results'
+end

data/test/bench/tree.rb

@@ -1,26 +1,31 @@
+require 'compsci/node'
 require 'compsci/tree'
-require 'minitest/autorun'
-require 'minitest/benchmark'
+require 'benchmark/ips'
 
 include CompSci
 
-describe "BinaryTree#push Benchmark" do
-  bench_range do
-    # note, 5000 takes way too long and is definitely not constant time
-    # TODO: BUG?
-    # [10, 100, 1000, 2000, 5000]
-    [10, 100, 1000, 2000]
+Benchmark.ips do |b|
+  b.config time: 3, warmup: 0.5
+
+  b.report("99x BinaryTree(ChildNode)#push") do
+    tree = BinaryTree.new(ChildFlexNode, 42)
+    99.times { tree.push rand 99 }
   end
 
-  bench_performance_constant "BinaryTree#push (constant)" do |n|
-    tree = NaryTree.new(ChildNode, 42, child_slots: 2)
-    n.times { tree.push rand 99 }
+  b.report("99x BinaryTree(FlexNode)#push") do
+    tree = BinaryTree.new(FlexNode, 42)
+    99.times { tree.push rand 99 }
   end
 
-  bench_performance_linear "BinaryTree#push (linear)" do |n|
-    skip "this fails with r^2 around 0.91"
+  b.report("99x TernaryTree(ChildFlexNode)#push") do
+    tree = TernaryTree.new(ChildFlexNode, 42)
+    99.times { tree.push rand 99 }
+  end
 
-    tree = NaryTree.new(ChildNode, 42, child_slots: 2)
-    n.times { tree.push rand 99 }
+  b.report("99x TernaryTree(FlexNode)#push") do
+    tree = TernaryTree.new(FlexNode, 42)
+    99.times { tree.push rand 99 }
   end
+
+  b.compare!
 end

data/test/binary_search_tree.rb

@@ -0,0 +1,106 @@
+require 'compsci/node'
+require 'compsci/binary_search_tree'
+require 'compsci/names'
+require 'minitest/autorun'
+
+include CompSci
+
+describe BinarySearchTree do
+  def ww2_names(count)
+    Array.new(count) { |i| Names::WW2[i].to_s }
+  end
+
+  def nato_names(count)
+    Array.new(count) { |i| Names::NATO[i].to_s }
+  end
+
+  before do
+    @keys = ww2_names(4)
+    @values = Array.new(4) { Names::SOLAR.sample }
+    @nodes = Array.new(4) { |i|
+      KeyNode.new(@values[i], key: @keys[i], children: 2)
+    }
+    @tree = BinarySearchTree.new(@nodes.first)
+
+    # tree will look like:
+    # A:val1
+    #  B:val2
+    #   C:val3
+    #    D:val4
+  end
+
+  it "must display_level" do
+    str = BinarySearchTree.display_level nodes: @nodes, width: 80
+    str.size.must_be :>=, 80  # it can overflow
+
+    str = BinarySearchTree.display_level nodes: @nodes, width: 200
+    str.size.must_equal 200   # it won't overflow
+
+    @keys.each { |k| str.must_include k.to_s }
+    @values.each { |v| str.must_include v.to_s }
+  end
+
+  it "must provide a new_node" do
+    node = BinarySearchTree.new_node('the key', 'the value')
+    node.must_be_kind_of Node
+    node.must_be_kind_of KeyNode
+    node.key.must_equal 'the key'
+    node.value.must_equal 'the value'
+  end
+
+  it "must instantiate with key and value" do
+    tree = BinarySearchTree.new_with_kv('the key', 'the value')
+    node = tree.root
+    node.must_be_kind_of Node
+    node.must_be_kind_of KeyNode
+    node.key.must_equal 'the key'
+    node.value.must_equal 'the value'
+  end
+
+  it "must decide what to do with duplicate nodes" do
+  end
+
+  it "must decide what to do with duplicate keys" do
+  end
+
+  it "must insert nodes" do
+    1.upto(@nodes.size - 1) { |i| @tree[@keys[i]] = @values[i] }
+    @tree.root.children.wont_be_empty
+    @tree.root.children[0].nil?.must_equal true
+    @tree.root.children[1].key.must_equal @keys[1]
+    @tree.root.children[1].children[0].nil?.must_equal true
+    @tree.root.children[1].children[1].value.must_equal @values[2]
+  end
+
+  it "must search nodes" do
+    tree = nil
+    new_order = (0..9).to_a.shuffle
+    new_order.each { |i|
+      k, v = Names::NATO[i], Names::SOLAR.sample
+      if tree.nil?
+        tree = BinarySearchTree.new_with_kv(k, v)
+      else
+        tree[k] = v
+      end
+    }
+
+    2.times {
+      i = new_order.sample
+      key = Names::NATO[new_order.sample]
+      node = tree.search_iterative key
+      node.wont_be_nil
+      node.key.must_equal key
+    }
+
+    2.times {
+      i = new_order.sample
+      key = Names::NATO[new_order.sample]
+      node = tree.search_recursive key
+      node.wont_be_nil
+      node.key.must_equal key
+    }
+
+    tree.search_iterative(Names::SOLAR.sample).must_be_nil
+    tree.search_recursive(Names::SOLAR.sample).must_be_nil
+  end
+end

data/test/fit.rb

@@ -27,24 +27,18 @@ describe Fit do
   end
 
   # y = a
+  # Note: Thinking about dropping this.
+  #       I don't know how to test the variance for constantness or any
+  #       alternate measure.  A low slope and r2 for linear fit, maybe.
+  #
   describe "Fit.constant" do
-    it "must accept constant data" do
+    it "must stuff" 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 noisy constant data" do
-      [0, 1, 10, 100, 1000, 9999].each { |a|
-        y_bar, variance = Fit.constant(@xs, @xs.map { |x| a + noise() })
-        y_bar.must_be_close_to a, 0.3
-        (variance / @xs.size).must_be_close_to 0.1, 0.09
-      }
-    end
   end
 
   # y = a + b*ln(x)

data/test/node.rb

@@ -16,6 +16,42 @@ describe Node do
     }
   end
 
+  it "must not respond to :parent" do
+    @martin_sheen.respond_to?(:parent).must_equal false
+  end
+end
+
+describe KeyNode do
+  before do
+    @martin_sheen =   KeyNode.new 'martin',  key: 'marty'
+    @charlie_sheen =  KeyNode.new 'charlie', key: 'charles'
+    @emilio_estevez = KeyNode.new 'emilio',  key: 'emile'
+  end
+
+  it "must start with no children" do
+    [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
+      n.children.must_be_empty
+    }
+  end
+
+  it "must not respond to :parent" do
+    @martin_sheen.respond_to?(:parent).must_equal false
+  end
+
+  it "must have a key" do
+    @martin_sheen.key.must_equal 'marty'
+    @charlie_sheen.key.must_equal 'charles'
+    @emilio_estevez.key.must_equal 'emile'
+  end
+end
+
+describe FlexNode do
+  before do
+    @martin_sheen = FlexNode.new 'martin'
+    @charlie_sheen = FlexNode.new 'charlie'
+    @emilio_estevez = FlexNode.new 'emilio'
+  end
+
   it "must track children" do
     @charlie_sheen.add_parent(@martin_sheen)
     @martin_sheen.children.must_include @charlie_sheen
@@ -25,10 +61,6 @@ describe Node do
     @martin_sheen.children.must_include @emilio_estevez
   end
 
-  it "must not respond to :parent" do
-    @martin_sheen.respond_to?(:parent).must_equal false
-  end
-
   it "must create children from scalars" do
     @martin_sheen.new_child 'fake_emilio'
     @martin_sheen.children.size.must_equal 1
@@ -51,6 +83,25 @@ describe ChildNode do
     }
   end
 
+  it "must track parent and children" do
+    @charlie_sheen.set_parent(0, @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.set_child(0, @emilio_estevez)
+    @martin_sheen.children.must_include @emilio_estevez
+    @emilio_estevez.parent.must_equal @martin_sheen
+  end
+end
+
+describe ChildFlexNode do
+  before do
+    @martin_sheen = ChildFlexNode.new 'martin'
+    @charlie_sheen = ChildFlexNode.new 'charlie'
+    @emilio_estevez = ChildFlexNode.new 'emilio'
+  end
+
   it "must track parent and children" do
     @charlie_sheen.add_parent(@martin_sheen)
     @charlie_sheen.parent.must_equal @martin_sheen