borel 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/.rspec

@@ -0,0 +1 @@
+--colour

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2012 Amadeus Folego
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+Borel
+=====
+
+Borelian sets are sets formed by the enumerable union and intersection, or the complement, of intervals in the Real line.
+
+**Borel** aims to make it really easy to make union and intersection operations of interval in any ordered set.

data/Rakefile

@@ -0,0 +1,6 @@
+task_file_pattern = File.expand_path("../tasks/**/*.rb", __FILE__)
+Dir[task_file_pattern].each do |task_file|
+  require File.expand_path(task_file)
+end
+
+task :default => [ :rspec ]

data/borel.gemspec

@@ -0,0 +1,17 @@
+require 'borel/version.rb'
+
+Gem::Specification.new do |s|
+  s.name = "borel"
+  s.version = Borel.version
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Amadeus Folego"]
+  s.email = ["amadeusfolego@gmail.com"]
+  s.homepage = "http://github.com/amadeusfolego/borel"
+  s.summary = "Generic ordered set's operations"
+  s.description = "Borel sets are made of enumerable union and intersection of intervals. Borel performs regular set operations on any interval of a Comparable class."
+  s.rubyforge_project = s.name
+  s.required_ruby_version = ">= 1.9.3"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+end

data/lib/borel.rb

@@ -0,0 +1,3 @@
+require 'borel/interval'
+require 'borel/range'
+require 'borel/numeric'

data/lib/borel/interval.rb

@@ -0,0 +1,226 @@
+Infinity = 1/0.0
+
+class Interval
+  include Enumerable
+
+  def Interval.[](*array)
+    union(*
+      if array.empty?
+        []
+      elsif array.first.kind_of?(Array)
+        array.select{|x| !x.empty?}.map{|x| Simple.new(*x)}
+      else
+        [Simple.new(*array)]
+      end
+    )
+  rescue
+    unless
+        array.size <= 2 || array.all?{|x| Array === x && x.size <= 2}
+      raise Exception::Construction, array
+    end
+    raise
+  end
+
+  def Interval.union(*array)
+    l = []
+    array.map(&:components).flatten.sort_by(&:inf).each{|x|
+      if x.sup < x.inf
+        # skip it
+      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
+  end
+
+  def construction
+    map{|x| x.extrema.uniq}
+  end
+
+  def simple?
+    false
+  end
+
+  def inspect
+    "Interval" + construction.inspect
+  end
+
+  def to_s
+    inspect
+  end
+
+  def ==(other)
+    self.components == other.components
+  end
+
+  def include?(x)
+    any?{|i| i.include? x}
+  end
+
+  def to_interval
+    self
+  end
+
+  def coerce(other)
+    [other.to_interval, self]
+  end
+
+  def +(other)
+    self | other
+  end
+
+  def ^(other)
+    self & other
+  end
+
+  def |(other)
+    Interval.union(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
+
+  [[:&, :intersect]].each do |op, meth|
+    define_method(op) {|other|
+      (other.to_interval.map{|y| map{|x| x.send(meth,y)}}.flatten).reduce(:|)
+    }
+  end
+
+  [[:~, :complement]].each do |op, meth|
+    define_method(op) {
+      map{|x| x.to_interval.map(&meth).reduce(:&)}.flatten.reduce(:|)
+    }
+  end
+
+  [[:-, :minus]].each do |op, meth|
+    define_method(op) {|other|
+      map{|x| other.to_interval.map{|y| x.send(meth,y)}.reduce(:&)}.flatten.reduce(:|)
+    }
+  end
+end
+
+class Interval::Simple < Interval
+  include Enumerable
+
+  attr :inf
+  attr :sup
+
+  def each
+    yield(self)
+    self
+  end
+
+  def components
+    [self]
+  end
+
+  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 ==(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
+end
+
+class Interval::Multiple < Interval
+
+  attr :components
+
+  def initialize(array)
+    @components = array
+    freeze
+  end
+
+  def each
+    components.each{|o| yield(o)}
+    self
+  end
+end
+
+module Borel
+  class Construction < ArgumentError
+    def initialize(array)
+      super(
+        "An interval can only be constructed either from at most two " \
+        "numbers or from a sequence of arrays of at most two numbers: " +
+        array.inspect)
+    end
+  end
+
+  class NonDegenerate < ArgumentError
+    def initialize(i)
+      super("#{i.inspect} is not degenerate.")
+    end
+  end
+
+  class NonSimple < ArgumentError
+    def initialize(i)
+      super("#{i.inspect} is not simple.")
+    end
+  end
+
+  class OpenRight < ArgumentError
+    def initialize(range)
+      super(
+        "Cannot construct an interval from a three-dot range " \
+        "with end-value #{range.last.inspect}.")
+    end
+  end
+end

data/lib/borel/numeric.rb

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

data/lib/borel/range.rb

@@ -0,0 +1,13 @@
+class Range
+  def to_interval
+    Interval[first,
+      if exclude_end?
+        (last - 1).succ - 1
+      else
+        last
+      end]
+  rescue NoMethodError
+    raise Borel::OpenRight, self if exclude_end? && !last.respond_to?(:succ)
+    raise
+  end
+end

data/lib/borel/version.rb

@@ -0,0 +1,11 @@
+module Borel
+  MAJOR = 0
+  MINOR = 0
+  TINY = 1
+
+  VERSION = [MAJOR, MINOR, TINY].join('.')
+
+  def self.version
+    VERSION
+  end
+end

data/spec/interval_spec.rb

@@ -0,0 +1,116 @@
+require 'borel/interval'
+
+describe Interval do
+  context '#intersection' do
+
+    it "[]^[0,3] = []" do
+      pending
+      (Interval[] ^ Interval[0,3]).should eq Interval[]
+    end
+
+    it "[0,3]^[] = []" do
+      pending
+      (Interval[0,3] ^ Interval[]).should eq Interval[]
+    end
+
+    it "[0,2]^[1] = [1]" do
+      (Interval[0,2] ^ Interval[1]).should eq Interval[1]
+    end
+
+    it "[-infty, infty]^[0,1] = [0,1]" do
+      (Interval[-Infinity, Infinity] ^ Interval[0,1]).should eq Interval[0,1]
+    end
+
+    it "[0,3]^[1,2] = [1,2]" do
+      (Interval[0,3] ^ Interval[1,2]).should eq Interval[1,2]
+    end
+
+    it "[[-2,-1],[1,2]]^[[0,3],[4,5]] = [1,2]" do
+      (Interval[[-2,-1],[1,2]] ^ Interval[[0,3],[4,5]]).should eq Interval[1,2]
+    end
+  end
+
+  context '#union' do
+    it "[0,3]U[1,2] = [0,3]" do
+      (Interval[0,3] | Interval[1,2]).should eq Interval[0,3]
+    end
+
+    it "[1,2]U[0,3] = [0,3]" do
+      (Interval[1,2] | Interval[0,3]).should eq Interval[0,3]
+    end
+
+    it "[1,2]U[1,2] = [1,2]" do
+      (Interval[1,2] | Interval[1,2]).should eq Interval[1,2]
+    end
+
+    it "[1,2]U[2,3] = [1,3]" do
+      (Interval[1,2] | Interval[2,3]).should eq Interval[1,3]
+    end
+
+    it "[1,2]U[3,4] = [[1,2],[3,4]]" do
+      (Interval[1,2] | Interval[3,4]).should eq Interval[[1,2],[3,4]]
+    end
+  end
+
+  context '#minus' do
+    it "[2,3]-(0,1) = [2,3]" do
+      (Interval[2,3] - Interval[0,1]).should eq Interval[2,3]
+    end
+
+    it '[0,1]-(2,3) = [0,1]' do
+      (Interval[0,1] - Interval[2,3]).should eq Interval[0,1]
+    end
+
+    it '[1,2]-(0,3) = []' do
+      (Interval[1,2] - Interval[0,3]).should be_empty
+    end
+
+    it '[0,3]-(1,2) = [0,1]U[2,3]' do
+      (Interval[0,3] - Interval[1,2]).should eq Interval[[0,1],[2,3]]
+    end
+
+    it '[0,1]-(0,1) = [0]U[1]' do
+      (Interval[0,1] - Interval[0,1]).should eq Interval[0] | Interval[1]
+    end
+
+    it '[1,2]-(2,3) = [1,2]' do
+      (Interval[1,2] - Interval[2,3]).should eq Interval[1,2]
+    end
+
+    it '[2,3]-(1,2) = [2,3]' do
+      (Interval[2,3] - Interval[1,2]).should eq Interval[2,3]
+    end
+
+    it '[1,4]-(0,3) = [3,4]' do
+      (Interval[1,4] - Interval[0,3]).should eq Interval[3,4]
+    end
+
+    it '[1,3]-(2,4) = [1,2]' do
+      (Interval[1,3] - Interval[2,4]).should eq Interval[1,2]
+    end
+
+    it '[1,4]-(1,3) = [1]U[3,4]' do
+      (Interval[1,4] - Interval[1,3]).should eq Interval[3,4] | Interval[1]
+    end
+
+    it '[1,4]-(1,5) = [1]' do
+      (Interval[1,4] - Interval[1,5]).should eq Interval[1]
+    end
+
+    it '[1,3]-(2,3) = [1,2]U[3]' do
+      (Interval[1,3] - Interval[2,3]).should eq Interval[1,2] | Interval[3]
+    end
+
+    it '[1,3]-(0,3) = [3]' do
+      (Interval[1,3] - Interval[0,3]).should eq Interval[3]
+    end
+
+    it '[-infty,infty]-[0,1] = [-infty,0]U[1,infty]' do
+      (Interval[-Infinity,Infinity] - Interval[0,1]).should eq Interval[-Infinity,0]|Interval[1,Infinity]
+    end
+
+    it '[0,1]-[-infty,infty] = []' do
+      (Interval[0,1] - Interval[-Infinity,Infinity]).should eq Interval[]
+    end
+  end
+end

data/spec/range_spec.rb

@@ -0,0 +1,30 @@
+require 'borel/interval'
+require 'borel/range'
+
+describe Range do
+  context '#to_interval' do
+    it '(1..3) should be [1,3]' do
+      (1..3).to_interval.should eq Interval[1,3]
+    end
+
+    it '(1...3) should be [1,2]' do
+      (1...3).to_interval.should eq Interval[1,2]
+    end
+
+    it '(1..Infinity) should be [1,infty]' do
+      (1..Infinity).to_interval.should eq Interval[1,Infinity]
+    end
+
+    it '(1...Infinity) should raise OpenRight' do
+      expect{(1...Infinity).to_interval}.to raise_error Borel::OpenRight
+    end
+
+    it '(-Infinity..1) should be [-infty,1]' do
+      (-Infinity..1).to_interval.should eq Interval[-Infinity,1]
+    end
+
+    it '(-Infinity..Infinity) should be [-infty,infty]' do
+      (-Infinity..Infinity).to_interval.should eq Interval[-Infinity,Infinity]
+    end
+  end
+end

data/tasks/gem.rb

@@ -0,0 +1,28 @@
+gemspec = eval(File.read("borel.gemspec"))
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc "Build gem locally"
+task :build => :gemspec do
+  system "gem build #{gemspec.name}.gemspec"
+  FileUtils.mkdir_p "pkg"
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", "pkg"
+end
+
+desc "Install gem locally"
+task :install => :build do
+  system "gem install pkg/#{gemspec.name}-#{gemspec.version}"
+end
+
+desc "Launches interactive console with borel"
+task :console => :install do
+  system "irb -r #{gemspec.name}"
+end
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+end

data/tasks/rspec.rb

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+
+desc "Run specifications"
+RSpec::Core::RakeTask.new(:rspec)

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: borel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Amadeus Folego
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-12 00:00:00.000000000 Z
+dependencies: []
+description: Borel sets are made of enumerable union and intersection of intervals.
+  Borel performs regular set operations on any interval of a Comparable class.
+email:
+- amadeusfolego@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- MIT-LICENSE
+- README.md
+- Rakefile
+- borel.gemspec
+- lib/borel.rb
+- lib/borel/interval.rb
+- lib/borel/numeric.rb
+- lib/borel/range.rb
+- lib/borel/version.rb
+- spec/interval_spec.rb
+- spec/range_spec.rb
+- tasks/gem.rb
+- tasks/rspec.rb
+homepage: http://github.com/amadeusfolego/borel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: borel
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Generic ordered set's operations
+test_files: []