interval_notation 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a937def556100b39f5ceda9350746e0bd4d8ecb7
-  data.tar.gz: 41f639a8c41a16cbecb65dce7bfa8862429196da
+  metadata.gz: 4160164096cbfcc4f171ce43a2c460fb1d3df70c
+  data.tar.gz: 3b4f604be240d5d714bd1eacfc3b158c41de7287
 SHA512:
-  metadata.gz: ef63264b1222cc9014f420b3dcf35528dec369db7d2515ac6ff7fa66e96714ec1b091e51a8d7c77c5dd9052b2856d6332adcf92c9a117f71bd67bb1dcbb7ac27
-  data.tar.gz: f453f8d84ed5900c06713ede45ef045e0fe562ab8e469e4522db0be2daedb4aad1c593dd1f3970d5cdc40793942ea40ef412a809bd325a3f1e27e95894f2b566
+  metadata.gz: a5988e37f501ec499213a5eee17c63012c99d5d55df1f3e076e62bab39f11b03f3a5b60958e109b8b07237499bab442bb0688f3da0a176da827d3f487fa62fb8
+  data.tar.gz: c89451349d28a973a45ec6ed7017be6502be18bb9e72745031d638b2763aaa825d57266abc708696e8c5fbb7bc5ab0eee44bd2ee9a1038beb9082ef994d5fe4d

data/benchmark/benchmark.rb

@@ -0,0 +1,51 @@
+require 'benchmark'
+require_relative '../lib/interval_notation'
+include IntervalNotation::Syntax::Long
+
+num_intervals_to_unite = 10_000
+srand(13)
+random_intervals_1 = num_intervals_to_unite.times.map{|i| 2.times.map{ 0.3*i + rand }.sort }.reject{|a,b| a==b }.map{|a,b| closed_closed(a,b)  }
+random_intervals_2 = num_intervals_to_unite.times.map{|i| 2.times.map{ 3000 + 0.3*i + rand }.sort }.reject{|a,b| a==b }.map{|a,b| closed_closed(a,b)  }
+
+N = 10
+M = 100_000
+
+dispersed_interval_1 = IntervalNotation::Operations.union(random_intervals_1)
+dispersed_interval_2 = IntervalNotation::Operations.union(random_intervals_2)
+
+singular_interval_1 = closed_closed(500 + rand, 1000 + rand)
+singular_interval_2 = closed_closed(700 + rand, 1700 + rand)
+
+Benchmark.bm do |benchmark_report|
+
+  benchmark_report.report("old intersection check for dispersed intervals to singular interval (#{N} times)") do
+    N.times do
+      dispersed_interval_1.intersection(singular_interval_1).empty?
+    end
+  end
+
+  benchmark_report.report("intersect? dispersed intervals to singular interval (#{M} times)") do
+    M.times do
+      dispersed_interval_1.intersect?(singular_interval_1)
+    end
+  end
+
+  benchmark_report.report("intersect? singular interval to dispersed intervals (#{M} times)") do
+    M.times do
+      singular_interval_1.intersect?(dispersed_interval_1)
+    end
+  end
+
+  benchmark_report.report("intersect? two dispersed intervals (#{M} times)") do
+    M.times do
+      dispersed_interval_2.intersect?(dispersed_interval_1)
+      dispersed_interval_1.intersect?(dispersed_interval_2)
+    end
+  end
+
+  benchmark_report.report("Unite #{num_intervals_to_unite} intervals (#{N} times)") do
+    N.times do
+      IntervalNotation::Operations.union(random_intervals_1)
+    end
+  end
+end

data/lib/interval_notation/basic_intervals.rb

@@ -47,6 +47,11 @@ module IntervalNotation
       def singular_point?; false; end
       def hash; [@from, @to, include_from?, include_to?].hash; end;
       def eql?(other); other.class.equal?(self.class) && from.eql?(other.from) && to.eql?(other.to); end
+
+      # include position and its vicinity
+      def deep_include_position?(pos)
+        from < pos && pos < to
+      end
     end
 
     class OpenOpenInterval
@@ -190,6 +195,11 @@ module IntervalNotation
       def interval_boundaries(interval_index)
         BoundaryPoint.new(from, true, nil, interval_index, false)
       end
+
+      # include position and its vicinity (point can't include vicinity of a position)
+      def deep_include_position?(pos)
+        false
+      end
     end
 
     def self.interval_by_boundary_inclusion(include_from, from, include_to, to)

data/lib/interval_notation/interval_set.rb

@@ -53,10 +53,15 @@ module IntervalNotation
     # Checks whether an interval set contains certain position.
     # Operation complexity is O(ln N), where N is a number of contiguous regions in an interval set
     def include_position?(value)
-      interval = @intervals.bsearch{|interv| interv.to >= value }
+      interval = @intervals.bsearch{|interv| value <= interv.to }
       interval && interval.include_position?(value)
     end
 
+    def deep_include_position?(value)
+      interval = @intervals.bsearch{|interv| value <= interv.to }
+      interval && interval.deep_include_position?(value)
+    end
+
     # Checks whether an interval set contains another interval set. Alias: +#include?+
     def contain?(other)
       self.intersection(other) == other
@@ -69,10 +74,81 @@ module IntervalNotation
     end
     alias covered_by? contained_by?
 
-    # TODO: optimize if possible.
-    # Checks whether an interval set intersects another interval set. Alias: +#intersect?+
+
+    def bsearch_last_not_meeting_condition(arr)
+      found_ind = (0...arr.size).bsearch{|idx| yield(arr[idx]) } # find first not meeting condition
+      if found_ind
+        found_ind == 0 ? nil : arr[found_ind - 1]
+      else
+        arr.last
+      end
+    end
+    private :bsearch_last_not_meeting_condition
+
+    # Checks intersection with a single (basic) interval in a O(log N) time.
+    def intersect_single_interval?(interval) # :nodoc:
+      from = interval.from
+      to = interval.to
+
+      # If from is against a singular point, then ignore it.
+      #..............................pos............................
+      # interval_left_to_pos...................interval_right_to_pos
+      #
+      #..............................pos.............................
+      # interval_left_to_pos........point.......interval_right_to_pos
+      # reversed_intervals = @intervals.reverse
+
+      # find last interval +interv+ such that (interv.from < from)
+      left_to_start  = bsearch_last_not_meeting_condition(@intervals){|interv| interv.from >= from }
+      # find last interval +interv+ such that (interv.from < to)
+      left_to_finish = bsearch_last_not_meeting_condition(@intervals){|interv| interv.from >= to }
+
+      # find first interval +interv+ such that from < interv.to
+      right_to_start  = @intervals.bsearch{|interv| from < interv.to }
+      # find first interval +interv+ such that to < interv.to
+      right_to_finish = @intervals.bsearch{|interv| to < interv.to }
+
+      # If +from+ or +to+ is included in an interval, it is either
+      # a) deeply immersed (i.e. lie within interval with its vicinity) in it or
+      # b) just adjoins an interval(then it matters, whether it's included)
+      # If neither of points lie on an interval set, then it can still intersect an interval
+      # if +from+ and +to+ points are between different pairs of intervals.
+      # Problems come with singular points. If one is against interval's from or to,
+      # it is either treated as included, or is a deleted point going as either left or right boundary.
+      # It's hard to distinguish which boundary it is, so we just ignore a point if it is against +from+ or +to+
+      # (see a trick above) and treat intervals going the same side from a point as non-intersecting it.
+      # If no singular point exist against +from+ and +to+ positions, the non-overlapping interval have both
+      # +left_to_start == left_to_finish+  and  +right_to_start == right_to_finish+.
+      # Otherwise +interval+ overlap (cover) some interval.
+      include_position?(from) && (deep_include_position?(from) || interval.include_from?) ||
+      include_position?(to) && (deep_include_position?(to) || interval.include_to?) ||
+      !(left_to_start == left_to_finish || right_to_start == right_to_finish)
+    end
+    protected :intersect_single_interval?
+
+    # Checks whether intervals intersect in O(M*log N) where M and N are interval set sizes
+    def intersect_n_log_n?(other)
+      # sz_1 = num_connected_components + 2
+      # sz_2 = other.num_connected_components + 2
+      # if sz_1*Math.log2(sz_2) < sz_2 * Math.log2(sz_1)
+
+      # each of N intervals intersection check takes log(M). We prefer to take small N, large M than vice-versa
+      if @intervals.size < other.intervals.size
+        @intervals.any? do |segment|
+          other.intersect_single_interval?(segment)
+        end
+      else
+        other.intervals.any? do |segment|
+          intersect_single_interval?(segment)
+        end
+      end
+    end
+    protected :intersect_n_log_n?
+
+    # Checks whether an interval set intersects another interval set. Alias: +#overlap?+
     def intersect?(other)
-      ! intersection(other).empty?
+      intersect_n_log_n?(other) # ToDo: balance different implementations for different interval set sizes
+      # ! intersection(other).empty? # Simplest and too slow implementation
     end
     alias overlap? intersect?
 

data/lib/interval_notation/version.rb

@@ -1,3 +1,3 @@
 module IntervalNotation
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/basic_intervals_spec.rb

@@ -1,4 +1,4 @@
-require 'interval_notation'
+require_relative '../lib/interval_notation'
 
 include IntervalNotation
 include IntervalNotation::BasicIntervals

data/spec/intersection_spec.rb

@@ -0,0 +1,275 @@
+require_relative 'spec_helper'
+
+describe IntervalNotation do
+  describe IntervalSet do
+
+    describe '#intersection'  do
+      {
+        [oo(1,3), oo(1,3)] => oo(1,3),
+        [oo(1,3), oc(1,3)] => oo(1,3),
+        [oo(1,3), co(1,3)] => oo(1,3),
+        [oo(1,3), cc(1,3)] => oo(1,3),
+
+        [pt(2), pt(3)] => Empty,
+        [pt(3), pt(3)] => pt(3),
+        [pt(3)|pt(5), pt(3)|pt(5)] => pt(3)|pt(5),
+        [pt(3)|pt(5), pt(3)|pt(7)] => pt(3),
+
+        [oo(1,3)|oo(5,7), oo(1,3)|oo(5,7)] => oo(1,3)|oo(5,7),
+        [oo(1,3)|co(5,7), oo(1,3)|oo(5,7)] => oo(1,3)|oo(5,7),
+        [oo(1,3)|oo(5,7), oo(1,3)|co(5,7)] => oo(1,3)|oo(5,7),
+        [oo(1,3)|co(5,7), oo(1,3)|co(5,7)] => oo(1,3)|co(5,7),
+
+        [oo(1,3)|oo(3,5), oo(1,3)] => oo(1,3),
+        [oo(1,3)|oo(3,5), oo(1,3)|oo(7,9)] => oo(1,3),
+        [oo(1,3)|oo(3,5), oo(3,5)] => oo(3,5),
+        [oo(1,3)|oo(3,5), oo(1,3)|oo(3,5)] => oo(1,3)|oo(3,5),
+
+        [oo(1,3), oo(4,5)] => Empty,
+        [oo(1,3), oo(3,5)] => Empty,
+        [oo(1,3), co(3,5)] => Empty,
+        [oc(1,3), oo(3,5)] => Empty,
+        [oc(1,3), co(3,5)] => pt(3),
+
+        [oo(1,3), oo(0,5)] => oo(1,3),
+        [oc(1,3), oo(0,5)] => oc(1,3),
+        [co(1,3), oo(0,5)] => co(1,3),
+        [cc(1,3), oo(0,5)] => cc(1,3),
+
+        [oo(1,3), oo(1,5)] => oo(1,3),
+        [co(1,3), oo(1,5)] => oo(1,3),
+        [oc(1,3), oo(1,5)] => oc(1,3),
+        [cc(1,3), oo(1,5)] => oc(1,3),
+        [co(3,5), oo(1,5)] => co(3,5),
+
+        [oo(1,3), oo(2,5)] => oo(2,3),
+        [oc(1,3), oo(2,5)] => oc(2,3),
+        [oo(1,3), co(2,5)] => co(2,3),
+        [oc(1,3), co(2,5)] => cc(2,3),
+
+        [oo(1,3), pt(2)] => pt(2),
+        [oo(1,3), pt(3)] => Empty,
+        [oc(1,3), pt(3)] => pt(3),
+        [oo(1,3), pt(4)] => Empty,
+        [oc(1,3), pt(4)] => Empty,
+
+        [oo(1,3)|oo(3,5), oo(2,3)|oo(3,7)] => oo(2,3)|oo(3,5),
+        [oo(1,3)|oo(3,5), oo(2,7)] => oo(2,3)|oo(3,5),
+
+        [oo(2,6), oo(1,3)|co(5,7)] => oo(2,3)|co(5,6),
+        [oo(1,6), oo(1,3)|co(5,7)] => oo(1,3)|co(5,6),
+        [oo(0,6), oo(1,3)|co(5,7)] => oo(1,3)|co(5,6),
+        [oo(0,6), oo(1,3)|co(5,6)] => oo(1,3)|co(5,6),
+
+
+      }.each do |intervals, answer|
+        it "IntervalNotation::Operations.intersection(#{intervals.map(&:to_s).join(',')} should equal #{answer}" do
+          expect( IntervalNotation::Operations.intersection(intervals) ).to eq answer
+        end
+
+        it "IntervalNotation::Operations.intersection(#{intervals.map(&:to_s).join(',')} should equal consequent unite: #{intervals.map(&:to_s).join('&')}" do
+          expect( IntervalNotation::Operations.intersection(intervals) ).to eq intervals.inject(&:intersection)
+        end
+
+        if intervals.size == 2
+          interval_1, interval_2 = intervals
+          it "#{interval_1} & #{interval_2} should equal #{answer}" do
+            expect( interval_1.intersection(interval_2) ).to eq answer
+          end
+        end
+      end
+
+      {
+        [oo(1,3), oo(1,3), oo(1,3)] => oo(1,3),
+        [oo(1,3), cc(1,3), oo(1,3)] => oo(1,3),
+        [oo(1,3), cc(0,5), cc(1,3)] => oo(1,3),
+        [cc(1,5), cc(3,7), cc(1,3)|cc(5,7)] => pt(3)|pt(5),
+        [oo(1,5), oo(3,7), oo(1,3)|oo(5,7)] => Empty,
+        [oo(1,5), oc(1,3), co(3,5)] => pt(3)
+      }.each do |intervals, answer|
+        it "#{intervals.map(&:to_s).join('&')} should equal #{answer}" do
+          expect( IntervalNotation::Operations.intersection(intervals) ).to eq answer
+        end
+      end
+    end
+
+    # Very extensive automatic testing
+    describe '#intersect?', too_extensive_testing: true, slow: true do
+      examples = []
+      examples += [
+        [[oo(1,3)|oo(4,6)|oo(8,10),  oo(3,8)], true],
+        [[oo(1,3)|oo(4,6)|oo(8,10)|cc(12,14) ,  oo(3,8)], true],
+        [[oo(1,3)|cc(4,6)|oo(8,10),  oo(3,8)], true],
+        [[oo(1,3)|pt(5)|oo(8,10),  oo(3,8)], true],
+        [[oo(1,3)|oo(8,10),  oo(3,8)], false],
+        [[cc(1,3)|cc(8,10),  oo(3,8)], false],
+
+        [[oo(1,3)|oo(8,10),  cc(3,8)], false],
+        [[co(1,3)|oc(8,10),  cc(3,8)], false],
+        [[oc(1,3)|oo(8,10),  cc(3,8)], true],
+        [[oo(1,3)|co(8,10),  cc(3,8)], true],
+        [[oc(1,3)|co(8,10),  cc(3,8)], true],
+        [[cc(1,3)|cc(8,10),  cc(3,8)], true],
+
+        [[oc(1,3)|oo(8,10),  co(3,8)], true],
+        [[oc(1,3)|cc(8,10),  co(3,8)], true],
+        [[oo(1,3)|oo(8,10),  co(3,8)], false],
+        [[oo(1,3)|cc(8,10),  co(3,8)], false],
+
+        [[oo(1,3)|oo(8,10),  oc(3,8)], false],
+        [[oo(1,3)|oc(8,10),  oc(3,8)], false],
+        [[oo(1,3)|co(8,10),  oc(3,8)], true],
+        [[oo(1,3)|cc(8,10),  oc(3,8)], true],
+
+        [[oo(1,3)|oo(8,10)|cc(12,14),  oo(3,8)], false],
+        [[oo(1,3)|oo(8,10)|cc(12,14),  cc(3,8)], false],
+        [[oc(1,3)|oo(8,10)|cc(12,14),  cc(3,8)], true],
+        [[oc(1,3)|oo(8,10)|cc(12,14),  co(3,8)], true],
+        [[oo(1,3)|co(8,10)|cc(12,14),  cc(3,8)], true],
+        [[oo(1,3)|co(8,10)|cc(12,14),  oc(3,8)], true],
+      ]
+      examples += interval_for_each_boundary_type(1,3).flat_map{|interval|
+        [
+          [[interval, pt(2)], true],
+          [[interval, pt(4)], false],
+        ]
+      }
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 1,3, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 1,2, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 2,3, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 1.5,2.5, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 2,4, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 0,2, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 0,4, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 0,4, true)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, 4,5, false)
+      examples += pairs_of_intervals_for_each_boundary_with_answer(1,3, -1,0, false)
+
+      examples += [
+        [[oo(1,3), oo(3,4)], false],
+        [[oo(1,3), oc(3,4)], false],
+        [[oo(1,3), co(3,4)], false],
+        [[oo(1,3), cc(3,4)], false],
+        [[oo(1,3), oo(0,1)], false],
+        [[oo(1,3), oc(0,1)], false],
+        [[oo(1,3), co(0,1)], false],
+        [[oo(1,3), cc(0,1)], false],
+        [[oo(1,3), pt(3)], false],
+        [[oo(1,3), pt(1)], false],
+
+        [[co(1,3), oo(3,4)], false],
+        [[co(1,3), oc(3,4)], false],
+        [[co(1,3), co(3,4)], false],
+        [[co(1,3), cc(3,4)], false],
+        [[co(1,3), oo(0,1)], false],
+        [[co(1,3), oc(0,1)], true],
+        [[co(1,3), co(0,1)], false],
+        [[co(1,3), cc(0,1)], true],
+        [[co(1,3), pt(1)], true],
+        [[co(1,3), pt(3)], false],
+
+        [[oc(1,3), oo(3,4)], false],
+        [[oc(1,3), oc(3,4)], false],
+        [[oc(1,3), co(3,4)], true],
+        [[oc(1,3), cc(3,4)], true],
+        [[oc(1,3), oo(0,1)], false],
+        [[oc(1,3), oc(0,1)], false],
+        [[oc(1,3), co(0,1)], false],
+        [[oc(1,3), cc(0,1)], false],
+        [[oc(1,3), pt(1)], false],
+        [[oc(1,3), pt(3)], true],
+
+        [[cc(1,3), oo(3,4)], false],
+        [[cc(1,3), oc(3,4)], false],
+        [[cc(1,3), co(3,4)], true],
+        [[cc(1,3), cc(3,4)], true],
+        [[cc(1,3), oo(0,1)], false],
+        [[cc(1,3), oc(0,1)], true],
+        [[cc(1,3), co(0,1)], false],
+        [[cc(1,3), cc(0,1)], true],
+        [[cc(1,3), pt(1)], true],
+        [[cc(1,3), pt(3)], true],
+
+
+        [[oo(1,3), oo(4,5)], false],
+        [[cc(1,3), cc(4,5)], false],
+        [[cc(1,3), pt(2)|cc(4,5)], true],
+        [[co(1,3), pt(2)|cc(4,5)], true],
+        [[cc(1,3), pt(3)|cc(4,5)], true],
+        [[co(1,3), pt(3)|cc(4,5)], false],
+        [[cc(1,3), cc(4,5)|pt(6)], false],
+      ]
+
+      # Enable to add extensive tests for #intersect? testing
+      examples = examples.flat_map{|(interval_1,interval_2), ans|
+        [
+          [[interval_1, interval_2], ans],
+          [[interval_1 | pt(100), interval_2], ans],
+          [[interval_1, interval_2 | pt(-100)], ans],
+          [[interval_1 | pt(100), interval_2 | pt(-100)], ans],
+        ] +
+        interval_for_each_boundary_type(-150, -100).flat_map {|interval_3| # distant intervals doesn't interfere intersection property
+          [
+            [[interval_1, interval_2 | interval_3], ans],
+            [[interval_1 | interval_3, interval_2], ans]
+          ]
+        } +
+        interval_for_each_boundary_type(100, 150).flat_map {|interval_3|
+          [
+            [[interval_1, interval_2 | interval_3], ans],
+            [[interval_1 | interval_3, interval_2], ans]
+          ]
+        } +
+        interval_for_each_boundary_type(-150, -100).flat_map {|interval_3|
+          interval_for_each_boundary_type(100, 150).flat_map {|interval_4|
+            [
+              [[interval_1, interval_2|interval_3|interval_4], ans],
+              [[interval_1|interval_3|interval_4, interval_2], ans],
+              [[interval_1|interval_3, interval_2|interval_4], ans],
+              [[interval_1|interval_4, interval_2|interval_3], ans],
+            ]
+          }
+        }
+      }
+
+      examples += [
+        [[lt(10), oo(1,3)], true],
+        [[lt(10), oo(11,12)], false],
+        [[lt(10), oo(10,11)], false],
+        [[le(10), co(10,11)], true],
+        [[le(10), le(9)], true],
+        [[le(10), le(11)], true],
+        [[le(10), ge(11)], false],
+        [[le(10), ge(10)], true],
+        [[le(10), gt(10)], false],
+        [[le(10), gt(11)], false],
+      ]
+      examples += examples.flat_map{|(interval_1, interval_2), ans|
+        [interval_1, interval_2]
+      }.uniq.flat_map{|interval|
+        [
+          [[interval, Empty], false],
+          [[interval, R], interval != Empty],
+        ]
+      }
+
+      examples.each do |(interval_1, interval_2), answer|
+        if answer
+          it "#{interval_1}.intersect?(#{interval_2}) should be truthy" do
+            expect( interval_1.intersect?(interval_2) ).to be_truthy
+          end
+          it "#{interval_2}.intersect?(#{interval_1}) should be truthy" do
+            expect( interval_2.intersect?(interval_1) ).to be_truthy
+          end
+        else
+          it "#{interval_1}.intersect?(#{interval_2}) should be falsy" do
+            expect( interval_1.intersect?(interval_2) ).to be_falsy
+          end
+          it "#{interval_2}.intersect?(#{interval_1}) should be falsy" do
+            expect( interval_2.intersect?(interval_1) ).to be_falsy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/interval_notation_spec.rb

@@ -1,21 +1,4 @@
-require 'interval_notation'
-
-include IntervalNotation
-include IntervalNotation::BasicIntervals
-include IntervalNotation::Syntax::Short
-
-def each_combination_of_intervals(intervals)
-  basic_intervals = intervals.flat_map(&:intervals)
-  (1..basic_intervals.size / 2).each do |chunk_1_size|
-    indices = basic_intervals.size.times.to_a
-    indices.combination(chunk_1_size).each do |chunk_1_indices|
-      chunk_2_indices = indices - chunk_1_indices
-      chunk_1 = IntervalNotation::Operations.union(chunk_1_indices.map{|i| IntervalSet.new([basic_intervals[i]]) })
-      chunk_2 = IntervalNotation::Operations.union(chunk_2_indices.map{|i| IntervalSet.new([basic_intervals[i]]) })
-      yield chunk_1, chunk_2
-    end
-  end
-end
+require_relative 'spec_helper'
 
 describe IntervalNotation do
   describe IntervalSet do
@@ -53,14 +36,14 @@ describe IntervalNotation do
         [OpenOpenInterval.new(-Float::INFINITY, 1), Point.new(0)],
         [OpenOpenInterval.new(-Float::INFINITY, 1), Point.new(1)],
         [Point.new(2), OpenOpenInterval.new(-Float::INFINITY, 1)],
-        
+
         [Point.new(11), OpenOpenInterval.new(10, Float::INFINITY)],
         [Point.new(10), OpenOpenInterval.new(10, Float::INFINITY)],
         [OpenOpenInterval.new(10, Float::INFINITY), Point.new(11)],
         [OpenOpenInterval.new(10, Float::INFINITY), Point.new(9)],
         [OpenOpenInterval.new(10, Float::INFINITY), OpenOpenInterval.new(9,13)],
         [OpenOpenInterval.new(10, Float::INFINITY), OpenOpenInterval.new(11,13)],
-        
+
         [OpenOpenInterval.new(1,3), Point.new(3)],
         [OpenOpenInterval.new(1,3), ClosedOpenInterval.new(3,4)],
         [OpenClosedInterval.new(1,3), ClosedOpenInterval.new(3,4)],
@@ -201,7 +184,7 @@ describe IntervalNotation do
       [oo(1,3), oo(4,5)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(4,5)]),
       [oo(3,5), oo(1,3)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(3,5)]),
       [oo(4,5), oo(1,3)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(4,5)]),
-      
+
       [oo(1,3), oo(3,5), cc(7,9)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(3,5), ClosedClosedInterval.new(7,9)]),
       [oo(1,3), oo(3,5), oo(5,7)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(3,5), OpenOpenInterval.new(5,7)]),
       [oo(1,3), cc(7,9), oo(3,5)] => IntervalSet.new([OpenOpenInterval.new(1,3), OpenOpenInterval.new(3,5), ClosedClosedInterval.new(7,9)]),
@@ -259,13 +242,13 @@ describe IntervalNotation do
       [ge(3), co(1,3)] => ge(1),
       [ge(3), oc(1,3)] => gt(1),
       [ge(3), cc(1,3)] => ge(1),
-      
+
       [ge(3), oo(2,5)] => gt(2),
       [ge(3), co(2,5)] => ge(2),
       [ge(3), co(4,5)] => ge(3),
       [ge(3), oo(4,5)] => ge(3),
       [ge(3), oo(3,5)] => ge(3),
-      [ge(3), co(3,5)] => ge(3),     
+      [ge(3), co(3,5)] => ge(3),
       [ge(3), pt(2)] => IntervalSet.new([Point.new(2), ClosedOpenInterval.new(3, Float::INFINITY)]),
       [ge(3), pt(3)] => ge(3),
       [ge(3), pt(4)] => ge(3),
@@ -314,7 +297,7 @@ describe IntervalNotation do
     }).merge({ # too long hash to be one hash
       # non-adjacent
       [oo(1,3), oo(5,6)] => IntervalSet.new([OpenOpenInterval.new(1, 3), OpenOpenInterval.new(5, 6)]),
-      
+
       # adjacent
       [oo(1,3), oo(3,6)] => IntervalSet.new([OpenOpenInterval.new(1, 3), OpenOpenInterval.new(3, 6)]),
       [oo(1,3), co(3,6)] => oo(1,6),
@@ -420,97 +403,6 @@ describe IntervalNotation do
     end
   end
 
-
-  describe '#intersection'  do
-    {
-      [oo(1,3), oo(1,3)] => oo(1,3),
-      [oo(1,3), oc(1,3)] => oo(1,3),
-      [oo(1,3), co(1,3)] => oo(1,3),
-      [oo(1,3), cc(1,3)] => oo(1,3),
-
-      [pt(2), pt(3)] => Empty,
-      [pt(3), pt(3)] => pt(3),
-      [pt(3)|pt(5), pt(3)|pt(5)] => pt(3)|pt(5),
-      [pt(3)|pt(5), pt(3)|pt(7)] => pt(3),
-
-      [oo(1,3)|oo(5,7), oo(1,3)|oo(5,7)] => oo(1,3)|oo(5,7),
-      [oo(1,3)|co(5,7), oo(1,3)|oo(5,7)] => oo(1,3)|oo(5,7),
-      [oo(1,3)|oo(5,7), oo(1,3)|co(5,7)] => oo(1,3)|oo(5,7),
-      [oo(1,3)|co(5,7), oo(1,3)|co(5,7)] => oo(1,3)|co(5,7),
-
-      [oo(1,3)|oo(3,5), oo(1,3)] => oo(1,3),
-      [oo(1,3)|oo(3,5), oo(1,3)|oo(7,9)] => oo(1,3),
-      [oo(1,3)|oo(3,5), oo(3,5)] => oo(3,5),
-      [oo(1,3)|oo(3,5), oo(1,3)|oo(3,5)] => oo(1,3)|oo(3,5),
-
-      [oo(1,3), oo(4,5)] => Empty,
-      [oo(1,3), oo(3,5)] => Empty,
-      [oo(1,3), co(3,5)] => Empty,
-      [oc(1,3), oo(3,5)] => Empty,
-      [oc(1,3), co(3,5)] => pt(3),
-      
-      [oo(1,3), oo(0,5)] => oo(1,3),
-      [oc(1,3), oo(0,5)] => oc(1,3),
-      [co(1,3), oo(0,5)] => co(1,3),
-      [cc(1,3), oo(0,5)] => cc(1,3),
-
-      [oo(1,3), oo(1,5)] => oo(1,3),
-      [co(1,3), oo(1,5)] => oo(1,3),
-      [oc(1,3), oo(1,5)] => oc(1,3),
-      [cc(1,3), oo(1,5)] => oc(1,3),
-      [co(3,5), oo(1,5)] => co(3,5),
-
-      [oo(1,3), oo(2,5)] => oo(2,3),
-      [oc(1,3), oo(2,5)] => oc(2,3),
-      [oo(1,3), co(2,5)] => co(2,3),
-      [oc(1,3), co(2,5)] => cc(2,3),
-
-      [oo(1,3), pt(2)] => pt(2),
-      [oo(1,3), pt(3)] => Empty,
-      [oc(1,3), pt(3)] => pt(3),
-      [oo(1,3), pt(4)] => Empty,
-      [oc(1,3), pt(4)] => Empty,
-
-      [oo(1,3)|oo(3,5), oo(2,3)|oo(3,7)] => oo(2,3)|oo(3,5),
-      [oo(1,3)|oo(3,5), oo(2,7)] => oo(2,3)|oo(3,5),
-
-      [oo(2,6), oo(1,3)|co(5,7)] => oo(2,3)|co(5,6),
-      [oo(1,6), oo(1,3)|co(5,7)] => oo(1,3)|co(5,6),
-      [oo(0,6), oo(1,3)|co(5,7)] => oo(1,3)|co(5,6),
-      [oo(0,6), oo(1,3)|co(5,6)] => oo(1,3)|co(5,6),
-
-
-    }.each do |intervals, answer|
-      it "IntervalNotation::Operations.intersection(#{intervals.map(&:to_s).join(',')} should equal #{answer}" do
-        expect( IntervalNotation::Operations.intersection(intervals) ).to eq answer
-      end
-
-      it "IntervalNotation::Operations.intersection(#{intervals.map(&:to_s).join(',')} should equal consequent unite: #{intervals.map(&:to_s).join('&')}" do
-        expect( IntervalNotation::Operations.intersection(intervals) ).to eq intervals.inject(&:intersection)
-      end
-
-      if intervals.size == 2
-        interval_1, interval_2 = intervals
-        it "#{interval_1} & #{interval_2} should equal #{answer}" do
-          expect( interval_1.intersection(interval_2) ).to eq answer
-        end
-      end
-    end
-
-    {
-      [oo(1,3), oo(1,3), oo(1,3)] => oo(1,3),
-      [oo(1,3), cc(1,3), oo(1,3)] => oo(1,3),
-      [oo(1,3), cc(0,5), cc(1,3)] => oo(1,3),
-      [cc(1,5), cc(3,7), cc(1,3)|cc(5,7)] => pt(3)|pt(5),
-      [oo(1,5), oo(3,7), oo(1,3)|oo(5,7)] => Empty,
-      [oo(1,5), oc(1,3), co(3,5)] => pt(3)
-    }.each do |intervals, answer|
-      it "#{intervals.map(&:to_s).join('&')} should equal #{answer}" do
-        expect( IntervalNotation::Operations.intersection(intervals) ).to eq answer
-      end
-    end
-  end
-
   describe '#subtract' do
     {
       [oo(1,5)|oo(6,8),(oo(1,5))] => oo(6,8),
@@ -663,7 +555,7 @@ describe IntervalNotation do
     end
   end
 
-  describe '#contain? / contained_by?' do 
+  describe '#contain? / contained_by?' do
     {
       [oo(1,3), oo(1,2)] => true,
       [oo(1,3), oo(1.5,2.5)] => true,
@@ -700,53 +592,13 @@ describe IntervalNotation do
     end
   end
 
-  describe '#intersect?' do 
-    {
-      [oo(1,3), oo(1,2)] => true,
-      [oo(1,3), oo(1,3)] => true,
-      [oo(1,3), cc(1.5,2.5)] => true,
-      
-      [oo(1,3), oo(3,4)] => false,
-      [oc(1,3), oo(3,4)] => false,
-      [oo(1,3), co(3,4)] => false,
-      [oc(1,3), co(3,4)] => true,
-
-      [oo(1,3), oo(4,5)] => false,
-      [cc(1,3), cc(4,5)] => false,
-      [cc(1,3), pt(2)|cc(4,5)] => true,
-      [co(1,3), pt(2)|cc(4,5)] => true,
-      [cc(1,3), pt(3)|cc(4,5)] => true,
-      [co(1,3), pt(3)|cc(4,5)] => false,
-      [cc(1,3), cc(4,5)|pt(6)] => false,
 
-      [lt(10), oo(1,3)] => true,
-      [lt(10), oo(11,12)] => false,
-      [lt(10), oo(10,11)] => false,
-      [le(10), co(10,11)] => true,
-      [le(10), le(9)] => true,
-      [le(10), le(11)] => true,
-      [le(10), ge(11)] => false,
-      [le(10), ge(10)] => true,
-      [le(10), gt(10)] => false,
-      [le(10), gt(11)] => false,
-    }.each do |(interval_1, interval_2), answer|
-      if answer
-        it "#{interval_1}.intersect?(#{interval_2}) should be truthy" do
-          expect( interval_1.intersect?(interval_2) ).to be_truthy
-        end
-      else
-        it "#{interval_1}.intersect?(#{interval_2}) should be falsy" do
-          expect( interval_1.intersect?(interval_2) ).to be_falsy
-        end
-      end
-    end
-  end
 
   describe '#contiguous?' do
     it 'Empty interval is treated as contiguous' do
       expect(Empty).to be_contiguous
     end
-    
+
     it 'Single component intervals are treated as contiguous' do
       expect(R).to be_contiguous
       expect(oo(1,3)).to be_contiguous

data/spec/spec_helper.rb

@@ -1 +1,36 @@
 require 'rspec'
+
+require_relative '../lib/interval_notation'
+
+include IntervalNotation
+include IntervalNotation::BasicIntervals
+include IntervalNotation::Syntax::Short
+
+def interval_for_each_boundary_type(from, to)
+  return enum_for(:interval_for_each_boundary_type, from, to)  unless block_given?
+  [true, false].product([true,false]).each do |include_from, include_to|
+    yield BasicIntervals.interval_by_boundary_inclusion(include_from, from, include_to, to).to_interval_set
+  end
+end
+
+
+def pairs_of_intervals_for_each_boundary_with_answer(from_1, to_1, from_2, to_2, answer)
+  interval_for_each_boundary_type(from_1, to_1).flat_map { |interval_1|
+    interval_for_each_boundary_type(from_2, to_2).map { |interval_2|
+      [[interval_1, interval_2], answer]
+    }
+  }
+end
+
+def each_combination_of_intervals(intervals)
+  basic_intervals = intervals.flat_map(&:intervals)
+  (1..basic_intervals.size / 2).each do |chunk_1_size|
+    indices = basic_intervals.size.times.to_a
+    indices.combination(chunk_1_size).each do |chunk_1_indices|
+      chunk_2_indices = indices - chunk_1_indices
+      chunk_1 = IntervalNotation::Operations.union(chunk_1_indices.map{|i| IntervalSet.new([basic_intervals[i]]) })
+      chunk_2 = IntervalNotation::Operations.union(chunk_2_indices.map{|i| IntervalSet.new([basic_intervals[i]]) })
+      yield chunk_1, chunk_2
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interval_notation
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-25 00:00:00.000000000 Z
+date: 2014-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,7 @@ files:
 - README.md
 - Rakefile
 - TODO.md
+- benchmark/benchmark.rb
 - interval_notation.gemspec
 - lib/interval_notation.rb
 - lib/interval_notation/basic_intervals.rb
@@ -61,6 +62,7 @@ files:
 - lib/interval_notation/operations.rb
 - lib/interval_notation/version.rb
 - spec/basic_intervals_spec.rb
+- spec/intersection_spec.rb
 - spec/interval_notation_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/prijutme4ty/interval_notation
@@ -89,5 +91,6 @@ specification_version: 4
 summary: interval_notation allows one to work with 1D-intervals.
 test_files:
 - spec/basic_intervals_spec.rb
+- spec/intersection_spec.rb
 - spec/interval_notation_spec.rb
 - spec/spec_helper.rb