interval_notation 0.1.3 → 0.2.0

data/spec/segmentation_spec.rb

@@ -0,0 +1,177 @@
+require_relative '../lib/interval_notation'
+
+include IntervalNotation
+include IntervalNotation::Syntax::Short
+
+interval_set_vs_segmentation = {
+  'for non-empty interval set' => [
+    cc(0,3) | oo(4,5) | oc(5,10) | co(12,15),
+    Segmentation.new([
+      Segmentation::Segment.new(lt_basic(0), false),
+      Segmentation::Segment.new(cc_basic(0,3), true),
+      Segmentation::Segment.new(oc_basic(3,4), false),
+      Segmentation::Segment.new(oo_basic(4,5), true),
+      Segmentation::Segment.new(pt_basic(5), false),
+      Segmentation::Segment.new(oc_basic(5,10), true),
+      Segmentation::Segment.new(oo_basic(10,12), false),
+      Segmentation::Segment.new(co_basic(12,15), true),
+      Segmentation::Segment.new(ge_basic(15), false),
+    ])
+  ],
+  'for empty interval set' => [
+    Empty,
+    Segmentation.new([
+      Segmentation::Segment.new(oo_basic(-Float::INFINITY, Float::INFINITY), false)
+    ])
+  ],
+  'for entire R interval set' => [
+    R,
+    Segmentation.new([
+      Segmentation::Segment.new(oo_basic(-Float::INFINITY, Float::INFINITY), true)
+    ])
+  ],
+  'for a single point' => [
+    pt(3),
+    Segmentation.new([
+      Segmentation::Segment.new(lt_basic(3), false),
+      Segmentation::Segment.new(pt_basic(3), true),
+      Segmentation::Segment.new(gt_basic(3), false),
+    ])
+  ],
+  'for left-infinite interval set' => [
+    lt(3) | oo(5,10),
+    Segmentation.new([
+      Segmentation::Segment.new(lt_basic(3), true),
+      Segmentation::Segment.new(cc_basic(3,5), false),
+      Segmentation::Segment.new(oo_basic(5,10), true),
+      Segmentation::Segment.new(ge_basic(10), false),
+    ])
+  ],
+  'for right-infinite interval set' => [
+    oo(5,10) | gt(15),
+    Segmentation.new([
+      Segmentation::Segment.new(le_basic(5), false),
+      Segmentation::Segment.new(oo_basic(5,10), true),
+      Segmentation::Segment.new(cc_basic(10,15), false),
+      Segmentation::Segment.new(gt_basic(15), true),
+    ])
+  ],
+  'for left- and right- infinite interval set' => [
+    lt(3) | oo(5,10) | ge(15),
+    Segmentation.new([
+      Segmentation::Segment.new(lt_basic(3), true),
+      Segmentation::Segment.new(cc_basic(3,5), false),
+      Segmentation::Segment.new(oo_basic(5,10), true),
+      Segmentation::Segment.new(co_basic(10,15), false),
+      Segmentation::Segment.new(ge_basic(15), true),
+    ])
+  ],
+}
+
+describe IntervalNotation::Segmentation do
+  describe '#make_interval_set' do
+    interval_set_vs_segmentation.each do |example, (interval_set, segmentation)|
+      it "#{example} returns corresponding segmentation" do
+        expect(interval_set.make_segmentation).to eq(segmentation)
+      end
+    end
+  end
+end
+
+describe IntervalNotation::IntervalSet do
+  describe '#make_segmentation' do
+    interval_set_vs_segmentation.each do |example, (interval_set, segmentation)|
+      it "#{example} returns corresponding interval set" do
+        expect(segmentation.make_interval_set).to eq(interval_set)
+      end
+    end
+  end
+end
+
+
+describe IntervalNotation::Segmentation do
+  let(:segmentation){
+    Segmentation.new([
+      Segmentation::Segment.new(lt_basic(0), :A),
+      Segmentation::Segment.new(co_basic(0,3), :B),
+      Segmentation::Segment.new(cc_basic(3,5), :C),
+      Segmentation::Segment.new(oo_basic(5,7), :D),
+      Segmentation::Segment.new(pt_basic(7), :E),
+      Segmentation::Segment.new(oc_basic(7,10), :F),
+      Segmentation::Segment.new(gt_basic(10), :G),
+    ])
+  }
+
+  let(:segmentation_le_ge_infinite_segments){
+    Segmentation.new([
+      Segmentation::Segment.new(le_basic(0), :A),
+      Segmentation::Segment.new(oo_basic(0,3), :B),
+      Segmentation::Segment.new(cc_basic(3,5), :C),
+      Segmentation::Segment.new(oo_basic(5,7), :D),
+      Segmentation::Segment.new(pt_basic(7), :E),
+      Segmentation::Segment.new(oo_basic(7,10), :F),
+      Segmentation::Segment.new(ge_basic(10), :G),
+    ])
+  }
+
+  describe '#segment_covering_point' do
+    specify 'returns segment' do
+      expect(segmentation.segment_covering_point(2)).to eq Segmentation::Segment.new(co_basic(0,3), :B)
+    end
+    specify 'works for general position case in closed-open interval' do
+      expect(segmentation.segment_covering_point(2).state).to eq(:B)
+    end
+    specify 'works for general position case in closed-closed interval' do
+      expect(segmentation.segment_covering_point(4).state).to eq(:C)
+    end
+    specify 'works for general position case in open-open interval' do
+      expect(segmentation.segment_covering_point(6).state).to eq(:D)
+    end
+    specify 'works for general position case in open-closed interval' do
+      expect(segmentation.segment_covering_point(8).state).to eq(:F)
+    end
+    specify 'works for general position case in less-than interval' do
+      expect(segmentation.segment_covering_point(-1).state).to eq(:A)
+    end
+    specify 'works for general position case in greater-than interval' do
+      expect(segmentation.segment_covering_point(11).state).to eq(:G)
+    end
+    specify 'works for general position case in less-than-or-equal-to interval' do
+      expect(segmentation_le_ge_infinite_segments.segment_covering_point(-1).state).to eq(:A)
+    end
+    specify 'works for general position case in greater-than-or-equal-to interval' do
+      expect(segmentation_le_ge_infinite_segments.segment_covering_point(11).state).to eq(:G)
+    end
+    specify 'works for singular point segment' do
+      expect(segmentation.segment_covering_point(7).state).to eq(:E)
+    end
+
+    specify 'works for leftmost boundary in closed-open interval' do
+      expect(segmentation.segment_covering_point(0).state).to eq(:B)
+    end
+    specify 'works for rightmost boundary in open-closed interval' do
+      expect(segmentation.segment_covering_point(10).state).to eq(:F)
+    end
+    specify 'works for leftmost boundary in closed-closed interval' do
+      expect(segmentation.segment_covering_point(3).state).to eq(:C)
+    end
+    specify 'works for rightmost boundary in closed-closed interval' do
+      expect(segmentation.segment_covering_point(5).state).to eq(:C)
+    end
+
+    specify 'works for rightmost boundary in less-than interval' do
+      expect(segmentation.segment_covering_point(0).state).to eq(:B)
+    end
+    specify 'works for leftmost boundary in greater-than interval' do
+      expect(segmentation.segment_covering_point(10).state).to eq(:F)
+    end
+
+
+    specify 'works for rightmost boundary in less-than-or-equal-to interval' do
+      expect(segmentation_le_ge_infinite_segments.segment_covering_point(0).state).to eq(:A)
+    end
+    specify 'works for leftmost boundary in greater-than-or-equal-to interval' do
+      expect(segmentation_le_ge_infinite_segments.segment_covering_point(10).state).to eq(:G)
+    end
+  end
+end

data/spec/tagging_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../lib/interval_notation'
+
+include IntervalNotation
+include IntervalNotation::Syntax::Short
+
+describe IntervalNotation::SweepLine do
+  describe '#make_segmentation' do
+
+    describe 'SingleTagging' do
+      specify 'When tags are all different' do
+        tagged_intervals = [[oo(0,10), :A], [cc(0,8), :B], [oo(5,15), :C]]
+        segmentation = SweepLine.make_tagging(tagged_intervals)
+        expected_result = Segmentation.new([
+          Segmentation::Segment.new(lt_basic(0), Set.new),
+          Segmentation::Segment.new(pt_basic(0), Set.new([:B])),
+          Segmentation::Segment.new(oc_basic(0,5), Set.new([:A,:B])),
+          Segmentation::Segment.new(oc_basic(5,8), Set.new([:A,:B,:C])),
+          Segmentation::Segment.new(oo_basic(8,10), Set.new([:A,:C])),
+          Segmentation::Segment.new(co_basic(10,15), Set.new([:C])),
+          Segmentation::Segment.new(ge_basic(15), Set.new),
+        ])
+        expect(segmentation).to eq(expected_result)
+      end
+      specify 'When some tags are the same' do
+        tagged_intervals = [[oo(0,10), :A], [cc(0,8), :B], [oo(5,15), :A]]
+        segmentation = SweepLine.make_tagging(tagged_intervals)
+        expected_result = Segmentation.new([
+          Segmentation::Segment.new(lt_basic(0), Set.new),
+          Segmentation::Segment.new(pt_basic(0), Set.new([:B])),
+          Segmentation::Segment.new(oc_basic(0,8), Set.new([:A,:B])),
+          Segmentation::Segment.new(oo_basic(8,15), Set.new([:A])),
+          Segmentation::Segment.new(ge_basic(15), Set.new),
+        ])
+        expect(segmentation).to eq(expected_result)
+      end
+    end
+
+    describe 'MultiTagging' do
+      specify 'When tags are all different' do
+        tagged_intervals = [[oo(0,10), :A], [cc(0,8), :B], [oo(5,15), :C]]
+        segmentation = SweepLine.make_multitagging(tagged_intervals)
+        expected_result = Segmentation.new([
+          Segmentation::Segment.new(lt_basic(0), {}),
+          Segmentation::Segment.new(pt_basic(0), {:B => 1}),
+          Segmentation::Segment.new(oc_basic(0,5), {:A => 1, :B => 1}),
+          Segmentation::Segment.new(oc_basic(5,8), {:A => 1, :B => 1, :C => 1}),
+          Segmentation::Segment.new(oo_basic(8,10), {:A => 1, :C => 1}),
+          Segmentation::Segment.new(co_basic(10,15), {:C => 1}),
+          Segmentation::Segment.new(ge_basic(15), {}),
+        ])
+        expect(segmentation).to eq(expected_result)
+      end
+      specify 'When some tags are the same' do
+        tagged_intervals = [[oo(0,10), :A], [cc(0,8), :B], [oo(5,15), :A]]
+        segmentation = SweepLine.make_multitagging(tagged_intervals)
+        expected_result = Segmentation.new([
+          Segmentation::Segment.new(lt_basic(0), {}),
+          Segmentation::Segment.new(pt_basic(0), {:B => 1}),
+          Segmentation::Segment.new(oc_basic(0,5), {:A => 1, :B => 1}),
+          Segmentation::Segment.new(oc_basic(5,8), {:A => 2, :B => 1}),
+          Segmentation::Segment.new(oo_basic(8,10), {:A => 2}),
+          Segmentation::Segment.new(co_basic(10,15), {:A => 1}),
+          Segmentation::Segment.new(ge_basic(15), {}),
+        ])
+        expect(segmentation).to eq(expected_result)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interval_notation
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,15 +70,26 @@ files:
 - interval_notation.gemspec
 - lib/interval_notation.rb
 - lib/interval_notation/basic_intervals.rb
-- lib/interval_notation/combiners.rb
 - lib/interval_notation/error.rb
 - lib/interval_notation/interval_set.rb
 - lib/interval_notation/operations.rb
+- lib/interval_notation/segmentation.rb
+- lib/interval_notation/sweep_line.rb
+- lib/interval_notation/sweep_line/sweep_line.rb
+- lib/interval_notation/sweep_line/trace_state/intersection.rb
+- lib/interval_notation/sweep_line/trace_state/multiple_state.rb
+- lib/interval_notation/sweep_line/trace_state/subtract.rb
+- lib/interval_notation/sweep_line/trace_state/symmetric_difference.rb
+- lib/interval_notation/sweep_line/trace_state/tagging.rb
+- lib/interval_notation/sweep_line/trace_state/union.rb
+- lib/interval_notation/sweep_line/trace_states.rb
 - lib/interval_notation/version.rb
 - spec/basic_intervals_spec.rb
 - spec/intersection_spec.rb
 - spec/interval_notation_spec.rb
+- spec/segmentation_spec.rb
 - spec/spec_helper.rb
+- spec/tagging_spec.rb
 homepage: https://github.com/prijutme4ty/interval_notation
 licenses:
 - MIT
@@ -107,4 +118,6 @@ test_files:
 - spec/basic_intervals_spec.rb
 - spec/intersection_spec.rb
 - spec/interval_notation_spec.rb
+- spec/segmentation_spec.rb
 - spec/spec_helper.rb
+- spec/tagging_spec.rb

data/lib/interval_notation/combiners.rb

@@ -1,166 +0,0 @@
-require 'set'
-
-module IntervalNotation
-  # Combiner is an internal helper class for combining interval sets using sweep line.
-  # It starts moving from -∞ to +∞ and keep which intervals are crossed by sweep line.
-  # Class helps to effectively recalculate number of crossed intervals without rechecking
-  # all intervals each time, and dramatically reduces speed of operations on large number of intervals.
-  #
-  # Usage example:
-  #   UnionCombiner.new(3).combine([interval_1, interval_2, interval_3])
-  class Combiner
-    attr_reader :num_interval_sets
-    attr_reader :previous_state
-
-    def initialize(num_interval_sets)
-      @num_interval_sets = num_interval_sets
-      @inside = Array.new(num_interval_sets, false)
-      @num_intervals_inside = 0 # number of intervals, we are inside (for efficiency)
-    end
-
-    # Combines intervals according on an information given by #state/#include_last_point functions
-    # which tell whether current section or point should be included to a new interval.
-    def combine(interval_sets)
-      points = interval_sets.each_with_index.flat_map{|interval_set, interval_set_index|
-        interval_set.intervals.flat_map{|interval|
-          interval.interval_boundaries(interval_set_index)
-        }
-      }.sort_by(&:value)
-
-      intervals = []
-
-      incl_from = nil
-      from = nil
-
-      points.chunk(&:value).each do |point_value, points_on_place|
-        pass(points_on_place)
-
-        if previous_state
-          if state
-            unless include_last_point
-              intervals << BasicIntervals.interval_by_boundary_inclusion(incl_from, from, false, point_value)
-              incl_from = false
-              from = point_value
-            end
-          else
-            to = point_value
-            incl_to = include_last_point
-            intervals << BasicIntervals.interval_by_boundary_inclusion(incl_from, from, incl_to, to)
-            from = nil # easier to find an error (but not necessary code)
-            incl_from = nil # ditto
-          end
-        else
-          if state
-            from = point_value
-            incl_from = include_last_point
-          else
-            intervals << BasicIntervals::Point.new(point_value)  if include_last_point
-          end
-        end
-      end
-      IntervalSet.new_unsafe(intervals)
-    end
-
-    # When sweep line pass several interval boundaries, +#pass+ should get all those points at once
-    # and update status of crossing sweep line.
-    # It also stores previous state, because it's actively used downstream.
-    def pass(points_on_place)
-      @previous_state = state
-      pass_recalculation(points_on_place)
-    end
-
-    # See +#pass+ for details
-    def pass_recalculation(points_on_place) # :nodoc:
-      num_spanning_intervals = @num_intervals_inside
-      num_covering_boundaries = 0
-
-      points_on_place.each do |point|
-        num_covering_boundaries += 1  if point.included
-
-        if point.interval_boundary
-          num_spanning_intervals -= 1  if point.closing
-          @num_intervals_inside += (@inside[point.interval_index] ? -1 : 1)
-          @inside[point.interval_index] ^= true
-        end
-      end
-      @num_interval_sets_covering_last_point = num_spanning_intervals + num_covering_boundaries
-    end
-    private :pass_recalculation
-  end
-
-  class UnionCombiner < Combiner
-    # checks whether current section should be included
-    def state
-      @num_intervals_inside > 0
-    end
-
-    # checks whether last passed point should be included
-    def include_last_point
-      @num_interval_sets_covering_last_point > 0
-    end
-  end
-
-  class IntersectCombiner < Combiner
-    # checks whether current section should be included
-    def state
-      @num_intervals_inside == num_interval_sets
-    end
-
-    # checks whether last passed point should be included
-    def include_last_point
-      @num_interval_sets_covering_last_point == num_interval_sets
-    end
-  end
-
-  class SubtractCombiner < Combiner
-    # checks whether last passed point should be included
-    attr_reader :include_last_point
-
-    def initialize
-      @include_last_point = nil
-      @inside = [false, false]
-    end
-
-    # checks whether current section should be included
-    def state
-      @inside[0] && ! @inside[1]
-    end
-
-    # See +#pass+ for details
-    def pass_recalculation(points_on_place) # :nodoc:
-      included = @inside.dup
-      points_on_place.each do |point|
-        @inside[point.interval_index] ^= point.interval_boundary # doesn't change on singular points
-        included[point.interval_index] = point.included
-      end
-      @include_last_point = included[0] && !included[1]
-    end
-    private :pass_recalculation
-  end
-
-  class SymmetricDifferenceCombiner < Combiner
-    # checks whether last passed point should be included
-    attr_reader :include_last_point
-
-    def initialize
-      @include_last_point = nil
-      @inside = [false, false]
-    end
-
-    # checks whether current section should be included
-    def state
-      @inside[0] ^ @inside[1]
-    end
-
-    # See +#pass+ for details
-    def pass_recalculation(points_on_place) # :nodoc:
-      included = @inside.dup
-      points_on_place.each do |point|
-        @inside[point.interval_index] ^= point.interval_boundary # doesn't change on singular points
-        included[point.interval_index] = point.included
-      end
-      @include_last_point = included[0] ^ included[1]
-    end
-    private :pass_recalculation
-  end
-end