intervals 0.3.63 → 0.4.75

data/README.txt

@@ -191,6 +191,11 @@ Interval
 Analysis}[http://www.ebooks.dekker.com/eBookCover.asp?eBookID=0824758706&type=ISBN] -
 Second Edition, Revised and Expanded. John Dekker, Inc., 2003.
 
+David Goldberg, {What Every Computer Scientist Should Know About
+Floating-Point
+Arithmetic}[http://docs-pdf.sun.com/800-7895/800-7895.pdf], ACM
+Computing Surveys, vol. 23 (1991), pp. 5--48.
+
 == Author & License
 
 Copyright (c) 2006, Stefano Taschini.

data/VERSION.txt

@@ -1 +1 @@
-0.3.61:62M
+0.4.75

data/lib/fpu.rb

@@ -27,6 +27,10 @@ end
 
 require File.dirname(__FILE__) + '/struct_float'
 
+# This module provides the way of controlling the rounding mode of the
+# floating-point unit (FPU) and also provides mathematical functions
+# that round their result consistently with the specified rounding
+# mode.
 module FPU
 
   #
@@ -81,207 +85,4 @@ module FPU
 
 end
 
-require 'test/unit'
-
-# Tests the FPU rounding modes.
-class FPU::TestRounding < Test::Unit::TestCase
-  include FPU
-
-  def setup
-    @saved = rounding
-  end
-
-  def teardown
-    self.rounding = @saved
-  end
-
-  # 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 +");
-  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 +");
-  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 +");
-  end
-
-  def test_platform
-    modes = case (RUBY_PLATFORM)
-      when /powerpc/  then [0,2,3]
-      when /i[0-9]86/ then [0,0x0800,0x0400]
-      when /sparc/    then [0,0x80000000, 0xC0000000]
-      else flunk("Cannot be sure of the processor flags for platform "+RUBY_PLATFORM)
-    end
-    assert_equal(modes,
-      [rounding, FPU.up { rounding }, FPU.down { rounding }])
-  end
-
-  def test_rounding_consts
-    assert_equal(PlusRounding    , FPU.up { FPU.rounding })
-    assert_equal(MinusRounding   , FPU.down { FPU.rounding })
-    assert_equal(StandardRounding, rounding)
-
-    tester = proc { |x| assert_equal(x, (self.rounding = x; FPU.rounding))}
-    tester.call(PlusRounding);
-    tester.call(MinusRounding);
-    tester.call(StandardRounding);
-  end
-
-  def test_exception_safety
-    assert_raise(ArgumentError){FPU.up {[2.0, 0/0.0].sort}}
-    assert_equal(StandardRounding, rounding)
-    assert_raise(ArgumentError){FPU.down {[2.0, 0/0.0].sort}}
-    assert_equal(StandardRounding, rounding)
-  end
-
-  def test_power
-    x = 1/3.0;
-    # The cube of one third should depend on the rounding mode
-    assert_operator(FPU.down{x*x*x}, :<, FPU.up{x*x*x})
-    # But using the built-in power operator, usually it doesn't
-    # assert_equal(FPU.down{x**3}, FPU.up{x**3})
-    # So we define an integer power methods that does
-    assert_operator(FPU.down{FPU.power(x, 3)}, :<, FPU.up{FPU.power(x, 3)})
-
-    assert_equal(32, FPU.power(2, 5))
-    assert_equal([FPU.down{x*x*x}, FPU.up{x*x*x}],[FPU.down{FPU.power(x, 3)},FPU.up{FPU.power(x, 3)}])
-    assert_equal(1.25 ** 13, FPU.power(1.25, 13))
-    assert_equal((-1.25) ** 17, FPU.power(-1.25, 17))
-    assert_equal((-1.25) ** 18, FPU.power(-1.25, 18))
-    (1..10).each {|i|
-      assert_equal(2.0 ** i, FPU.power(2.0, i))
-    }
-
-  end
-
-end
-
-if !FPU.respond_to?(:exp_up)
-  warn "***\n*** Module fpu is compiled without transcendetal functions\n***"
-else
-  # Tests the correct-rounding transcendental functions, if they exist.
-  class FPU::TestTranscendental < Test::Unit::TestCase
-  require 'enumerator'
-
-  def locate(name)
-    ([File.dirname(__FILE__)] + $LOAD_PATH).
-      map{|p| File.expand_path("../test/#{name}", File.expand_path(p))}.
-      find(proc {raise LoadError, "Cannot locate #{name}"}) {|p|
-        File.exist?(p)
-    }
-  end
-
-  @@test_vectors_cache = {}
-
-  def get_vectors (name)
-    @@test_vectors_cache[name] ||= IO.readlines(locate(name)).map{|x|
-      e1,m1,e2,m2 = x.chomp.split(' ').map{|y| y.to_i}
-      [e1,m1,e2,m2,e2,m2 - 1].enum_slice(2).map{|e,m| Math::ldexp(m,e)}}
-  end
-
-  def test_easy
-    a, b, c= [
-     [-1, 1008, 2553927345288884],
-     [1, 1022, 4503168880409012],
-     [1, 1022, 4503168880409011]].map{|x| Struct::Float[*x].to_f}
-    assert_equal(b, FPU.exp_up(a))
-    assert_equal(c, FPU.exp_down(a))
-
-    assert_equal(Infinity, FPU.exp_up(Infinity))
-    assert_equal(Infinity, FPU.exp_down(Infinity))
-    assert_equal(0, FPU.exp_up(-Infinity))
-    assert_equal(0, FPU.exp_down(-Infinity))
-
-    assert_equal(Infinity, FPU.log_up(Infinity))
-    assert_equal(Infinity, FPU.log_down(Infinity))
-    assert_equal(-Infinity, FPU.log_up(0))
-    assert_equal(-Infinity, FPU.log_down(0))
-
-    assert_equal(Math::PI, 2*FPU.atan_down(Infinity))
-    assert_equal(Math::PI+2 ** -51, 2*FPU.atan_up(Infinity))
-    assert_equal(-Math::PI, 2*FPU.atan_up(-Infinity))
-    assert_equal(-Math::PI-2 ** -51, 2*FPU.atan_down(-Infinity))
-  end
-
-  def test_exp
-    get_vectors("data_exp.txt").map{|x,y,z|
-      assert_equal(y, FPU.exp_up(x))
-      assert_equal(z, FPU.exp_down(x))
-    }
-  end
-
-  def test_log
-    get_vectors("data_log.txt").map{|x,y,z|
-      assert_equal(y, FPU.log_up(x))
-      assert_equal(z, FPU.log_down(x))
-    }
-  end
-
-  def test_atan
-    get_vectors("data_atan.txt").map{|x,y,z|
-      assert_equal(y, FPU.atan_up(x))
-      assert_equal(z, FPU.atan_down(x))
-    }
-  end
-
-  def test_cos
-    get_vectors("data_cos.txt").map{|x,y,z|
-      assert_equal(y, FPU.cos_up(x))
-      assert_equal(z, FPU.cos_down(x))
-    }
-  end
-
-  def test_sin
-    get_vectors("data_sin.txt").map{|x,y,z|
-      assert_equal(y, FPU.sin_up(x))
-      assert_equal(z, FPU.sin_down(x))
-    }
-  end
-
-  def test_tan
-    get_vectors("data_tan.txt").map{|x,y,z|
-      assert_equal(y, FPU.tan_up(x))
-      assert_equal(z, FPU.tan_down(x))
-    }
-  end
-
-  def test_cosh
-    get_vectors("data_cosh.txt").map{|x,y,z|
-      assert_equal(y, FPU.cosh_up(x))
-      assert_equal(z, FPU.cosh_down(x))
-    }
-  end
-
-  def test_sinh
-    get_vectors("data_sinh.txt").map{|x,y,z|
-      assert_equal(y, FPU.sinh_up(x))
-      assert_equal(z, FPU.sinh_down(x))
-    }
-  end
-
-  # It can happen, depending on the implementation, that Math::sinh is broken
-  def broken_math  #:nodoc:
-    x = -8218111829489689 * 2.0 **(-67)
-    y = -8218111833737307 * 2.0 **(-67)
-    assert_equal(y, FPU.sinh_up(x))
-    z = Math::sinh(x);
-    assert(z <= y, [FPU.split(x), FPU.split(z), FPU.split(y)].inspect)
-  end
-
-end end
-
-Test::Unit.run = (__FILE__ != $0)
+require File.dirname(__FILE__) + '/../test/test_fpu.rb' if __FILE__ == $0

data/lib/interval.rb

@@ -27,6 +27,10 @@ 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]
@@ -38,25 +42,34 @@ class Interval
   #  Interval[[1,3],[2,4]]    # => Interval[1, 4]
   #
   def Interval.[](*array)
-    make(
+    union(*
       if array.empty?
         []
-      elsif array.first.kind_of?(Numeric)
-        [Simple[*array]]
+      elsif array.first.kind_of?(Array)
+        array.select{|x| !x.empty?}.map { |x| Simple.new(*x) }
       else
-        array.select{|x| !x.empty?}.map { |x| Simple[*x] }
+        [Simple.new(*array)]
       end
     )
+  rescue StandardError
+    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}"
+    end
+    raise
   end
 
-  # Create a closed (multi-)interval from a set of simple intervals.
+  # Create the union of an array of intervals.
   #
-  #  Interval.make(Interval[1,2], Interval[3,4])
+  #  Interval.union(Interval[1,2], Interval[3,4])
   #                           # => Interval[[1, 2], [3, 4]]
   #
-  def Interval.make(comps)
+  def Interval.union(*array)
     l = []
-    comps.sort_by{|x| x.inf}.each{|x|
+    array.map{|x| x.components}.flatten.sort_by{|x| x.inf}.each{|x|
       if x.sup < x.inf
         # skip it
       elsif l.empty? || x.inf > l.last.sup
@@ -72,6 +85,20 @@ class Interval
     end
   end
 
+  # Add all the arguments using Kahan's summation formula, which
+  # provides sharper results than conventional sum.
+  def Interval.sum(*array)
+    Interval.union *array.inject([[Interval[0],Interval[0]]]) {|sc, xx|
+      sc.inject([]){|a1,(s,c)|
+        xx.inject(a1){|a2,x|
+          y = x.dsub(c)
+          t = s + y
+          a2 + [[t, t.dsub(s).dsub(y)]]
+        }
+      }
+    }.transpose.first
+  end
+
   # Returns a list of the parameters that can be used to reconstruct the
   # interval.
   #
@@ -222,7 +249,7 @@ class Interval
   ## Implement unary operations
   [:inverse, :exp, :log, :atan, :cos, :sin, :tan, :cosh, :sinh].each {|op|
     define_method(op) {
-      Interval.make(map{|x| x.send(op).components}.flatten)
+      Interval.union(*map{|x| x.send(op)})
     }
   }
 
@@ -231,7 +258,7 @@ class Interval
   #  Interval[-2,2]**2        # => Interval[0, 4]
   #
   def ** (n)
-    Interval.make(map{|x| (x**n).components}.flatten)
+    Interval.union(*map{|x| (x**n)})
   end
 
   # Sum of intervals.
@@ -282,7 +309,7 @@ class Interval
   ## Implement binary operations: Sum (+), Multiplication (*) and Intersection (&)
   [[:+, :add], [:*, :multiply], [:&, :intersect]].each {|op, meth|
     define_method(op) {|other|
-      Interval.make(other.to_interval.map {|y| self.map {|x| x.send(meth,y) } }.flatten)
+      Interval.union(*other.to_interval.map {|y| self.map {|x| x.send(meth,y) } }.flatten)
     }
   }
 
@@ -302,7 +329,7 @@ class Interval
   #                           # => Interval[1, 4]
   #
   def | (other)
-    Interval.make(other.to_interval.components + self.components)
+    Interval.union(other.to_interval, self)
   end
 
   # True if the interval has no elements.
@@ -334,10 +361,10 @@ class Interval
     end
   end
 
-  @@newtonOpts = {
+  # The default options for Interval#newton.
+  NewtonOptions = {
     :maxIterations => 100,
-    :verbose => false
-  }
+    :verbose => false }
 
   # Solve a non-linear equation using the Newton-Raphson method,
   # finding all solutions in a in interval.
@@ -354,7 +381,7 @@ class Interval
   # a sharp result showing the three roots -1, 0 and +1.
   #
   def newton(f, fp, opts = {})
-    effectiveOpts = @@newtonOpts.dup.update(opts)
+    effectiveOpts = NewtonOptions.dup.update(opts)
     verbose = effectiveOpts[:verbose]
     puts "Starting on #{self}" if verbose
     step = proc {|w,ww| (w - f.call(Interval[w]) / fp.call(ww) ) & ww}
@@ -428,21 +455,14 @@ class Interval::Simple < Interval
     [self]
   end
 
-  # Constructs a simple interval with given extrema.
-  #
-  #  Interval::Simple[1]      # => Interval[1]
-  #  Interval::Simple[1,2]    # => Interval[1,2]
-  #
-  def Simple.[](a, b = a)
-    new(a, b)
-  end
-
   # Constructs a simple interval, with given lower and upper bounds.
   #
-  #  Interval::Simple.new(1,1) # => Interval[1]
+  #  Interval::Simple.new(1)   # => Interval[1]
   #  Interval::Simple.new(1,2) # => Interval[1,2]
   #
-  def initialize (a, b)
+  def initialize (a, b = a)
+    raise ArgumentError, "Extrema must be numeric: #{[a,b].uniq.inspect}" unless
+      Numeric === a && Numeric === b
     if (a.respond_to?(:nan?) && a.nan? ) || (b.respond_to?(:nan?) && b.nan?)
       @inf, @sup = -Infinity, Infinity
     else
@@ -515,9 +535,9 @@ class Interval::Simple < Interval
   #  Interval[1,2] + Interval[2]
   #                           # => Interval[3,4]
   def dsub(other)
-    Interval[
+    self.class.new(
       FPU.down{inf - other.inf},
-      FPU.up  {sup - other.sup}]
+      FPU.up  {sup - other.sup})
   end
 
   # Used to implement Interval's multiplicative operator (\*).
@@ -529,6 +549,9 @@ class Interval::Simple < Interval
       FPU.up {
         [inf * other.inf, inf * other.sup,
          sup * other.inf, sup * other.sup]}.max)
+    # min and max fail if any of the products is a NaN, which can only
+    # be generated by 0 * Infinity. In this case, the result is the
+    # whole R-star.
     rescue ArgumentError
       self.class.new(-Infinity, Infinity)
   end
@@ -708,6 +731,12 @@ class Range
       else
         last
       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"
+    end
+    raise
   end
 
 end
@@ -722,483 +751,4 @@ class Interval
 
 end
 
-require 'test/unit'
-
-# Assertions to be used when testing intervals.
-module  Interval::Assertions
-
-  def assert_sharp(x)
-    assert(x.sharp?, x.inspect + " should be sharp.")
-    assert((-x).sharp?, (-x).inspect + " should be 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.")
-  end
-
-  # Assert that +s+ is a solution to +f+ == 0. Unless the +weak+ flag is set, 
-  # assert also that +s+ == +expected+.
-  # If the +weak+ flag is set, assert that +s+ includes +expected+.
-  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)
-    # Is it a solution?
-    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")
-    # Is it the expected solution?
-    if weak
-      # check the granularity
-      assert_equal(expected.components.size, s.components.size, [expected,s].inspect)
-      # check for inclusion
-      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.
-class Interval::TestFundamentals < Test::Unit::TestCase
-
-  def test_constructor_and_equality
-    tester = proc {|i,ex,klass|
-      assert_equal(klass, i.class)
-      assert_equal(ex, i.construction)
-      assert_equal(i, Interval[*i.construction])
-    }
-
-    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::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::Multiple
-  end
-
-  def test_construction_failure
-    assert_raise(NoMethodError) { Interval[1,[2,3]] }
-    assert_raise(ArgumentError) { Interval[1,2,3] }
-    assert_raise(NoMethodError) { Interval[1,[2,3]] }
-    assert_raise(NoMethodError) { Interval[[1],2] }
-  end
-
-  def test_inequality
-    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
-    tester = proc {|s|
-      i = eval(s)
-      assert_equal(s,i.inspect)
-      assert_equal(s,i.to_s)
-    }
-    tester.call "Interval[1]"
-    tester.call "Interval[1, 2]"
-    tester.call "Interval[[1, 2], [3, 4]]"
-    tester.call "Interval[[1, 2], [4], [5, 6], [Infinity]]"
-    tester.call "Interval[1, 2]"
-  end
-
-end
-
-# Tests the arithmetic of Interval::Simple.
-class Interval::TestSimpleArithmetic < Test::Unit::TestCase
-
-  def test_plus
-    assert_equal(Interval[-Infinity,+Infinity], Interval[-Infinity] + Interval[Infinity])
-    assert_equal(Interval[4,6], Interval[1,2] + Interval[3,4])
-    assert_equal(Interval[3,Infinity], Interval[1,Infinity]+Interval[2])
-    assert_equal(Interval[-Infinity,+Infinity],Interval[-Infinity,-1] + Interval[2,+Infinity])
-    assert_equal(Interval[-Infinity,+Infinity],Interval[-Infinity] + Interval[8,+Infinity])
-  end
-
-  def test_minus
-    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])
-    assert_equal(Interval[-8,+10], Interval[1,2] * Interval[-4,5])
-    assert_equal(Interval[3,8], Interval[1,2] * Interval[3,4])
-    assert_equal(Interval[-Infinity,+Infinity],Interval[0,1] * Interval[2,Infinity])
-    assert_equal(Interval[2, Infinity], Interval[-Infinity,-2] * Interval[-Infinity,-1])
-  end
-
-  def test_inverse
-    assert_equal(Interval[0.5,1],Interval[1,2].inverse)
-    assert_equal(Interval[-1,-0.5],(-Interval[1,2]).inverse)
-    assert_equal(Interval[[-Infinity,-1],[0.5,+Infinity]],Interval[-1,2].inverse)
-    assert_equal(Interval[[-Infinity],[1,+Infinity]],Interval[0,1].inverse)
-  end
-
-  def test_power
-    assert_equal((-Interval[1,2]).inverse, (-Interval[1,2]) ** -1)
-    assert_equal(Interval[0,4], Interval[-1,2]**2)
-    assert_equal(Interval[-27,8], Interval[-3,2]**3)
-
-    assert_equal(
-      Interval[FPU.down{(1/3.0)*(1/3.0)},FPU.up{(1/3.0)*(1/3.0)}],
-      (Interval[1]/3.0) ** 2)
-
-    assert_equal(
-      Interval[
-        FPU.down{(1/3.0)*(1/3.0)*(1/3.0)},
-        FPU.up{(1/3.0)*(1/3.0)*(1/3.0)}],
-      (Interval[1]/3.0) ** 3)
-  end
-
-end
-
-# Tests other methods of Interval::Simple.
-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 }
-  end
-
-  def test_width
-    assert_equal(1, Interval[1,2].width)
-    assert_equal(1, Interval[1,2].width)
-    tester = proc{|x|
-      assert_equal(
-        2.0 ** (-(Math.log(x)/Math.log(2)).ceil - 52),
-        (1/Interval[x]).width)
-    }
-    tester.call(3.0)
-    tester.call(5.0)
-    tester.call(119.0)
-    tester.call(34e-4)
-  end
-
-end
-
-# Tests Interval algebra.
-class Interval::TestAlgebra < Test::Unit::TestCase
-
-  def test_union
-    assert_equal(Interval[[1, 6], [9, 9]], Interval[[1, 3],[4, 6]] | Interval[[2, 5], [9,9]])
-  end
-
-  def test_plus
-    tester = proc{|x,y,sum|
-      assert_equal(sum,x+y)
-      assert_equal(sum,y+x)
-    }
-    tester.call(Interval[[1,2],[10,Infinity]], Interval[[1,9],[-2,-1]], Interval[[-1,1],[2,Infinity]])
-    tester.call(Interval[1,9], Interval[[1,2],[10,Infinity]], Interval[2,Infinity])
-    tester.call(Interval[1,2], 2, Interval[3,4])
-  end
-
-  def test_intersection
-    tester = proc{|x,y,z|
-      assert_equal(z, x & y)
-      assert_equal(z, y & x)
-    }
-    tester.call(Interval[1,2], Interval[0,3], Interval[1,2])
-    tester.call(Interval[1.1,1.9], Interval[1.3,2.5], Interval[1.3, 1.9])
-    tester.call(Interval[1.1,1.9], Interval[0.3,0.7], Interval[])
-  end
-
-  def test_inverse
-    assert_equal(Interval[[-Infinity, -2.0],[0.0, Infinity]],Interval[[-0.5,0.5],[0.2,Infinity]].inverse)
-  end
-
-  def test_minus
-    assert_equal(Interval[[-4,-3],[-2,-1]], -Interval[[1,2],[3,4]])
-  end
-
-  def test_times
-    tester = proc{|x,y,z|
-      assert_equal(z,x*y)
-      assert_equal(z,y*x)
-    }
-    tester.call(Interval[[1, 2], [3, 4]], Interval[0.5, 2], Interval[0.5,8])
-    tester.call(Interval[1,2], 2, Interval[2,4])
-  end
-
-  def test_division
-    assert_equal(Interval[-Infinity, Infinity], Interval[0,1]/Interval[0,1])
-    assert_equal(Interval[0.5], Interval[1]/2)
-  end
-
-  def test_power
-    assert_equal(Interval[-1,2], (Interval[-1,2]**-1)**-1)
-  end
-
-end
-
-#Tests other Interval methods.
-class Interval::TestMethods < Test::Unit::TestCase
-  include Interval::Assertions
-
-  def test_include?
-    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?
-    assert(Interval[1,2].simple?)
-    assert(!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?)
-  end
-
-  def test_sharp?
-    assert_sharp(Interval[5,5])
-    assert_sharp(Interval[[1],[2]])
-    assert_fuzzy(Interval[[1],[2,3]])
-    assert_fuzzy(Interval[5,6])
-    assert_fuzzy(Interval[1.1,1.2])
-    assert_fuzzy(Interval[Struct::Float[-1,0,1].to_f,Struct::Float[+1,0,1].to_f])
-    assert_sharp(Interval[Struct::Float[1,1022,2**52-1].to_f,1])
-    assert_sharp(Interval[Struct::Float[1,1029,2**52-1].to_f,128])
-    assert_sharp(Interval[-0.0,0.0])
-    assert_sharp(Interval[0.0,Struct::Float[1,0,1].to_f])
-    assert_sharp(Interval[6369051672525772, 6369051672525773] * 2.0 ** -52)
-    assert_sharp(Interval[6369051672525772, 6369051672525772] * 2.0 ** -52)
-    assert_fuzzy(Interval[6369051672525771, 6369051672525773] * 2.0 ** -52)
-    assert_fuzzy(Interval[6369051672525771, 6369051672525785] * 2.0 ** -52)
-  end
-
-  def test_hull
-    assert_equal(Interval[1,4], Interval[[1,2],[3,4]].hull)
-    assert_equal(Interval[1,4], Interval[1,4].hull)
-    assert_equal(Interval[], Interval[].hull)
-  end
-
-  def test_conversion_from_range
-    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(NoMethodError){ (1 ... 3.1).to_interval }
-  end
-
-end
-
-# Tests the Interval-based non-linear solver.
-class Interval::TestNewton < Test::Unit::TestCase
-  include Interval::Assertions
-
-  def test_sqrt2
-    f, fp = proc {|x| x**2 - 2}, proc {|x| 2*x}
-    s = Math::sqrt(2)
-    assert_equal(6369051672525773 * 2.0 **-52, s)
-    assert_equal(Interval[s],         Interval[0.1,5.0].newton(f, fp))
-    assert_equal(Interval[],          Interval[2.0,5.0].newton(f,fp))
-    assert_equal(Interval[s],         Interval[-1.0,10.0].newton(f,fp))
-    assert_equal(Interval[-s],        Interval[-5.0,0].newton(f,fp))
-    assert_equal(Interval[[-s],[s]],  Interval[-5.0,5.0].newton(f,fp))
-  end
-
-  def test_cubic_1
-    f, fp = proc {|x| x**3 + x - 10}, proc {|x| 3*x**2 + 1}
-    s = Interval[-1,5].newton(f,fp)
-    assert_solution(s, f, Interval[2])
-  end
-
-  def test_cubic_2
-    f, fp = proc {|x| x**3 + x - 15}, proc {|x| 3*x**2 + 1}
-    s = Interval[-1.0,5.0].newton(f,fp)
-    assert_solution(s, f, Interval[5249383869325654 * 2.0 ** -51])
-  end
-
-  def test_cubic_3
-    f, fp = proc {|x| x * (x ** 2 - 1)}, proc {|x| 3*x**2 - 1}
-    s = Interval[-5.0,5.0].newton(f,fp)
-    assert_solution(s, f, Interval[[-1],[0],[1]])
-  end
-
-  def test_dennis_schnabel
-    f1 = proc {|x| (((x-12) * x + 47 ) * x - 60 )* x}
-    f2 = proc {|x| f1.call(x) + 24 }
-    f3 = proc {|x| f1.call(x) + 24.1 }
-    fp = proc {|x| ((4 * x - 12*3) * x + 47*2) * x - 60}
-
-    assert_solution(Interval[-1e2,1e2].newton(f1,fp), f1, Interval[[0],[3],[4],[5]],:weak)
-    assert_solution(Interval[-1e2,1e2].newton(f2,fp), f2, Interval[[0.888305779071752],[1]], :weak)
-    assert_equal(Interval[], Interval[-1e2,1e2].newton(f3,fp))
-  end
-
-  if FPU.respond_to?(:exp_up)
-  def test_exp
-    f, fp = proc{|x| x.exp + x}, proc {|x| x.exp + 1}
-    z0 = Interval[-1e2,1e2].newton(f,fp)
-    assert_solution(z0, f, Interval[-0.56714329040978384])
-
-    f, fp = proc{|x| x*(-x).exp + 1}, proc {|x| (1-x)*(-x).exp}
-    z1 = Interval[-1e2,1e2].newton(f,fp)
-    assert_solution(z0, f, z0, :weak)
-    assert_sharp(z1)
-  end end
-
-  if FPU.respond_to?(:exp_up)
-  def test_trig
-    f = proc{|x| (x*Interval::PI/3.0).cos() -0.5}
-    fp = proc{|x| -(x*Interval::PI/3).sin() * Interval::PI/3}
-    s = Interval[-10.0,10.0].newton(f, fp)
-    assert_solution(s, f, Interval[[-7], [-5], [-1], [1], [5], [7]], :weak)
-  end end
-
-end
-
-if FPU.respond_to?(:exp_up)
-  # Tests Interval transcendental functions.
-class Interval::TestTranscendental < Test::Unit::TestCase
-  include Interval::Assertions
-
-  def test_exp
-    assert_equal(Interval::E, Interval[1].exp)
-    assert_equal(Interval[1,Interval::E.sup], Interval[0,1].exp)
-    assert_equal(Interval[Interval::E.inf, Infinity], Interval[1,Infinity].exp)
-    assert_equal(Interval[0], Interval[-Infinity].exp)
-    assert_equal(Interval[[0, 1], [Math::E, Infinity]], Interval[[-Infinity,0],[1,Infinity]].exp)
-  end
-
-  def test_log
-    assert_equal(Interval[-Infinity, 0], Interval[-1,+1].log)
-    assert_equal(Interval[0], Interval[1].log)
-    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_include(Interval::E.log, 1)
-    assert_equal(3 * 2 ** -53, Interval[1].exp.log.width)
-  end
-
-  def test_atan
-    assert_equal(Interval::PI, 4 * Interval[1].atan)
-    assert_equal(Interval[-Interval::PI.sup, Interval::PI.sup], 2 * Interval[-Infinity,Infinity].atan)
-    assert_equal(Interval[0], Interval[0].atan)
-  end
-
-  def test_cosh
-    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)
-    assert_equal((Interval[0] | Interval[3].cosh).hull, Interval[-1,3].cosh)
-    assert_equal(Interval[-1,3].cosh, Interval[-3,1].cosh)
-    assert_equal(Interval[0, Infinity], Interval[-Infinity,Infinity].cosh)
-  end
-
-  def test_sinh
-    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)
-  end
-
-  def test_cos
-    assert_equal(Interval[-1,-1 + 2 ** -53], Interval::PI.cos)
-    assert_equal(Interval[1 - 2 ** -53, 1], (2*Interval::PI).cos)
-    assert_equal(Interval[-1,1], Interval[Infinity].cos)
-    assert_equal(Interval[-1,1], Interval[-Infinity].cos)
-    onehalf = (Interval::PI/3).cos
-    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_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
-    assert_equal(Interval[-1,1], full.cos)
-    assert_equal(Interval[-1,1], (full + 2 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 4 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 6 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 8 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 2 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 4 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 6 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 8 * Interval::PI).cos)
-  end
-
-  def test_sin
-    assert_equal(Interval[-1,-1 + 2 ** -53], (3*Interval::PI/2).sin)
-    assert_equal(Interval[1 - 2 ** -53, 1], (Interval::PI/2).sin)
-    assert_equal(Interval[-1,1], Interval[Infinity].sin)
-    assert_equal(Interval[-1,1], Interval[-Infinity].sin)
-    onehalf = (Interval::PI/6).sin
-    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_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
-    assert_equal(Interval[-1,1], full.sin)
-    assert_equal(Interval[-1,1], (full + 2 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 4 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 6 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full + 8 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 2 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 4 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 6 * Interval::PI).cos)
-    assert_equal(Interval[-1,1], (full - 8 * Interval::PI).cos)
-  end
-
-  def test_tan
-    assert_equal(Interval[0], Interval[0].tan)
-    assert_equal(Interval[], Interval[].tan)
-    assert_equal(Interval[-Infinity, Infinity], Interval[0,6].tan)
-    assert_equal(Interval[-Infinity, Infinity],  (-Interval::PI/2 | Interval::PI/2).hull.tan)
-    assert_equal(Interval[-Infinity, Infinity], (- Interval::PI/4 | Interval::PI * 1.25).hull.tan)
-    assert_equal(Interval[-Infinity, Infinity], (4.75 *Interval::PI | Interval::PI * 6.25).hull.tan)
-
-    assert_equal(2 ** -51, Interval::PI.tan.width)
-    assert_include(Interval::PI.tan, 0)
-    assert_equal(3 * 2 ** -53, (Interval::PI/4).tan.width)
-    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)
-
-    x = (Interval::PI | -Interval::PI).hull/4
-    assert_equal((Interval[x.inf].tan | Interval[x.sup].tan).hull, x.tan)
-  end
-
-end end
-
-Test::Unit.run = (__FILE__ != $0)
+require File.dirname(__FILE__) + '/../test/test_interval.rb' if __FILE__ == $0