segment_tree 0.0.3 → 0.1.0

data/lib/segment_tree/version.rb

@@ -1,3 +1,3 @@
 class SegmentTree
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/segment_tree.rb

@@ -12,73 +12,24 @@
 #   ip_tree = SegmentTree.new(data)
 #
 #   client_ip = IPAddr.new("87.224.241.66")
-#   ip_tree.find_first(client_ip).value # => {:city=>"YEKT"}
+#   ip_tree.find(client_ip).value # => {:city=>"YEKT"}
 class SegmentTree
-  # An abstract tree node
-  class Node #:nodoc:all:
-    attr_reader :begin, :end
-
-    def initialize(*)
-      @begin, @end = @range.begin, @range.end
-    end
-    protected :initialize
-
-    def include?(x)
-      @range.include?(x)
-    end
-  end
-
-  # An elementary intervals or nodes container
-  class Container < Node #:nodoc:all:
-    extend Forwardable
-
-    #attr_reader :left, :right
-
-    # Node constructor, accepts both +Node+ and +Segment+
-    def initialize(left, right)
-      @left, @right = left, right
-      @range = left.begin..(right || left).end
-
-      super
-    end
-
-    # Find all intervals containing point +x+ within node's children. Returns array
-    def find(x)
-      [@left, @right].compact.
-                      select { |node| node.include?(x) }.
-                      map    { |node| node.find(x) }.
-                      flatten
-    end
-
-    # Find first interval containing point +x+ within node's children
-    def find_first(x)
-      subset = [@left, @right].compact.find { |node| node.include?(x) }
-      subset && subset.find_first(x)
-    end
-
-    # Do not expose left and right, otherwise output shall be too long on large trees
-    def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)} @range=#{@range.inspect}>"
-    end
-  end
-
   # An elementary interval
-  class Segment < Node #:nodoc:all:
-    attr_reader :value
+  class Segment #:nodoc:all:
+    attr_reader :range, :value
 
     def initialize(range, value)
       raise ArgumentError, 'Range expected, %s given' % range.class.name unless range.is_a?(Range)
 
       @range, @value = range, value
-      super
-    end
-
-    def find(x)
-      [find_first(x)].compact
     end
 
-    def find_first(x)
-      @range.include?(x) ? self : nil
+    # segments are sorted from left to right, from shortest to longest
+    def <=>(other)
+      case cmp = @range.begin <=> other.range.begin
+        when 0 then @range.end <=> other.range.end
+        else cmp
+      end
     end
   end
 
@@ -90,37 +41,60 @@ class SegmentTree
   # 2. 2-dimensional array - an array of arrays where first element of
   #    each element is range, and second is value:
   #    <code>[[(0..3), some_value1], [(4..6), some_value2] ...]<code>
-  def initialize(data)
+  #
+  # You can pass optional argument +sorted+.
+  # If +sorted+ is true then tree consider that data already sorted in proper order.
+  # Use it at your own risk!
+  def initialize(data, sorted = false)
     # build elementary segments
-    nodes = case data
+    @segments = case data
       when Hash, Array, Enumerable then
         data.collect { |range, value| Segment.new(range, value) }
       else raise ArgumentError, '2-dim Array or Hash expected'
-    end.sort! do |x, y|
-      # intervals are sorted from left to right, from shortest to longest
-      x.begin == y.begin ?
-          x.end <=> y.end :
-          x.begin <=> y.begin
-    end
-
-    # now build binary tree
-    while nodes.length > 1
-      nodes = nodes.each_slice(2).collect { |left, right| Container.new(left, right) }
     end
 
-    # root node is first node or nil when tree is empty
-    @root = nodes.first
+    @segments.sort! unless sorted
   end
 
-  # Find all intervals containing point +x+
-  # @return [Array]
+  # Find first interval containing point +x+.
+  # @return [Segment|NilClass]
   def find(x)
-    @root ? @root.find(x) : []
+    return nil if x.nil?
+    low = 0
+    high = @segments.size - 1
+    while low <= high
+      mid = (low + high) / 2
+
+      case matches?(x, low, high, mid)
+        when -1 then high = mid - 1
+        when 1 then low = mid + 1
+        when 0 then return @segments[mid]
+        else return nil
+      end
+    end
+    nil
   end
 
-  # Find first interval containing point +x+.
-  # @return [Segment|NilClass]
-  def find_first(x)
-    @root && @root.find_first(x)
+  def inspect
+    if @segments.size > 0
+      "SegmentTree(#{@segments.first.range.begin}..#{@segments.last.range.end})"
+    else
+      "SegmentTree(empty)"
+    end
+  end
+
+  private
+  def matches?(x, low_idx, high_idx, idx) #:nodoc:
+    low, high = @segments[low_idx], @segments[high_idx]
+    segment   = @segments[idx]
+    left      = idx > 0 && @segments[idx - 1]
+    right     = idx < @segments.size - 1 && @segments[idx + 1]
+
+    case
+      when left && (low.range.begin..left.range.end).include?(x) then -1
+      when segment.range.include?(x) then 0
+      when right && (right.range.begin..high.range.end).include?(x) then 1
+      else nil
+    end
   end
 end

data/spec/segment_tree_spec.rb

@@ -1,32 +1,63 @@
 require "spec_helper"
 require "segment_tree"
 
+# subject { tree }
+# it { should query(12).and_return("b") }
+RSpec::Matchers.define :query do |key|
+  chain :and_return do |expected|
+    @expected = expected
+    @expected = nil if @expected == :nothing
+  end
+
+  match do |tree|
+    result = tree.find(key)
+    result &&= result.value
+
+    result.should eq @expected
+  end
+
+  failure_message_for_should do |tree|
+    result = tree.find(key)
+    result &&= result.value
+
+    "expected that #{tree.inspect} would return #{@expected.inspect} when querying #{key.inspect}, " +
+    "but #{result.inspect} returned instead"
+  end
+end
+
 describe SegmentTree do
   # some fixtures
   # [[0..9, "a"], [10..19, "b"], ..., [90..99, "j"]] - spanned intervals
-  let(:sample_spanned) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 1, letter] } }
-  # [[0..12, "a"], [10..22, "b"], ..., [90..102, "j"]] - partially overlapping intervals
-  let(:sample_overlapping) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 + 2, letter] } }
+  let(:sample_spanned) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 1, letter] }.shuffle }
+  # [[0..10, "a"], [10..20, "b"], ..., [90..100, "j"]] - partially overlapping intervals
+  let(:sample_overlapping) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 + 2, letter] }.shuffle }
   # [[0..5, "a"], [10..15, "b"], ..., [90..95, "j"]] - sparsed intervals
-  let(:sample_sparsed) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 5, letter] } }
+  let(:sample_sparsed) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 5, letter] }.shuffle }
+
+  # [[0..5, "a"], [0..7, "aa"], [10..15, "b"], [10..17, "bb"], ..., [90..97, "jj"]]
+  let(:sample_overlapping2) do
+    (0..9).zip("a".."j").map do |num, letter|
+      [(num * 10)..(num + 1) * 10 - 5, letter,
+       (num * 10)..(num + 1) * 10 - 3, letter * 2]
+    end.
+    flatten.
+    each_slice(2).
+    to_a.
+    shuffle
+  end
 
   describe ".new" do
     context "given a hash with ranges as keys" do
       let :data do
-        {0..3 => "a",
+        {7..9 => "a",
          4..6 => "b",
-         7..9 => "c",
+         0..3 => "c",
          10..12 => "d"}
       end
 
       subject(:tree) { SegmentTree.new(data) }
 
       it { should be_a SegmentTree }
-
-      it "should have a root" do
-        root = tree.instance_variable_get :@root
-        root.should be_a SegmentTree::Container
-      end
     end
 
     context "given an array of arrays" do
@@ -34,17 +65,26 @@ describe SegmentTree do
         [[0..3, "a"],
          [4..6, "b"],
          [7..9, "c"],
-         [10..12, "d"]]
+         [10..12, "d"]].shuffle
       end
 
       subject(:tree) { SegmentTree.new(data) }
 
       it { should be_a SegmentTree }
+    end
 
-      it "should have a root" do
-        root = tree.instance_variable_get :@root
-        root.should be_a SegmentTree::Container
+    context "given preordered data" do
+      let :data do
+        [[0..3, "a"],
+         [4..6, "b"],
+         [7..9, "c"],
+         [10..12, "d"]]
       end
+
+      subject(:tree) { SegmentTree.new(data, true) }
+
+      it { should be_a SegmentTree }
+      it { should query(8).and_return("c") }
     end
 
     context "given nor hash neither array" do
@@ -63,107 +103,32 @@ describe SegmentTree do
     end
   end
 
-  describe "#find" do
+  describe "querying" do
     context "given spanned intervals" do
-      let(:tree) { SegmentTree.new(sample_spanned) }
+      subject { SegmentTree.new(sample_spanned) }
 
-      context "and looking up for existent point" do
-        subject { tree.find 12 }
-
-        it { should be_a Array }
-        it { should have_exactly(1).item }
-        its(:first) { should be_a SegmentTree::Segment }
-        its('first.value') { should eq 'b' }
-      end
-
-      context "and looking up for non-existent point" do
-        subject { tree.find 101 }
-
-        it { should be_a Array }
-        it { should be_empty }
-      end
+      it { should query(12).and_return('b') }
+      it { should query(101).and_return(:nothing) }
     end
 
     context "given partially overlapping intervals" do
-      let(:tree) { SegmentTree.new(sample_overlapping) }
-
-      context "and looking up for existent point" do
-        subject { tree.find 11 }
+      subject { SegmentTree.new(sample_overlapping) }
 
-        it { should be_a Array }
-        it { should have_exactly(2).item }
-        its(:first) { should be_a SegmentTree::Segment }
-        its('first.value') { should eq 'a' }
-        its(:last) { should be_a SegmentTree::Segment }
-        its('last.value') { should eq 'b' }
-      end
+      it { should query(11).and_return('a') }
     end
 
     context "given sparsed intervals" do
-      let(:tree) { SegmentTree.new(sample_sparsed) }
+      subject { SegmentTree.new(sample_sparsed) }
 
-      context "and looking up for existent point" do
-        subject { tree.find 12 }
-
-        it { should be_a Array }
-        it { should have_exactly(1).item }
-        its(:first) { should be_a SegmentTree::Segment }
-        its('first.value') { should eq 'b' }
-      end
-
-      context "and looking up for non-existent point" do
-        subject { tree.find 8 }
-
-        it { should be_a Array }
-        it { should be_empty }
-      end
+      it { should query(12).and_return('b') }
+      it { should query(8).and_return(:nothing) }
     end
-  end
-
-  describe "#find_first" do
-    context "given spanned intervals" do
-      let(:tree) { SegmentTree.new(sample_spanned) }
-
-      context "and looking up for existent point" do
-        subject { tree.find_first 12 }
-
-        it { should be_a SegmentTree::Segment }
-        its(:value) { should eq 'b' }
-      end
 
-      context "and looking up for non-existent point" do
-        subject { tree.find_first 101 }
-
-        it { should be_nil }
-      end
-    end
+    context "given hardly overlapping intervals" do
+      subject { SegmentTree.new(sample_overlapping2) }
 
-    context "given partially overlapping intervals" do
-      let(:tree) { SegmentTree.new(sample_overlapping) }
-
-      context "and looking up for existent point" do
-        subject { tree.find_first 11 }
-
-        it { should be_a SegmentTree::Segment }
-        its(:value) { should eq 'a' }
-      end
-    end
-
-    context "given sparsed intervals" do
-      let(:tree) { SegmentTree.new(sample_sparsed) }
-
-      context "and looking up for existent point" do
-        subject { tree.find_first 12 }
-
-        it { should be_a SegmentTree::Segment }
-        its(:value) { should eq 'b' }
-      end
-
-      context "and looking up for non-existent point" do
-        subject { tree.find_first 8 }
-
-        it { should be_nil }
-      end
+      it { should query(12).and_return('b') }
+      it { should query(8).and_return(:nothing) }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: segment_tree
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-04 00:00:00.000000000Z
+date: 2012-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &82956300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *82956300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &82956050 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +37,12 @@ dependencies:
         version: '2.11'
   type: :development
   prerelease: false
-  version_requirements: *82956050
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
 description: Tree data structure for storing segments. It allows querying which of
   the stored segments contain a given point.
 email: amikhailov83@gmail.com
@@ -66,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Tree data structure for storing segments. It allows querying which of the