fast_interval_tree 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42b8ee0cf97e339df2d7b54b29291f6a9365eab9bda925a92d935b2c5c23ac47
+  data.tar.gz: 90000f00518ca5f3a547e7990f9c57c7a8a72a35929b650f05b511dfa4aab2e1
+SHA512:
+  metadata.gz: b4c99025fa3a0071bacc862ae2080e3236ad8052da0ce4556b0cc0db4c241b4a263b5df964e99f222084b3b96d3aa08098cf3197f02578acb2be8b6966da178f
+  data.tar.gz: 6756e05df8be87515476355806a0549736512cf1eb1243db7ceeb86c2042d89c2286daababaeae8fbaee97d6baeb63cf18834207fedb9d507458c3aefb539153

data/Gemfile

@@ -0,0 +1,4 @@
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    fast_interval_tree (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    rake (13.0.1)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fast_interval_tree!
+  rake (~> 13.0.1)
+  rspec (~> 3.10)
+
+BUNDLED WITH
+   1.17.3

data/README.md

@@ -0,0 +1,70 @@
+# IntervalTree
+
+An implementation of the centered interval tree algorithm in Ruby.
+
+This is a fork of [https://github.com/misshie/interval-tree] until our (performance related PR)[https://github.com/misshie/interval-tree/pull/8] gets merged.
+
+## See also
+
+* description in Wikipedia http://en.wikipedia.org/wiki/Interval_tree
+* an implementation in Python by Tyler Kahn http://forrst.com/posts/Interval_Tree_implementation_in_python-e0K (broken link)
+
+## ChangeLog
+
+### 2020-11-09, contribution by Brendan Weibrecht, Chris Nankervis and Thomas van der Pol
+
+* Substantially improved performance when supplied with a large range as the search query.
+
+### 2017-05-12, contribution by Sam Davies ( https://github.com/samphilipd )
+
+* User can specify an option in search `unique: false` if s/he wants multiple matches to be returned.
+
+### 2015-11-02, contribution by Carlos Alonso ( https://github.com/calonso )
+
+* Improved centering
+* Fixed searching: With some use cases with very large trees, the library fails to find intervals.
+* Added rubygems structure to be able to be pushed as a gem
+
+### 2013-04-06, contribution by Simeon Simeonov ( https://github.com/ssimeonov )
+
+* **Range factory**: The current design allows for Range-compatible elements to be added except for the case where `Tree#ensure_exclusive_end` constructs a Range in a private method. In keeping with good design practices of containers such as Hash, this pull requests allows for a custom range factory to be provided to `Tree#initialize` while maintaining perfect backward compatibility.
+Search in empty trees failing
+* Adds a nil guard in `Tree#search` to protect against empty tree searches failing.
+* **Cosmetic improvements**: Language & whitespace in specs, Gemfile addition, and .gitignore update
+
+## Install
+
+```bash
+$ gem install fast_interval_tree
+```
+
+## Usage
+
+See spec/interval_tree_spec.rb for details.
+
+```ruby
+require "interval_tree"
+
+itv = [(0...3), (1...4), (3...5), (0...3)]
+t = IntervalTree::Tree.new(itv)
+p t.search(2)     #=> [0...3, 1...4]
+p t.search(2, unique: false) #=> [0...3, 0...3, 1...4]
+p t.search(1...4) #=> [0...3, 1...4, 3...5]
+```
+
+## Note
+
+Result intervals are always returned
+in the "left-closed and right-open" style that can be expressed
+by three-dotted Range object literals `(first...last)`
+
+Two-dotted full-closed intervals `(first..last)` are also accepted and internally
+converted to half-closed intervals.
+
+## Copyright
+
+**Author**: MISHIMA, Hiroyuki ( https://github.com/misshie ),  Simeon Simeonov ( https://github.com/ssimeonov ), Carlos Alonso ( https://github.com/calonso ), Sam Davies ( https://github.com/samphilipd ), Brendan Weibrecht (https://github.com/ZimbiX), Chris Nankervis (https://github.com/chrisnankervis), Thomas van der Pol (https://github.com/tvanderpol).
+
+**Copyright**: (c) 2011-2020 MISHIMA, Hiroyuki; Simeon Simeonov; Carlos Alonsol; Sam Davies; Brendan Weibrecht; Chris Nankervis; Thomas van der Pol
+
+**License**: The MIT/X11 license

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/fast_interval_tree.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require_relative 'lib/interval_tree/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'fast_interval_tree'
+  s.version     = IntervalTree::VERSION
+  s.summary     = 'A Ruby implementation of the Centered Interval Tree data structure'
+  s.description = <<-END.gsub(/^ {4}/, '')
+    A Ruby implementation of the Centered Interval Tree data structure.
+    See also: http://en.wikipedia.org/wiki/Interval_tree
+  END
+  s.authors     = ['Hiroyuki Mishima', 'Simeon Simeonov', 'Carlos Alonso', 'Sam Davies', 'Brendan Weibrecht', 'Chris Nankervis', 'Thomas van der Pol']
+  s.email       = ['brendan@weibrecht.net.au']
+  s.files       = ['lib/interval_tree.rb']
+  s.homepage    = 'https://github.com/greensync/interval-tree'
+  s.metadata['source_code_uri'] = 'https://github.com/greensync/interval-tree'
+  s.license     = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{bin,lib}/**/*') + %w[README.md Gemfile Gemfile.lock Rakefile fast_interval_tree.gemspec]
+  end
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rspec', '~> 3.10'
+  s.add_development_dependency 'rake', '~> 13.0.1'
+end

data/lib/interval_tree.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+
+module IntervalTree
+
+  class Tree
+    def initialize(ranges, &range_factory)
+      range_factory = lambda { |l, r| (l ... r+1) } unless block_given?
+      ranges_excl = ensure_exclusive_end([ranges].flatten, range_factory)
+      @top_node = divide_intervals(ranges_excl)
+    end
+    attr_reader :top_node
+
+    def divide_intervals(intervals)
+      return nil if intervals.empty?
+      x_center = center(intervals)
+      s_center = Array.new
+      s_left = Array.new
+      s_right = Array.new
+
+      intervals.each do |k|
+        case
+        when k.last < x_center
+          s_left << k
+        when k.first > x_center
+          s_right << k
+        else
+          s_center << k
+        end
+      end
+      Node.new(x_center, s_center,
+               divide_intervals(s_left), divide_intervals(s_right))
+    end
+
+    # Search by range or point
+    DEFAULT_OPTIONS = {unique: true}
+    def search(query, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+
+      return nil unless @top_node
+
+      if query.respond_to?(:first)
+        result = top_node.search(query)
+        options[:unique] ? result.uniq : result
+      else
+        point_search(self.top_node, query, [], options[:unique])
+      end
+        .sort_by{|x|[x.first, x.last]}
+    end
+
+    def ==(other)
+      top_node == other.top_node
+    end
+
+    private
+
+    def ensure_exclusive_end(ranges, range_factory)
+      ranges.map do |range|
+        case
+        when !range.respond_to?(:exclude_end?)
+          range
+        when range.exclude_end?
+          range
+        else
+          range_factory.call(range.first, range.end)
+        end
+      end
+    end
+
+    # Note: Floors the result
+    def center(intervals)
+      (
+        intervals.map(&:begin).min +
+        intervals.map(&:end).max
+      ) / 2
+    end
+
+    def point_search(node, point, result, unique = true)
+      node.s_center.each do |k|
+        if k.include?(point)
+          result << k
+        end
+      end
+      if node.left_node && ( point < node.x_center )
+        point_search(node.left_node, point, []).each{|k|result << k}
+      end
+      if node.right_node && ( point >= node.x_center )
+        point_search(node.right_node, point, []).each{|k|result << k}
+      end
+      if unique
+        result.uniq
+      else
+        result
+      end
+    end
+  end # class Tree
+
+  class Node
+    def initialize(x_center, s_center, left_node, right_node)
+      @x_center = x_center
+      @s_center = s_center
+      @left_node = left_node
+      @right_node = right_node
+    end
+    attr_reader :x_center, :s_center, :left_node, :right_node
+
+    def ==(other)
+      x_center == other.x_center &&
+      s_center == other.s_center &&
+      left_node == other.left_node &&
+      right_node == other.right_node
+    end
+
+    # Search by range only
+    def search(query)
+      search_s_center(query) +
+        (query.begin < x_center && left_node&.search(query) || []) +
+        (query.end > x_center && right_node&.search(query) || [])
+    end
+
+    private
+
+    def search_s_center(query)
+      s_center.select do |k|
+        (
+          # k is entirely contained within the query
+          (k.begin >= query.begin) &&
+          (k.end <= query.end)
+        ) || (
+          # k's start overlaps with the query
+          (k.begin >= query.begin) &&
+          (k.begin < query.end)
+        ) || (
+          # k's end overlaps with the query
+          (k.end > query.begin) &&
+          (k.end <= query.end)
+        ) || (
+          # k is bigger than the query
+          (k.begin < query.begin) &&
+          (k.end > query.end)
+        )
+      end
+    end
+  end # class Node
+
+end # module IntervalTree

data/lib/interval_tree/version.rb

@@ -0,0 +1,3 @@
+module IntervalTree
+  VERSION = "0.2.0"
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: fast_interval_tree
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Hiroyuki Mishima
+- Simeon Simeonov
+- Carlos Alonso
+- Sam Davies
+- Brendan Weibrecht
+- Chris Nankervis
+- Thomas van der Pol
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+description: |
+  A Ruby implementation of the Centered Interval Tree data structure.
+  See also: http://en.wikipedia.org/wiki/Interval_tree
+email:
+- brendan@weibrecht.net.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- fast_interval_tree.gemspec
+- lib/interval_tree.rb
+- lib/interval_tree/version.rb
+homepage: https://github.com/greensync/interval-tree
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/greensync/interval-tree
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A Ruby implementation of the Centered Interval Tree data structure
+test_files: []