intervals 0.4.76 → 0.5.83

data/VERSION.txt

@@ -1 +1 @@
-0.4.76
+0.5.83

data/lib/interval.rb

@@ -27,10 +27,6 @@ end
 class Interval
   include Enumerable
 
-  # Exception class for failed preconditions on construction arguments.
-  class ConstructionError < ArgumentError
-  end
-
   # Create a closed (multi-)interval with the given numerical extrema.
   #
   #  Interval[3]              # In mathematical notation: [3,3]
@@ -55,9 +51,7 @@ class Interval
     unless
         array.all?{|x| Numeric === x} && array.size <= 2 ||
         array.all?{|x| Array === x && x.size <= 2 && x.all?{|c| Numeric === c}}
-      raise ConstructionError,
-        "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}"
+      raise Exception::Construction, array
     end
     raise
   end
@@ -99,6 +93,17 @@ class Interval
     }.transpose.first
   end
 
+  # Construct an interval by evaluating the given block using rounding
+  # down and rounding up modes.
+  #
+  #  Interval.eval{1/3.0}     # => Interval[0.333333333333333, 0.333333333333333]
+  #
+  def Interval.eval(&block)
+    Simple.new(
+      FPU.down {block.call},
+      FPU.up   {block.call})
+  end
+
   # Returns a list of the parameters that can be used to reconstruct the
   # interval.
   #
@@ -349,6 +354,14 @@ class Interval
     all? {|x| x.sharp?}
   end
 
+  # An interval is degenerate if each component includes exactly one element.
+  #
+  #  Interval
+  #
+  def degenerate?
+    all? {|x| x.degenerate?}
+  end
+
   # The hull is the smallest simple interval containing the interval itself.
   #
   #  Interval[[1,2],[3,4]]    # => Interval[1, 4]
@@ -516,6 +529,21 @@ class Interval::Simple < Interval
     (inf + sup) * 2 **-1
   end
 
+  # If the interval is degenerate, return its only element, else raise an exception.
+  #
+  #  Interval.eval{1/2.0}.number
+  #                           # => 0.5
+  #  Interval.eval{1/3.0}.number
+  #                           # fails
+  #
+  def number
+    if inf == sup
+      inf
+    else
+      raise Exception::Nondegenerate, self
+    end
+  end
+
   # Used to implement Interval's plus operator (\+).
   def add (other)
     self.class.new(
@@ -528,7 +556,7 @@ class Interval::Simple < Interval
     self.class.new(-sup,-inf)
   end
 
-  # Dependent subtraction, i.e., the inverse of the addition
+  # Dependent subtraction, i.e., the inverse of the addition.
   #
   #  Interval[3,4].dsub Interval[1,2]
   #                           # => Interval[2]
@@ -604,12 +632,17 @@ class Interval::Simple < Interval
       true
     elsif w.kind_of?(Float) && (inf >= 0  || sup <= 0)
       s1, s2 = extrema.map{|x| x.abs}.sort
-      s1 + s1.ulp == s2
+      s1 + s1.to_f.ulp == s2
     else
       false
     end
   end
 
+  # Implements Interval#degenerate?
+  def degenerate?  # :nodoc:
+    inf == sup
+  end
+
   # Implements Interval#exp
   def exp  #:nodoc:
     self.class.new(FPU.exp_down(inf), FPU.exp_up(sup))
@@ -714,6 +747,14 @@ class Interval::Multiple < Interval
     self
   end
 
+  # Raise more expressive exceptions than NoMethodError when invoking
+  # methods specific to simple intervals
+  [:number,:midpoint,:width].each{|f|
+    define_method(f) {
+      raise Exception::Nonsimple, self
+    }
+  }
+
 end
 
 class Range
@@ -733,8 +774,7 @@ class Range
       end]
   rescue NoMethodError
     if exclude_end? && !last.respond_to?(:succ)
-      raise Interval::ConstructionError,
-      "A three-dot range with non-discrete upper bound cannot be made into a closed interval"
+      raise Interval::Exception::OpenRight, self
     end
     raise
   end
@@ -749,6 +789,44 @@ class Interval
   # The sharp interval that includes Pi.
   PI = Math::PI + Interval[0, 2 ** -51]
 
+  # Module for the possible interval exceptions.
+  module Exception
+
+    # Exception class for failed preconditions on construction arguments.
+    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
+
+    # Exception class for a failed precondition on an interval being degenerate.
+    class Nondegenerate < ArgumentError
+      def initialize(i)
+        super("#{i.inspect} is not degenerate.")
+      end
+    end
+
+    # Exception class for a failed precondition on an interval being simple.
+    class Nonsimple < ArgumentError
+      def initialize(i)
+        super("#{i.inspect} is not simple.")
+      end
+    end
+
+    # Exception class for failed preconditions on range type.
+    class OpenRight < ArgumentError
+      def initialize(range)
+        super(
+          "Cannot construct an interval from a three-dot range " \
+          "with end-value of type #{range.last.class}.")
+      end
+    end
+
+  end
+
 end
 
 require File.dirname(__FILE__) + '/../test/test_interval.rb' if __FILE__ == $0

data/test/assertions.rb

@@ -0,0 +1,23 @@
+require 'test/unit/assertions'
+
+module Test
+  module Unit
+    module Assertions
+
+      def assert_predicate(x, predicate, message = nil)
+        template = "<?> should be ?, but it is not."
+        assert_block(
+          build_message(message, template, x, predicate.to_s.gsub(/\?$/){})
+        ) { x.send(predicate) }
+      end
+
+      def assert_not_predicate(x, predicate, message = nil)
+        template = "<?> is ?."
+        assert_block(
+          build_message(message, template, x, predicate.to_s.gsub(/\?$/){})
+        ) { !x.send(predicate) }
+      end
+
+    end
+  end
+end

data/test/test_fpu.rb

@@ -22,26 +22,26 @@ class FPU::TestRounding < Test::Unit::TestCase
 
   # Nearest rounding of 1/3 is downwards.
   def test_third
-    assert(FPU.down {1/3.0} == 1/3.0, "1/3 to -");
-    assert(FPU.up  {1/3.0} != 1/3.0, "1/3 to +");
-    assert(FPU.down {-1/3.0} != -1/3.0, "-1/3 to -");
-    assert(FPU.up  {-1/3.0} == -1/3.0, "-1/3 to +");
+    assert_equal      1/3.0, FPU.down {1/3.0}
+    assert_not_equal  1/3.0, FPU.up  {1/3.0}
+    assert_not_equal -1/3.0, FPU.down {-1/3.0}
+    assert_equal     -1/3.0, FPU.up  {-1/3.0}
   end
 
   # 1/4 is exact.
   def test_fourth
-    assert(FPU.down {1/4.0} == 1/4.0, "1/4 to -");
-    assert(FPU.up  {1/4.0} == 1/4.0, "1/4 to +");
-    assert(FPU.down {-1/4.0} == -1/4.0, "-1/4 to -");
-    assert(FPU.up  {-1/4.0} == -1/4.0, "-1/4 to +");
+    assert_equal  1/4.0, FPU.down {1/4.0}
+    assert_equal  1/4.0, FPU.up   {1/4.0}
+    assert_equal -1/4.0, FPU.down {-1/4.0}
+    assert_equal -1/4.0, FPU.up   {-1/4.0}
   end
 
   # Nearest rounding of 1/5 is upwards.
   def test_fifth
-    assert(FPU.down {1/5.0} != 1/5.0, "1/5 to -");
-    assert(FPU.up  {1/5.0} == 1/5.0, "1/5 to +");
-    assert(FPU.down {-1/5.0} == -1/5.0, "-1/5 to -");
-    assert(FPU.up  {-1/5.0} != -1/5.0, "-1/5 to +");
+    assert_not_equal  1/5.0, FPU.down {1/5.0}
+    assert_equal      1/5.0, FPU.up  {1/5.0}
+    assert_equal     -1/5.0, FPU.down {-1/5.0}
+    assert_not_equal -1/5.0, FPU.up  {-1/5.0}
   end
 
   def test_platform

data/test/test_interval.rb

@@ -8,19 +8,20 @@
 # To control the FPU's rounding mode
 require File.dirname(__FILE__) + '/../lib/interval' if __FILE__ == $0
 require 'test/unit'
+require File.dirname(__FILE__) + '/assertions.rb'
 
 # Assertions to be used when testing intervals.
-module  Interval::Assertions
+module Interval::Assertions
 
-  def assert_sharp(x)
-    assert(x.sharp?, x.inspect + " should be sharp.")
-    assert((-x).sharp?, (-x).inspect + " should be sharp.")
+  def assert_sharp(x, message = nil)
+    assert_predicate(x, :sharp?)
+    assert_predicate(-x, :sharp?)
   end
 
   # Assert that an interval is not sharp.
-  def assert_fuzzy(x)
-    assert(!x.sharp?, x.inspect + " should not be sharp.")
-    assert(!(-x).sharp?, (-x).inspect + " should not be sharp.")
+  def assert_fuzzy(x, message = nil)
+    assert_not_predicate(x, :sharp?)
+    assert_not_predicate(-x, :sharp?)
   end
 
   # Assert that +s+ is a solution to +f+ == 0. Unless the +weak+ flag is set, 
@@ -29,7 +30,7 @@ module  Interval::Assertions
   def assert_solution(s,f,expected, weak = nil)
     res = s.map{|c| f.call(c)}.inject{|a,c| a|c}
     # Did something spectacarly unexpected happen?
-    assert(res.simple?, res)
+    assert_predicate(res, :simple?)
     # Is it a solution?
     assert_include(res, 0)
     # Is it minimal?
@@ -48,18 +49,21 @@ module  Interval::Assertions
   end
 
   # Assert that the interval +i+ includes +x+.
-  def assert_include(i, x)
-    assert(i.include?(x), i.inspect + " should include " + x.inspect)
+  def assert_include(i, x, message = nil)
+    template = "<?> should include <?>, but it does not."
+    assert_block(build_message(message, template, i, x)) { i.include?(x) }
   end
 
   # Assert that the interval +i+ does not include +x+.
-  def assert_outside(i, x)
-    assert(!i.include?(x), i.inspect + " should not include " + x.inspect)
+  def assert_outside(i, x, message = nil)
+    template = "<?> should not include <?>, but it does."
+    assert_block(build_message(message, template, i, x)) { !i.include?(x) }
   end
 
   # Assert that +x+ is a subset of +y+.
-  def assert_subset(x,y)
-    assert(x == x & y, x.inspect + " should be a subset of " + y.inspect)
+  def assert_subset(x, y, message = nil)
+    template = "<?> should be a subset of <?>, but is not."
+    assert_block(build_message(message, template, x, y)) { x == x & y }
   end
 
 end
@@ -85,11 +89,11 @@ class Interval::TestFundamentals < Test::Unit::TestCase
   end
 
   def test_construction_failure
-    assert_raise(Interval::ConstructionError) { Interval[1,[2,3]] }
-    assert_raise(Interval::ConstructionError) { Interval[1,2,3] }
-    assert_raise(Interval::ConstructionError) { Interval[[1],2] }
-    assert_raise(Interval::ConstructionError) { Interval['a', 1] }
-    assert_raise(Interval::ConstructionError) { Interval['a', 'b'] }
+    assert_raise(Interval::Exception::Construction) { Interval[1,[2,3]] }
+    assert_raise(Interval::Exception::Construction) { Interval[1,2,3] }
+    assert_raise(Interval::Exception::Construction) { Interval[[1],2] }
+    assert_raise(Interval::Exception::Construction) { Interval['a', 1] }
+    assert_raise(Interval::Exception::Construction) { Interval['a', 'b'] }
   end
 
   def test_inequality
@@ -177,7 +181,13 @@ class Interval::TestSimpleMethods < Test::Unit::TestCase
 
   def test_midpoint
     assert_equal(1.5,Interval[1,2].midpoint)
-    assert_raise(NoMethodError){ Interval[[1,2],[3,4]].midpoint }
+    ex = assert_raise(Interval::Exception::Nonsimple){ Interval[[1,2],[3,4]].midpoint }
+  end
+
+  def test_number
+    assert_equal(0.5, Interval.eval{1/2.0}.number)
+    assert_raise(Interval::Exception::Nondegenerate) { Interval.eval{1/3.0}.number }
+    assert_raise(Interval::Exception::Nonsimple) { Interval[[1,2],[3,4]].number }
   end
 
   def test_width
@@ -192,6 +202,7 @@ class Interval::TestSimpleMethods < Test::Unit::TestCase
     tester.call(5.0)
     tester.call(119.0)
     tester.call(34e-4)
+    assert_raise(Interval::Exception::Nonsimple) { Interval[[1,2],[3,4]].width }
   end
 
 end
@@ -264,19 +275,22 @@ class Interval::TestMethods < Test::Unit::TestCase
   end
 
   def test_simple?
-    assert(Interval[1,2].simple?)
-    assert(!Interval[[1,2],[3,4]].simple?)
+    assert_predicate(Interval[1,2], :simple?)
+    assert_not_predicate(Interval[[1,2],[3,4]], :simple?)
   end
 
   def test_empty?
-    assert(!Interval[1,2].empty?)
-    assert(!Interval[[1,2],[4,3]].empty?)
-    assert(Interval[].empty?)
+    assert_not_predicate(Interval[1,2], :empty?)
+    assert_not_predicate(Interval[[1,2],[4,3]], :empty?)
+    assert_predicate(Interval[], :empty?)
   end
 
   def test_sharp?
     assert_sharp(Interval[5,5])
+    assert_sharp(Interval[5,5.0])
+    assert_sharp(Interval[5.0,5])
     assert_sharp(Interval[[1],[2]])
+    assert_fuzzy(Interval[5,5.1])
     assert_fuzzy(Interval[[1],[2,3]])
     assert_fuzzy(Interval[5,6])
     assert_fuzzy(Interval[1.1,1.2])
@@ -291,6 +305,25 @@ class Interval::TestMethods < Test::Unit::TestCase
     assert_fuzzy(Interval[6369051672525771, 6369051672525785] * 2.0 ** -52)
   end
 
+  def test_degenerate?
+    assert_predicate(Interval[5], :degenerate?)
+    assert_predicate(Interval[5.43], :degenerate?)
+    assert_predicate(Interval.eval{1/2.0}, :degenerate?)
+
+    assert_not_predicate(Interval.eval{1/3.0}, :degenerate?)
+    assert_not_predicate(Interval.eval{1/5.0}, :degenerate?)
+    assert_not_predicate(Interval[1,1.1], :degenerate?)
+
+    assert_predicate(Interval[[1],[2]], :degenerate?)
+    assert_predicate(Interval[[1.23],[2]], :degenerate?)
+    assert_predicate(Interval[[1],[2.3]], :degenerate?)
+    assert_predicate(Interval[[1.0123],[2.3]], :degenerate?)
+
+    assert_not_predicate(Interval[[1],[1.1,1.2]], :degenerate?)
+    assert_not_predicate(Interval[[1,1.1],[2]], :degenerate?)
+    assert_not_predicate(Interval[[1,1.1],[2,3]], :degenerate?)
+  end
+
   def test_hull
     assert_equal(Interval[1,4], Interval[[1,2],[3,4]].hull)
     assert_equal(Interval[1,4], Interval[1,4].hull)
@@ -301,14 +334,36 @@ class Interval::TestMethods < Test::Unit::TestCase
     assert_equal(Interval[1.2, 5.3], (1.2 .. 5.3).to_interval)
     assert_equal(Interval[1, 4], (1 .. 4).to_interval)
     assert_equal(Interval[1, 3], (1 ... 4).to_interval)
-    assert_raise(Interval::ConstructionError){ (1 ... 3.1).to_interval }
+    assert_raise(Interval::Exception::OpenRight){ (1 ... 3.1).to_interval }
     if defined?(Rational)
       x = Rational(1,3)
       assert_equal(Interval[1, x], (1 .. x).to_interval)
-      assert_raise(Interval::ConstructionError){ (1 ... x).to_interval }
+      assert_raise(Interval::Exception::OpenRight){ (1 ... x).to_interval }
     end
   end
 
+  def test_eval
+    assert_equal(1/Interval[3.0], Interval.eval{1/3.0})
+    assert_equal(1/Interval[5.0], Interval.eval{1/5.0})
+    assert_equal(Interval[0.5], Interval.eval{1/2.0})
+  end
+
+  def test_exceptions
+    ex = assert_raise(Interval::Exception::Nonsimple){ Interval[[1,2],[3,4]].midpoint }
+    assert_equal("Interval[[1, 2], [3, 4]] is not simple.", ex.message)
+    ex = assert_raise(Interval::Exception::Nondegenerate) { Interval[1,2].number }
+    assert_equal("Interval[1, 2] is not degenerate.", ex.message)
+    ex = assert_raise(Interval::Exception::Construction) { Interval[1,2,3] }
+    assert_equal(
+      "An interval can only be constructed either from at most two " \
+      "numbers or from a sequence of arrays of at most two numbers: [1, 2, 3]",
+      ex.message)
+    ex = assert_raise(Interval::Exception::OpenRight){ (1 ... 3.1).to_interval }
+    assert_equal(
+      "Cannot construct an interval from a three-dot range " \
+      "with end-value of type Float.", ex.message)
+  end
+
 end
 
 # Tests the Interval-based non-linear solver.

data/test/test_struct_float.rb

@@ -7,6 +7,7 @@
 
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/struct_float.rb' if __FILE__ == $0
+require File.dirname(__FILE__) + '/assertions.rb'
 
 # Tests Struct::Float.
 class Struct::Float::Test < Test::Unit::TestCase
@@ -23,10 +24,10 @@ class Struct::Float::Test < Test::Unit::TestCase
     # it does not make sense to have it as a constant as for
     # Infinity. In particular a NaN has 2047 as biased exponent and
     # non-zero fraction
-    assert(2047, s.biased_exp)
-    assert(!s.fraction.zero?, s.fraction)
+    assert_equal(2047, s.biased_exp)
+    assert_not_predicate(s.fraction, :zero?)
     # You cannot test for NaN with equality. You MUST use nan?
-    assert(s.to_f.nan?, s.to_f)
+    assert_predicate(s.to_f, :nan?)
     assert_equal(s, eval(s.inspect))
   end
 

data/var/clean-nan.rb

@@ -13,13 +13,17 @@ module Enumerable
   # Enumerable#min fails if the collection includes a NaN. Instead,
   # this methods returns a NaN.
   def ieee_min
-    find( proc { min } ){|x| x.respond_to?(:nan?) && x.nan?}
+    min
+  rescue ArgumentError
+    find{|x| x.respond_to?(:nan?) && x.nan?} or raise
   end
 
   # Enumerable#max fails if the collection includes a NaN. Instead,
   # this methods returns a NaN.
   def ieee_max
-    find( proc { max } ){|x| x.respond_to?(:nan?) && x.nan?}
+    max
+  rescue ArgumentError
+    find{|x| x.respond_to?(:nan?) && x.nan?} or raise
   end
 
 end
@@ -39,18 +43,17 @@ class Interval::Simple
 
 end
 
+require 'test/unit'
+require File.dirname(__FILE__) + '/../test/assertions.rb'
+
 # Tests exception-free multiplication.
 class CleanNanTest < Test::Unit::TestCase
 
-  def assert_nan(s)
-    assert(s.nan?, "#{s} is not nan")
-  end
-
   def test_ieee_min_and_max
     assert_equal(1,[1,2,3].ieee_min)
     assert_equal(3,[1,2,3].ieee_max)
-    assert_nan([1,0.0/0.0,3].ieee_min)
-    assert_nan([1,0.0/0.0,3].ieee_max)
+    assert_predicate([1,0.0/0.0,3].ieee_min, :nan?)
+    assert_predicate([1,0.0/0.0,3].ieee_max, :nan?)
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: intervals
 version: !ruby/object:Gem::Version 
-  version: 0.4.76
-date: 2006-04-09 00:00:00 +02:00
+  version: 0.5.83
+date: 2006-04-13 00:00:00 +02:00
 summary: Interval arithmetic in Ruby.
 require_paths: 
 - lib
@@ -40,6 +40,7 @@ files:
 - test/test_struct_float.rb
 - test/data_cos.txt
 - test/test_fpu.rb
+- test/assertions.rb
 - ext/jamis-mod.rb
 - ext/extconf.rb
 - ext/fpu.c