multi_range 2.2.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d67638eab33c3a377488c4fb32c0e33f8385eab6d743d3f37f7476f20f94b97
-  data.tar.gz: 198971530fc824d45690f92b4c45013a8bd58ddb204e9a84a2971bdda20ed1fb
+  metadata.gz: fa2432c646c4156bab9056f7c92820959bb4d856940737835b7b8785cd2dd771
+  data.tar.gz: 0e1da8c9c9332444d5a65573be13415d07121ec30d8625ad7e1a5655f3496d41
 SHA512:
-  metadata.gz: 752b8eff047ed5b7dded92afbdf612fc0e2f63b119fba141421d07e2983d8fd9aa79914cb60e890414362d6e84497b2737145dc18166299f772a74e74ffb231d
-  data.tar.gz: 48e47778eaf9066be35983239fdf073e011010ba2555d1a2b4a48d4c507db7e9d419a64503f469a54e16363be61e5e300977f364d02c91f12d56ad3028ef315f
+  metadata.gz: 80e4731b7df2487a3aad29028ff370f833c3d4b993e6aafb14aeeefb9cb505bdfbe7663553907a9725fcf11f626d43d6b30342338eafed40d2ec9c22bcb53363
+  data.tar.gz: f70e7893acf075f2a74da10692206c71a7785812d086a75ccfa533b526eeb47f199585c38e4b82e3f24a4b9ecbeb2d490b0ab59e9424981e3b4a0db4d49f1a5a

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 ## Change Log
 
-### [v2.2.0](https://github.com/khiav223577/multi_range/compare/v1.3.2...v2.2.0) 2023/10/21
+### [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)
+
+### [v2.2.0](https://github.com/khiav223577/multi_range/compare/v2.1.1...v2.2.0) 2023/10/21
 - [#34](https://github.com/khiav223577/multi_range/pull/34) Fix: wrong empty range check which causes some differences to be dropped  (@khiav223577)
 - [#33](https://github.com/khiav223577/multi_range/pull/33) Fix: result should not be empty when intersection with inclusive range with one element (@khiav223577)
 - [#32](https://github.com/khiav223577/multi_range/pull/32) Drop the support of ruby 2.2 (@khiav223577)

data/lib/multi_range/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class MultiRange
-  VERSION = '2.2.1'
+  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" \
@@ -27,7 +28,8 @@ class MultiRange
       @ranges = ranges.ranges
       @is_float = ranges.is_float?
     else
-      @ranges = ranges.map{|s| s.is_a?(Numeric) ? s..s : s }.sort_by(&:begin).freeze
+      ranges = [ranges] if !ranges.is_a?(Array)
+      @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
@@ -44,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
@@ -60,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|
@@ -95,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
@@ -111,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)
@@ -190,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
@@ -202,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
 
@@ -233,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.1
+  version: 2.2.3
 platform: ruby
 authors:
 - khiav reoy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-28 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: