flt 1.0.0

data/test/test_odd_even.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestOddEven < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_even
+    assert !DecNum.nan.even?
+    assert !DecNum.infinity.even?
+    assert !DecNum.infinity(-1).even?
+    assert DecNum.zero.even?
+    assert DecNum.zero(-1).even?
+    assert !DecNum('0.1').even?
+    assert !DecNum('-0.1').even?
+    assert !DecNum(-7).even?
+    assert DecNum(-6).even?
+    assert !DecNum(-5).even?
+    assert DecNum(-4).even?
+    assert !DecNum(-3).even?
+    assert DecNum(-2).even?
+    assert !DecNum(-1).even?
+    assert DecNum(0).even?
+    assert !DecNum(1).even?
+    assert DecNum(2).even?
+    assert !DecNum(3).even?
+    assert DecNum(4).even?
+    assert !DecNum(5).even?
+    assert DecNum(6).even?
+    assert !DecNum(7).even?
+    assert !DecNum('101').even?
+    assert  DecNum('102').even?
+    assert !DecNum('103').even?
+    assert  DecNum('10100').even?
+    assert  DecNum('10200').even?
+    assert !DecNum('101.00').even?
+    assert  DecNum('102.00').even?
+    assert !DecNum('101.01').even?
+    assert !DecNum('102.01').even?
+  end
+
+  def test_odd
+    assert !DecNum.nan.odd?
+    assert !DecNum.infinity.odd?
+    assert !DecNum.infinity(-1).odd?
+    assert !DecNum.zero.odd?
+    assert !DecNum.zero(-1).odd?
+    assert !DecNum('0.1').odd?
+    assert !DecNum('-0.1').odd?
+    assert DecNum(-7).odd?
+    assert !DecNum(-6).odd?
+    assert DecNum(-5).odd?
+    assert !DecNum(-4).odd?
+    assert DecNum(-3).odd?
+    assert !DecNum(-2).odd?
+    assert DecNum(-1).odd?
+    assert !DecNum(0).odd?
+    assert DecNum(1).odd?
+    assert !DecNum(2).odd?
+    assert DecNum(3).odd?
+    assert !DecNum(4).odd?
+    assert DecNum(5).odd?
+    assert !DecNum(6).odd?
+    assert  DecNum(7).odd?
+    assert  DecNum(101).odd?
+    assert !DecNum(102).odd?
+    assert  DecNum(103).odd?
+    assert !DecNum(10100).odd?
+    assert !DecNum(10200).odd?
+    assert  DecNum('101.00').odd?
+    assert !DecNum('102.00').odd?
+    assert !DecNum('101.01').odd?
+    assert !DecNum('102.01').odd?
+  end
+
+end

data/test/test_round.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+class TestRound < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+
+  def test_round
+
+    assert_equal(101,  DecNum('100.5').round)
+    assert DecNum('100.5').round.kind_of?(Integer)
+    assert_equal 100, DecNum('100.4999999999').round
+    assert_equal(-101, DecNum('-100.5').round)
+    assert_equal(-100, DecNum('-100.4999999999').round)
+
+    assert_equal 101, DecNum('100.5').round(:places=>0)
+    assert DecNum('100.5').round(:places=>0).kind_of?(DecNum)
+    assert_equal 101, DecNum('100.5').round(0)
+    assert DecNum('100.5').round(0).kind_of?(DecNum)
+
+    assert_equal DecNum('123.12'), DecNum('123.123').round(2)
+    assert_equal DecNum('123'), DecNum('123.123').round(0)
+    assert_equal DecNum('120'), DecNum('123.123').round(-1)
+    assert_equal DecNum('120'), DecNum('123.123').round(:precision=>2)
+    assert_equal DecNum('123.12'), DecNum('123.123').round(:precision=>5)
+
+    assert_equal 100, DecNum('100.5').round(:rounding=>:half_even)
+    assert_equal 101, DecNum('100.5000001').round(:rounding=>:half_even)
+    assert_equal 102, DecNum('101.5').round(:rounding=>:half_even)
+    assert_equal 101, DecNum('101.4999999999').round(:rounding=>:half_even)
+
+    assert_equal 101, DecNum('100.0001').ceil
+    assert_equal(-100, DecNum('-100.0001').ceil)
+    assert_equal(-100, DecNum('-100.9999').ceil)
+    assert_equal 100, DecNum('100.9999').floor
+    assert_equal(-101, DecNum('-100.9999').floor)
+    assert_equal(-101, DecNum('-100.0001').floor)
+
+    assert_equal 100, DecNum('100.99999').truncate
+    assert_equal(-100, DecNum('-100.99999').truncate)
+
+    assert_equal(10,  DecNum('9.99999').round(:rounding=>:half_up))
+    assert_equal(1,  DecNum('0.999999').round(:rounding=>:half_up))
+    assert_equal(0,  DecNum('0.0999999').round(:rounding=>:half_up))
+    assert_equal(1,  DecNum('0.0999999').round(:rounding=>:up))
+
+  end
+
+  def detect_rounding(type)
+    x = type.new(1)*type.int_radix_power(type.context.precision+1)
+    y = x + type.int_radix_power(2)
+    h = type.radix/2
+    b = h*type.radix
+    z = type.new(type.int_radix_power(2) - 1)
+    type.context do
+      type.context.precision = 8 if type.context.exact?
+      if x + 1 == y
+        if (y + 1 == y) && type.radix==10
+          :up05
+        elsif -x - 1 == -y
+          :up
+        else
+          :ceiling
+        end
+      else # x + 1 == x
+        if x + z == x
+          if -x - z == -x
+            :down
+          else
+            :floor
+          end
+        else # x + z == y
+          # round to nearest
+          if x + b == x
+            if y + b == y
+              :half_down
+            else
+              :half_even
+            end
+          else # x + b == y
+            :half_up
+          end
+        end
+      end
+    end
+  end
+
+  def test_round_detection
+    [DecNum, BinNum].each do |type|
+      [:half_even, :half_up, :half_down, :down, :up, :floor, :ceiling, :up05].each do |rounding|
+        type.context(:rounding=>rounding) do
+          next if type==BinNum && rounding==:up05
+          assert_equal rounding, detect_rounding(type)
+        end
+      end
+    end
+  end
+
+
+end

data/test/test_to_int.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestToInt < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_to_i
+
+    assert_same 0, DecNum('0.0').to_i
+    assert_same 123, DecNum('0.0123000E4').to_i
+    assert 1234567890.eql?(DecNum('123456789E1').to_i)
+    assert 1234567890.eql?(DecNum('123456789000E-2').to_i)
+    assert_same(-123, DecNum('-0.0123000E4').to_i)
+    assert(-1234567890.eql?(DecNum('-123456789E1').to_i))
+    assert(-1234567890.eql?(DecNum('-123456789000E-2').to_i))
+    assert_raise(DecNum::Error) { DecNum.infinity.to_i }
+    assert_nil DecNum.nan.to_i
+    assert_same(1, DecNum('1.9').to_i)
+    assert_same(-1, DecNum('-1.9').to_i)
+
+  end
+
+  def test_to_integral_value
+
+    assert_equal DecNum('0'), DecNum('0.0').to_integral_value
+    assert_equal DecNum('123'), DecNum('0.0123000E4').to_integral_value
+    assert_equal DecNum('1234567890'), DecNum('123456789E1').to_integral_value
+    assert_equal DecNum('1234567890'), DecNum('123456789000E-2').to_integral_value
+    assert_equal DecNum('0'), DecNum('-0.0').to_integral_value
+    assert_equal DecNum('-123'), DecNum('-0.0123000E4').to_integral_value
+    assert_equal DecNum('-1234567890'), DecNum('-123456789E1').to_integral_value
+    assert_equal DecNum('-1234567890'), DecNum('-123456789000E-2').to_integral_value
+    DecNum.context.rounding = :half_up
+    assert_equal DecNum('2'), DecNum('1.9').to_integral_value
+    assert_equal DecNum('-2'), DecNum('-1.9').to_integral_value
+    DecNum.context.rounding = :down
+    assert_equal DecNum('1'), DecNum('1.9').to_integral_value
+    assert_equal DecNum('-1'), DecNum('-1.9').to_integral_value
+    assert DecNum.nan.to_integral_value.nan?
+    assert_equal DecNum.infinity, DecNum.infinity.to_integral_value
+
+  end
+
+  def test_to_integral_exact
+
+    DecNum.context.regard_flags DecNum::Rounded
+    DecNum.context.traps[DecNum::Rounded] = false
+    DecNum.context.regard_flags DecNum::Rounded
+    DecNum.context.traps[DecNum::Inexact] = true
+    assert_equal DecNum('0'), DecNum('0').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('0'), DecNum('0.0').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('123'), DecNum('123').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('123'), DecNum('0.0123000E4').to_integral_exact
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    assert_equal DecNum('1234567890'), DecNum('123456789E1').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('1234567890'), DecNum('123456789000E-2').to_integral_exact
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    assert_equal DecNum('0'), DecNum('-0.0').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('-123'), DecNum('-0.0123000E4').to_integral_exact
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    assert_equal DecNum('-1234567890'), DecNum('-123456789E1').to_integral_exact
+    assert !DecNum.context.flags[DecNum::Rounded]
+    assert_equal DecNum('-1234567890'), DecNum('-123456789000E-2').to_integral_exact
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    assert_raise(DecNum::Inexact) { DecNum('1.9').to_integral_exact }
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    assert_raise(DecNum::Inexact) { DecNum('-1.9').to_integral_exact }
+    assert DecNum.nan.to_integral_exact.nan?
+    assert_equal DecNum.infinity, DecNum.infinity.to_integral_exact
+    assert DecNum.context.flags[DecNum::Rounded]
+    DecNum.context.flags[DecNum::Rounded] = false
+    DecNum.context.traps[DecNum::Inexact] = false
+    DecNum.context.rounding = :half_up
+    assert_equal DecNum('2'), DecNum('1.9').to_integral_exact
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert_equal DecNum('-2'), DecNum('-1.9').to_integral_exact
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    DecNum.context.rounding = :down
+    assert_equal DecNum('1'), DecNum('1.9').to_integral_exact
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert_equal DecNum('-1'), DecNum('-1.9').to_integral_exact
+    assert DecNum.nan.to_integral_exact.nan?
+    assert_equal DecNum.infinity, DecNum.infinity.to_integral_exact
+
+  end
+
+
+end

data/test/test_to_rf.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestToRF < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_to_r
+    [
+      [ '0', 0, 1 ],
+      [ '1', 1, 1 ],
+      [ '-1', -1, 1 ],
+      [ '1234567.1234567', 12345671234567, 10000000 ],
+      [ '-1234567.1234567', -12345671234567, 10000000 ],
+      [ '0.200', 2, 10 ],
+      [ '-0.200', -2, 10 ]
+    ].each do |n, num, den|
+      r = Rational(num,den)
+      d = DecNum(n)
+      assert d.to_r.is_a?(Rational)
+      assert_equal r, d.to_r
+    end
+  end
+
+  def test_to_f
+    ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+      f = Float(n)
+      d = DecNum(n)
+      assert d.to_f.is_a?(Float)
+      assert_equal f, d.to_f
+    end
+  end
+
+end

data/test/test_tol.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestTolerance < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+    float_emulation_context
+
+    DecNum.context.define_conversion_from(Float) do |x, dec_context|
+      BinNum.context(:rounding=>dec_context.rounding) do |bin_context|
+        BinNum(x).to_decimal
+      end
+    end
+
+    DecNum.context.define_conversion_from(BinNum) do |x, dec_context|
+      BinNum.context(:rounding=>dec_context.rounding) do |bin_context|
+        x.to_decimal
+      end
+    end
+
+    BinNum.context.define_conversion_from(DecNum) do |x, bin_context|
+      BinNum(x.to_s)
+    end
+
+  end
+
+  def test_absolute
+
+    tol = Tolerance(100, :absolute)
+    assert_equal 100, tol.value(1.0)
+    assert_equal 100, tol.value(1.5)
+    assert_equal 100, tol.value(1.0E10)
+    assert_equal 100, tol.value(-1.0E10)
+    assert_equal 100, tol.value(DecNum('1.0'))
+    assert_equal 100, tol.value(DecNum('1.5'))
+    assert_equal 100, tol.value(DecNum('1.0E10'))
+    assert_equal 100, tol.value(DecNum('-1.0E10'))
+    assert tol.eq?(11234.0, 11280.0)
+    assert tol.eq?(11234.0, 11135.0)
+    assert tol.eq?(-11234.0, -11280.0)
+    assert tol.eq?(DecNum('11234.0'), DecNum('11280.0'))
+    assert tol.eq?(DecNum('11234.0'), DecNum('11135.0'))
+    assert tol.eq?(DecNum('-11234.0'), DecNum('-11280.0'))
+    assert tol.eq?(DecNum('-11234.0'), DecNum('-11135.0'))
+    assert !tol.eq?(11234.0, -11280.0)
+    assert !tol.eq?(-11234.0, 11280.0)
+    assert !tol.eq?(11234.0, 11335.0)
+    assert !tol.eq?(11234.0, 11133.0)
+
+  end
+
+  def test_relative
+
+    tol = Tolerance(100, :relative)
+    assert_equal 100, tol.value(1.0)
+    assert_equal 150, tol.value(1.5)
+    assert_equal 1E12, tol.value(1.0E10)
+    assert_equal 1E12, tol.value(-1.0E10)
+    assert_equal 100, tol.value(DecNum('1.0'))
+    assert_equal 150, tol.value(DecNum('1.5'))
+    assert_equal 1E12, tol.value(DecNum('1.0E10'))
+    assert_equal 1E12, tol.value(DecNum('-1.0E10'))
+
+  end
+
+  def test_floating
+
+    tol = Tolerance(100, :floating)
+    assert_equal 100, tol.value(1.0)
+    assert_equal 200, tol.value(1.5)
+    assert_equal 100*2.0**34, tol.value(1.0E10)
+    assert_equal 100*2.0**34, tol.value(-1.0E10)
+    assert_equal 100, tol.value(DecNum('1.0'))
+    assert_equal 1000, tol.value(DecNum('1.5'))
+    assert_equal 1E12, tol.value(DecNum('1.0E10'))
+    assert_equal 1E12, tol.value(DecNum('-1.0E10'))
+
+  end
+
+  def test_significant_decimals
+    t = SigDecimalsTolerance.new(4)
+
+    assert t.eq?(DecNum('1.2345678'), DecNum('1.235'))
+    assert t.eq?(DecNum('12345678'), DecNum('12350000'))
+    assert !t.eq?(DecNum('1.2345678'), DecNum('1.234'))
+
+  end
+
+  def test_ulps
+    DecNum.context.precision = 4
+    t = UlpsTolerance.new(2)
+
+    assert t.eq?(DecNum('1.2345678'), DecNum('1.236'))
+    assert !t.eq?(DecNum('1.2345678'), DecNum('1.237'))
+    assert t.eq?(DecNum('12345678'), DecNum('12360000'))
+    assert !t.eq?(DecNum('12345678'), DecNum('12370000'))
+
+  end
+
+
+end

data/test/test_ulp.rb

@@ -0,0 +1,127 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestUlp < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+
+  NUMBERS = %w{
+    0.0000
+    0.0001
+    0.0002
+    0.0003
+    0.0999
+    0.1000
+    0.1001
+    0.1999
+    0.2000
+    0.2001
+    0.8999
+    0.9000
+    0.9001
+    0.9999
+    1.0000
+    1.0001
+    1E27
+    1.0001E27
+  }
+
+  def test_ulp_4dig
+    DecNum.context.precision = 4
+    DecNum.context.emin = -99
+    DecNum.context.emax =  99
+
+    (NUMBERS+[DecNum.zero,DecNum.zero(-1),
+             DecNum.context.minimum_nonzero, DecNum.context.maximum_subnormal, DecNum.context.minimum_normal,
+             DecNum.context.maximum_finite]).each do |n|
+        x = DecNum(n)
+        if x >= 0
+          assert_equal x-x.next_minus, x.ulp
+        else
+          assert_equal x.next_plus-x, x.ulp
+        end
+    end
+
+    assert_equal DecNum.context.maximum_finite-DecNum.context.maximum_finite.next_minus, DecNum.infinity.ulp
+    assert_equal DecNum('0.00001'), DecNum('0.1').ulp
+    assert_equal DecNum('1E-7'), DecNum('0.001').ulp
+    assert_equal DecNum('0.00001'), DecNum('0.100').ulp
+    assert_equal DecNum('0.00001'), DecNum('0.1000').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.1001').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.9').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.99999').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.9000').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.990').ulp
+    assert_equal DecNum('0.0001'), DecNum('0.23').ulp
+    assert_equal DecNum('1E-101'), DecNum('1.001E-98').ulp
+    assert_equal DecNum('1E-102'), DecNum('1.001E-99').ulp
+    assert_equal DecNum('1E-102'), DecNum('1E-99').ulp
+    assert_equal DecNum('1E-102'), DecNum('9.99E-100').ulp
+    assert_equal DecNum('1E-102'), DecNum('1E-102').ulp
+    assert_equal DecNum('1E-102'), DecNum('0').ulp
+    assert_equal DecNum('1E-102'), DecNum('0').ulp
+
+    DecNum.context.exact = true
+    assert DecNum(1).ulp.nan?, "No ulps can be computed in exact contexts"
+    DecNum.context.traps[DecNum::InvalidOperation] = true
+    assert_raise(DecNum::InvalidOperation) { DecNum(1).ulp }
+
+  end
+
+  BIN_NUMBERS = %w{
+    00000
+    00001
+    00010
+    00011
+    00111
+    01000
+    01001
+    01111
+    10000
+    10001
+  }
+
+
+  def test_ulp_bin
+    BinNum.context.precision = 4
+    BinNum.context.emin = -99
+    BinNum.context.emax =  99
+
+    numbers = []
+    [0, -10, 10].each do |exp|
+      numbers += BIN_NUMBERS.map{|n| BinNum(+1, n.to_i(2), exp)}
+      numbers += BIN_NUMBERS.map{|n| BinNum(-1, n.to_i(2), exp)}
+    end
+
+    (numbers+[BinNum.zero,BinNum.zero(-1),
+             BinNum.context.minimum_nonzero, BinNum.context.maximum_subnormal, BinNum.context.minimum_normal,
+             BinNum.context.maximum_finite]).each do |x|
+        if x >= 0
+          assert_equal x-x.next_minus, x.ulp
+        else
+          assert_equal x.next_plus-x, x.ulp
+        end
+    end
+
+    assert_equal BinNum.context.maximum_finite-BinNum.context.maximum_finite.next_minus, BinNum.infinity.ulp
+    assert_equal BinNum(+1,1,-5), BinNum(+1,1,-1).ulp
+    assert_equal BinNum(+1,1,-7), BinNum(+1,1,-3).ulp
+    assert_equal BinNum(+1,1,-5), BinNum(+1,4,-3).ulp
+    assert_equal BinNum(+1,1,-7), BinNum(+1,4,-5).ulp
+    assert_equal BinNum(+1,1,-5), BinNum(+1,2**4-1,-5).ulp
+    assert_equal BinNum(+1,1,-7), BinNum(+1,2**4-1,-7).ulp
+    assert_equal BinNum(+1,1,-5), BinNum(+1,4*(2**4-1),-7).ulp
+    assert_equal BinNum(+1,1,-7), BinNum(+1,4*(2**4-1),-9).ulp
+
+    BinNum.context.exact = true
+    assert BinNum(1).ulp.nan?, "No ulps can be computed in exact contexts"
+    BinNum.context.traps[BinNum::InvalidOperation] = true
+    assert_raise(BinNum::InvalidOperation) { BinNum(1).ulp }
+
+  end
+
+
+end