interval_notation 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4160164096cbfcc4f171ce43a2c460fb1d3df70c
-  data.tar.gz: 3b4f604be240d5d714bd1eacfc3b158c41de7287
+  metadata.gz: 48b23bd79ddea327e0d8da11597e387ef1df690a
+  data.tar.gz: 6911357f55445730fcf793991412b74830ac510f
 SHA512:
-  metadata.gz: a5988e37f501ec499213a5eee17c63012c99d5d55df1f3e076e62bab39f11b03f3a5b60958e109b8b07237499bab442bb0688f3da0a176da827d3f487fa62fb8
-  data.tar.gz: c89451349d28a973a45ec6ed7017be6502be18bb9e72745031d638b2763aaa825d57266abc708696e8c5fbb7bc5ab0eee44bd2ee9a1038beb9082ef994d5fe4d
+  metadata.gz: ca29426c646771b4cc577d64d2ce15d5856daf22f84bba9aa8b2be2912f047881041d8ef92926bb31989e6101de8f8935f6a1b13bd3dbedd9a94478b1cb57100
+  data.tar.gz: 1c7571f48cf241d8e8876070e1a9417421cb145b1aa3bf1e9289d90bb7de8b5fb27bf1f3af9163e9675fd45fe6d4307e9b34095984fed8c6d9bf64baf843ce9f

data/TODO.md

@@ -1,3 +1,7 @@
 * Write benchmarks
-* Optimize `#closure` and `#intersect?`
+* Optimize `#closure`, `#complement`
 * Visualization in console and in IRuby (how to scale into 80-symbol or 1200px screen); SVG; TeX formatters
+* Remove old git history related to mTOR project
+* 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

data/interval_notation.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
 end

data/lib/interval_notation/basic_intervals.rb

@@ -38,6 +38,9 @@ module IntervalNotation
       def from_finite?; from.to_f.finite?; end
       def to_finite?; to.to_f.finite?; end
       def finite?; from_finite? && to_finite?; end
+      def from_infinite?; from.to_f.infinite?; end
+      def to_infinite?; to.to_f.infinite?; end
+      def infinite?; from_infinite? || to_infinite?; end
 
       def from_to_s; from_finite? ? from : MINUS_INFINITY_SYMBOL; end
       def to_to_s; to_finite? ? to : PLUS_INFINITY_SYMBOL; end
@@ -85,6 +88,7 @@ module IntervalNotation
       def include_to?; true; end
 
       def to_finite?; true; end
+      def to_infinite?; false; end
       def to_to_s; to; end
 
       def closure
@@ -116,6 +120,7 @@ module IntervalNotation
       def include_to?; false; end
 
       def from_finite?; true; end
+      def from_infinite?; false; end
       def from_to_s; from; end
 
       def closure
@@ -149,6 +154,9 @@ module IntervalNotation
       def from_finite?; true; end
       def to_finite?; true; end
       def finite?; true; end
+      def from_infinite?; false; end
+      def to_infinite?; false; end
+      def infinite?; false; end
       def from_to_s; from; end
       def to_to_s; to; end
 
@@ -177,6 +185,9 @@ module IntervalNotation
       def from_finite?; true; end
       def to_finite?; true; end
       def finite?; true; end
+      def from_infinite?; false; end
+      def to_infinite?; false; end
+      def infinite?; false; end
 
       def length; 0; end
       def to_s; "{#{@value}}"; end

data/lib/interval_notation/combiners.rb

@@ -4,7 +4,10 @@ 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
+  # 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
@@ -15,6 +18,49 @@ module IntervalNotation
       @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.

data/lib/interval_notation/interval_set.rb

@@ -220,12 +220,12 @@ module IntervalNotation
 
     # Difference between an interval set and another interval set +other+. Alias: +-+
     def subtract(other)
-      Operations.combine([self, other], SubtractCombiner.new)
+      SubtractCombiner.new.combine([self, other])
     end
 
     # Symmetric difference between an interval set and another interval set +other+. Alias: +^+
     def symmetric_difference(other)
-      Operations.combine([self, other], SymmetricDifferenceCombiner.new)
+      SymmetricDifferenceCombiner.new.combine([self, other])
     end
 
     # Complement of an interval set in R. Alias: +~+

data/lib/interval_notation/operations.rb

@@ -4,59 +4,16 @@ require_relative 'combiners'
 
 module IntervalNotation
   module Operations
-    # Internal method which combines intervals according to an algorithm given by a combiner.
-    # Combiner tells whether current section or point should be included to a new interval.
-    def combine(interval_sets, combiner)
-      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|
-        combiner.pass(points_on_place)
-
-        if combiner.previous_state
-          if combiner.state
-            unless combiner.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 = combiner.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 combiner.state
-            from = point_value
-            incl_from = combiner.include_last_point
-          else
-            intervals << BasicIntervals::Point.new(point_value)  if combiner.include_last_point
-          end
-        end
-      end
-      IntervalSet.new_unsafe(intervals)
-    end
-
     # Union of multiple intervals.
     def union(intervals)
-      combine(intervals, UnionCombiner.new(intervals.size))
+      UnionCombiner.new(intervals.size).combine(intervals)
     end
 
     # Intersection of multiple intervals
     def intersection(intervals)
-      combine(intervals, IntersectCombiner.new(intervals.size))
+      IntersectCombiner.new(intervals.size).combine(intervals)
     end
 
-    module_function :combine, :union, :intersection
+    module_function :union, :intersection
   end
 end

data/lib/interval_notation/version.rb

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

data/lib/interval_notation.rb

@@ -38,7 +38,11 @@ module IntervalNotation
       end
 
       def cc(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+        if from != to
+          IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+        else
+          IntervalSet.new_unsafe( [BasicIntervals::Point.new(from)] )
+        end
       end
 
       def pt(value)
@@ -86,7 +90,11 @@ module IntervalNotation
       end
 
       def closed_closed(from, to)
-        IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+        if from != to
+          IntervalSet.new_unsafe( [BasicIntervals::ClosedClosedInterval.new(from, to)] )
+        else
+          IntervalSet.new_unsafe( [BasicIntervals::Point.new(from)] )
+        end
       end
 
       def point(value)

data/spec/interval_notation_spec.rb

@@ -59,6 +59,13 @@ describe IntervalNotation do
     end
   end
 
+  describe 'closed_closed helper' do
+    specify 'closed_closed(x,x) returns point(x)' do
+      expect(cc(3,3)).to eq(pt(3))
+      expect(IntervalNotation::Syntax::Long.closed_closed(3,3)).to eq(IntervalNotation::Syntax::Long.point(3))
+    end
+  end
+
   describe '.to_s' do
     {
       Empty => '∅',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interval_notation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-27 00:00:00.000000000 Z
+date: 2015-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
 description: interval_notation provides methods to create intervals with open or closed
   boundaries or singular points, unite and intersect them, check inclusion into an
   interval and so on.
@@ -85,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: interval_notation allows one to work with 1D-intervals.