binary_decision_tree 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61ea2ac1f016a28ef9c96ce8e61f08231876764a
-  data.tar.gz: a4bcc60c2d5df5ebdb587708fb659ab357fe3333
+  metadata.gz: cd430f35feb7cf78297db1208f4678ad0cb192f3
+  data.tar.gz: 4777835269c7eca78d13d3694e11070c2b8f5729
 SHA512:
-  metadata.gz: b15ee21a0e80ef48c4864159959f3916f17816c3d9148c6c9fb4c7b815b16d8bc580808846f291d97e600fbbeaf86478437e31565641b8bbcccd28fad9479710
-  data.tar.gz: 2fcec32b0ba97197c44db1446003f3dda074b164c4d68f3a1309f20527de0d25789c29e05bf7abb155217cb275ebc789c33bcfeef442533907a73b3132af6aa2
+  metadata.gz: 7998bc2ad37b1d2b0652ac4b4117e199679a64b2594cafa3a2594e2c3b92c71e8b4c2b1a8b330f60c21d60b40d75cf546517d27d3f9c89aacd2bc370773fd81e
+  data.tar.gz: 000651f02ad554ab4ab1350936e16bba13e54f47cb8a417301c70bd9fbfcfd209f2fbf6a326c97db9162e2e9cc4fb6bb775c80607fe77377d281ac2d0bb582db

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.1
+  #- 2.1.0 not working on travis ci
+  - 2.0.0
+  - jruby-19mode

data/Gemfile

@@ -2,3 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in binary_decision_tree.gemspec
 gemspec
+

data/Guardfile

@@ -0,0 +1,5 @@
+guard :minitest do
+  watch(%r{^test/(.*)_test\.rb$})
+  watch(%r{^lib/(.+)\.rb$})         { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$}) { 'test' }
+end

data/README.md

@@ -1,5 +1,11 @@
 # BinaryDecisionTree
 
+[![Build Status](https://travis-ci.org/haruska/binary_decision_tree.svg?branch=master)](https://travis-ci.org/haruska/binary_decision_tree)
+[![Coverage Status](https://coveralls.io/repos/haruska/binary_decision_tree/badge.png?branch=master)](https://coveralls.io/r/haruska/binary_decision_tree?branch=master)
+[![Gem Version](https://badge.fury.io/rb/binary_decision_tree.svg)](http://badge.fury.io/rb/binary_decision_tree)
+[![Dependency Status](https://gemnasium.com/haruska/binary_decision_tree.svg)](https://gemnasium.com/haruska/binary_decision_tree)
+[![Code Climate](https://codeclimate.com/github/haruska/binary_decision_tree.png)](https://codeclimate.com/github/haruska/binary_decision_tree)
+
 A binary tree designed to record decisions based on child nodes. This data structure is useful
 in things like single elimination tournaments. They can be marshalled and unmarshalled to two
 numbers.

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+end

data/binary_decision_tree.gemspec

@@ -20,4 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
 end

data/lib/binary_decision_tree/marshalled_tree.rb

@@ -1,45 +1,47 @@
-class BinaryDecisionTree::MarshalledTree
-  attr_reader :depth
-  attr_reader :decisions
-  attr_reader :mask
-
-  def initialize(depth, decisions, mask)
-    @depth = depth
-    @decisions = decisions
-    @mask = mask
-  end
+module BinaryDecisionTree
+  class MarshalledTree
+    attr_reader :depth
+    attr_reader :decisions
+    attr_reader :mask
+
+    def initialize(depth, decisions, mask)
+      @depth = depth
+      @decisions = decisions
+      @mask = mask
+    end
+
+    def self.from_tree(tree)
+      depth = tree.depth
+      decisions = 0
+      mask = 0
 
-  def self.from_tree(tree)
-    depth = tree.depth
-    decisions = 0
-    mask = 0
-
-    (2**tree.depth).times do |i|
-      next if i == 0
-      node = tree.at(i)
-      if !node.decision.nil?
-        mask |= 1 << i
-        decisions |= node.decision << i
+      (2**tree.depth).times do |i|
+        next if i == 0
+        node = tree.at(i)
+        if !node.decision.nil?
+          mask |= 1 << i
+          decisions |= node.decision << i
+        end
       end
-    end
 
-    new(depth, decisions, mask)
-  end
+      new(depth, decisions, mask)
+    end
 
-  def to_tree
-    tree = Tree.new(depth)
+    def to_tree
+      tree = Tree.new(depth)
 
-    (2**tree.depth).times do |i|
-      next if i == 0
+      (2**tree.depth).times do |i|
+        next if i == 0
 
-      current_position = 1 << i
+        current_position = 1 << i
 
-      if (mask & current_position) != 0
-        node = tree.at(i)
-        node.decision = (decisions & current_position) == 0 ? 0 : 1
+        if (mask & current_position) != 0
+          node = tree.at(i)
+          node.decision = (decisions & current_position) == 0 ? 0 : 1
+        end
       end
-    end
 
-    tree
+      tree
+    end
   end
-end
+end

data/lib/binary_decision_tree/node.rb

@@ -1,43 +1,60 @@
-class BinaryDecisionTree::Node
-  attr_accessor :decision #nil, 0, or 1
+module BinaryDecisionTree
+  class Node
+    LEFT = 0
+    RIGHT = 1
 
-  attr_reader :slot #bit position
-  attr_reader :tree
+    attr_accessor :decision #nil, 0, or 1
 
-  def initialize(tree, slot, decision: nil)
-    @tree = tree
-    @slot = slot
-    @decision = decision
-  end
+    attr_reader :slot #bit position
+    attr_reader :tree
 
-  def value
-    case decision
-      when 0
-        left.nil? ? left_position : left.value
-      when 1
-        right.nil? ? right_position : right.value
-      else
-        nil
+    def initialize(tree, slot)
+      @tree = tree
+      @slot = slot
+      @decision = nil
     end
-  end
 
-  def leaf?
-    left.nil? && right.nil?
-  end
+    def value
+      case decision
+        when LEFT
+          left.nil? ? left_position : left.value
+        when RIGHT
+          right.nil? ? right_position : right.value
+        else
+          nil
+      end
+    end
 
-  def left_position
-    slot * 2
-  end
+    def leaf?
+      left.nil? && right.nil?
+    end
 
-  def right_position
-    left_position + 1
-  end
+    def current_depth
+      Math.log2(slot).floor + 1
+    end
 
-  def left
-    tree.at(left_position)
-  end
+    def parent_position
+      (slot % 2 == 0 ? slot + 1 : slot) / 2
+    end
 
-  def right
-    tree.at(right_position)
+    def left_position
+      slot * 2
+    end
+
+    def right_position
+      left_position + 1
+    end
+
+    def parent
+      tree.at(parent_position)
+    end
+
+    def left
+      tree.at(left_position)
+    end
+
+    def right
+      tree.at(right_position)
+    end
   end
-end
+end

data/lib/binary_decision_tree/tree.rb

@@ -1,16 +1,22 @@
-class BinaryDecisionTree::Tree
-  attr_reader :depth
+module BinaryDecisionTree
+  class Tree
+    attr_reader :depth
 
-  def initialize(depth)
-    @depth = depth
-    @nodes = Array.new(2**depth) {|i| i == 0 ? nil : Node.new(self, i)}
-  end
+    def initialize(depth)
+      @depth = depth
+      @nodes = Array.new(size) {|i| i == 0 ? nil : Node.new(self, i)}
+    end
 
-  def root
-    @nodes[1]
-  end
+    def root
+      @nodes[1]
+    end
+
+    def at(position)
+      @nodes[position]
+    end
 
-  def at(position)
-    @nodes[position]
+    def size
+      2**depth
+    end
   end
-end
+end

data/lib/binary_decision_tree/version.rb

@@ -1,3 +1,3 @@
 module BinaryDecisionTree
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'binary_decision_tree'
+require 'minitest/autorun'
+
+class MiniTest::Spec
+  def assert_same_node(exp, act, msg = nil)
+    assert_equal exp.decision, act.decision, msg
+    assert_equal exp.slot, act.slot, msg
+  end
+
+  def assert_same_tree(exp, act, msg = nil)
+    assert_equal exp.depth, act.depth, msg
+    exp.size.times do |i|
+      next if i == 0
+      exp_node = exp.at(i)
+      act_node = act.at(i)
+      assert_same_node exp_node, act_node, msg
+    end
+  end
+end
+
+

data/test/unit/binary_decision_tree/marshalled_tree_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../../test/test_helper'
+
+module BinaryDecisionTree
+  class MarshalledTreeTest < MiniTest::Spec
+    before do
+      @tree = Tree.new(6)
+      @tree.size.times do |i|
+        next if i == 0
+        @tree.at(i).decision = rand(2)
+      end
+    end
+
+    describe "marshalling a tree" do
+      before do
+        @marshalled_tree = MarshalledTree.from_tree(@tree)
+      end
+
+      it "should marshal and unmarshal to the same tree" do
+        assert_same_tree @tree, @marshalled_tree.to_tree
+      end
+
+      it "should be able to unmarshal from numeric values" do
+        another_tree = MarshalledTree.new(@tree.depth, @marshalled_tree.decisions, @marshalled_tree.mask).to_tree
+        assert_same_tree @tree, another_tree
+      end
+    end
+  end
+end

data/test/unit/binary_decision_tree/node_test.rb

@@ -0,0 +1,169 @@
+require_relative '../../../test/test_helper'
+
+module BinaryDecisionTree
+  class NodeTest < MiniTest::Spec
+    describe "creating a new node" do
+      before do
+        @tree = Tree.new(1)
+      end
+
+      it "should take both a tree and slot number and expose them" do
+        node = Node.new(@tree, 1)
+
+        assert_equal @tree, node.tree
+        assert_equal 1, node.slot
+        assert_nil node.decision
+      end
+    end
+
+    describe "calculating a value" do
+      before do
+        @tree = Tree.new(2)
+        @nodes = @tree.size.times.collect {|i| @tree.at(i)}
+        @nodes.each {|n| n.decision = rand(2) unless n.nil?}
+      end
+
+      describe "when decision is left" do
+        before do
+          @nodes.each {|n| n.decision = Node::LEFT unless n.nil?}
+        end
+
+        it "should return the slot id of next left position on a leaf" do
+          node = @nodes.last
+          assert node.leaf?
+
+          assert_equal node.left_position, node.value
+        end
+      end
+
+      describe "when decision is right" do
+        before do
+          @nodes.each {|n| n.decision = Node::RIGHT unless n.nil?}
+        end
+
+        it "should return the slot id of next right position on a leaf" do
+          node = @nodes.last
+          assert node.leaf?
+
+          assert_equal node.right_position, node.value
+        end
+      end
+
+      it "should traverse the tree until at a leaf and return that value" do
+        node = @tree.root
+        node.decision = Node::LEFT
+
+        assert_equal node.left.value, node.value
+      end
+
+      it "should be nil if a decision is not set" do
+        node = Tree.new(1).root
+        assert_nil node.decision
+        assert_nil node.value
+      end
+    end
+
+    describe "a leaf node" do
+      before do
+        @node = Tree.new(2).at(2)
+      end
+
+      it "should know it is a leaf node" do
+        assert @node.leaf?
+      end
+
+      it "should not have a left or right child in the tree" do
+        assert_nil @node.left
+        assert_nil @node.right
+      end
+
+      it "should still have left and right positions" do
+        assert !@node.left_position.nil?
+        assert !@node.right_position.nil?
+      end
+
+      it "should have a parent" do
+        assert !@node.parent.nil?
+      end
+    end
+
+    describe "current depth calculation" do
+      before do
+        @depth_hash = {}
+
+        #bfs
+        tree = Tree.new(6) #63 nodes
+        tree.depth.times do |i|
+          current_depth = i + 1
+          @depth_hash[current_depth] = []
+          if current_depth == 1
+            @depth_hash[current_depth] << tree.root
+          else
+            @depth_hash[current_depth - 1].each do |parent_node|
+              @depth_hash[current_depth] << parent_node.left
+              @depth_hash[current_depth] << parent_node.right
+            end
+          end
+        end
+      end
+
+      it "should return the correct depth" do
+        @depth_hash.each do |depth, nodes|
+          nodes.each do |node|
+            assert_equal depth, node.current_depth
+          end
+        end
+      end
+    end
+
+    describe "parent position calculation" do
+      before do
+        @tree = Tree.new(6)
+      end
+
+      it "should be half of the current slot value" do
+        i = 1
+        while !@tree.at(i).nil? && !@tree.at(i).left.nil?
+          node = @tree.at(i)
+          assert_same node, node.left.parent
+          assert_same node, node.right.parent
+          i += 1
+        end
+      end
+
+      it "should have a get node helper" do
+        node = @tree.at(3)
+        assert_equal 1, node.parent_position
+        assert_same @tree.at(1), node.parent
+      end
+    end
+
+    describe "child position calculations" do
+      before do
+        @tree = Tree.new(3)
+        @node = @tree.at(2)
+      end
+
+      describe "left position calculation" do
+        it "should be twice the current slot value" do
+          assert_equal 4, @node.left_position
+        end
+
+        it "should have a get node helper" do
+          assert_same @tree.at(4), @node.left
+        end
+      end
+
+      describe "right position calculation" do
+        it "should be next to the left child (one greater)" do
+          assert_equal 5, @node.right_position
+        end
+
+        it "should have a get node helper" do
+          assert_same @tree.at(5), @node.right
+        end
+      end
+
+      end
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binary_decision_tree
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Jason Haruska
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-29 00:00:00.000000000 Z
+date: 2014-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,48 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A binary decision tree useful for brackets of single elimination tournaments.
 email:
 - jason@haruska.com
@@ -45,8 +87,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
+- .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -56,6 +101,9 @@ files:
 - lib/binary_decision_tree/node.rb
 - lib/binary_decision_tree/tree.rb
 - lib/binary_decision_tree/version.rb
+- test/test_helper.rb
+- test/unit/binary_decision_tree/marshalled_tree_test.rb
+- test/unit/binary_decision_tree/node_test.rb
 homepage: http://github.com/haruska/binary_decision_tree
 licenses:
 - MIT
@@ -80,4 +128,7 @@ rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A binary decision tree
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/unit/binary_decision_tree/marshalled_tree_test.rb
+- test/unit/binary_decision_tree/node_test.rb