compsci 0.0.1.1

data/lib/compsci/tree.rb

@@ -0,0 +1,140 @@
+require 'compsci'
+
+module CompSci
+  class Tree
+    attr_reader :root, :child_slots
+
+    def initialize(root_node, child_slots: 2)
+      @root = root_node
+      @child_slots = child_slots
+      @open_parent = @root
+    end
+
+    def push(value)
+      self.open_parent.new_child value
+    end
+
+    def open_parent?(node)
+      node.children.size < @child_slots
+    end
+
+    def open_parent
+      return @open_parent if self.open_parent?(@open_parent)
+      @open_parent = self.bf_search { |n| self.open_parent?(n) }
+    end
+
+    def df_search(node: nil, &blk)
+      node ||= @root
+      return node if yield node
+      node.children.each { |c|
+        stop_node = self.df_search(node: c, &blk)
+        return stop_node if stop_node
+      }
+      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]
+      while !destinations.empty?
+        node = destinations.shift
+        return node if yield node
+        destinations += node.children
+      end
+      nil
+    end
+
+    class Node
+      attr_accessor :value, :parent
+      attr_reader :children
+
+      def initialize(value)
+        @value = value
+        @parent = nil
+        @children = []
+        # @metadata = {}
+      end
+
+      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
+        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
+  end
+
+  class BinaryTree < Tree
+    def initialize(root_node)
+      super(root_node, child_slots: 2)
+    end
+
+    def bf_print(node: nil, width: 80)
+      count = 0
+      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, ' ')
+      }
+      puts
+    end
+  end
+
+  # A CompleteBinaryTree can very efficiently use an array for storage using
+  # simple arithmetic to determine parent child relationships.
+  #
+  class CompleteBinaryTree
+    # 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: [])
+      @store = store
+      # yield self if block_given?
+    end
+
+    def size
+      @store.size
+    end
+
+    def last_idx
+      @store.size - 1 unless @store.empty?
+    end
+  end
+end

data/lib/compsci.rb

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

data/test/bench/fib.rb

@@ -0,0 +1,114 @@
+require 'compsci/fib'
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+include CompSci
+
+# CLASSIC_RANGE = [3, 5, 10, 15, 20, 25, 30, 31, 32, 33, 34, 35]
+CLASSIC_RANGE = [10, 15, 20, 25, 30, 31, 32, 33, 34, 35]
+# RECURSIVE_RANGE = [10, 100, 1000, 2500, 5000, 7500]
+RECURSIVE_RANGE = [100, 1000, 2500, 5000, 7500]
+# CACHE_RANGE = [100, 1000, 10000, 100000, 112500, 125000]
+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]
+
+#SPEC_BENCHMARK = true
+#CLASS_BENCHMARK = false
+#BENCHMARK_IPS = true
+SPEC_BENCHMARK = false
+CLASS_BENCHMARK = true
+BENCHMARK_IPS = false
+
+
+if SPEC_BENCHMARK
+  describe "Fibonacci.classic Benchmark" do
+    bench_range do
+      CLASSIC_RANGE
+    end
+
+    fc = ["Fibonacci.classic (exponential, 0.95)", 0.95]
+    bench_performance_exponential(*fc) do |n|
+      Fibonacci.classic(n)
+    end
+  end
+
+  describe "Fibonacci.cache_recursive Benchmark" do
+    bench_range do
+      RECURSIVE_RANGE
+    end
+
+    fcr = ["Fibonacci.cache_recursive (linear, 0.95)", 0.95]
+    bench_performance_linear(*fcr) do |n|
+      Fibonacci.cache_recursive(n)
+    end
+  end
+
+  describe "Fibonacci.cache_iterative Benchmark" do
+    bench_range do
+      CACHE_RANGE
+    end
+
+    fci = ["Fibonacci.cache_iterative (linear, 0.99)", 0.99]
+    bench_performance_linear(*fci) do |n|
+      Fibonacci.cache_iterative(n)
+    end
+  end
+
+  describe "Fibonacci.dynamic Benchmark" do
+    bench_range do
+      DYNAMIC_RANGE
+    end
+
+    fd = ["Fibonacci.dynamic (linear, 0.99)", 0.99]
+    bench_performance_linear(*fd) do |n|
+      Fibonacci.dynamic(n)
+    end
+  end
+end
+
+if CLASS_BENCHMARK
+  require 'compsci/timer'
+
+  class BenchFib < Minitest::Benchmark
+    def bench_fib
+      times = CLASSIC_RANGE.map { |n|
+        _answer, elapsed = Timer.elapsed { Fibonacci.classic(n) }
+        elapsed
+      }
+      _a, _b, r2 = self.fit_exponential(CLASSIC_RANGE, times)
+      puts
+      puts "self-timed Fibonacci.classic(n) exponential fit: %0.3f" % r2
+      puts
+    end
+  end
+end
+
+if BENCHMARK_IPS
+  require 'benchmark/ips'
+
+  Benchmark.ips do |b|
+    b.config time: 3, warmup: 0.5
+    num = 25
+
+    b.report("Fibonacci.classic(#{num})") {
+      Fibonacci.classic(num)
+    }
+
+    b.report("Fibonacci.cache_recursive(#{num})") {
+      Fibonacci.cache_recursive(num)
+    }
+
+    b.report("Fibonacci.cache_iterative(#{num})") {
+      Fibonacci.cache_iterative(num)
+    }
+
+    b.report("Fibonacci.dynamic(#{num})") {
+      Fibonacci.dynamic(num)
+    }
+
+    b.compare!
+  end
+end

data/test/bench/heap.rb

@@ -0,0 +1,15 @@
+require 'compsci/heap'
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+include CompSci
+
+describe "Heap#push Benchmark" do
+  before do
+    @heap = Heap.new
+  end
+
+  bench_performance_constant "Heap#push (constant, 0.9999)", 0.9999 do |n|
+    n.times { @heap.push rand 99999 }
+  end
+end

data/test/bench/tree.rb

@@ -0,0 +1,19 @@
+require 'compsci/tree'
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+include CompSci
+
+describe "Tree#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]
+  end
+
+  bench_performance_constant "Tree#push (constant)" do |n|
+    tree = Tree.new Tree::Node.new 42
+    n.times { tree.push rand 99 }
+  end
+end

data/test/fib.rb

@@ -0,0 +1,13 @@
+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

data/test/fit.rb

@@ -0,0 +1,162 @@
+require 'compsci/fit'
+require 'minitest/autorun'
+
+include CompSci
+
+describe Fit do
+  before do
+    @xs = [1, 2, 5, 10, 20, 50, 100, 200, 500]
+  end
+
+  describe "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
+    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
+    end
+  end
+
+  # y = a
+  describe "constant" do
+    # note, this test can possibly fail depending on the uniformity of
+    # rand's output for our sample
+    it "must accept 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.must_be_close_to a, 0.3
+        var_val.must_be_close_to 0.1, 0.09
+      }
+    end
+  end
+
+  # y = a + b*ln(x)
+  describe "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|
+          ary = Fit.logarithmic(@xs, @xs.map { |x| a + b * Math.log(x) })
+          ary[0].must_be_close_to a
+          ary[1].must_be_close_to b
+          ary[2].must_equal 1.0
+        }
+      }
+    end
+  end
+
+  # y = a + bx
+  describe "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|
+          ary = Fit.linear(@xs, @xs.map { |x| a + b * x })
+          ary[0].must_be_close_to a
+          ary[1].must_be_close_to b
+          ary[2].must_equal 1.0
+        }
+      }
+    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
+    #
+    # note, this test can possibly fail depending on the uniformity of
+    # rand's output for our sample
+    #
+    it "must accept 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[0].must_be_close_to a, 0.4
+        ary[1].must_be_close_to 0, 0.05
+        r2s << ary[2]
+      }
+      mean_r2 = Fit.sigma(r2s) / r2s.size
+      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
+      #
+
+      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
+    end
+  end
+
+  # y = ae^(bx)
+  describe "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|
+          ary = Fit.exponential(@xs, @xs.map { |x| a * Math::E**(b * x) })
+          ary[0].must_be_close_to a
+          ary[1].must_be_close_to b
+          ary[2].must_equal 1.0
+        }
+      }
+    end
+  end
+
+  # y = ax^b
+  describe "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|
+          next if b == -114 # Fit.error warning: Bignum out of Float range
+          ary = Fit.power(@xs, @xs.map { |x| a * x**b })
+          ary[0].must_be_close_to a
+          ary[1].must_be_close_to b
+          ary[2].must_equal 1.0
+        }
+      }
+    end
+  end
+end

data/test/heap.rb

@@ -0,0 +1,46 @@
+require 'compsci/heap'
+require 'minitest/autorun'
+
+include CompSci
+
+describe Heap do
+  before do
+    @maxheap = Heap.new
+    @minheap = Heap.new(minheap: true)
+    @inserts = (1..10).to_a
+    @inserts.each { |i|
+      @maxheap.push i
+      @minheap.push i
+    }
+  end
+
+  it "must satisfy the heap property" do
+    @maxheap.heap?.must_equal true
+    @minheap.heap?.must_equal true
+    @minheap.store.must_equal @inserts
+    @maxheap.store.wont_equal @inserts
+    @maxheap.store.wont_equal @inserts.reverse
+  end
+
+  it "must recognize heap violations" do
+    @minheap.store.push 0
+    @minheap.heap?.must_equal false
+    @minheap.sift_up @minheap.last_idx
+    @minheap.heap?.must_equal true
+
+    @minheap.store.unshift 10
+    @minheap.heap?.must_equal false
+    @minheap.sift_down 0
+    @minheap.heap?.must_equal true
+
+    @maxheap.store.push 10
+    @maxheap.heap?.must_equal false
+    @maxheap.sift_up @maxheap.last_idx
+    @maxheap.heap?.must_equal true
+
+    @maxheap.store.unshift 0
+    @maxheap.heap?.must_equal false
+    @maxheap.sift_down 0
+    @maxheap.heap?.must_equal true
+  end
+end

data/test/timer.rb

@@ -0,0 +1,48 @@
+require 'compsci/timer'
+require 'minitest/autorun'
+
+include CompSci
+
+describe Timer do
+  describe "elapsed" do
+    it "must return the block value and positive number" do
+      answer, elapsed = Timer.elapsed { sleep 0.01; :foo }
+      answer.must_equal :foo
+      elapsed.must_be_close_to 0.015, 0.005
+    end
+  end
+
+  describe "since" do
+    it "must be positive" do
+      start = Timer.now
+      sleep 0.01
+      Timer.since(start).must_be_close_to 0.015, 0.005
+    end
+  end
+
+  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) {
+        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
+    end
+
+    it "must repeat short loops and stop on time" do
+      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
+      }
+      Timer.since(start).must_be_close_to avg_et, 0.05
+      avg_et.must_be_close_to 0.3, 0.05
+    end
+  end
+end