interval_notation 0.1.3 → 0.2.0

data/lib/interval_notation/sweep_line.rb

@@ -0,0 +1,3 @@
+require_relative 'segmentation'
+require_relative 'sweep_line/trace_states'
+require_relative 'sweep_line/sweep_line'

data/lib/interval_notation/sweep_line/sweep_line.rb

@@ -0,0 +1,97 @@
+require_relative '../segmentation'
+
+module IntervalNotation
+  # SweepLine is an internal helper module for combining interval sets using sweep line.
+  # It starts moving from -∞ to +∞ and keep which intervals are crossed by sweep line in trace-state variable.
+  # State object have methods which recalculate state when sweep line meets a group of boundary points
+  # and a method to convolve state underlying representation into surface state value.
+  # E.g. `Union` trace state can store information about which intervals are intersected by a sweep line,
+  # but on surface one knows only whether it intersects any interval.
+  #
+  # Boundary points for state recalculation are grouped by the same coordinate. As sweep lines goes left-to-right,
+  # initial state is a state at -∞.
+  # See `TraceState` module for an examples of trace-states.
+  #
+  # Principially sweep line method 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:
+  #   SweepLine.make_interval_set([interval_1, interval_2, interval_3], SweepLine::TraceState::Union.initial_state(3))
+  #
+  module SweepLine
+    # Make segmentation by state of a list of interval sets.
+    # Accepts a list of pairs (interval, tag)
+    def self.make_segmentation(indexed_interval_sets, initial_state)
+      points = interval_boundaries(indexed_interval_sets)
+      segmentation_by_boundary_points(points, initial_state).map_state{|segment|
+        segment.state.state_convolution
+      }
+    end
+
+    # Make segmentation by state of a list of interval sets.
+    # Accepts a list of intervals without tags.
+    def self.make_interval_set(interval_sets, initial_state)
+      make_segmentation(interval_sets.each_with_index, initial_state).make_interval_set
+    end
+
+    # Make tagging segmentation of interval sets.
+    # Each segment's state in a resulting segmentation is a set of tags lying against a segment.
+    def self.make_tagging(indexed_interval_sets)
+      make_segmentation(indexed_interval_sets, SweepLine::TraceState::SingleTagging.initial_state)
+    end
+
+    # Make multi-tagging segmentation of interval sets. Multi-tagging means that segment store 
+    # not only tag but number of times this tag was met.
+    # Each segment's state in a resulting segmentation is a hash {tag => count} for tags lying against a segment.
+    def self.make_multitagging(indexed_interval_sets)
+      make_segmentation(indexed_interval_sets, SweepLine::TraceState::MultiTagging.initial_state)
+    end
+
+    # Extracts interval boundaries marked by interval indices or tags
+    # Accepts a list of pairs (interval, tag)
+    def self.interval_boundaries(tagged_interval_sets)
+      tagged_interval_sets.flat_map{|interval_set, interval_set_tag|
+        interval_set.intervals.flat_map{|interval|
+          interval.interval_boundaries(interval_set_tag)
+        }
+      }
+    end
+
+    # Make a segmentation using sweep line along boundary points.
+    def self.segmentation_by_boundary_points(boundary_points, initial_state)
+      if boundary_points.empty?
+        segment = Segmentation::Segment.new(BasicIntervals::OpenOpenInterval.new(-Float::INFINITY, Float::INFINITY), initial_state)
+        return Segmentation.new([segment])
+      end
+
+      point_chunks = boundary_points.sort_by(&:value).chunk(&:value).to_a
+      state = initial_state
+
+      # Process minus-infinity points which can change initial state
+      if point_chunks.first.first == -Float::INFINITY
+        point_value, points_at_minus_infinity = point_chunks.shift
+        state = state.state_after_point(points_at_minus_infinity)
+      end
+
+      # Remove plus-infinity points as they can change state but this won't be reflected by any interval
+      if point_chunks.last.first == Float::INFINITY
+        point_value, points_at_plus_infinity = point_chunks.pop
+      end
+
+      prev_point_value = -Float::INFINITY
+      segments = []
+      # We removed points at plus or minus infinity so now we process inner points
+      point_chunks.each do |point_value, points_on_place|
+        segments << Segmentation::Segment.new(BasicIntervals::OpenOpenInterval.new(prev_point_value, point_value), state)
+        segments << Segmentation::Segment.new(BasicIntervals::Point.new(point_value), state.state_at_point(points_on_place))
+        state = state.state_after_point(points_on_place)
+        prev_point_value = point_value
+      end
+
+      # add fictive segment up to plus-infinity point (may be fictive)
+      segments << Segmentation::Segment.new(BasicIntervals::OpenOpenInterval.new(prev_point_value, Float::INFINITY), state)
+      Segmentation.new(segments, skip_validation: true) # here we can skip validation but not normalization
+    end
+
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/intersection.rb

@@ -0,0 +1,56 @@
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # Class allows to observe whether sweep line is inside of interval sets intersection or outside
+      Intersection = Struct.new(:num_uncovered) do
+        def self.initial_state(num_interval_sets)
+          self.new(num_interval_sets)
+        end
+
+        # map state before point into state at point
+        def state_at_point(points_on_place)
+          new_state = num_uncovered
+          points_on_place.each{|point|
+            if point.singular_point?
+              new_state -= 1
+            else
+              if point.closing && !point.included
+                new_state += 1
+              elsif point.opening && point.included
+                new_state -= 1
+              end
+            end
+          }
+          self.class.new(new_state)
+        end
+
+        # map state at point into state after point
+        def state_after_point(points_on_place)
+          new_state = num_uncovered
+          points_on_place.reject(&:singular_point?).each{|point|
+            new_state += point.opening ? -1 : +1
+          }
+          
+          self.class.new(new_state)
+        end
+
+        def state_convolution
+          num_uncovered == 0
+        end
+      end
+
+      # # More generic but less efficient version of Intersection state
+      # class IntersectionMultiState < MultipleState
+      #   def self.initial_state(num_interval_sets)
+      #     self.new( Array.new(num_interval_sets, false) )
+      #   end
+
+      #   def state_convolution
+      #     inclusion_state.all?
+      #   end
+      # end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/multiple_state.rb

@@ -0,0 +1,46 @@
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # MultipleState is a simple abstract class to store and manage state of intersection with sweep line of several interval sets
+      # 
+      # In order to use it one should define subclass with `#state_convolution` method.
+      # If specific convolution can be defined in easier terms, `#state_at_point` and `#state_after_point`
+      # also can be redefined in a subclass for perfomance and clarity reasons
+      MultipleState = Struct.new(:inclusion_state) do
+        # map state before point into state at point
+        def state_at_point(points_on_place)
+          new_state = inclusion_state.dup
+          points_on_place.each{|point|
+            new_state[point.interval_index] = point.included
+          }
+          self.class.new(new_state)
+        end
+
+        # map state before point (not at point!) into state after point
+        def state_after_point(points_on_place)
+          new_state = inclusion_state.dup
+
+          interval_boundary_points = points_on_place.reject(&:singular_point?)
+          points_by_closing = interval_boundary_points.group_by(&:closing)
+          closing_points = points_by_closing.fetch(true){ [] }
+          opening_points = points_by_closing.fetch(false){ [] }
+
+          closing_points.each{|point|
+            new_state[point.interval_index] = false
+          }
+          opening_points.each{|point|
+            new_state[point.interval_index] = true
+          }
+          self.class.new(new_state)
+        end
+
+        # Convolve state inner state into state result
+        def state_convolution
+          raise NotImplementedError, '#state_convolution should be redefined in a superclass'
+        end
+      end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/subtract.rb

@@ -0,0 +1,20 @@
+require_relative 'multiple_state'
+
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # Class allows to observe whether sweep line is inside of first and outside of second interval set
+      class Subtract < MultipleState
+        def self.initial_state
+          self.new([false, false])
+        end
+
+        def state_convolution
+          inclusion_state[0] && !inclusion_state[1]
+        end
+      end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/symmetric_difference.rb

@@ -0,0 +1,20 @@
+require_relative 'multiple_state'
+
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # Class allows to observe whether sweep line is inside of exactly one of two intervals
+      class SymmetricDifference < MultipleState
+        def self.initial_state
+          self.new([false, false])
+        end
+
+        def state_convolution
+          inclusion_state[0] ^ inclusion_state[1]
+        end
+      end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/tagging.rb

@@ -0,0 +1,72 @@
+require 'set'
+
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # Tagging is an abstract state class which stores an overlay markup of several tagged interval-sets.
+      # Look at SingleTagging and MultiTagging which implement different convolution strategies (see below). 
+      #
+      # Each interval set can be marked with the only tag but for an overlay each individual point
+      # can be marked with zero to many tags.
+      # Tag name is taken from boundary point's interval index.
+      # Tag names needn't be unique.
+      #
+      # When a point is overlapped by several tags with the same name, there are two strategies:
+      # * SingleTagging takes into account only the fact, that the point/interval was tagged
+      # * MultiTagging count the number of times each tag was assigned to a point/interval
+      #
+      Tagging = Struct.new(:tag_count) do
+        def self.initial_state
+          self.new(Hash.new(0))
+        end
+
+        # map state before point into state at point
+        def state_at_point(points_on_place)
+          new_state = tag_count.dup
+          points_on_place.each{|point|
+            if point.singular_point?
+              new_state[point.interval_index] += 1
+            else
+              if point.closing && !point.included
+                new_state[point.interval_index] -= 1
+              elsif point.opening && point.included
+                new_state[point.interval_index] += 1
+              end
+            end
+          }
+          new_state.reject!{|tag, count| count.zero?}
+          self.class.new(new_state)
+        end
+
+        # map state before point (not at point!) into state after point
+        def state_after_point(points_on_place)
+          new_state = tag_count.dup
+          points_on_place.reject(&:singular_point?).each{|point|
+            new_state[point.interval_index] += point.opening ? 1 : -1
+          }
+          new_state.reject!{|tag, count| count.zero?}
+          self.class.new(new_state)
+        end
+
+        # Convolve state inner state into state result
+        def state_convolution
+          raise NotImplementedError, 'Tagging is an abstract state class. Use SingleTagging or MultiTagging instead'
+        end
+      end
+
+      class SingleTagging < Tagging
+        def state_convolution; tag_count.keys.to_set; end
+        def to_s; "{#{tag_count.keys.join(', ')}}"; end
+        def inspect; to_s; end
+      end
+
+      class MultiTagging < Tagging
+        def state_convolution; tag_count; end
+        def to_s; tag_count.to_s; end
+        def inspect; to_s; end
+      end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_state/union.rb

@@ -0,0 +1,57 @@
+module IntervalNotation
+  module SweepLine
+    module TraceState
+
+      # Class allows to observe whether sweep line is inside of interval sets union or outside
+      Union = Struct.new(:num_covered) do
+        def self.initial_state(num_interval_sets)
+          self.new(0)
+        end
+
+        # map state before point into state at point
+        def state_at_point(points_on_place)
+          new_state = num_covered
+          points_on_place.each{|point|
+            if point.singular_point?
+              new_state += 1
+            else
+              if point.closing && !point.included
+                new_state -= 1
+              elsif point.opening && point.included
+                new_state += 1
+              end
+            end
+          }
+          self.class.new(new_state)
+        end
+
+        # map state at point into state after point
+        def state_after_point(points_on_place)
+          new_state = num_covered
+          points_on_place.reject(&:singular_point?).each{|point|
+            new_state += point.opening ? 1 : -1
+          }
+          
+          self.class.new(new_state)
+        end
+
+        def state_convolution
+          num_covered > 0
+        end
+      end
+
+      # # More generic but less efficient version of Union state
+      # require_relative 'multiple_state'
+      # class Union < MultipleState
+      #   def self.initial_state(num_interval_sets)
+      #     self.new( Array.new(num_interval_sets, false) )
+      #   end
+
+      #   def state_convolution
+      #     inclusion_state.any?
+      #   end
+      # end
+
+    end
+  end
+end

data/lib/interval_notation/sweep_line/trace_states.rb

@@ -0,0 +1,6 @@
+require_relative 'trace_state/multiple_state'
+require_relative 'trace_state/tagging'
+require_relative 'trace_state/union'
+require_relative 'trace_state/intersection'
+require_relative 'trace_state/subtract'
+require_relative 'trace_state/symmetric_difference'

data/lib/interval_notation/version.rb

@@ -1,3 +1,3 @@
 module IntervalNotation
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/interval_notation_spec.rb

@@ -736,5 +736,47 @@ describe IntervalNotation do
         expect(interval.closure).to eq answer
       end
     end
+
+    describe '#connected_components' do
+      {
+        Empty => [],
+        oo(1,3) => [oo(1,3)],
+        cc(5,6) => [cc(5,6)],
+        pt(4) => [pt(4)],
+        oo(1,3) | pt(4) => [oo(1,3), pt(4)],
+        oo(1,3) | cc(5,6) => [oo(1,3), cc(5,6)],
+        oo(1,3) | pt(4) | cc(5,6) => [oo(1,3), pt(4), cc(5,6)],
+      }.each do |interval, answer|
+        it "#{interval}.connected_components should equal #{answer}" do
+          expect(interval.connected_components).to eq answer
+        end
+      end
+    end
+
+    describe '#interval_covering_point' do
+      {
+        [Empty, 2] => nil,
+        [oo(1,3), 2] => OpenOpenInterval.new(1,3),
+        [cc(1,3), 2] => ClosedClosedInterval.new(1,3),
+        [oo(1,3), 4] => nil,
+        [oo(1,3), 3] => nil,
+        [oo(1,3), 1] => nil,
+        [cc(1,3), 1] => ClosedClosedInterval.new(1,3),
+        [cc(1,3), 3] => ClosedClosedInterval.new(1,3),
+        [pt(4), 5] => nil,
+        [pt(4), 4] => Point.new(4),
+        [oo(1,3) | pt(4), 4] => Point.new(4),
+        [oo(1,3) | oo(5,6), 4] => nil,
+        [oo(1,3) | oo(5,6), 2] => OpenOpenInterval.new(1,3),
+        [oo(1,3) | oo(5,6), 5.5] => OpenOpenInterval.new(5,6),
+        [oo(1,3) | pt(4) | oo(5,6), 4] => Point.new(4),
+        [oo(1,3) | pt(4) | oo(5,6), 2] => OpenOpenInterval.new(1,3),
+        [oo(1,3) | pt(4) | oo(5,6), 5.5] => OpenOpenInterval.new(5,6),
+      }.each do |(interval, point), answer|
+        it "#{interval}.interval_covering_point(#{point}) should equal #{answer}" do
+          expect(interval.interval_covering_point(point)).to eq answer
+        end
+      end
+    end
   end
 end