intervals 0.3.56

data/lib/interval.rb

@@ -0,0 +1,1170 @@
+#!/usr/bin/ruby
+
+# Definitions 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 "fpu"
+
+class Numeric
+  #
+  # Define a degenerate interval from a single value.
+  #
+  #  3.to_interval            # => Interval[3]
+  #
+  def to_interval
+    Interval[self]
+  end
+end
+
+# A class representing the finite union of closed mathematical intervals
+# in the extended real set.
+#
+# The real set is extended with +Infinity and -Infinity, and the intervals
+# are closed, i.e. they include their extrema.
+class Interval
+  include Enumerable
+
+  # Create a closed (multi-)interval with the given numerical extrema.
+  #
+  #  Interval[3]              # In mathematical notation: [3,3]
+  #  Interval[1,2]            # In mathematical notation: [1,2]
+  #  Interval[[1,2],[3,4]]    # Union of [1,2] and [3,4]
+  #
+  # Note that the created interval is always in canonical form:
+  #
+  #  Interval[[1,3],[2,4]]    # => Interval[1, 4]
+  #
+  def Interval.[](*array)
+    make(
+      if array.empty?
+        []
+      elsif array.first.kind_of?(Numeric)
+        [Simple[*array]]
+      else
+        array.select{|x| !x.empty?}.map { |x| Simple[*x] }
+      end
+    )
+  end
+
+  # Create a closed (multi-)interval from a set of simple intervals.
+  #
+  #  Interval.make(Interval[1,2], Interval[3,4])
+  #                           # => Interval[[1, 2], [3, 4]]
+  #
+  def Interval.make(comps)
+    l = []
+    comps.sort_by{|x| x.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
+      Interval::Complex.new(l)
+    end
+  end
+
+  # Returns a list of the parameters that can be used to reconstruct the
+  # interval.
+  #
+  #  a = Interval[1,2]        # => Interval[1, 2]
+  #  b = a.construction       # => [1, 2]
+  #  Interval[*b] == a        # => true
+  #
+  def construction
+    map{|x| x.extrema.uniq}
+  end
+
+  # True if the interval is _simple_, i.e., if it has only one
+  # connected component.
+  #
+  #  Interval[1,2].simple?    # => true
+  #  Interval[[1,2],[3,4]].simple?
+  #                           # => false
+  # If simple? is true, then the object is in fact of class 
+  # Interval::Simple.
+  #
+  #  Interval[1,2].class      # => Interval::Simple
+  #  Interval[1,2].midpoint   # => 1.5
+  #  Interval[[1,2],[3,4]].midpoint
+  #                           # raises a NoMethodError exception
+  #
+  def simple?
+    false
+  end
+
+  # Overrides Object#inspect, returning a string representation of the interval.
+  #
+  #  Interval[1,2].inspect    #= > "Interval[1, 2]"
+
+  def inspect
+    "Interval" + construction.inspect
+  end
+
+  # Overrides Object#to_s and uses #inspect to create a string representation of the interval.
+  def to_s
+    inspect
+  end
+
+  # Two intervals are equal if and only if they have equal components.
+  #
+  #  Interval[[1,3],[2,4]] == Interval[1,4]
+  #                           # => true
+  def == (other)
+    self.class === other && self.components == other.components
+  end
+
+  # True if a point _x_ belongs to the interval.
+  #
+  #  Interval[[1,2],[3,4]].include?(1.5)
+  #                           # => true
+  #  Interval[[1,2],[3,4]].include?(2.5)
+  #                           # => false
+  def include?(x)
+    any?{|i| i.include?(x)}
+  end
+
+  # Return itself.
+  def to_interval
+    self
+  end
+
+  # Make _other_ into an interval.
+  def coerce (other)
+    [other.to_interval, self]
+  end
+
+  # Unitary minus: applied to _I_ returns -_I_.
+  #
+  #  -Interval[1,2]           # => Interval[-2, -1]
+  #
+  def -@
+    self.class.new map{|x| -x}.reverse
+  end
+
+  # The inverse of the interval, _I_.+inverse+ is the same as 1/_I_.
+  #
+  #  Interval[1,2].inverse    # => Interval[0.5, 1.0]
+  #  Interval[-2,4].inverse   # => Interval[[-Infinity, -0.5], [0.25, Infinity]]
+  #
+  def inverse
+    # implemented below
+  end
+
+  # The exponential function.
+  #
+  #  Interval[[-Infinity,0],[1,Infinity]].exp
+  #                           # => Interval[[0,1],[Math::E,Infinity]]
+  #
+  def exp
+    # implemented below
+  end
+
+  # The logarithm function.
+  #
+  #  Interval[1,Math::E].log  # Interval[0,1]
+  #  Interval[-1,+1].log      # Interval[-Infinity,0]
+  #
+  def log
+    # implemented below
+  end
+
+  # The arc tangent function.
+  #
+  #  4 * Interval[1].atan     # => Interval::PI
+  #
+  def atan
+    # implemented below
+  end
+
+  # The cosine function.
+  #
+  #  (Interval::PI/3).cos     # => Interval[0.5, 0.5]
+  #
+  def cos
+    # implemented below
+  end
+
+  # The sine function.
+  #
+  #  (Interval::PI/6).sin     # => Interval[0.5, 0.5]
+  #
+  def sin
+    # implemented below
+  end
+
+  # The tangent function.
+  #
+  #  The cosine function.     # => Interval[1.0, 1.0]
+  #
+  def tan
+    # implemented below
+  end
+
+  # Hyperbolic cosine.
+  def cosh
+    # implemented below
+  end
+
+  # Hyperbolic sine.
+  def sinh
+    # implemented below
+  end
+
+  ## 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)
+    }
+  }
+
+  # Integer power.
+  #
+  #  Interval[-2,2]**2        # => Interval[0, 4]
+  #
+  def ** (n)
+    Interval.make(map{|x| (x**n).components}.flatten)
+  end
+
+  # Sum of intervals.
+  #
+  #  Interval[1,2] + Interval[3,4]
+  #                           # => Interval[4, 6]
+  #  Interval[2] + Interval[2]
+  #                           # => Interval[4]
+  #
+  # Note that
+  #
+  #  Interval[-Infinity] + Interval[Infinity]
+  #                           # => Interval[-Infinity, Infinity]
+  #
+  def + (other)
+    # implemented below
+  end
+
+  # Multiplication of intervals.
+  #
+  #  Interval[1,2] * Intervals[3,4]
+  #                           # => Interval[3, 8]
+  #  Interval[2] * Interval[2]
+  #                           # => Interval[4]
+  #
+  # Note that
+  #
+  #  Interval[0,1]  * Interval[2,Infinity]
+  #                           # => Interval[-Infinity, Infinity]
+  #
+  def * (other)
+    # implemented below
+  end
+
+  # Set intersection.
+  #
+  #  Interval[1,3] & Interval[2,4]
+  #                           # => Interval[2,3]
+  #  Interval[1,2] & Interval[3,4]
+  #                           # => Interval[]
+  #  (Interval[1,2] & Interval[3,4]).empty?
+  #                           # => true
+  #
+  def & (other)
+    # implemented below
+  end
+
+  ## 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)
+    }
+  }
+
+  # Subtraction: _A_ - _B_ is equivalent to _A_ + (-_B_).
+  def - (other)
+    self + (-other)
+  end
+
+  # Division: _A_ / _B_ is equivalent to _A_ * (_B_ ** -1).
+  def / (other)
+    self * other.to_interval.inverse
+  end
+
+  # Set union.
+  #
+  #  Interval[1,3] | Interval[2,4]
+  #                           # => Interval[1, 4]
+  #
+  def | (other)
+    Interval.make(other.to_interval.components + self.components)
+  end
+
+  # True if the interval has no elements.
+  def empty?
+    components.empty?
+  end
+
+  # An interval is sharp if each pair of extrema differ by at most a bit in the
+  # least significant position.
+  #
+  #  Interval[3].sharp?       # => true
+  #  Interval[1,2].sharp?     # => false
+  #  (1/Interval[3.0]).sharp? # => true
+  #  Interval[[1],[2]].sharp? # => true
+  #
+  def sharp?
+    all? {|x| x.sharp?}
+  end
+
+  # The hull is the smallest simple interval containing the interval itself.
+  #
+  #  Interval[[1,2],[3,4]]    # => Interval[1, 4]
+  #
+  def hull
+    if empty?
+      Interval[]
+    else
+      Interval[components.first.inf, components.last.sup]
+    end
+  end
+
+  @@newtonOpts = {
+    :maxIterations => 100,
+    :verbose => false
+  }
+
+  # Solve a non-linear equation using the Newton-Raphson method,
+  # finding all solutions in a in interval.
+  #
+  # For instance, to solve
+  #  x**3 == x
+  # we rewrite it first in the form
+  #  x**3 - x == 0
+  # The left-hand side of this equation has derivative
+  #  3* x**2 - 1
+  # To find all solutions in [-100,100] we call
+  #  Interval[-100,100].newton(proc {|x| x**3 - x}, proc {|x| 3* x**2 - 1})
+  #                           # => Interval[[-1.0], [-0.0], [1.0]]
+  # a sharp result showing the three roots -1, 0 and +1.
+  #
+  def newton(f, fp, opts = {})
+    effectiveOpts = @@newtonOpts.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}
+    self.map{|xx|
+      effectiveOpts[:maxIterations].times{
+        previous = xx;
+        xx = step.call(xx.midpoint,xx)
+        if previous == xx
+          if xx.sharp?
+            puts "Sharp fixed point #{xx}" if verbose
+            xx = Interval[xx.extrema.select {|x| f.call(Interval[x]).include?(0)}]
+            break
+          end
+          nonminimal_extrema = xx.extrema.reject {|x| f.call(Interval[x]).include?(0)}
+          if nonminimal_extrema == [] then
+            puts "Unsharp fixed point #{xx}" if verbose
+            break
+          end
+          if nonminimal_extrema.each {|x|
+              yy = step.call(x,xx)
+              if yy != xx
+                xx = yy;
+                break
+              end
+            }
+            xx = Interval[
+              if nonminimal_extrema.include?(xx.inf)
+                xx.inf + xx.inf.ulp
+              else
+                xx.inf
+              end,
+              if nonminimal_extrema.include?(xx.sup)
+                xx.sup - xx.sup.ulp
+              else
+                xx.sup
+              end]
+          end
+        end
+        if xx.empty?
+          puts "No solution" if verbose
+          break
+        elsif ! xx.simple?
+          puts "Branch splitting" if verbose
+          xx = xx.newton(f,fp,opts)
+          break
+        end
+      } && verbose && puts("Failed convergence #{effectiveOpts[:maxIterations]}")
+      xx
+    }. inject{|a,x| a |=x}
+  end
+
+end
+
+# Implements simple intervals. A simple interval is an interval with a single
+# component, i.e., a connected set of real numbers (extended with plus and minus
+# infinity.)
+class Interval::Simple < Interval
+  attr :inf
+  attr :sup
+
+  include Enumerable
+
+  # Implements Enumerable#each
+  def each
+    yield(self)
+    self
+  end
+
+  # Return an array with one element, itself.
+  def components
+    [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,2) # => Interval[1,2]
+  #
+  def initialize (a, b)
+    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
+
+  # Overrides Interval#construction
+  def construction # :nodoc:
+    extrema.uniq
+  end
+
+  # Implements Interval#simple?, returning true.
+  def simple?  # :nodoc:
+    true
+  end
+
+  # Two simple intervals are equal if they have same inf and sup.
+  def == (other)
+    self.class == other.class && inf == other.inf && sup == other.sup
+  end
+
+  # Implements Interval#include?.
+  def include?(x)  # :nodoc:
+    inf <= x  && x <= sup
+  end
+
+  # Returns the array with inf and sup.
+  #
+  #  Interval[1,2].extrema    # => [1, 2]
+  #
+  def extrema
+    [inf,sup]
+  end
+
+  # The interval's width is sup - inf.
+  #
+  #  Interval[2].width        # => 0
+  #  Interval[2,3].width      # => 1
+  #
+  def width
+    sup - inf
+  end
+
+  # The point in the middle of the interval.
+  #
+  #  Interval[1,3].midpoint   # => 2.0
+  #
+  def midpoint
+    (inf + sup) * 2 **-1
+  end
+
+  # Used to implement Interval's plus operator (\+).
+  def add (other)
+    self.class.new(
+      FPU.down {inf + other.inf},
+      FPU.up {sup + other.sup})
+  end
+
+  # Unitary minus.
+  def -@  # :nodoc:
+    self.class.new(-sup,-inf)
+  end
+
+  # Used to implement Interval's multiplicative operator (\*).
+  def multiply (other)
+    self.class.new(
+      FPU.down {
+        [inf * other.inf, inf * other.sup,
+         sup * other.inf, sup * other.sup]}.min,
+      FPU.up {
+        [inf * other.inf, inf * other.sup,
+         sup * other.inf, sup * other.sup]}.max)
+    rescue ArgumentError
+      self.class.new(-Infinity, Infinity)
+  end
+
+  # Implements Interval#inverse.
+  def inverse  # :nodoc:
+    if include?(0) then
+      Interval[
+        [-Infinity, FPU::up { inf == 0 ? -Infinity : inf**-1 }],
+        [FPU::down { sup == 0 ? Infinity  : sup**-1 }, Infinity]]
+    else
+      self.class.new(
+        FPU::down { sup ** -1 },
+        FPU::up   { inf ** -1 })
+    end
+  end
+
+  # Implements Interval's power operator.
+  def ** (n)  # :nodoc:
+    if n < 0
+      (self ** -n).inverse
+    elsif inf > 0
+      self.class.new(
+        FPU::down { FPU.power(inf, n) },
+        FPU::up   { FPU.power(sup, n) })
+    elsif sup < 0
+      if (-1) ** n > 0
+        (-self)**n
+      else
+        - (-self)**n
+      end
+    elsif (-1) ** n > 0
+      self.class.new(0, FPU::up {[FPU.power(inf, n), FPU.power(sup, n)]}.max )
+    else
+      self.class.new(
+        FPU::down { FPU.power(inf, n) },
+        FPU::up   { FPU.power(sup, n) })
+    end
+  end
+
+  # Implements Interval's & operator.
+  def intersect (other)
+    self.class.new([inf,other.inf].max, [sup,other.sup].min)
+  end
+
+  # Implements Interval#sharp?
+  def sharp?  # :nodoc:
+    w = width
+    if w == 0
+      true
+    elsif w.kind_of?(Float) && (inf >= 0  || sup <= 0)
+      s1, s2 = extrema.map{|x| x.abs}.sort
+      s1 + s1.ulp == s2
+    else
+      false
+    end
+  end
+
+  # Implements Interval#exp
+  def exp  #:nodoc:
+    self.class.new(FPU.exp_down(inf), FPU.exp_up(sup))
+  end
+
+  # Implements Interval#atan
+  def atan  #:nodoc:
+    self.class.new(FPU.atan_down(inf), FPU.atan_up(sup))
+  end
+
+  # Implements Interval#sinh
+  def sinh  #:nodoc:
+    self.class.new(FPU.sinh_down(inf), FPU.sinh_up(sup))
+  end
+
+  # Implements Interval#log
+  def log  #:nodoc:
+    if inf >= 0
+      self.class.new(FPU.log_down(inf), FPU.log_up(sup))
+    elsif sup >= 0
+      self.class.new(-Infinity, FPU.log_up(sup))
+    else
+      Interval[]
+    end
+  end
+
+  # Implements Interval#cosh
+  def cosh  #:nodoc:
+    if inf >=0
+      self.class.new(FPU.cosh_down(inf), FPU.cosh_up(sup))
+    elsif sup <= 0
+      self.class.new(FPU.cosh_down(sup), FPU.cosh_up(inf))
+    else
+      self.class.new(0,FPU.cosh_up([-inf,sup].max))
+    end
+  end
+
+  # Implements Interval#cos
+  def cos  #:nodoc:
+    return Interval[-1,1] if inf.abs == Infinity || sup.abs == Infinity
+    p = inf.divmod(Math::PI).first.to_i
+    self.class.new(
+      if include?((2*((p-1).div(2))+3) * Math::PI)
+        -1
+      else
+        [FPU.cos_down(inf), FPU.cos_down(sup)].min
+      end,
+      if include?((2*(p.div(2))+2) * Math::PI)
+        +1
+      else
+        [FPU.cos_up(inf), FPU.cos_up(sup)].max
+      end)
+  end
+
+  # Implements Interval#sin
+  def sin  #:nodoc:
+    return Interval[-1,1] if inf.abs == Infinity || sup.abs == Infinity
+    q = inf.divmod(Math::PI/2).first.to_i
+    p = (q-1).div(2)
+    self.class.new(
+      if include?((2*((p-1).div(2))+3.5) * Math::PI)
+        -1
+      else
+        [FPU.sin_down(inf), FPU.sin_down(sup)].min
+      end,
+      if include?((2*(p.div(2))+2.5) * Math::PI)
+        +1
+      else
+        [FPU.sin_up(inf), FPU.sin_up(sup)].max
+      end)
+  end
+
+  # Implement Interval#tan
+  def tan  #:nodoc:
+    q = inf.divmod(Math::PI/2).first.to_i
+    p = (q-1).div(2)
+    if include?(Math::PI * (p+2.5))
+      self.class.new(-Infinity,Infinity)
+    elsif include?(Math::PI * (p+1.5))
+      Interval[[-Infinity,FPU.tan_up(sup)],[FPU.tan_down(inf),Infinity]]
+    else
+      self.class.new(FPU.tan_down(inf),FPU.tan_up(sup))
+    end
+  end
+
+end
+
+# Implements an interval with multiple components.
+class Interval::Complex < Interval
+
+  # The array with the interval's components.
+  attr :components
+
+  def initialize (array)  # :nodoc:
+    @components = array
+    freeze
+  end
+
+  # Implements Enumerable#each.
+  def each
+    components.each { |o| yield(o) }
+    self
+  end
+
+end
+
+class Range
+
+  # Convert to Interval.
+  #
+  #  (1.2 .. 5.3).to_interval # => Interval[1.2, 5.3]
+  #  (1 ... 4).to_interval    # => Interval[1, 3]
+  #  (1 ... 3.1).to_interval  # Fails
+  #
+  def to_interval
+    Interval[first,
+      if exclude_end?
+        (last - 1).succ - 1
+      else
+        last
+      end]
+  end
+
+end
+
+class Interval
+
+  # The sharp interval that includes which Euler's constant.
+  E  = Math::E  + Interval[0, 2 ** -51]
+
+  # The sharp interval that includes Pi.
+  PI = Math::PI + Interval[0, 2 ** -51]
+
+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(res.include?(0), res)
+    # 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_equal(expected, s & expected, s)
+    else
+      # check for equality
+      assert_equal(expected,s)
+    end
+  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::Complex
+    tester.call Interval[[1],[2]],     [[1],[2]],             Interval::Complex
+    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
+  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(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]])
+  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_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(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")
+  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(Interval::E.log.include?(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(Interval[1].cosh.sharp?)
+    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(Interval[1].sinh.sharp?)
+    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( onehalf.include?(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_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( onehalf.include?(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_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(Interval::PI.tan.include?(0))
+    assert_equal(3 * 2 ** -53, (Interval::PI/4).tan.width)
+    assert((Interval::PI/4).tan.include?(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)