btree 0.0.0

data/.bnsignore

@@ -0,0 +1,18 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   Bones {
+#     ignore_file  '.gitignore'
+#   }
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
+announcement.txt
+coverage
+doc
+pkg

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.0 / 2010-12-20
+
+* 1 major enhancement
+  * Initial Release!

data/README.md

@@ -0,0 +1,69 @@
+Ruby-BTree
+==========
+
+Pure ruby implementation of a btree as described in Introduction to Algorithms by 
+Cormen, Leiserson, Rivest and Stein, Chapter 18.
+
+Features
+--------
+
+* Create B-Tree of arbitrary degree (2 by default)
+* Insert key value pairs using a Map like interface
+* Query for values associated with keys using a Map like interface
+* Keys can be any object supporting comparison operators: <, > and ==
+
+Examples
+--------
+
+    require 'btree'
+    tree = Btree.create    # default degree = 2
+    tree = Btree.create(5) # degree = 5
+    tree['foo'] = 'foo value'
+    tree['bar'] = 'bar value'
+    
+    puts "key 'foo' has value: #{tree['foo']}"
+    puts "BTree has #{tree.size} key-value pairs"
+
+Future
+------
+
+* Deletion is not implemented. TODO: Implement deletion
+* Attempt to insert existing key raises RuntimeError.
+  TODO: Allow replacement of value associated with existing key instead of raising RuntimeError.
+* Persist state to backing store
+
+Install
+-------
+
+* gem install btree
+
+Author
+------
+
+Original author: Douglas A. Seifert (doug@dseifert.net)
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2010,2011 Douglas A. Seifert
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+  name  'btree'
+  authors  'Douglas A. Seifert'
+  email    'doug@dseifert.net'
+  url      'http://www.dseifert.net/btree'
+  readme_file 'README.md'
+}
+

data/lib/btree.rb

@@ -0,0 +1,70 @@
+# :main: README.md
+module Btree
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    @version ||= File.read(path('version.txt')).strip
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args, &block )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args, &block )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  def self.create(degree)
+    raise "Degree of Btree must be >= 2" if degree < 2
+    return Btree::Tree.new(degree)
+  end
+
+end  # module Btree
+
+Btree.require_all_libs_relative_to(__FILE__)
+

data/lib/btree/node.rb

@@ -0,0 +1,139 @@
+class Btree::Node
+  attr_accessor :leaf
+  def initialize(degree)
+    @degree = degree
+    @keys = []
+    @children = []
+    @leaf = true
+  end
+
+  def dump(level = 0)
+    @keys.each_with_index do |key, idx|
+      if @children[idx]
+         @children[idx].dump(level + 1)
+      end
+      puts "#{level}: #{key.first}: full? #{full?} leaf? #{leaf?}"
+    end
+    (@children[@keys.size..-1] || []).each do |c|
+      c.dump(level+1)
+    end
+    nil
+  end
+
+  def add_child(node)
+    @children << node
+  end
+
+  def children
+    @children.dup.freeze
+  end
+
+  def keys
+    @keys.map(&:first).freeze
+  end
+
+  def values
+    @keys.map(&:last).freeze
+  end
+
+  def full?
+    size >= 2 * @degree - 1
+  end
+
+  def leaf?
+    @leaf
+  end
+
+  def size
+    @keys.size
+  end
+
+  def value_of(key)
+    i = 1
+    while i <= size && key > @keys[i-1].first
+      i += 1
+    end
+
+    if i <= size && key == @keys[i-1].first
+      return @keys[i-1].last
+    elsif leaf?
+      return nil
+    else
+      return @children[i-1].value_of(key)
+    end
+  end
+
+  def insert(key, value)
+    i = size - 1
+    #puts "INSERTING #{key} INTO NODE: #{self.inspect}"
+    if leaf?
+      raise "Duplicate key" if @keys.any?{|(k,v)| k == key }  #OPTIMIZE: This is inefficient
+      while i >= 0 && @keys[i] && key < @keys[i].first
+        @keys[i+1] = @keys[i]
+        i -= 1
+      end
+      @keys[i+1] = [key, value]
+    else
+      while i >= 0 && @keys[i] &&  key < @keys[i].first
+        i -= 1
+      end
+      #puts "   -- INSERT KEY INDEX #{i}"
+      if @children[i+1] && @children[i+1].full?
+        split(i+1)
+        if key > @keys[i+1].first
+          i += 1
+        end
+      end
+      @children[i+1].insert(key, value)
+    end
+  end
+
+  def split(child_idx)
+    raise "Invalid child index #{child_idx} in split, num_children = #{@children.size}" if child_idx < 0 || child_idx >= @children.size
+    #puts "SPLIT1: #{self.inspect}"
+    splitee = @children[child_idx]
+    y = Btree::Node.new(@degree)
+    z = Btree::Node.new(@degree)
+    z.leaf = splitee.leaf
+    (@degree-1).times do |j|
+      z._keys[j] = splitee._keys[j+@degree]
+      y._keys[j] = splitee._keys[j]
+    end
+    if !splitee.leaf?
+      @degree.times do |j|
+        z._children[j] = splitee._children[j+@degree]
+        y._children[j] = splitee._children[j]
+      end
+    end
+    mid_val = splitee._keys[@degree-1]
+    #puts "SPLIT2: #{self.inspect}"
+    (@keys.size).downto(child_idx) do |j|
+      @children[j+1] = @children[j]
+    end
+
+    @children[child_idx+1] = z
+    @children[child_idx] = y
+    
+    #puts "SPLIT3: #{self.inspect}"
+
+    (@keys.size - 1).downto(child_idx) do |j|
+      @keys[j+1] = @keys[j]
+    end
+
+    #puts "SPLIT4: #{self.inspect}"
+
+    @keys[child_idx] = mid_val
+    #puts "SPLIT5: #{self.inspect}"
+  end
+
+  protected
+
+  def _keys
+    @keys
+  end
+
+  def _children
+    @children
+  end
+
+end

data/lib/btree/tree.rb

@@ -0,0 +1,46 @@
+class Btree::Tree
+  attr_reader :root, :degree, :size
+
+  # Creates a BTree of degree 2 by default.  Keys
+  # Must support being compared using >, < and == methods.
+  def initialize(degree = 2)
+    @degree = degree
+    @root = Btree::Node.new(@degree)
+    @root.leaf = true
+    @size = 0
+  end
+
+  # Insert a key-value pair into the btree
+  def insert(key, value = nil)
+    node = @root
+    if node.full?  
+      @root = Btree::Node.new(@degree)
+      @root.leaf = false
+      @root.add_child(node)
+      @root.split(@root.children.size - 1)
+      #puts "After split, root = #{@root.inspect}"
+      # split child(@root, 1)
+      node = @root
+    end
+    node.insert(key, value)
+    @size += 1
+    return self
+  end
+
+  # puts internal state
+  def dump
+    @root.dump
+  end
+
+  # Get value associated with the specified key
+  def value_of(key)
+    @root.value_of(key)
+  end
+
+  # Support map like access
+  alias_method :"[]", :value_of
+
+  # Support map like key-value setting
+  alias_method :"[]=", :insert
+
+end

data/test/test_btree.rb

@@ -0,0 +1,110 @@
+require 'test/unit'
+require 'btree'
+require 'shoulda'
+
+class TestBtree < Test::Unit::TestCase
+  def test_insert_notfull
+    t = Btree.create(5)
+    t.insert(5, "5")
+    assert_equal 1, t.root.size
+    assert !t.root.full?
+    assert_equal 5, t.degree
+    assert_equal 1, t.size
+  end
+ 
+  def test_degree_too_small
+    assert_raises(RuntimeError) do
+      Btree.create(1)
+    end
+  end
+
+  def test_insert_duplicate_key
+    t = Btree.create(2)
+    t.insert(1, "1")
+    assert_raises(RuntimeError) do
+      t.insert(1, "1")
+    end
+  end
+
+  def test_value_of
+    t = Btree.create(5)
+    t.insert(1, "foo")
+    t.insert(5, "bar")
+    t.insert(7, "baz")
+    t.insert(3, "findme")
+    assert_equal "findme", t.value_of(3)
+    assert_equal "baz", t.value_of(7)
+    assert_equal "bar", t.value_of(5)
+    assert_equal "foo", t.value_of(1)
+    assert_nil t.value_of(11)
+    assert_equal 4, t.size
+  end
+
+  def test_fill_root
+    t = Btree.create(2)
+    3.times {|n| t.insert(n, n.to_s)}
+    assert t.root.full?
+    assert_equal [0,1,2], t.root.keys
+    assert_equal ['0','1','2'], t.root.values
+    assert_equal 3, t.size
+  end
+
+  context 'full root' do
+    setup do
+      @t = Btree.create(2)
+      3.times {|n| @t.insert(n*2, n.to_s)}
+    end
+    should "be able to insert at end" do
+      @t.insert(10, "10")
+      assert_equal "10", @t.value_of(10)
+      assert_equal "0", @t.value_of(0)
+      assert_equal "1", @t.value_of(2)
+      assert_equal "2", @t.value_of(4)
+      assert_equal 4, @t.size
+    end
+    should "be able to insert at front" do
+      @t.insert(-1, "10")
+      assert_equal "10", @t.value_of(-1)
+      assert_equal "0", @t.value_of(0)
+      assert_equal "1", @t.value_of(2)
+      assert_equal "2", @t.value_of(4)
+      assert_equal 4, @t.size
+    end
+    should "be able to insert in the middle" do
+      @t.insert(3, "10")
+      assert_equal "10", @t.value_of(3)
+      assert_equal "0", @t.value_of(0)
+      assert_equal "1", @t.value_of(2)
+      assert_equal "2", @t.value_of(4)
+      assert_equal 4, @t.size
+    end
+    context 'full last child' do 
+      setup do
+        2.times {|n| @t.insert(n*2 + 10, "foo") }
+      end
+      should "have full last child" do
+        assert @t.root.children.last.full?, "Last child of root should be full"
+        assert_equal 5, @t.size
+      end
+      should "be able to add to end" do
+        @t.insert(100, "YEAH!")
+        assert_equal "YEAH!", @t.value_of(100)
+        assert_equal 6, @t.size
+      end
+      should "be able to insert many" do
+        10.times { |n| @t.insert((n+1) * 100, "YEAH!") }
+        assert_equal "YEAH!", @t.value_of(100)
+        assert_equal 15, @t.size
+      end
+    end
+    context 'second split of root' do
+      setup do
+        6.times {|n| @t.insert(n*2 + 10, "foo") }
+      end
+      should "work" do
+        assert_equal 'foo', @t.value_of(10)
+        assert_equal 9, @t.size
+      end
+    end
+  end
+end

data/version.txt

@@ -0,0 +1 @@
+0.0.0

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: btree
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Douglas A. Seifert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-20 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 3
+        - 5
+        - 4
+        version: 3.5.4
+  type: :development
+  version_requirements: *id001
+description: |-
+  Pure ruby implementation of a btree as described in Introduction to Algorithms by 
+  Cormen, Leiserson, Rivest and Stein, Chapter 18.
+email: doug@dseifert.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- lib/btree/.node.rb.swp
+- version.txt
+files: 
+- .bnsignore
+- History.txt
+- README.md
+- Rakefile
+- lib/btree.rb
+- lib/btree/.node.rb.swp
+- lib/btree/node.rb
+- lib/btree/tree.rb
+- test/test_btree.rb
+- version.txt
+has_rdoc: true
+homepage: http://www.dseifert.net/btree
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: btree
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Pure ruby implementation of a btree as described in Introduction to Algorithms by  Cormen, Leiserson, Rivest and Stein, Chapter 18.
+test_files: 
+- test/test_btree.rb