intervals 0.3.56 → 0.3.61

data/{lib/intervals.rb → README.txt}

@@ -1,5 +1,3 @@
-#!/usr/bin/ruby
-=begin rdoc
 = Intervals -- Interval arithmetic in Ruby
 
 Besides making obvious a possible loss of precision during floating
@@ -54,7 +52,7 @@ results.
 Using interval arithmetic it is possible to detect the loss of
 precision due to floating-point roundings.
 
-  require "intervals"          # you must have installed this package, obviously
+  require "interval"          # you must have this library installed, obviously
 
   1/Interval[3.0]             # => Interval[0.333333333333333, 0.333333333333333]
 
@@ -206,7 +204,3 @@ under the terms of LGPL.
 
 RDoc template by {Jamis Buck}[http://rubyforge.org/frs/?group_id=1458].
 
-=end
-require 'interval'
-
-Test::Unit.run = (__FILE__ != $0)

data/VERSION.txt

@@ -1 +1 @@
-0.3.56
+0.3.61

data/lib/interval.rb

@@ -68,7 +68,7 @@ class Interval
     if l.size == 1
       l.first
     else
-      Interval::Complex.new(l)
+      Interval::Multiple.new(l)
     end
   end
 
@@ -508,6 +508,18 @@ class Interval::Simple < Interval
     self.class.new(-sup,-inf)
   end
 
+  # Dependent subtraction, i.e., the inverse of the addition
+  #
+  #  Interval[3,4].dsub Interval[1,2]
+  #                           # => Interval[2]
+  #  Interval[1,2] + Interval[2]
+  #                           # => Interval[3,4]
+  def dsub(other)
+    Interval[
+      FPU.down{inf - other.inf},
+      FPU.up  {sup - other.sup}]
+  end
+
   # Used to implement Interval's multiplicative operator (\*).
   def multiply (other)
     self.class.new(
@@ -663,7 +675,7 @@ class Interval::Simple < Interval
 end
 
 # Implements an interval with multiple components.
-class Interval::Complex < Interval
+class Interval::Multiple < Interval
 
   # The array with the interval's components.
   attr :components
@@ -734,7 +746,7 @@ module  Interval::Assertions
     # Did something spectacarly unexpected happen?
     assert(res.simple?, res)
     # Is it a solution?
-    assert(res.include?(0), res)
+    assert_include(res, 0)
     # Is it minimal?
     assert(s.all? {|x| x.extrema.all? {|y| f.call(Interval[y]).include?(0)}}, s.inspect +
       " is non minmal")
@@ -743,13 +755,28 @@ module  Interval::Assertions
       # check the granularity
       assert_equal(expected.components.size, s.components.size, [expected,s].inspect)
       # check for inclusion
-      assert_equal(expected, s & expected, s)
+      assert_subset(expected, s)
     else
       # check for equality
       assert_equal(expected,s)
     end
   end
 
+  # Assert that the interval +i+ includes +x+.
+  def assert_include(i, x)
+    assert(i.include?(x), i.inspect + " should include " + x.inspect)
+  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)
+  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)
+  end
+
 end
 
 # Tests Interval fundamentals: construction, equality and inspection.
@@ -764,12 +791,12 @@ class Interval::TestFundamentals < Test::Unit::TestCase
 
     tester.call Interval[1],           [1],                   Interval::Simple
     tester.call Interval[1,2],         [1,2],                 Interval::Simple
-    tester.call Interval[[1,2],[3,4]], [[1,2],[3,4]],         Interval::Complex
-    tester.call Interval[[1],[2]],     [[1],[2]],             Interval::Complex
+    tester.call Interval[[1,2],[3,4]], [[1,2],[3,4]],         Interval::Multiple
+    tester.call Interval[[1],[2]],     [[1],[2]],             Interval::Multiple
     tester.call Interval[[1]],         [1],                   Interval::Simple
     tester.call Interval[2,0/0.0],     [-Infinity,+Infinity], Interval::Simple
     tester.call Interval[0/0.0,9],     [-Infinity,+Infinity], Interval::Simple
-    tester.call Interval[[1,3],[4,6],[2,5],[9,9]], [[1,6],[9]], Interval::Complex
+    tester.call Interval[[1,3],[4,6],[2,5],[9,9]], [[1,6],[9]], Interval::Multiple
   end
 
   def test_construction_failure
@@ -780,11 +807,11 @@ class Interval::TestFundamentals < Test::Unit::TestCase
   end
 
   def test_inequality
-    assert(Interval[1,2] != Interval[1,3])
-    assert(Interval[1,2] != Interval[0,2])
-    assert(Interval[1,2] != Interval[0,3])
-    assert(Interval[1,2] != 3)
-    assert(Interval[[1,2],[3,4]] != Interval[[1,0],[3,4]])
+    assert_not_equal(Interval[1,2], Interval[1,3])
+    assert_not_equal(Interval[1,2], Interval[0,2])
+    assert_not_equal(Interval[1,2], Interval[0,3])
+    assert_not_equal(Interval[1,2], 3)
+    assert_not_equal(Interval[[1,2],[3,4]], Interval[[1,0],[3,4]])
   end
 
   def test_inspect_and_to_s
@@ -817,6 +844,13 @@ class Interval::TestSimpleArithmetic < Test::Unit::TestCase
     assert_equal(Interval[-2,-1], -Interval[1,2])
   end
 
+  def test_dsub
+    assert_equal(Interval[2], Interval[3,4].dsub(Interval[1,2]))
+    assert_equal(Interval[3,4], Interval[4,6].dsub(Interval[1,2]))
+    assert_equal(Interval[], Interval[3,4].dsub(Interval[0,2]))
+
+  end
+
   def test_times
     assert_equal(Interval[-Infinity,+Infinity],Interval[Infinity] * Interval[0])
     assert_equal(Interval[+Infinity],Interval[Infinity] * Interval[3])
@@ -935,11 +969,11 @@ class Interval::TestMethods < Test::Unit::TestCase
   include Interval::Assertions
 
   def test_include?
-    assert(Interval[1,2].include?(1.5),"1")
-    assert(Interval[1,2].include?(1),"2")
-    assert(Interval[1,2].include?(2),"3")
-    assert(!Interval[1,2].include?(0),"4")
-    assert(!Interval[1,2].include?(4),"5")
+    assert_include(Interval[1,2], 1.5)
+    assert_include(Interval[1,2], 1)
+    assert_include(Interval[1,2], 2)
+    assert_outside(Interval[1,2], 0)
+    assert_outside(Interval[1,2], 4)
   end
 
   def test_simple?
@@ -1070,7 +1104,7 @@ class Interval::TestTranscendental < Test::Unit::TestCase
     assert_equal(Interval[], Interval[-2,-1].log)
     assert_equal(Interval[-Infinity], Interval[-2,0].log)
     assert_equal(Interval[-Infinity,0], Interval[0,1].log)
-    assert(Interval::E.log.include?(1))
+    assert_include(Interval::E.log, 1)
     assert_equal(3 * 2 ** -53, Interval[1].exp.log.width)
   end
 
@@ -1081,7 +1115,7 @@ class Interval::TestTranscendental < Test::Unit::TestCase
   end
 
   def test_cosh
-    assert(Interval[1].cosh.sharp?)
+    assert_sharp(Interval[1].cosh)
     assert_equal(Interval[1], Interval[0].cosh)
     assert_equal((Interval[1].cosh | Interval[3].cosh).hull, Interval[1,3].cosh)
     assert_equal(Interval[1,3].cosh, Interval[-3,-1].cosh)
@@ -1091,7 +1125,7 @@ class Interval::TestTranscendental < Test::Unit::TestCase
   end
 
   def test_sinh
-    assert(Interval[1].sinh.sharp?)
+    assert_sharp(Interval[1].sinh)
     assert_equal(Interval[0], Interval[0].sinh)
     assert_equal((Interval[-1].sinh | Interval[3].sinh).hull, Interval[-1,3].sinh)
     assert_equal(Interval[-Infinity, Infinity], Interval[-Infinity,Infinity].sinh)
@@ -1103,10 +1137,10 @@ class Interval::TestTranscendental < Test::Unit::TestCase
     assert_equal(Interval[-1,1], Interval[Infinity].cos)
     assert_equal(Interval[-1,1], Interval[-Infinity].cos)
     onehalf = (Interval::PI/3).cos
-    assert( onehalf.include?(0.5))
+    assert_include(onehalf, 0.5)
     assert_equal(Interval[onehalf.inf,1], (-Interval::PI/4 | Interval::PI/3).hull.cos)
     minusonehalf = (2*Interval::PI/3).cos
-    assert(minusonehalf.include?(-0.5))
+    assert_include(minusonehalf, -0.5)
     assert_equal(Interval[-1,minusonehalf.sup], (5*Interval::PI/4 | 2*Interval::PI/3).hull.cos)
     assert_equal((minusonehalf | onehalf).hull, ((Interval::PI | 2*Interval::PI).hull/3).cos)
     full = (5 * Interval::PI/3 | 3.5 * Interval::PI).hull
@@ -1127,10 +1161,10 @@ class Interval::TestTranscendental < Test::Unit::TestCase
     assert_equal(Interval[-1,1], Interval[Infinity].sin)
     assert_equal(Interval[-1,1], Interval[-Infinity].sin)
     onehalf = (Interval::PI/6).sin
-    assert( onehalf.include?(0.5))
+    assert_include(onehalf, 0.5)
     assert_equal(Interval[onehalf.inf,1], (3 * Interval::PI/4 | Interval::PI/6).hull.sin)
     minusonehalf = (7*Interval::PI/6).sin
-    assert(minusonehalf.include?(-0.5))
+    assert_include(minusonehalf, -0.5)
     assert_equal(Interval[-1,minusonehalf.sup], (7*Interval::PI/4 | 7*Interval::PI/6).hull.sin)
     assert_equal((-onehalf | onehalf).hull, ((Interval::PI | -Interval::PI).hull/6.0).sin)
     full = ((5 * Interval::PI/3 | 3.5 * Interval::PI) + Interval::PI/2).hull
@@ -1154,9 +1188,9 @@ class Interval::TestTranscendental < Test::Unit::TestCase
     assert_equal(Interval[-Infinity, Infinity], (4.75 *Interval::PI | Interval::PI * 6.25).hull.tan)
 
     assert_equal(2 ** -51, Interval::PI.tan.width)
-    assert(Interval::PI.tan.include?(0))
+    assert_include(Interval::PI.tan, 0)
     assert_equal(3 * 2 ** -53, (Interval::PI/4).tan.width)
-    assert((Interval::PI/4).tan.include?(1) )
+    assert_include((Interval::PI/4).tan, 1)
 
     x = (Interval::PI/4 | Interval::PI * 0.75).hull
     assert_equal((Interval[x.sup].tan | -Infinity).hull | (Interval[x.inf].tan | Infinity).hull, x.tan)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: intervals
 version: !ruby/object:Gem::Version 
-  version: 0.3.56
-date: 2006-03-29 00:00:00 +02:00
+  version: 0.3.61
+date: 2006-03-30 00:00:00 +02:00
 summary: Interval arithmetic in Ruby.
 require_paths: 
 - lib
@@ -160,9 +160,9 @@ files:
 - ext/crlibm/triple-double.h
 - ext/crlibm/VERSION
 - lib/interval.rb
-- lib/intervals.rb
 - lib/struct_float.rb
 - lib/fpu.rb
+- README.txt
 - VERSION.txt
 test_files: 
 - lib/interval.rb
@@ -173,9 +173,9 @@ rdoc_options:
 - --title
 - "Intervals: Interval arithmetic in Ruby"
 - --main
-- lib/intervals.rb
-extra_rdoc_files: []
-
+- README.txt
+extra_rdoc_files: 
+- README.txt
 executables: []
 
 extensions: