flt 1.5.0 → 1.5.1

data/test/test_float.rb

@@ -1,40 +1,38 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestFloat < Test::Unit::TestCase
-
+class TestFloat < Minitest::Test
   def setup
     initialize_context
   end
 
   def test_sign
-    assert_equal -1, Float.context.sign(-1.0)
-    assert_equal -1, Float.context.sign(-100.0)
-    assert_equal -1, Float.context.sign(-0.0)
-    assert_equal -1, Float.context.sign(-Float::MIN)
-    assert_equal -1, Float.context.sign(-Float::MAX)
-    assert_equal -1, Float.context.sign(-Float::EPSILON)
-    assert_equal -1, Float.context.sign(-Float::INFINITY)
+    assert_equal(-1, Float.context.sign(-1.0))
+    assert_equal(-1, Float.context.sign(-100.0))
+    assert_equal(-1, Float.context.sign(-0.0))
+    assert_equal(-1, Float.context.sign(-Float::MIN))
+    assert_equal(-1, Float.context.sign(-Float::MAX))
+    assert_equal(-1, Float.context.sign(-Float::EPSILON))
+    assert_equal(-1, Float.context.sign(-Float::INFINITY))
 
-    assert_equal +1, Float.context.sign(+1.0)
-    assert_equal +1, Float.context.sign(+100.0)
-    assert_equal +1, Float.context.sign(+0.0)
-    assert_equal +1, Float.context.sign(Float::MIN)
-    assert_equal +1, Float.context.sign(Float::MAX)
-    assert_equal +1, Float.context.sign(Float::EPSILON)
-    assert_equal +1, Float.context.sign(Float::INFINITY)
+    assert_equal(+1, Float.context.sign(+1.0))
+    assert_equal(+1, Float.context.sign(+100.0))
+    assert_equal(+1, Float.context.sign(+0.0))
+    assert_equal(+1, Float.context.sign(Float::MIN))
+    assert_equal(+1, Float.context.sign(Float::MAX))
+    assert_equal(+1, Float.context.sign(Float::EPSILON))
+    assert_equal(+1, Float.context.sign(Float::INFINITY))
 
     assert_nil Float.context.sign(Float.context.nan)
   end
 
   def copy_sign
-    assert_equal -1.23, BigDecimal.context.copy_sign(1.23, -1)
-    assert_equal -1.23, BigDecimal.context.copy_sign(1.23, -10.0)
-    assert_equal -1.23, BigDecimal.context.copy_sign(-1.23, -1)
-    assert_equal -1.23, BigDecimal.context.copy_sign(-1.23, -10.0)
-    assert_equal 1.23, BigDecimal.context.copy_sign(-1.23, +1)
-    assert_equal 1.23, BigDecimal.context.copy_sign(-1.23, 10.0)
-    assert_equal 1.23, BigDecimal.context.copy_sign(1.23, +1)
-    assert_equal 1.23, BigDecimal.context.copy_sign(1.23, 10.0)
+    assert_equal(-1.23, BigDecimal.context.copy_sign(1.23, -1))
+    assert_equal(-1.23, BigDecimal.context.copy_sign(1.23, -10.0))
+    assert_equal(-1.23, BigDecimal.context.copy_sign(-1.23, -1))
+    assert_equal(-1.23, BigDecimal.context.copy_sign(-1.23, -10.0))
+    assert_equal(1.23, BigDecimal.context.copy_sign(-1.23, +1))
+    assert_equal(1.23, BigDecimal.context.copy_sign(-1.23, 10.0))
+    assert_equal(1.23, BigDecimal.context.copy_sign(1.23, +1))
+    assert_equal(1.23, BigDecimal.context.copy_sign(1.23, 10.0))
   end
-
 end

data/test/test_format.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestFormat < Test::Unit::TestCase
+class TestFormat < Minitest::Test
 
   def setup
     initialize_context

data/test/test_formatter.rb

@@ -1,9 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 
-class TestExact < Test::Unit::TestCase
-
-
+class TestFormatter < Minitest::Test
   def setup
     initialize_context
   end
@@ -25,7 +23,7 @@ class TestExact < Test::Unit::TestCase
     digits = formatter.format(x, f, e, :up, BinNum.context.precision, false)
     assert_equal [1], digits
 
-    assert_raise(Flt::Support::InfiniteLoopError) { formatter.format(x, f, e, :up, BinNum.context.precision, true) }
+    assert_raises(Flt::Support::InfiniteLoopError) { formatter.format(x, f, e, :up, BinNum.context.precision, true) }
 
     digits = formatter.format(x, f, e, :down, BinNum.context.precision, false)
     assert_equal [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
@@ -48,7 +46,7 @@ class TestExact < Test::Unit::TestCase
     digits = formatter.format(x, f, e, :up, BinNum.context.precision, false)
     assert_equal [5], digits
 
-    assert_raise(Flt::Support::InfiniteLoopError) { formatter.format(x, f, e, :up, BinNum.context.precision, true) }
+    assert_raises(Flt::Support::InfiniteLoopError) { formatter.format(x, f, e, :up, BinNum.context.precision, true) }
 
     digits = formatter.format(x, f, e, :down, BinNum.context.precision, false)
     assert_equal [5], digits
@@ -58,7 +56,7 @@ class TestExact < Test::Unit::TestCase
     refute formatter.round_up
   end
 
-def test_binary_to_repeating_decimal_formatter
+  def test_binary_to_repeating_decimal_formatter
     Flt::BinNum.context = Flt::BinNum::IEEEDoubleContext
     formatter = Flt::Support::Formatter.new(BinNum.radix, BinNum.context.etiny, 10, :raise_on_repeat => false)
 
@@ -144,12 +142,12 @@ def test_binary_to_repeating_decimal_formatter
     digits = formatter.format(x, f, e, :up, DecNum.context.precision, false)
     assert_equal [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1], digits
 
-    assert_raise(Support::InfiniteLoopError) { formatter.format(x, f, e, :up, DecNum.context.precision, true) }
+    assert_raises(Support::InfiniteLoopError) { formatter.format(x, f, e, :up, DecNum.context.precision, true) }
 
     digits = formatter.format(x, f, e, :down, DecNum.context.precision, false)
     assert_equal [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1], digits
 
-    assert_raise(Support::InfiniteLoopError) { formatter.format(x, f, e, :down, DecNum.context.precision, true) }
+    assert_raises(Support::InfiniteLoopError) { formatter.format(x, f, e, :down, DecNum.context.precision, true) }
   end
 
   def test_decimal_to_repeating_binary_formatter

data/test/test_hex_format.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestHexFormat< Test::Unit::TestCase
+class TestHexFormat< Minitest::Test
 
   def setup
     @hex_test_data = [0.1, 1.0/3, 0.1e10, 1e10/3.0, 0.1e-10, 1e-10/3.0, 123456.789,
@@ -32,7 +32,7 @@ class TestHexFormat< Test::Unit::TestCase
       BinNum.context(BinNum::FloatContext) do
         @hex_test_data.each do |number|
           hex_upcase = "%A" % number
-          hex_downcase = "%a" % number
+          # hex_downcase = "%a" % number
           number = BinNum(number)
           # text = number.to_s(:base => :hex_bin, :all_digits => false,  :output_rounding => BinNum.context.rounding)
           text_up = BinNum.context(:capitals => true){

data/test/test_multithreading.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 
 
-class TestMultithreading < Test::Unit::TestCase
+class TestMultithreading < Minitest::Test
 
   def setup
     initialize_context

data/test/test_normalized.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 
-class TestNormalized < Test::Unit::TestCase
+class TestNormalized < Minitest::Test
 
   include Flt
 

data/test/test_num_constructor.rb

@@ -1,15 +1,20 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestNumConstructor < Test::Unit::TestCase
+class TestNumConstructor < Minitest::Test
 
 
   def setup
     initialize_context
+    @old_prec = DecNum.context.precision
     DecNum.context.precision = 28
     @dprec5 = DecNum::Context(:precision=>5)
     @bprec5 = BinNum::Context(:precision=>5)
   end
 
+  def teardown
+    DecNum.context.precision = @old_prec
+  end
+
   def test_direct
     assert_equal [1, 1234, -2], DecNum(+1, 1234, -2).split
     assert_equal [1, 1234, -2],  DecNum(+1, 1234, -2, @dprec5).split

data/test/test_odd_even.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestOddEven < Test::Unit::TestCase
+class TestOddEven < Minitest::Test
 
 
   def setup

data/test/test_rationalizer.rb

@@ -11,7 +11,7 @@ else
   end
 end
 
-class TestRationalizer < Test::Unit::TestCase
+class TestRationalizer < Minitest::Test
 
   def setup
     initialize_context

data/test/test_round.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
 
-class TestRound < Test::Unit::TestCase
+class TestRound < Minitest::Test
 
 
   def setup
@@ -50,6 +50,41 @@ class TestRound < Test::Unit::TestCase
 
   end
 
+  def test_ruby_2_4_round
+    assert_equal 100, DecNum('100.5').round(:half => :even)
+    assert_equal 101, DecNum('100.5000001').round(:half => :even)
+    assert_equal 102, DecNum('101.5').round(:half => :even)
+    assert_equal 101, DecNum('101.4999999999').round(:half => :even)
+
+    assert_equal 100, DecNum('100.5').round(:half => :down)
+    assert_equal 101, DecNum('100.5000001').round(:half => :down)
+    assert_equal 101, DecNum('101.5').round(:half => :down)
+    assert_equal 101, DecNum('101.4999999999').round(:half => :down)
+
+    assert_equal 101, DecNum('100.5').round(:half => :up)
+    assert_equal 101, DecNum('100.5000001').round(:half => :up)
+    assert_equal 102, DecNum('101.5').round(:half => :up)
+    assert_equal 101, DecNum('101.4999999999').round(:half => :up)
+
+    assert_equal 101, DecNum('100.5').round(0)
+    assert_equal DecNum('100.5'), DecNum('100.5').round(1)
+    assert_equal 100, DecNum('100.5').round(-1)
+    assert_equal DecNum('100.1235'), DecNum('100.1235'), DecNum('100.12345').round(4)
+
+    assert_equal 100, DecNum('100.5').round(0, :half => :even)
+    assert_equal 101, DecNum('100.5').round(0, :half => :up)
+    assert_equal 100, DecNum('100.5').round(0, :half => :down)
+    assert_equal DecNum('100.5'), DecNum('100.5').round(1, half: :even)
+    assert_equal DecNum('100.5'), DecNum('100.5').round(1, half: :up)
+    assert_equal DecNum('100.5'), DecNum('100.5').round(1, half: :down)
+    assert_equal 100, DecNum('100.5').round(-1, half: :even)
+    assert_equal 100, DecNum('100.5').round(-1, half: :down)
+    assert_equal 100, DecNum('100.5').round(-1, half: :up)
+    assert_equal DecNum('100.1234'), DecNum('100.12345').round(4, half: :even)
+    assert_equal DecNum('100.1235'), DecNum('100.12345').round(4, half: :up)
+    assert_equal DecNum('100.1234'), DecNum('100.12345').round(4, half: :down)
+  end
+
   def detect_rounding(type)
     x = type.new(1)*type.int_radix_power(type.context.precision+1)
     y = x + type.int_radix_power(2)

data/test/test_sugar.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 require File.dirname(__FILE__) + '/../lib/flt/sugar'
 
-class TestSugar < Test::Unit::TestCase
+class TestSugar < Minitest::Test
 
   def test_pseudo_literals
     assert_equal Flt::DecNum, 10._3223.class
@@ -14,11 +14,11 @@ class TestSugar < Test::Unit::TestCase
                  123456789123._01234567890123456789012345678901234567890123456789
     assert_equal Flt::DecNum('-123456789123.01234567890123456789012345678901234567890123456789'),
                  -123456789123._01234567890123456789012345678901234567890123456789
-    assert_raise(NoMethodError,NameError){3._x}
-    assert_raise(NoMethodError,NameError){3._3233x}
-    assert_raise(NoMethodError,NameError){3._3233x34333}
-    assert_raise(NoMethodError,NameError){3.__}
-    assert_raise(NoMethodError,NameError){3._}
+    assert_raises(NoMethodError,NameError){3._x}
+    assert_raises(NoMethodError,NameError){3._3233x}
+    assert_raises(NoMethodError,NameError){3._3233x34333}
+    assert_raises(NoMethodError,NameError){3.__}
+    assert_raises(NoMethodError,NameError){3._}
     assert_equal Flt::DecNum, 10._32_23.class
     assert_equal Flt::DecNum('10.3223'), 10._32_23
     assert_equal Flt::DecNum('3.01234567890123456789012345678901234567890123456789'),

data/test/test_to_int.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestToInt < Test::Unit::TestCase
+class TestToInt < Minitest::Test
 
 
   def setup
@@ -16,7 +16,7 @@ class TestToInt < Test::Unit::TestCase
     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_raises(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)
@@ -74,10 +74,10 @@ class TestToInt < Test::Unit::TestCase
     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_raises(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_raises(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]

data/test/test_to_rf.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-class TestToRF < Test::Unit::TestCase
+class TestToRF < Minitest::Test
 
 
   def setup
@@ -31,6 +31,131 @@ class TestToRF < Test::Unit::TestCase
       assert d.to_f.is_a?(Float)
       assert_equal f, d.to_f
     end
+    assert DecNum.nan.to_f.nan?
+    assert DecNum.infinity.to_f.infinite?
+    assert DecNum.infinity.to_f > 0
+    assert DecNum.infinity(-1).to_f.infinite?
+    assert DecNum.infinity(-1).to_f < 0
+    assert 1.0/DecNum('-0').to_f < 0
+    assert 1.0/DecNum('+0').to_f > 0
+
+    data  = []
+    [10, 100, 1000, 10000].each do |n_digits|
+      data << DecNum('+0.'+'1'*n_digits)
+      data << DecNum('-0.'+'1'*n_digits)
+    end
+
+    srand 1023022
+    data = []
+    DecNum.context(:precision=>15, :elimit=>90) do
+      data += [DecNum('1.448997445238699'), DecNum('1E23'),DecNum('-6.22320623338259E+16'),
+               DecNum('-3.83501075447972E-10'), DecNum('1.448997445238699')]
+      data += %w{
+        1E23
+        1.448997445238699
+        -6.22320623338259E+16
+        -3.83501075447972E-10
+        1.448997445238699
+        1.23E-30
+        1.23456789E-20
+        1.23456789E-30
+        1.234567890123456789
+        0.9999999999999995559107901499
+        0.9999999999999996114219413812
+        0.9999999999999996669330926125
+        0.9999999999999997224442438437
+        0.9999999999999997779553950750
+        0.9999999999999998334665463062
+        0.9999999999999998889776975375
+        0.9999999999999999444888487687
+        1
+        1.000000000000000111022302463
+        1.000000000000000222044604925
+        1.000000000000000333066907388
+        1.000000000000000444089209850
+        1.000000000000000555111512313
+        1.000000000000000666133814775
+        1.000000000000000777156117238
+        1.000000000000000888178419700
+      }.map{ |num| DecNum(num) }
+      data += Array.new(10000){random_num(DecNum)}
+    end
+
+    assert_equal 2, Float::RADIX
+
+    data.each do |x|
+      expected = Flt::Num.convert_exact(x, 2, Flt::BinNum::FloatContext).to_f
+      assert_equal expected, x.to_s.to_f
+
+      relative_error_limit = Float::EPSILON
+      # rel_err = (x.to_f - expected).abs/expected.abs
+      assert  expected.abs*relative_error_limit > (x.to_f - expected).abs, "#{x.to_f} != #{expected} (#{x})"
+    end
   end
 
+  def test_to_f_bin
+    BinNum.context(BinNum::FloatContext) do
+      ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+        f = Float(n)
+        b = BinNum(n, :fixed)
+        assert b.to_f.is_a?(Float)
+        assert_equal f, b.to_f
+      end
+      assert BinNum.nan.to_f.nan?
+      assert BinNum.infinity.to_f.infinite?
+      assert BinNum.infinity.to_f > 0
+      assert BinNum.infinity(-1).to_f.infinite?
+      assert BinNum.infinity(-1).to_f < 0
+      assert 1.0/BinNum('-0', :fixed).to_f < 0
+      assert 1.0/BinNum('+0', :fixed).to_f > 0
+
+      data  = []
+      [10, 100, 1000, 10000].each do |n_digits|
+        data << BinNum('+0.'+'1'*n_digits)
+        data << BinNum('-0.'+'1'*n_digits)
+      end
+
+      srand 1023022
+      data = []
+        data += [BinNum('1.448997445238699', :fixed), BinNum('1E23', :fixed),BinNum('-6.22320623338259E+16', :fixed),
+                BinNum('-3.83501075447972E-10', :fixed), BinNum('1.448997445238699', :fixed)]
+        data += %w{
+          1E23
+          1.448997445238699
+          -6.22320623338259E+16
+          -3.83501075447972E-10
+          1.448997445238699
+          1.23E-30
+          1.23456789E-20
+          1.23456789E-30
+          1.234567890123456789
+          0.9999999999999995559107901499
+          0.9999999999999996114219413812
+          0.9999999999999996669330926125
+          0.9999999999999997224442438437
+          0.9999999999999997779553950750
+          0.9999999999999998334665463062
+          0.9999999999999998889776975375
+          0.9999999999999999444888487687
+          1
+          1.000000000000000111022302463
+          1.000000000000000222044604925
+          1.000000000000000333066907388
+          1.000000000000000444089209850
+          1.000000000000000555111512313
+          1.000000000000000666133814775
+          1.000000000000000777156117238
+          1.000000000000000888178419700
+        }.map{ |num| BinNum(num, :fixed) }
+        data += Array.new(10000){random_num(BinNum)}
+
+      data.each do |x|
+        expected = x.to_decimal_exact(exact: true).to_s.to_f
+        assert_equal expected, x.to_f
+      end
+    end
+
+  end
+
+
 end