intervals 0.3.63 → 0.4.75

data/lib/struct_float.rb

@@ -65,69 +65,5 @@ class Float
 
 end
 
-require 'test/unit'
+require File.dirname(__FILE__) + '/../test/test_struct_float.rb' if __FILE__ == $0
 
-# Tests Struct::Float.
-class Struct::Float::Test < Test::Unit::TestCase
-
-  def assert_consistent(f,s)
-    assert_equal(f,s.to_f)
-    assert_equal(s,f.to_struct)
-    assert_equal(s, eval(s.inspect))
-    assert(f.ulp.infinite? || (f/f.ulp).to_i == f/f.ulp, [f,f.ulp].inspect)
-  end
-
-  def assert_nan(s)
-    # NaN does not have a unique representation, and therefore
-    # 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)
-    # You cannot test for NaN with equality. You MUST use nan?
-    assert(s.to_f.nan?, s.to_f)
-    assert_equal(s, eval(s.inspect))
-  end
-
-  def test_consistency
-    assert_consistent Infinity, Struct::Float[1,2047,0]
-    assert_consistent -Infinity, Struct::Float[-1,2047,0]
-    assert_consistent 2.0 ** -1074, Struct::Float[1,0,1]
-    assert_consistent 0.0, Struct::Float[1,0,0]
-    assert_consistent -0.0, Struct::Float[-1,0,0]
-    assert_consistent 1.0, Struct::Float[1,1023, 0]
-    assert_consistent 1/3.0, Struct::Float[1,1021,0x5555555555555]
-    assert_consistent 1/5.0, Struct::Float[1,1020,0x999999999999a]
-  end
-
-  def test_nan
-    assert_nan( (0.0/0.0).to_struct)
-    assert_nan( Struct::Float[-1,2047,34])
-    assert_nan( Struct::Float[+1,2047,34])
-  end
-
-  def test_denormalized
-    assert_consistent 34 * 2.0 ** -(1023+51), Struct::Float[1,0,34]
-  end
-
-  def test_normalized
-    assert_consistent -(2**52+34) * 2.0**(1043-1023-52), Struct::Float[-1,1043,34]
-  end
-
-  def test_samples
-    n = 1000
-    srand 12345
-    n.times{
-      s = Struct::Float[2*rand(2) -1, rand(2048), rand(2**52)]
-      f = s.to_f
-      if f.nan?
-        assert_nan(s)
-      else
-        assert_consistent(f,s)
-      end
-    }
-  end
-
-end
-
-Test::Unit.run = (__FILE__ != $0)

data/test/runall.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby
+
+# Tests for the whole library.
+#
+# Copyright (c) 2006 Stefano Taschini <taschini@ieee.org>.
+# Licensed under the terms of LGPL: http://www.gnu.org/copyleft/lesser.html
+
+require File.dirname(__FILE__) + '/../lib/interval'
+
+Dir.glob(File.dirname(__FILE__) + '/test*.rb').each{|f|
+  require f
+}
+
+Test::Unit.run = (__FILE__ != $0)

data/test/test_fpu.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/ruby
+
+# Tests for the module FPU.
+#
+# Copyright (c) 2006 Stefano Taschini <taschini@ieee.org>.
+# Licensed under the terms of LGPL: http://www.gnu.org/copyleft/lesser.html
+
+require File.dirname(__FILE__) + '/../lib/fpu' if __FILE__ == $0
+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

data/test/test_interval.rb

@@ -0,0 +1,645 @@
+#!/usr/bin/ruby
+
+# Tests for the class Interval.
+#
+# Copyright (c) 2006 Stefano Taschini <taschini@ieee.org>.
+# Licensed under the terms of LGPL: http://www.gnu.org/copyleft/lesser.html
+
+# To control the FPU's rounding mode
+require File.dirname(__FILE__) + '/../lib/interval' if __FILE__ == $0
+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(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'] }
+  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.union(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(Interval::ConstructionError){ (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 }
+    end
+  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
+
+# Tests Kahan's summation formula
+class Interval::KahanTest < Test::Unit::TestCase
+  include Interval::Assertions
+
+  # Generate a random data vector
+  #
+  #  data = Kahan_Test.gen_data(100)
+  #
+  def gen_data(n)
+    (0...n).map {rand - 0.5}
+  end
+
+  class PoorMansRational < Numeric
+    attr :num
+    attr :den
+
+    def initialize(n, d)
+      if d < 0
+        n, d = -n, -d
+      end
+      b, a = [n.abs,d].sort
+      while b > 0
+        a, b = b, a % b
+      end
+      @num = n.div(a)
+      @den = d.div(a)
+    end
+
+    def + (other)
+      case other
+      when self.class
+        self.class.new(num * other.den + den * other.num, den * other.den)
+      when Integer
+        self.class.new(num + den * other, den)
+      else
+        x, y = other.coerce(self)
+        x + y
+      end
+    end
+
+    def coerce(other)
+      case other
+      when self.class
+        return other, self
+      when Integer
+        return self.class.new(other, 1), self
+      else
+        super
+      end
+    end
+
+    def to_f
+      @num.to_f/@den.to_f
+    end
+
+  end
+
+  unless defined?(Rational)
+    def Rational(n, d = 1)
+      PoorMansRational.new(n,d)
+    end
+  end
+
+  # Convert to a rational number with no precision loss
+  #
+  #  to_r(1.1).to_f == 1.1     # => true
+  #
+  def to_r(x)
+    if !x.finite?
+      self
+    elsif x.zero?
+      0
+    else
+      exp = [Math.frexp(x).last - 53, -1074].max
+      sig = (x / (2.0 ** exp)).to_i
+      if exp >= 0
+        Rational(sig * 2 ** exp)
+      else
+        Rational(sig, 2 ** (-exp))
+      end
+    end
+  end
+
+  def assert_consistent_sum(raw, strict = nil)
+    # The exact sum, with rationals
+    exact = raw.inject(0){|a,x| a+to_r(x)}.to_f
+
+    # Summing them as floats
+    rawsum = raw.inject{|a,x| a+x}
+
+    # Data as a collection of intervals
+    data = raw.map{|x| Interval[x]}
+
+    # Kahan's sum
+    kahan = Interval.sum(*data)
+
+    # Naive sum
+    naive = data.inject{|a,x| a+x}
+
+    # Kahan must include the exact sum
+    assert_include(kahan, exact)
+
+    # In some cases the raw sum is outside Kahan's result
+    assert_outside(kahan, rawsum) if strict
+
+    # Kahan's result must be sharper than the naive sum
+    assert_subset(kahan, naive)
+
+    #puts [rawsum, exact, kahan.width, naive.width, naive.width/kahan.width].
+    #  inspect if @@long && ! kahan.include?(rawsum)
+  end
+
+  def test_basic_consistency
+    assert_equal(Interval[3], Interval.sum(Interval[1], Interval[2]))
+    assert_equal(Interval[[3],[6]], Interval.sum(Interval[[1],[4]], Interval[2]))
+    assert_equal(Interval[-2,14],Interval.sum(Interval[[1,9],[-2,-1]], Interval[[0,3],[1,5]]))
+    assert_equal(Interval[[-22, -20], [-19, -10], [-2, 0], [1, 10]],
+                 Interval.sum(Interval[[1,9],[-2,-1]], Interval[[0,1],[-20,-19]]))
+  end
+
+  @@long = ARGV.include?("long")
+
+  def test_large_data
+    assert_consistent_sum [0.694758884739873,
+         0.604772180759511,
+         0.796647997261382,
+         0.102320271311194,
+         0.87286348648478,
+         0.175213643903808,
+         0.82310391214613,
+         0.198147944349148,
+         0.24650422376045,
+         0.471233184991935].map{|x| x-0.5}, :strict
+    srand 12345
+    assert_consistent_sum gen_data(200), :strict
+    if @@long
+      assert_consistent_sum gen_data(2000), :strict
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(100)
+      assert_consistent_sum gen_data(1000)
+      assert_consistent_sum gen_data(10000)
+    end
+  end
+
+end