intervals 0.3.56

data/lib/fpu.rb

@@ -0,0 +1,287 @@
+#!/usr/bin/ruby
+
+# Definitions 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
+
+begin
+  require "fpu_c"
+rescue LoadError
+  Dir.chdir($LOAD_PATH.
+      map{|p| File.expand_path('../ext', p)}.
+      find(proc {$stderr.puts "Cannot locate fpu.c"; raise}) {|d|
+        File.exist?(File.expand_path('fpu.c',d))
+    }) {
+    begin
+      require "fpu_c"
+    rescue LoadError
+      $stderr.puts "*** I'll try and build fpu_c (it should happen only once)"
+      system("./extconf.rb")
+      system("make")
+      require "fpu_c"
+      $stderr.puts "*** Apparently, I succeeded in building fpu_c"
+    end
+  }
+end
+
+require "struct_float"
+
+module FPU
+
+  #
+  # Perform a computation with the FPU rounding downwards.
+  #
+  # Example:
+  #   FPU.down{1/5.0} < FPU.up{1/5.0}     # => true
+  #
+  def FPU.down
+    saved = roundingDown
+    yield
+  ensure
+    self.rounding = saved
+  end
+
+  #
+  # Perform a computation with the FPU rounding upwards.
+  #
+  # Example:
+  #   FPU.down{1/5.0} < FPU.up{1/5.0}     # => true
+  #
+  def FPU.up
+    saved = roundingUp
+    yield
+  ensure
+    self.rounding = saved
+  end
+
+  # Raise +x+ to the +n+-th power with correct rounding.
+  def FPU.power(x, n)
+    if Float === x && Integer === n
+      return 1/FPU.power(x,-n) if n < 0
+      l=[];
+      while n > 0
+        n,y=n.divmod(2);
+        l=[y,l]
+      end
+      l.flatten.inject(1){|p,i| if i == 1 then p*p*x; else p*p; end}
+    else
+      x ** n
+    end
+  end
+
+
+  # :stopdoc:
+  StandardRounding = rounding               # :nodoc:
+  PlusRounding     = up { rounding }        # :nodoc:
+  MinusRounding    = down{ rounding }       # :nodoc:
+
+  private_class_method :rounding=, :roundingDown, :roundingUp
+  # :startdoc:
+
+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)
+    $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)