interval_notation 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5959995f95355a82acf74a537288c6625466975d
-  data.tar.gz: b621dd95df2c290949cd919bc4e210444ff120f2
+  metadata.gz: 7c1800a973a0b109fedd3e4a0bc378af0f491c93
+  data.tar.gz: 224ceae1be9ff756b5fb5c0dd8fdc4688edd0585
 SHA512:
-  metadata.gz: 6e4acb6c0fc3834c1b4ebd915356f2169212a53ff8fa4b0f6f3868f1e2555fa589433cf97a984b7dae89eb738ee1dc96453a3872b82ae33875290900834f7899
-  data.tar.gz: 6fbc038e920099bde55ae847fa48b77ca9a1669c9bfa14507e3fa240ab73a6ecb52f7b9b8e846cd19397efc8976a7eccec7b67d31e846d40086dea64c377adef
+  metadata.gz: 4b18d4772d4f708e2a246ac71e0f17ca57e48885b3cc2e4845393fb1203d3279d08f993b5dde5be47079242100f0aa0d05a107ab6bfc23c14f8ae30f0f13d3d9
+  data.tar.gz: 0cf796a0a49792f1240e78413c95868cb8253a09cfd3ebbb65962b36f51885655b65fc057c4146f1e731e6157642c2b26619ff5788ed15d50a26b13068b7e7d2

data/README.md

@@ -46,12 +46,15 @@ interval_6_2 = oc(-Float::INFINITY, -3) # => (-∞,-3]
 interval_7_2 = oo(-3, Float::INFINITY) # => (-3,+∞)
 interval_8_2 = co(5.5, Float::INFINITY) # => [5.5,+∞)
 # Create interval set from string (see IntervalSet.from_string for details)
-interval_9 = int('{0}U[1,5)U(5,infty)') # => {0}U[1,5)U(5,+∞)
+interval_9 = interval('{0}U[1,5)U(5,infty)') # => {0}U[1,5)U(5,+∞)
 ```
 
 If you prefer more descriptive method names, use `IntervalNotation::Syntax::Long`. In such case you'll have `open_open`, `open_closed`, `closed_open`, `closed_closed`, `less_than`, `less_than_or_equal_to`, `greater_than`, `greater_than_or_equal_to` and `point` methods. `interval` is a long-form analog for `int` - to create interval set from string
 
-Consider that no one class is supposed to be used directly! For further details see section **Internal structure**.
+Sometimes you want to create one of `BasicInterval`s which are underlying structures of `IntervalSet`s. In that case you can use similar constructors with `_basic` suffix like `oo_basic(from, to)` and so on.
+Some constructors create not necessary contiguous intervals like `interval(String)` do. Such constructors do not have `*_basic` counterpart.
+
+Note that `BasicInterval` classes are not supposed to be used for interval operations directly! For further details see section **Internal structure**.
 
 ### Interval operations
 Intervals can be combined in many different ways:
@@ -60,7 +63,9 @@ include IntervalNotation::Syntax::Long
 a = open_closed(0,15) # => (0,15]
 b = closed_open(10,25) # => [10,25)
 c = point(-5) # => {-5}
+d = closed_closed(-200, -100) # => [-200,-100]
 bc = b | c # => {-5}∪[10,25)
+bcd = b | c | d # => [-200,-100]∪{-5}∪[10,25)
 
 # Union of a pair of intervals:
 a | b # => (0,25)
@@ -87,6 +92,17 @@ bc.closure # => {-5}∪[10,25]
 
 # Covering interval
 bc.covering_interval # => [-5,25)
+
+# Return connected components (contiguous non-adjacent intervals)
+# comprising `IntervalSet` (and wrapped in `IntervalSet`s)
+bc.connected_components # => [c, b]
+
+# Return connected components (contiguous non-adjacent intervals)
+# comprising `IntervalSet` (in `BasicInterval` representation; not wrapped)
+bc.intervals # => [point_basic(-5), closed_open_basic(10,25)]
+
+# Find connected component (BasicInterval representation) which covers a point
+bc.interval_covering_point(12) # => [10,25)
 ```
 
 If you want to combine more than two intervals, you can perform several consequent operations:
@@ -97,7 +113,7 @@ a & b & c # => ∅
 [a,b,c].inject(&:|) # => {-5}∪(0,25)
 [a,b,c].inject(&:&) # => ∅
 ```
-But there is a much better and faster way to unite or intersect multiple intervals:
+But there is a much faster way to unite or intersect multiple intervals:
 ```ruby
 IntervalNotation::Operations.union([a,b,c]) # => {-5}∪(0,25]
 IntervalNotation::Operations.intersection([a,b,c]) # => ∅
@@ -141,13 +157,85 @@ interval_set.contain?(interval_set)
 interval_set.contained_by?(interval_set)
 ```
 
+### Segmentation
+Another essential structure in a library is a `Segmentation`. Segmentation is a partitioning of number line into adjacent non-ovelapping intervals (covering entire R) such that each segment has its own state. Adjacent segments with the same state are glued.
+Segmentation can be used to trace lots of interval sets simultaneously. It's made with help of `Tagging` trace-states. `SingleTagging` and `MultiTagging` allow one to mark each interval set with its own tag and to partition number line into regions with certain tag sets.
+
+```ruby
+intervals_tagged          = {oo(0,10) => :A, cc(0,8) => :B, oo(5,15) => :C}
+intervals_tagged_dup_tags = {oo(0,10) => :A, cc(0,8) => :B, oo(5,15) => :A}
+
+### Usual tagging returns segments with states which are `Set`s of tags:
+IntervalNotation::SweepLine.make_tagging(intervals_tagged)
+# => Segmentation: [<(-∞;0): {}>, <{0}: {B}>, <(0;5]: {A, B}>, <(5;8]: {A, B, C}>, <(8;10): {A, C}>, <[10;15): {C}>, <[15;+∞): {}>]
+
+IntervalNotation::SweepLine.make_tagging(intervals_tagged_dup_tags)
+# => Segmentation: [<(-∞;0): {}>, <{0}: {B}>, <(0;8]: {A, B}>, <(8;15): {A}>, <[15;+∞): {}>] 
+
+### Multitagging returns segments with states which are `Hash`es of tag counts:
+IntervalNotation::SweepLine.make_multitagging(intervals_tagged)
+# => Segmentation: [<(-∞;0): {}>, <{0}: {:B=>1}>, <(0;5]: {:A=>1, :B=>1}>, <(5;8]: {:A=>1, :B=>1, :C=>1}>, <(8;10): {:A=>1, :C=>1}>, <[10;15): {:C=>1}>, <[15;+∞): {}>]
+
+IntervalNotation::SweepLine.make_multitagging(intervals_tagged_dup_tags)
+# => Segmentation: [<(-∞;0): {}>, <{0}: {:B=>1}>, <(0;5]: {:A=>1, :B=>1}>, <(5;8]: {:A=>2, :B=>1}>, <(8;10): {:A=>2}>, <[10;15): {:A=>1}>, <[15;+∞): {}>]
+```
+
+One can create different segmentation states using `SweepLine.make_segmentation` with custom trace-state objects. Operations like union and intersection are made this way, using special trace-states which return true when sweep line intersect any/all of intervals. Trace-state is a special object which can recalculate state when interval boundaries were hit. See `SweepLine::TraceState` module for details.
+
+`Segmentation` have some methods to transform states, query segments and so on:
+
+```ruby
+include IntervalNotation
+include IntervalNotation::Syntax::Short
+segmentation = 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 ),
+])
+# Segmentation: [<(-∞;0): {}>, <{0}: {B}>, <(0;8]: {A, B}>, <(8;15): {A}>, <[15;+∞): {}>]
+
+### `Segmentation#map_state` transforms state of each segment.
+### If necessary new segments will be glued
+segmentation.map_state{|segment| segment.state.size }
+# => Segmentation: [<(-∞;0): 0>, <{0}: 1>, <(0;8]: 2>, <(8;15): 1>, <[15;+∞): 0>]
+
+segmentation.map_state{|segment| segment.state.size > 1 }
+# => Segmentation: [<(-∞;0]: false>, <(0;8]: true>, <(8;+∞): false>] 
+
+### `Segmentation#boolean_segmentation` transforms state of each segment into
+### boolean value (useful to glue segments which are truthy/falsy but
+### have not exactly equal state). Same result can be obtained by `#map_state`.
+segmentation.boolean_segmentation{|segment| segment.state.size > 1 }
+# => Segmentation: [<(-∞;0]: false>, <(0;8]: true>, <(8;+∞): false>] 
+
+
+### `IntervalSet` and true/false `Segmentation` can be converted 
+### to each other.
+### Use `IntervalSet#make_segmentation` and `Segmentation#make_interval_set`.
+bool_segmentation = segmentation.boolean_segmentation{|segment|
+    segment.state.size > 1
+}
+bool_segmentation.make_interval_set
+# => (0,8]
+
+(oo(1,3) | pt(5)).make_segmentation
+# => Segmentation: [<(-∞;1]: false>, <(1;3): true>, <[3;5): false>, <{5}: true>, <(5;+∞): false>]
+
+### `Segmentation#segment_covering_point` returns a `Segment`
+### which lies against specified point
+segmentation.segment_covering_point(10)
+# => <(8;15): {A}>
+```
+
 ## Internal structure
 
 `IntervalNotation::IntervalSet` is designed in order to keep ordered list of non-overlapping intervals and represent 1-D point set. Each interval in the `IntervalSet` is an instance of one of following classes: `Point`, `OpenOpenInterval`, `OpenClosedInterval`, `ClosedOpenInterval` or `ClosedOpenInterval` representing contiguous 1-D subsets. One can find them in `IntervalNotation::BasicIntervals` module. None of these classes is intended to be directly instantiated, usually intervals are constructed using factory methods and combining operations.
 
 All factory methods listed above create `IntervalSet`s, wrapping an instance of corresponding interval or point class. All interval set operations create new `IntervalSet`s, even if they contain the only basic interval.
 
-`IntervalSet`s are value objects. Once instantiated they cannot be changed, all operations just create new objects. It also means, you can fearlessly use them as key values in hashes.
+`IntervalSet`s and `Segmentation`s (as well as `BasicInterval`s) are value objects. Once instantiated they cannot be changed, all operations just create new objects. It also means, you can fearlessly use them as key values in hashes.
 
 Combining of intervals is made by sweep line method, so is linear by number of intervals. Many querying operations (such as `#intersect`) rely on combining intervals thus also have linear complexity. Some of these perfomance drawbacks will be fixed in future.
 Query `#include_position?` is made by binary search (so has logarithmic complexity).

data/TODO.md

@@ -5,3 +5,4 @@
 * What about working with simgle intervals (their, length, relations etc)?
 * (?) Make it possible to use intervals with non-numeric objects to be possible to use math expressions as interval boundaries
 * May be we should check that boundary is an actual number, not a NaN
+* Make use of basic intervals (implement #coerce and make oo|co|pt|... return BasicIntervals)

data/lib/interval_notation.rb

@@ -2,7 +2,7 @@ require_relative 'interval_notation/version'
 
 require_relative 'interval_notation/error'
 require_relative 'interval_notation/basic_intervals'
-require_relative 'interval_notation/combiners'
+require_relative 'interval_notation/sweep_line'
 require_relative 'interval_notation/interval_set'
 require_relative 'interval_notation/operations'
 
@@ -21,51 +21,62 @@ module IntervalNotation
       R = ::IntervalNotation::R
       Empty = ::IntervalNotation::Empty
 
-      def int(str)
-        IntervalSet.from_string(str)
-      end
-
-      def oo(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(from, to)] )
+      def oo_basic(from, to)
+        BasicIntervals::OpenOpenInterval.new(from, to)
       end
 
-      def co(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedOpenInterval.new(from, to)] )
+      def co_basic(from, to)
+        BasicIntervals::ClosedOpenInterval.new(from, to)
       end
 
-      def oc(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenClosedInterval.new(from, to)] )
+      def oc_basic(from, to)
+        BasicIntervals::OpenClosedInterval.new(from, to)
       end
 
-      def cc(from, to)
+      def cc_basic(from, to)
         if from != to
-          IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+          BasicIntervals::ClosedClosedInterval.new(from, to)
         else
-          IntervalSet.new_unsafe( [BasicIntervals::Point.new(from)] )
+          BasicIntervals::Point.new(from)
         end
       end
 
-      def pt(value)
-        IntervalSet.new_unsafe( [BasicIntervals::Point.new(value)] )
+      def pt_basic(value)
+        BasicIntervals::Point.new(value)
       end
 
-      def lt(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(-Float::INFINITY, value)] )
+      def lt_basic(value)
+        BasicIntervals::OpenOpenInterval.new(-Float::INFINITY, value)
       end
 
-      def le(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenClosedInterval.new(-Float::INFINITY, value)] )
+      def le_basic(value)
+        BasicIntervals::OpenClosedInterval.new(-Float::INFINITY, value)
       end
 
-      def gt(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(value, Float::INFINITY)] )
+      def gt_basic(value)
+        BasicIntervals::OpenOpenInterval.new(value, Float::INFINITY)
       end
 
-      def ge(value)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedOpenInterval.new(value, Float::INFINITY)] )
+      def ge_basic(value)
+        BasicIntervals::ClosedOpenInterval.new(value, Float::INFINITY)
       end
 
-      module_function :oo, :co, :oc, :cc, :pt, :lt, :le, :gt, :ge, :int
+      module_function :oo_basic, :co_basic, :oc_basic, :cc_basic, :pt_basic, :lt_basic, :le_basic, :gt_basic, :ge_basic
+
+      def interval(str)
+        IntervalSet.from_string(str)
+      end
+
+      def oo(from, to);  IntervalSet.new_unsafe( [oo_basic(from, to)] );  end
+      def co(from, to);  IntervalSet.new_unsafe( [co_basic(from, to)] );  end
+      def oc(from, to);  IntervalSet.new_unsafe( [oc_basic(from, to)] );  end
+      def cc(from, to);  IntervalSet.new_unsafe( [cc_basic(from, to)] );  end
+      def pt(value);  IntervalSet.new_unsafe( [pt_basic(value)] );  end
+      def lt(value);  IntervalSet.new_unsafe( [lt_basic(value)] );  end
+      def le(value);  IntervalSet.new_unsafe( [le_basic(value)] );  end
+      def gt(value);  IntervalSet.new_unsafe( [gt_basic(value)] );  end
+      def ge(value);  IntervalSet.new_unsafe( [ge_basic(value)] );  end
+      module_function :oo, :co, :oc, :cc, :pt, :lt, :le, :gt, :ge, :interval
     end
 
     # Long syntax for interval factory methods
@@ -73,50 +84,63 @@ module IntervalNotation
       R = ::IntervalNotation::R
       Empty = ::IntervalNotation::Empty
 
-      def interval(str)
-        IntervalSet.from_string(str)
-      end
-
-      def open_open(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(from, to)] )
+      def open_open_basic(from, to)
+        BasicIntervals::OpenOpenInterval.new(from, to)
       end
 
-      def closed_open(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedOpenInterval.new(from, to)] )
+      def closed_open_basic(from, to)
+        BasicIntervals::ClosedOpenInterval.new(from, to)
       end
 
-      def open_closed(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenClosedInterval.new(from, to)] )
+      def open_closed_basic(from, to)
+        BasicIntervals::OpenClosedInterval.new(from, to)
       end
 
-      def closed_closed(from, to)
+      def closed_closed_basic(from, to)
         if from != to
-          IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+          BasicIntervals::ClosedClosedInterval.new(from, to)
         else
-          IntervalSet.new_unsafe( [BasicIntervals::Point.new(from)] )
+          BasicIntervals::Point.new(from)
         end
       end
 
-      def point(value)
-        IntervalSet.new_unsafe( [BasicIntervals::Point.new(value)] )
+      def point_basic(value)
+        BasicIntervals::Point.new(value)
       end
 
-      def less_than(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(-Float::INFINITY, value)] )
+      def less_than_basic(value)
+        BasicIntervals::OpenOpenInterval.new(-Float::INFINITY, value)
       end
 
-      def less_than_or_equal_to(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenClosedInterval.new(-Float::INFINITY, value)] )
+      def less_than_or_equal_to_basic(value)
+        BasicIntervals::OpenClosedInterval.new(-Float::INFINITY, value)
       end
 
-      def greater_than(value)
-        IntervalSet.new_unsafe( [BasicIntervals::OpenOpenInterval.new(value, Float::INFINITY)] )
+      def greater_than_basic(value)
+        BasicIntervals::OpenOpenInterval.new(value, Float::INFINITY)
       end
 
-      def greater_than_or_equal_to(value)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedOpenInterval.new(value, Float::INFINITY)] )
+      def greater_than_or_equal_to_basic(value)
+        BasicIntervals::ClosedOpenInterval.new(value, Float::INFINITY)
       end
 
+      module_function :open_open_basic, :closed_open_basic, :open_closed_basic, :closed_closed_basic, :point_basic,
+                      :less_than_basic, :less_than_or_equal_to_basic, :greater_than_basic, :greater_than_or_equal_to_basic
+
+      def interval(str)
+        IntervalSet.from_string(str)
+      end
+
+      def open_open(from, to);  IntervalSet.new_unsafe([ open_open_basic(from, to) ]);  end
+      def closed_open(from, to);  IntervalSet.new_unsafe([ closed_open_basic(from, to) ]);  end
+      def open_closed(from, to);  IntervalSet.new_unsafe([ open_closed_basic(from, to) ]);  end
+      def closed_closed(from, to);  IntervalSet.new_unsafe([ closed_closed_basic(from, to) ]);  end
+      def point(value);  IntervalSet.new_unsafe([ point_basic(value) ]);  end
+      def less_than(value);  IntervalSet.new_unsafe([ less_than_basic(value) ]);  end
+      def less_than_or_equal_to(value);  IntervalSet.new_unsafe([ less_than_or_equal_to_basic(value) ]);  end
+      def greater_than(value);  IntervalSet.new_unsafe([ greater_than_basic(value) ]);  end
+      def greater_than_or_equal_to(value);  IntervalSet.new_unsafe([ greater_than_or_equal_to_basic(value) ]);  end
+
       module_function :open_open, :closed_open, :open_closed, :closed_closed, :point,
                       :less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to,
                       :interval

data/lib/interval_notation/basic_intervals.rb

@@ -8,6 +8,9 @@ module IntervalNotation
       def closing
         !opening
       end
+      def singular_point?
+        !interval_boundary
+      end
     end
 
     module ActslikeInterval
@@ -208,7 +211,7 @@ module IntervalNotation
       def eql?(other); other.class.equal?(self.class) && value == other.value; end
       def ==(other); other.is_a?(Point) && value == other.value; end
       def interval_boundaries(interval_index)
-        BoundaryPoint.new(from, true, nil, interval_index, false)
+        [BoundaryPoint.new(from, true, nil, interval_index, false)]
       end
       def integer_points; value..value; end
 

data/lib/interval_notation/interval_set.rb

@@ -74,6 +74,16 @@ module IntervalNotation
     end
     alias covered_by? contained_by?
 
+    # Find connected component of an interval set which covers a point.
+    # Return `BasicIntervals` for this connected component or nil if point is not covered.
+    def interval_covering_point(value)
+      interval = @intervals.bsearch{|interv| value <= interv.to }
+      if interval && interval.include_position?(value)
+        interval
+      else
+        nil
+      end
+    end
 
     def bsearch_last_not_meeting_condition(arr)
       found_ind = (0...arr.size).bsearch{|idx| yield(arr[idx]) } # find first not meeting condition
@@ -220,12 +230,12 @@ module IntervalNotation
 
     # Difference between an interval set and another interval set +other+. Alias: +-+
     def subtract(other)
-      SubtractCombiner.new.combine([self, other])
+      SweepLine.make_interval_set([self, other], SweepLine::TraceState::Subtract.initial_state)
     end
 
     # Symmetric difference between an interval set and another interval set +other+. Alias: +^+
     def symmetric_difference(other)
-      SymmetricDifferenceCombiner.new.combine([self, other])
+      SweepLine.make_interval_set([self, other], SweepLine::TraceState::SymmetricDifference.initial_state)
     end
 
     # Complement of an interval set in R. Alias: +~+
@@ -245,6 +255,16 @@ module IntervalNotation
       self
     end
 
+    # Obtain nonadjacent contiguous intervals (connected components) from which whole interval set consists
+    def connected_components
+      intervals.map(&:to_interval_set)
+    end
+
+    # Create true/false `Segmentation` corresponding to an `IntervalSet`
+    def make_segmentation
+      SweepLine.make_segmentation({self => nil}, SweepLine::TraceState::Union.initial_state(1))
+    end
+
     class << self
       # auxiliary method to check that intervals are sorted and don't overlap
       def check_valid?(intervals)

data/lib/interval_notation/operations.rb

@@ -1,17 +1,17 @@
 require_relative 'interval_set'
 require_relative 'basic_intervals'
-require_relative 'combiners'
+require_relative 'sweep_line'
 
 module IntervalNotation
   module Operations
     # Union of multiple intervals.
     def union(intervals)
-      UnionCombiner.new(intervals.size).combine(intervals)
+      SweepLine.make_interval_set(intervals, SweepLine::TraceState::Union.initial_state(intervals.size))
     end
 
     # Intersection of multiple intervals
     def intersection(intervals)
-      IntersectCombiner.new(intervals.size).combine(intervals)
+      SweepLine.make_interval_set(intervals, SweepLine::TraceState::Intersection.initial_state(intervals.size))
     end
 
     module_function :union, :intersection

data/lib/interval_notation/segmentation.rb

@@ -0,0 +1,113 @@
+require_relative 'sweep_line/sweep_line'
+
+module IntervalNotation
+
+  # Segmentation is a sorted list of non-overlapping contiguous segments (singular point can be a segment too)
+  # covering whole R, i.e. (-∞; +∞).
+  # Each segment is an instance of `Segment` class, i.e. it is an interval which bear some state on it.
+  # State can be represented by any object. Intervals are expected to be `BasicIntervals`.
+  #
+  # Segmentations are treated equal if states of each point match. Thus adjacent segments can have the same state,
+  # in this case they will be glued together. Such normalization allows for comparison of segmentations.
+  # Note! Class provides no guarantees to store boundaries between same-state segments. They can be glued at any time.
+  Segmentation = Struct.new(:segments)
+  
+  # Wqe have to reopen class to make a lexical scope for Segmentation::Segment
+  class Segmentation
+    # Helper class to store a state of a segment
+    Segment = Struct.new(:interval, :state) do
+      def to_s
+        if state.is_a?(Set) # Set#to_s don't show any content. Quite uninformative
+          set_elements = '{' + state.to_a.join(', ') + '}'
+          "<#{interval}: #{set_elements}>"
+        else
+          "<#{interval}: #{state}>"
+        end
+      end
+      def inspect; to_s; end
+    end
+
+    # Don't skip validation unless you're sure, that Segmentation is a correct one
+    # Don't skip normalization unless you're sure, that all adjacent intervals are glued together:
+    # without normalization step comparison of two segmentations will give wrong results.
+    def initialize(segments, skip_validation: false, skip_normalization: false, &block)
+      super(segments, &block)
+      unless skip_validation
+        raise 'Segmentation is not valid'  unless valid?
+      end
+      join_same_state_segments!  unless skip_normalization
+    end
+
+    # Check that segments don't overlap, cover whole R, and go one-after-another
+    private def valid?
+      return false  if segments.empty?
+      return false  unless segments.all?{|segment|
+        segment.is_a?(Segment)
+      }
+      return false  unless segments.all?{|segment|
+        interval = segment.interval
+        interval.respond_to?(:from) && interval.respond_to?(:include_from?) && \
+        interval.respond_to?(:to) && interval.respond_to?(:include_to?)
+      }
+      first_interval = segments.first.interval
+      last_interval = segments.last.interval
+      return false  unless first_interval.from == -Float::INFINITY && last_interval.to == Float::INFINITY
+      return false  unless segments.each_cons(2).all?{|segment_1, segment_2|
+        segment_1.interval.to == segment_2.interval.from && (segment_1.interval.include_to? ^ segment_2.interval.include_from?)
+      }
+      true
+    end
+
+    # Join adjacent intervals with exactly the same state in order to compactify and normalize segmentation
+    private def join_same_state_segments!
+      new_segments = segments.chunk(&:state).map{|state, same_state_segments|
+        intervals = same_state_segments.map(&:interval) # ToDo: optimize; don't map all segments, only the first and the last ones
+        interval = BasicIntervals.interval_by_boundary_inclusion(
+          intervals.first.include_from?, intervals.first.from,
+          intervals.last.include_to?, intervals.last.to)
+        Segment.new(interval, state)
+      }
+      self.segments = new_segments
+    end
+
+    def to_s; "Segmentation: #{segments}"; end
+    def inspect; to_s; end
+
+    # Make true/false segmentation based on block result. Block takes a Segment.
+    # If block not specified, state is converted to boolean.
+    # If block specified, its result is converted to boolean.
+    def boolean_segmentation(&block)
+      if block_given?
+        map_state{|segment| !!block.call(segment) }
+      else
+        map_state{|segment| !!segment.state }
+      end
+    end
+
+    # Transform segmentation into interval set according with block result.
+    # Block takes a Segment and its result'd indicate whether to include corresponding interval into interval set
+    def make_interval_set(&block)
+      intervals = boolean_segmentation(&block).segments.select(&:state).map(&:interval)
+      IntervalSet.new( intervals )
+    end
+
+    # Method `#map_state` returns a new segmentation with the same boundaries and different states
+    # Block for `#map_state` takes a segment and returns new state of segment
+    def map_state(&block)
+      new_segments = segments.map{|segment| Segment.new(segment.interval, block.call(segment)) }
+      Segmentation.new(new_segments, skip_validation: true) # here we can skip validation but not normalization
+    end
+
+    # Find a segment in which specifying point falls. It always exist, so it can't return nil. 
+    def segment_covering_point(value)
+      segment_index = (0...segments.size).bsearch{|segment_index| value <= segments[segment_index].interval.to }
+      segment = segments[segment_index]
+      if segment.interval.include_position?(value)
+        segment
+      else
+        segments[segment_index + 1]
+      end
+    end
+  end
+
+end