borel 0.2.0 → 0.3.0

data/README.md

@@ -15,13 +15,15 @@ Borelian sets are formed by enumerable union, intersection or
 Install
 -------
 
-You may install it traditionally, for interactive sessions:
+You may install it traditionally, tipically for interactive sessions:
 
-    gem install borel
+    $ gem install borel
 
 Or just put this somewhere on your application's `Gemfile`
 
-    gem 'borel'
+```ruby
+gem 'borel'
+```
 
 Usage
 -----
@@ -102,15 +104,29 @@ __minus__ and __-__
 Interval[0,5] - Interval[-1,3] # -> Interval[3,5]
 ```
 
-### Classes of Intervals
+Generic Intervals
+-----------------
+
+You may use any **Comparable** class:
 
-You may use any comparable class
+* String
 
 ```ruby
 Interval['a','c'] ^ Interval['b','d'] # -> Interval['b','c']
 Interval['a','c'] | Interval['b','d'] # -> Interval['a','d']
 ```
 
+* Time
+
+```ruby
+def t(seconds)
+  Time.now + seconds
+end
+
+Interval[t(1),t(5)] ^ Interval[t(3),t(7)] # -> Interval[t(3),t(5)]
+Interval[t(1),t(2)] | Interval[t(3),t(4)] # -> Interval[[t(1),t(2)],[t(3),t(4)]]
+```
+
 Math Extensions
 ---------------
 
@@ -118,8 +134,10 @@ By requiring `borel/math_extensions` you are provided with some natural
 math-related interval methods:
 
 ```ruby
+require 'borel/math_extensions'
+
 Interval[1,5].rand  # -> Random.new.rand 1..5
-Interval[1,5].width # -> 5-1 or 4
+Interval[1,5].width # -> 5-1, only for simple intervals
 ```
 
 It's supported only for Numeric Comparable and arithmetic supported classes
@@ -127,9 +145,9 @@ It's supported only for Numeric Comparable and arithmetic supported classes
 Remarks
 -------
 
-* There is no distinction between **open** and **closed**intervals
-* Complement and Minus operations have limited support for
-non numeric-comparable classes
+* There is no distinction between _open_ and _closed_ intervals
+* _complement_ and _minus_ operations, and also _Math Extensions_ have limited
+support for non numeric-comparable classes
 
 License
 -------

data/lib/borel.rb

@@ -1,3 +1,6 @@
 require 'borel/interval'
+
+require 'borel/array'
 require 'borel/range'
 require 'borel/numeric'
+require 'borel/nil_class'

data/lib/borel/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def to_interval
+    Interval[*self]
+  end
+end

data/lib/borel/interval.rb

@@ -25,180 +25,96 @@ class Interval
 
   def Interval.union(*array)
     l = []
-    array.map(&:components).flatten.sort_by(&:inf).each{|x|
+    array.map(&:components).flatten.sort_by(&:inf).each do |x|
       if x.sup < x.inf
-        # skip it
+        next
       elsif l.empty? || x.inf > l.last.sup
         l <<= x
       elsif x.sup > l.last.sup
         l[-1] = Simple.new(l.last.inf, x.sup)
       end
-    }
-    if l.size == 1
-      l.first
-    else
-      Multiple.new(l)
     end
+    if l.size == 1 then l.first else Multiple.new(l) end
   end
 
-  def construction
-    map{|x| x.extrema.uniq}
+  def union(other)
+    Interval.union(other.to_interval, self)
   end
 
-  def simple?
-    false
+  def intersect(other)
+    other.to_interval.map{|y| map{|x| x.intersect(y)}}.
+      flatten.reduce(:union) || Interval[]
   end
 
-  def inspect
-    "Interval" + construction.inspect
+  def complement
+    map{|x| x.to_interval.map(&:complement).reduce(:intersect)}.
+      flatten.reduce(:union)
   end
 
-  def to_s
-    inspect
+  def minus(other)
+    if other.empty?
+      self
+    else
+      map{|x| other.to_interval.map{|y| x.minus(y)}.reduce(:intersect)}.
+        flatten.reduce(:union) || Interval[]
+    end
   end
 
   def ==(other)
-    self.components == other.components
+    construction == other.construction
   end
 
   def include?(x)
     any?{|i| i.include? x}
   end
 
-  def to_interval
-    self
-  end
-
-  def coerce(other)
-    [other.to_interval, self]
-  end
-
   def empty?
     components.empty?
   end
 
-  def degenerate?
-    all? {|x| x.degenerate?}
-  end
-
-  def hull
-    if empty?
-      Interval[]
-    else
-      Interval[components.first.inf, components.last.sup]
-    end
-  end
-
-  def union(other)
-    Interval.union(other.to_interval, self)
-  end
-
-  def +(other)
-    self | other
-  end
-
-  def ^(other)
-    self & other
+  def construction
+    map &:construction
   end
 
-  def |(other)
-    self.union other.to_interval
+  def degenerate?
+    all? &:degenerate?
   end
 
-  [[:&, :intersect]].each do |op, meth|
-    define_method(op) {|other|
-      (other.to_interval.map{|y| map{|x| x.send(meth,y)}}.flatten).reduce(:|) || Interval[]
-    }
+  def to_interval
+    self
   end
 
-  [[:~, :complement]].each do |op, meth|
-    define_method(op) {
-      map{|x| x.to_interval.map(&meth).reduce(:&)}.flatten.reduce(:|)
-    }
+  def inspect
+    "Interval" + construction.inspect
   end
 
-  [[:-, :minus]].each do |op, meth|
-    define_method(op) {|other|
-      if other.empty?
-        self
-      else
-        map{|x| other.to_interval.map{|y| x.send(meth,y)}.reduce(:&)}.flatten.reduce(:|) || Interval[]
-      end
-    }
+  def to_s
+    inspect
   end
-end
-
-class Interval::Simple < Interval
-  include Enumerable
-
-  attr :inf
-  attr :sup
 
-  def each
-    yield(self)
-    self
+  def inf
+    first.inf
   end
 
-  def components
-    [self]
+  def sup
+    last.sup
   end
 
-  def initialize (a, b = a)
-    if (a.respond_to?(:nan?) && a.nan? ) || (b.respond_to?(:nan?) && b.nan?)
-      @inf, @sup = -Infinity, Infinity
+  def hull
+    if empty?
+      Interval[]
     else
-      @inf, @sup = a, b
+      Interval[inf, sup]
     end
-    freeze
-  end
-
-  def ==(other)
-    [inf, sup] == [other.inf, other.sup]
-  end
-
-  def intersect(other)
-    Interval[[inf, other.inf].max, [sup, other.sup].min]
-  end
-
-  def complement
-    Interval[-Infinity,inf] | Interval[sup,Infinity]
   end
 
-  def minus (other)
-    self & ~other
-  end
-
-  def construction
-    extrema.uniq
-  end
-
-  def simple?
-    true
-  end
-
-  def include?(x)
-    inf <= x  && x <= sup
-  end
-
-  def extrema
-    [inf, sup]
-  end
-
-  def degenerate?
-    inf == sup
-  end
+  alias_method :+, :union
+  alias_method :|, :union
+  alias_method :&, :intersect
+  alias_method :^, :intersect
+  alias_method :~, :complement
+  alias_method :-, :minus
 end
 
-class Interval::Multiple < Interval
-  attr :components
-
-  def initialize(array)
-    @components = array
-    freeze
-  end
-
-  def each
-    components.each{|o| yield(o)}
-    self
-  end
-end
+require 'borel/interval_multiple'
+require 'borel/interval_simple'

data/lib/borel/interval_multiple.rb

@@ -0,0 +1,17 @@
+class Interval::Multiple < Interval
+  attr :components
+
+  def initialize(array)
+    @components = array
+    freeze
+  end
+
+  def each
+    components.each{|o| yield(o)}
+    self
+  end
+
+  def simple?
+    false
+  end
+end

data/lib/borel/interval_simple.rb

@@ -0,0 +1,53 @@
+class Interval::Simple < Interval
+  attr :inf, :sup
+
+  def initialize (a, b = a)
+    if (a.respond_to?(:nan?) && a.nan?) || (b.respond_to?(:nan?) && b.nan?)
+      @inf, @sup = -Infinity, Infinity
+    else
+      @inf, @sup = a, b
+    end
+    freeze
+  end
+
+  def each
+    yield(self)
+    self
+  end
+
+  def intersect(other)
+    Interval[[inf, other.inf].max, [sup, other.sup].min]
+  end
+
+  def complement
+    Interval[[-Infinity, inf], [sup, Infinity]]
+  end
+
+  def minus(other)
+    other.complement.intersect self
+  end
+
+  def components
+    [self]
+  end
+
+  def extrema
+    [inf, sup]
+  end
+
+  def construction
+    extrema.uniq
+  end
+
+  def include?(x)
+    inf <= x && x <= sup
+  end
+
+  def degenerate?
+    inf == sup
+  end
+
+  def simple?
+    true
+  end
+end

data/lib/borel/version.rb

@@ -1,6 +1,6 @@
 module Borel
   MAJOR = 0
-  MINOR = 2
+  MINOR = 3
   TINY = 0
 
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/array_spec.rb

@@ -0,0 +1,18 @@
+require 'borel/interval'
+require 'borel/array.rb'
+
+describe Array do
+  context "#to_interval" do
+    specify "[] -> Interval[]" do
+      [].to_interval.should eq Interval[]
+    end
+
+    specify "[1,2] -> Interval[1,2]" do
+      [1,2].to_interval.should eq Interval[1,2]
+    end
+
+    specify "[[1,2],[3,4]] -> Interval[[1,2],[3,4]]" do
+      [[1,2],[3,4]].to_interval.should eq Interval[[1,2],[3,4]]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: borel
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-24 00:00:00.000000000 Z
+date: 2012-04-09 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Borel sets are made of enumerable union and intersection of
 
@@ -31,8 +31,11 @@ files:
 - Rakefile
 - borel.gemspec
 - lib/borel.rb
+- lib/borel/array.rb
 - lib/borel/errors.rb
 - lib/borel/interval.rb
+- lib/borel/interval_multiple.rb
+- lib/borel/interval_simple.rb
 - lib/borel/math_extensions.rb
 - lib/borel/math_extensions/interval_arithmetic.rb
 - lib/borel/math_extensions/randomizable.rb
@@ -40,6 +43,7 @@ files:
 - lib/borel/numeric.rb
 - lib/borel/range.rb
 - lib/borel/version.rb
+- spec/array_spec.rb
 - spec/interval_spec.rb
 - spec/math_extensions/interval_arithmetic_spec.rb
 - spec/math_extensions/randomizable_spec.rb
@@ -69,8 +73,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: borel
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Generic ordered set's operations
 test_files: []
+has_rdoc: