multi_range 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f1ca3c6c80f92c3cbbd68f289ffd138c1d988bc33cd506e9eded313b0244504
-  data.tar.gz: e27a2de532a9b307e1f1ca7cfe8eff18fbe3af7e607f11291449eb22ec66ad42
+  metadata.gz: fa2432c646c4156bab9056f7c92820959bb4d856940737835b7b8785cd2dd771
+  data.tar.gz: 0e1da8c9c9332444d5a65573be13415d07121ec30d8625ad7e1a5655f3496d41
 SHA512:
-  metadata.gz: e3623cbe2b34d20ca94b5a15848fc579a597e5381cee8f2245d5e053ef692e4511821772cc4461d62d7e0ea7bc4cc55613468e5df166d5f56bf68ac91c55b7e4
-  data.tar.gz: c04934e7ddc717db16902fea4846b3aabf531b1ea2c8e015f8bf754d8d9dac8abf5cdd4b1bf4c6770752fc35ad02ecc5e9969ca35c05b73fffa8302c1847f779
+  metadata.gz: 80e4731b7df2487a3aad29028ff370f833c3d4b993e6aafb14aeeefb9cb505bdfbe7663553907a9725fcf11f626d43d6b30342338eafed40d2ec9c22bcb53363
+  data.tar.gz: f70e7893acf075f2a74da10692206c71a7785812d086a75ccfa533b526eeb47f199585c38e4b82e3f24a4b9ecbeb2d490b0ab59e9424981e3b4a0db4d49f1a5a

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Change Log
 
+### [v2.2.2](https://github.com/khiav223577/multi_range/compare/v2.2.1...v2.2.2) 2023/12/07
+- [#40](https://github.com/khiav223577/multi_range/pull/40) Enhance: do not need to flatten ranges when ranges is not array (@khiav223577)
+
 ### [v2.2.1](https://github.com/khiav223577/multi_range/compare/v2.2.0...v2.2.1) 2023/10/28
 - [#35](https://github.com/khiav223577/multi_range/pull/35) Fix: intersection with excluded empty range contains extra element (@khiav223577)
 

data/lib/multi_range/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class MultiRange
-  VERSION = '2.2.2'
+  VERSION = '2.2.3'
 end

data/lib/multi_range.rb

@@ -3,6 +3,7 @@
 require 'multi_range/version'
 require 'roulette-wheel-selection'
 require 'interval_tree'
+require_relative 'patches/patch_interval_tree'
 
 if not Range.method_defined?(:size)
   warn "Please backports Range#size method to use multi_range gem.\n" \
@@ -28,7 +29,7 @@ class MultiRange
       @is_float = ranges.is_float?
     else
       ranges = [ranges] if !ranges.is_a?(Array)
-      @ranges = ranges.map{|s| s.is_a?(Numeric) ? s..s : s }.sort_by(&:begin).freeze
+      @ranges = ranges.map{|s| s.is_a?(Numeric) ? s..s : s }.sort_by{|s| s.begin || -Float::INFINITY }.freeze
       @is_float = @ranges.any?{|range| range.begin.is_a?(Float) || range.end.is_a?(Float) }
     end
   end
@@ -45,10 +46,13 @@ class MultiRange
 
     @ranges.each do |range|
       next current_range = range if current_range == nil
-      next if range.end <= current_range.end
+      next if current_range.end == nil
+      next if range.end && range.end <= current_range.end
 
       if can_combine?(current_range, range, merge_same_value)
-        current_range = range.exclude_end? ? current_range.begin...range.end : current_range.begin..range.end
+        end_val = range.end
+        end_val = Float::INFINITY if end_val == nil && current_range.begin == nil
+        current_range = range.exclude_end? ? current_range.begin...end_val : current_range.begin..end_val
       else
         new_ranges << current_range
         current_range = range
@@ -61,11 +65,10 @@ class MultiRange
 
   def &(other)
     other_ranges = MultiRange.new(other).merge_overlaps.ranges
-    tree = IntervalTree::Tree.new(other_ranges)
+    tree = IntervalTree::Tree.new(other_ranges){|l, r| r ? (l...(r + 1)) : l...nil }
+
     intersected_ranges = merge_overlaps.ranges.flat_map do |range|
-      # A workaround for the issue: https://github.com/greensync/interval-tree/issues/17
-      query = (range.first == range.last) ? range.first : range
-      matching_ranges_converted_to_exclusive = tree.search(query) || []
+      matching_ranges_converted_to_exclusive = tree.search(range) || []
 
       # The interval tree converts interval endings to exclusive, so we need to restore the original
       matching_ranges = matching_ranges_converted_to_exclusive.map do |matching_range_converted_to_exclusive|
@@ -96,12 +99,12 @@ class MultiRange
       # when this range is smaller than and not overlaps with `other`
       #      range          other
       #   |---------|    |---------|
-      next if other.begin > range.end
+      next if other.begin && range.end && other.begin > range.end
 
       # when this range is larger than and not overlaps with `other`
       #      other          range
       #   |---------|    |---------|
-      break if other.end < range.begin
+      break if other.end && range.begin && other.end < range.begin
 
       sub_ranges = possible_sub_ranges_of(range, other)
       new_ranges[idx + changed_size, 1] = sub_ranges
@@ -112,7 +115,8 @@ class MultiRange
       # -------------|
       #   other
       # ---------|
-      break if other.end <= range.end
+      break if range.end == nil
+      break if other.end && other.end <= range.end
     end
 
     return MultiRange.new(new_ranges)
@@ -191,6 +195,8 @@ class MultiRange
 
   # make sure that range1.begin <= range2.begin
   def can_combine?(range1, range2, merge_same_value)
+    return true if range1.end == nil
+    return true if range2.begin == nil
     return merge_same_value if range1.end == range2.begin and range1.exclude_end?
     return range1.end >= range2.begin if @is_float
     return range1.end + 1 >= range2.begin
@@ -203,26 +209,28 @@ class MultiRange
   end
 
   def possible_sub_ranges_of(range, other)
-    sub_range1 = range.begin...other.begin
+    sub_range1 = range.begin...other.begin if other.begin
 
-    sub_range2_begin = if other.exclude_end?
-                         other.end
-                       else
-                         other.end.is_a?(Float) ? other.end.next_float : other.end + 1
-                       end
+    if other.end
+      sub_range2_begin = if other.exclude_end?
+                           other.end
+                         else
+                           other.end.is_a?(Float) ? other.end.next_float : other.end + 1
+                         end
 
-    sub_range2 = range.exclude_end? ? sub_range2_begin...range.end : sub_range2_begin..range.end
+      sub_range2 = range.exclude_end? ? sub_range2_begin...range.end : sub_range2_begin..range.end
+    end
 
     sub_ranges = []
-    sub_ranges << sub_range1 if not empty_range?(sub_range1)
-    sub_ranges << sub_range2 if not empty_range?(sub_range2)
+    sub_ranges << sub_range1 if sub_range1 and not empty_range?(sub_range1)
+    sub_ranges << sub_range2 if sub_range2 and not empty_range?(sub_range2)
     return sub_ranges
   end
 
   def overlaps_with_range?(range)
     return false if @ranges.empty?
-    return false if range.begin > @ranges.last.end # larger than maximum
-    return false if range.end < @ranges.first.begin # smaller than minimum
+    return false if range.begin && @ranges.last.end && range.begin > @ranges.last.end # larger than maximum
+    return false if range.end && @ranges.first.begin && range.end < @ranges.first.begin # smaller than minimum
     return true
   end
 
@@ -234,15 +242,21 @@ class MultiRange
   end
 
   def empty_range?(range)
-    range.begin > range.end || (range.begin == range.end && range.exclude_end?)
+    return false if range.begin == nil
+    return false if range.end == nil
+    return range.begin > range.end || (range.begin == range.end && range.exclude_end?)
   end
 
   def range_with_larger_start(range1, range2)
+    return range2 if range1.begin == nil
+    return range1 if range2.begin == nil
     return range1 if range1.begin > range2.begin
     return range2
   end
 
   def range_with_smaller_end(range1, range2)
+    return range2 if range1.end == nil
+    return range1 if range2.end == nil
     return range1 if range1.end < range2.end
     return range2 if range1.end > range2.end
     return range1 if range1.exclude_end?

data/lib/patches/patch_interval_tree.rb

@@ -0,0 +1,97 @@
+module Patches
+  module PatchIntervalTree
+    module ForTree
+      def divide_intervals(intervals)
+        return nil if intervals.empty?
+        x_center = center(intervals)
+        s_center = []
+        s_left = []
+        s_right = []
+
+        intervals.each do |k|
+          case
+          when k.end && k.end != Float::INFINITY && k.end.to_r < x_center
+            s_left << k
+          when k.begin && k.begin.to_r > x_center
+            s_right << k
+          else
+            s_center << k
+          end
+        end
+
+        IntervalTree::Node.new(x_center, s_center, divide_intervals(s_left), divide_intervals(s_right))
+      end
+
+      def search(query, options = {})
+        options = IntervalTree::Tree::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(top_node, query, [], options[:unique])
+        end
+          .sort_by{|x| [x.begin || -Float::INFINITY, x.end || Float::INFINITY] }
+      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.begin, range.end)
+          end
+        end
+      end
+
+      def center(intervals)
+        min_val = intervals.map(&:begin).compact.min
+        max_val = intervals.map(&:end).compact.max
+        return min_val * 2 if max_val == nil
+        return max_val / 2 if min_val == nil
+        return (min_val.to_r + max_val.to_r) / 2
+      end
+    end
+
+    module ForNode
+      def search_s_center(query)
+        s_center.select do |range|
+          # when this range is smaller than and not overlaps with `query`
+          #      range          query
+          #   |---------|    |---------|
+          if query.begin and range.end
+            next false if query.begin > range.end
+            next false if query.begin == range.end and range.exclude_end?
+          end
+
+          # when this range is larger than and not overlaps with `query`
+          #      query          range
+          #   |---------|    |---------|
+          if query.end and range.begin
+            next false if query.end < range.begin
+            next false if query.end == range.begin and query.exclude_end?
+          end
+
+          next true
+        end
+      end
+    end
+  end
+end
+
+module IntervalTree
+  class Tree
+    prepend Patches::PatchIntervalTree::ForTree
+  end
+
+  class Node
+    prepend Patches::PatchIntervalTree::ForNode
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_range
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - khiav reoy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-07 00:00:00.000000000 Z
+date: 2023-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -121,6 +121,7 @@ files:
 - gemfiles/Gemfile
 - lib/multi_range.rb
 - lib/multi_range/version.rb
+- lib/patches/patch_interval_tree.rb
 - multi_range.gemspec
 homepage: https://github.com/khiav223577/multi_range
 licenses: