compsci 0.3.0.1 → 0.3.2.1

data/lib/compsci/binary_search_tree.rb

@@ -1,86 +0,0 @@
-require 'compsci/node'
-require 'compsci/tree'
-
-module CompSci
-  class BinarySearchTree < BinaryTree
-    def self.display_level(nodes: [], width: 80)
-      unless self.power_of?(nodes.size, 2)
-        raise "unexpected node count: #{nodes.size}"
-      end
-      block_width = [width / nodes.size, 1].max
-      nodes.map { |node|
-        str = node ? node.to_s : '_'
-        space = [(block_width + str.size) / 2, str.size + 1].max
-        str.ljust(space, ' ').rjust(block_width, ' ')
-      }.join
-    end
-
-    # helper method; any object which responds to key, value, and children
-    # may be used
-    def self.new_node(key, val)
-      CompSci::KeyNode.new(val, key: key, children: 2)
-    end
-
-    def self.new_with_kv(key, val)
-      self.new(self.new_node(key, val))
-    end
-
-    def initialize(root_node)
-      @node_class = root_node.class
-      @child_slots = 2
-      if root_node.children.size == @child_slots
-        @root = root_node
-      else
-        raise "bad root: #{root_node}; expected #{@child_slots} child slots"
-      end
-    end
-
-    def search_recursive(key, node: @root)
-      return node if node.nil? or node.key == key
-      child = key < node.key ? node.children[0] : node.children[1]
-      search_recursive(key, node: child)
-    end
-
-    def search_iterative(key, node: @root)
-      while !node.nil?
-        return node if node.key == key
-        node = key < node.key ? node.children[0] : node.children[1]
-      end
-      node
-    end
-
-    def insert_recursive(key, val, node: @root)
-      return nil if node.nil? or node.key == key
-      if key < node.key
-        if node.children[0]
-          insert_recursive(key, val, node: node.children[0])
-        else
-          node.children[0] = @node_class.new(val, key: key, children: 2)
-        end
-      else
-        if node.children[1]
-          insert_recursive(key, val, node: node.children[1])
-        else
-          node.children[1] = @node_class.new(val, key: key, children: 2)
-        end
-      end
-    end
-    alias_method :insert, :insert_recursive
-    alias_method :[]=, :insert
-
-    def display(node: @root, width: 80)
-      levels = [self.class.display_level(nodes: [node], width: width)]
-      nodes = node.children
-      while nodes.any? { |n| !n.nil? }
-        levels << self.class.display_level(nodes: nodes, width: width)
-        children = []
-        nodes.each { |n|
-          children += n ? n.children : Array.new(@child_slots)
-        }
-        nodes = children
-      end
-      levels.join("\n")
-    end
-    alias_method :to_s, :display
-  end
-end

data/lib/compsci/tree.rb

@@ -1,142 +0,0 @@
-# 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
-
-    def initialize(node_class, val)
-      @root = node_class.new val
-    end
-
-    # does not support children gaps
-    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
-
-    # does not support children gaps
-    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
-
-    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
-
-  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:)
-      super(node_class, val)
-      @child_slots = child_slots
-    end
-
-    def open_parent?(node)
-      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)
-      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(node_class, val)
-      super(node_class, val, child_slots: 2)
-    end
-
-    def display(width: 80)
-      count = 0
-      str = ''
-      self.bf_search { |node|
-        count += 1
-        level = Math.log(count, 2).floor
-        block_width = width / (2**level)
-        val = node.to_s
-        str += "\n" if 2**level == count and count > 1
-        space = [(block_width + val.size) / 2, val.size + 1].max
-        str += val.ljust(space, ' ').rjust(block_width, ' ')
-        false # keep searching to visit every node
-      }
-      str
-    end
-    alias_method :to_s, :display
-  end
-
-  class TernaryTree < NaryTree
-    def initialize(node_class, val)
-      super(node_class, val, child_slots: 3)
-    end
-  end
-
-  class QuaternaryTree < NaryTree
-    def initialize(node_class, val)
-      super(node_class, val, child_slots: 4)
-    end
-  end
-end

data/test/bench/tree.rb

@@ -1,31 +0,0 @@
-require 'compsci/node'
-require 'compsci/tree'
-require 'benchmark/ips'
-
-include CompSci
-
-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
-
-  b.report("99x BinaryTree(FlexNode)#push") do
-    tree = BinaryTree.new(FlexNode, 42)
-    99.times { tree.push rand 99 }
-  end
-
-  b.report("99x TernaryTree(ChildFlexNode)#push") do
-    tree = TernaryTree.new(ChildFlexNode, 42)
-    99.times { tree.push rand 99 }
-  end
-
-  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

@@ -1,98 +0,0 @@
-require 'compsci/node'
-require 'compsci/binary_search_tree'
-require 'compsci/names'
-require 'minitest/autorun'
-
-include CompSci
-
-describe BinarySearchTree do
-  before do
-    @keys = Array.new(4) { |i| Names::WW2[i] }
-    @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/tree.rb

@@ -1,200 +0,0 @@
-require 'compsci/node'
-require 'compsci/tree'
-require 'minitest/autorun'
-
-include CompSci
-
-describe Tree do
-  before do
-    @tree = Tree.new(FlexNode, 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(FlexNode, 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(FlexNode, 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
-  it "must power_of?" do
-    powers = {}
-    basemax = 12
-    expmax = 10
-    2.upto(basemax) { |base|
-      0.upto(expmax) { |exp|
-        powers[base] ||= []
-        powers[base] << base**exp
-      }
-    }
-
-    # 12k assertions below!
-    2.upto(basemax) { |base|
-      1.upto(2**expmax) { |num|
-        if powers[base].include?(num)
-          NaryTree.power_of?(num, base).must_equal true
-        else
-          NaryTree.power_of?(num, base).must_equal false
-        end
-      }
-    }
-  end
-
-  describe "with FlexNode" do
-    before do
-      @tree = NaryTree.new(FlexNode, 42, child_slots: 3)
-    end
-
-    it "must have an open parent" do
-      @tree.open_parent?(@tree.root).must_equal true
-      @tree.open_parent?(@tree.open_parent).must_equal true
-    end
-
-    it "must push a value onto an open parent" do
-      op = @tree.open_parent
-      opc = op.children.size
-      @tree.push 5
-      @tree.open_parent.children.size.must_equal opc + 1
-    end
-  end
-
-  describe "with ChildFlexNode" do
-    before do
-      @tree = NaryTree.new(ChildFlexNode, 42, child_slots: 4)
-    end
-
-    it "must have an open parent" do
-      @tree.open_parent?(@tree.root).must_equal true
-      @tree.open_parent?(@tree.open_parent).must_equal true
-    end
-
-    it "must push a value onto an open parent" do
-      op = @tree.open_parent
-      opc = op.children.size
-      @tree.push 5
-      @tree.open_parent.children.size.must_equal opc + 1
-    end
-  end
-end
-
-describe "BinaryTree" do
-  before do
-    @tree = BinaryTree.new(FlexNode, 42)
-  end
-
-  it "must have 2 child_slots" do
-    @tree.child_slots.must_equal 2
-  end
-
-  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
-
-  describe "searching" do
-    before do
-      @tree = NaryTree.new(FlexNode, 42, child_slots: 2)
-      99.times { |i| @tree.push i }
-    end
-
-    it "must find 42 quickly" do
-      count = 0
-      @tree.df_search { |n|
-        count += 1
-        n.value == 42
-      }.must_equal @tree.root
-      count.must_equal 1
-
-      count = 0
-      @tree.bf_search { |n|
-        count += 1
-        n.value == 42
-      }.must_equal @tree.root
-      count.must_equal 1
-    end
-
-    it "must find 99 slowly" do
-      count = 0
-      @tree.df_search { |n|
-        count += 1
-        n.value == 99
-      }
-      count.must_equal 100
-
-      count = 0
-      @tree.bf_search { |n|
-        count += 1
-        n.value == 99
-      }
-      count.must_equal 100
-    end
-
-    it "must find 81 accordingly" do
-      count = 0
-      @tree.df_search { |n|
-        count += 1
-        n.value == 81
-      }
-      count.must_equal 42
-
-      count = 0
-      @tree.bf_search { |n|
-        count += 1
-        n.value == 81
-      }
-      count.must_equal 83
-    end
-  end
-end