flt 1.0.0

data/test/test_define_conversions.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestDefineConversions < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_convert_to
+    d = DecNum('1.1')
+    x = d.convert_to(Rational)
+    assert x.is_a?(Rational)
+    assert_equal d.to_r, x
+
+    d = DecNum('11')
+    x = d.convert_to(Integer)
+    assert x.is_a?(Integer)
+    assert_equal d.to_i, x
+
+    d = DecNum('11')
+    x = d.convert_to(Float)
+    assert x.is_a?(Float)
+    assert_equal d.to_f, x
+  end
+
+
+  def test_big_decimal_conversions
+
+    DecNum.local_context do
+
+      DecNum.context.define_conversion_from(BigDecimal) do |x, context|
+        DecNum(x.to_s) # or use x.split etc.
+      end
+      assert DecNum('0') == BigDecimal.new('0')
+      assert_equal BigDecimal.new('0'), DecNum('0')
+      assert_equal BigDecimal.new('1.2345'), DecNum('1.2345')
+      assert_equal BigDecimal.new('-1.2345'), DecNum('-1.2345')
+      assert_equal BigDecimal.new('1.2345'), DecNum('0.0012345000E3')
+      assert_equal DecNum('7.1'), BigDecimal.new('7')+DecNum('0.1')
+      assert_equal DecNum('7.1'), DecNum('7')+BigDecimal.new('0.1')
+      assert_equal DecNum('1.1'), DecNum(BigDecimal.new('1.1'))
+      assert DecNum(BigDecimal.new('1.1')).is_a?(DecNum)
+
+      DecNum.context.define_conversion_to(BigDecimal) do |x|
+        BigDecimal.new(x.to_s) # TODO: use x.split and handle special values
+      end
+
+      ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+        f = BigDecimal.new(n)
+        d = DecNum(n)
+        c = d.convert_to(BigDecimal)
+        assert c.is_a?(BigDecimal)
+        assert_equal f, c
+      end
+    end
+
+    assert_raise(TypeError) { DecNum('0') == BigDecimal.new('0') }
+    unless Num < Numeric
+      # BigDecimal#eql? is weird
+      assert_not_equal BigDecimal.new('0'), DecNum('0')
+      assert_not_equal BigDecimal.new('1.2345'), DecNum('1.2345')
+      assert_not_equal BigDecimal.new('-1.2345'), DecNum('-1.2345')
+      assert_not_equal BigDecimal.new('1.2345'), DecNum('0.0012345000E3')
+      assert_raise(TypeError) { BigDecimal.new('7')+DecNum('0.1') }
+    end
+    assert_raise(TypeError) { DecNum('7')+BigDecimal.new('0.1') }
+    assert_raise(TypeError) { DecNum(BigDecimal.new('1.1')) }
+
+    ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+      assert_raise(TypeError) { DecNum(n).convert_to(BigDecimal) }
+    end
+
+  end
+
+  def test_float_conversions
+
+    # Exact Float to DecNum conversion limited to context precision
+    # => DecNum('0.1') != DecNum(0.1) unless precision is low enough
+    DecNum.context.define_conversion_from(Float) do |x, context|
+      s,e = Math.frexp(x)
+      significand = Math.ldexp(s, Float::MANT_DIG).to_i
+      exponent = e - Float::MANT_DIG
+      # the number is (as a Rational) significand * exponent**Float::RADIX
+      DecNum(significand*(Float::RADIX**exponent ))
+    end
+
+    assert_equal 0.0, DecNum('0')
+    assert_equal DecNum('0'), 0.0
+    assert_equal 1234.5, DecNum('1234.5')
+    assert_equal DecNum('1234.5'), 1234.5
+    assert_equal(-1234.5, DecNum('-1234.5'))
+    assert_equal 1234.5, DecNum('0.0012345000E6')
+    assert_equal DecNum('7.1'), 7.0+DecNum('0.1')
+    DecNum.local_context(:precision=>12) do
+      assert_equal DecNum('7.1'), DecNum('7')+0.1
+    end
+    assert_equal DecNum('11'), DecNum(11.0)
+    assert_instance_of DecNum, DecNum(11.0)
+
+    DecNum.context.define_conversion_from(Float) do |x, context|
+      DecNum.context(context, :exact=>true) do
+        s,e = Math.frexp(x)
+        s = Math.ldexp(s, Float::MANT_DIG).to_i
+        e -= Float::MANT_DIG
+        DecNum(s*(Float::RADIX**e))
+      end
+    end
+
+    assert_equal '0.1000000000000000055511151231257827021181583404541015625', DecNum(0.1).to_s
+    assert_equal '1.100000000000000088817841970012523233890533447265625', DecNum(1.1).to_s
+
+  end
+
+  def test_conversion_types
+
+    assert_instance_of DecNum, DecNum(1)+3
+    assert_instance_of DecNum, 3+DecNum(1)
+    assert_instance_of DecNum, Rational(1,5)+DecNum(1)
+    assert_instance_of DecNum, DecNum(1)+Rational(1,5)
+    assert_instance_of Float, DecNum(1)+3.0
+    assert_instance_of Float, 3.0+DecNum(1)
+
+    DecNum.context.define_conversion_from(Float) do |x, context|
+      s,e = Math.frexp(x)
+      significand = Math.ldexp(s, Float::MANT_DIG).to_i
+      exponent = e - Float::MANT_DIG
+      # the number is (as a Rational) significand * exponent**Float::RADIX
+      DecNum(significand*(Float::RADIX**exponent ))
+    end
+
+    assert_instance_of DecNum, DecNum(1)+3.0
+    assert_instance_of DecNum, 3.0+DecNum(1)
+
+    DecNum.context.define_conversion_from(BigDecimal) do |x, context|
+      DecNum(x.to_s) # or use x.split etc.
+    end
+
+    assert_instance_of DecNum, DecNum(1)+BigDecimal('3')
+    assert_instance_of DecNum, BigDecimal('3')+DecNum(1)
+
+  end
+
+end

data/test/test_epsilon.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestEpsilon < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_epsilon
+    eps = DecNum.context.epsilon
+    assert_equal((DecNum(1).next_plus - DecNum(1)), eps)
+    assert_equal DecNum(1,1,1-DecNum.context.precision), eps
+  end
+
+  def test_epsilon_bin
+    eps = BinNum.context.epsilon
+    assert_equal((BinNum(1).next_plus - BinNum(1)), eps)
+    assert_equal BinNum(1,1,1-BinNum.context.precision), eps
+  end
+
+  def test_strict_epsilon
+    [:up, :ceiling, :down, :floor, :half_up, :half_down, :half_even, :up05].each do |rounding|
+      DecNum.context.rounding = rounding
+      eps = DecNum.context.strict_epsilon
+      eps_1 = DecNum(1)+eps
+      r = eps.next_minus
+      r_1 = DecNum(1)+r
+      assert((eps_1 > DecNum(1)) && (r_1 == DecNum(1)), "Test strict epsilon for rounding #{rounding}")
+      assert_equal(((DecNum(1)+eps)-DecNum(1)), DecNum.context.epsilon)
+    end
+  end
+
+  def test_strict_epsilon_bin
+    [:up, :ceiling, :down, :floor, :half_up, :half_down, :half_even].each do |rounding|
+      BinNum.context.rounding = rounding
+      eps = BinNum.context.strict_epsilon
+      eps_1 = BinNum(1)+eps
+      r = eps.next_minus
+      r_1 = BinNum(1)+r
+      assert((eps_1 > BinNum(1)) && (r_1 == BinNum(1)), "Test strict binary epsilon for rounding #{rounding}")
+      assert_equal(((BinNum(1)+eps)-BinNum(1)), BinNum.context.epsilon)
+    end
+  end
+
+  def test_half_epsilon
+    assert_equal DecNum.context.epsilon/2, DecNum.context.half_epsilon
+  end
+
+  def test_half_epsilon_bin
+    assert_equal BinNum.context.epsilon/2, BinNum.context.half_epsilon
+  end
+
+
+end

data/test/test_exact.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+class TestExact < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+
+  def test_exact_no_traps
+
+    DecNum.context.exact = true
+    DecNum.context.traps[DecNum::Inexact] = false
+
+    assert_equal DecNum("9"*100+"E-50"), DecNum('1E50')-DecNum('1E-50')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(2),DecNum(6)/DecNum(3)
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('1.5'),DecNum(6)/DecNum(4)
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('15241578780673678546105778281054720515622620750190521'), DecNum('123456789123456789123456789')*DecNum('123456789123456789123456789')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(2), DecNum('4').sqrt
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(4), DecNum('16').sqrt
+    assert !DecNum.context.flags[DecNum::Inexact]
+
+    assert_equal DecNum('42398.78077199232'), DecNum('1.23456')*DecNum('34343.232222')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('12.369885'), DecNum('210.288045')/DecNum('17')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('25'),DecNum('125')/DecNum('5')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('12345678900000000000.1234567890'),DecNum('1234567890E10')+DecNum('1234567890E-10')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('39304'),DecNum('34').power(DecNum(3))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('39.304'),DecNum('3.4').power(DecNum(3))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('4'),DecNum('16').power(DecNum('0.5'))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('4'),DecNum('10000.0').log10
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('-5'),DecNum('0.00001').log10
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity, DecNum.infinity.exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.zero, DecNum.infinity(-1).exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(1), DecNum(0).exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity(-1), DecNum(0).ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity, DecNum.infinity.ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(0), DecNum(1).ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+
+
+    assert((DecNum(1)/DecNum(3)).nan?)
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert((DecNum(18).power(DecNum('0.5'))).nan?)
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert((DecNum(18).power(DecNum('1.5'))).nan?)
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert DecNum(18).log10.nan?
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert DecNum(1).exp.nan?
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert DecNum('-1.2').exp.nan?
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+    assert DecNum('1.1').ln.nan?
+    assert DecNum.context.flags[DecNum::Inexact]
+    DecNum.context.flags[DecNum::Inexact] = false
+
+  end
+
+  def test_exact_traps
+
+    DecNum.context.exact = true
+
+    assert_nothing_raised(DecNum::Inexact){ DecNum(6)/DecNum(4) }
+
+    assert_equal DecNum("9"*100+"E-50"), DecNum('1E50')-DecNum('1E-50')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(2),DecNum(6)/DecNum(3)
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('1.5'),DecNum(6)/DecNum(4)
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('15241578780673678546105778281054720515622620750190521'), DecNum('123456789123456789123456789')*DecNum('123456789123456789123456789')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(2), DecNum('4').sqrt
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(4), DecNum('16').sqrt
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity, DecNum.infinity.exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.zero, DecNum.infinity(-1).exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(1), DecNum(0).exp
+    assert !DecNum.context.flags[DecNum::Inexact]
+
+    assert_equal DecNum('42398.78077199232'), DecNum('1.23456')*DecNum('34343.232222')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('12.369885'), DecNum('210.288045')/DecNum('17')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('25'),DecNum('125')/DecNum('5')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('12345678900000000000.1234567890'),DecNum('1234567890E10')+DecNum('1234567890E-10')
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('39304'),DecNum('34').power(DecNum(3))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('39.304'),DecNum('3.4').power(DecNum(3))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('4'),DecNum('16').power(DecNum('0.5'))
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('4'),DecNum('10000.0').log10
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum('-5'),DecNum('0.00001').log10
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity(-1), DecNum(0).ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum.infinity, DecNum.infinity.ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+    assert_equal DecNum(0), DecNum(1).ln
+    assert !DecNum.context.flags[DecNum::Inexact]
+
+    assert_raise(DecNum::Inexact){ DecNum(2).sqrt }
+    assert_raise(DecNum::Inexact){ DecNum(1)/DecNum(3) }
+    assert_raise(DecNum::Inexact){ DecNum(18).power(DecNum('0.5')) }
+    assert_raise(DecNum::Inexact){ DecNum(18).power(DecNum('1.5')) }
+    assert_raise(DecNum::Inexact){ DecNum(18).log10 }
+    assert_raise(DecNum::Inexact){ DecNum(1).exp }
+    assert_raise(DecNum::Inexact){ DecNum('1.2').exp }
+    assert_raise(DecNum::Inexact){ DecNum('1.2').ln }
+
+  end
+
+end

data/test/test_flags.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+class TestFlags < Test::Unit::TestCase
+
+  def test_flags
+    f = Flt::Support::Flags(:flag_one, :flag_three)
+    assert_equal "[:flag_one, :flag_three]",  f.to_a.sort_by{|flg| flg.to_s}.inspect
+    f.values = Flt::Support::FlagValues(:flag_one, :flag_two, :flag_three)
+    assert_equal "Flt::Support::Flags[flag_one, flag_three] (0x5)", f.inspect
+    f[:flag_two] = true
+    assert_equal "Flt::Support::Flags[flag_one, flag_two, flag_three] (0x7)", f.inspect
+    f[:flag_one] = false
+    assert_equal "Flt::Support::Flags[flag_two, flag_three] (0x6)", f.inspect
+    f.clear!
+    assert_equal "Flt::Support::Flags[] (0x0)", f.inspect
+    f << [:flag_one,:flag_two]
+    assert_equal "Flt::Support::Flags[flag_one, flag_two] (0x3)", f.inspect
+    g = Flt::Support::Flags(f.values)
+    g.bits = f.bits
+    assert_equal "Flt::Support::Flags[flag_one, flag_two] (0x3)", g.inspect
+    assert g==f
+    g.set!
+    assert_equal "Flt::Support::Flags[flag_one, flag_two, flag_three] (0x7)", g.inspect
+    assert g!=f
+
+    assert Flt::Support::Flags(:flag_one, :flag_three)==Flt::Support::Flags(:flag_three, :flag_one)
+    assert Flt::Support::Flags(:flag_one, :flag_three)!=Flt::Support::Flags(:flag_one)
+
+
+
+  end
+
+end

data/test/test_multithreading.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+
+class TestMultithreading < Test::Unit::TestCase
+
+  def setup
+    initialize_context
+  end
+
+  def test_concurrent_precision
+    threads = []
+    for prec in (5..100)
+      threads << Thread.new(prec) do |p|
+        n = 10000/(p/3)
+        n_fails = 0
+        DecNum.local_context do
+          DecNum.context.precision = p
+          n.times do
+            t = (DecNum(1)/DecNum(3)).to_s
+            n_fails += 1 if (t.size!=(p+2)) || (DecNum.context.precision!=p)
+          end
+        end
+        Thread.current[:n_fails] = n_fails
+      end
+    end
+    total_fails = 0
+    threads.each{|thr| thr.join; total_fails += thr[:n_fails]}
+    assert total_fails==0,"Context precision different per thread"
+  end
+
+end

data/test/test_num_constructor.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestNumConstructor < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+    DecNum.context.precision = 28
+    @dprec5 = DecNum::Context(:precision=>5)
+    @bprec5 = BinNum::Context(:precision=>5)
+  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
+    assert_equal [1, 1234, -2],  DecNum(+1, 1234, -2, :precision=>2).split
+    assert_equal [1, 1234, -2],  DecNum(+1, 1234, -2, nil).split
+
+    assert_equal [1, 1234, -2],  BinNum(+1, 1234, -2).split
+    assert_equal [1, 1234, -2],  BinNum(+1, 1234, -2, @bprec5).split
+    assert_equal [1, 1234, -2],  BinNum(+1, 1234, -2, :precision=>2).split
+    assert_equal [1, 1234, -2],  BinNum(+1, 1234, -2, nil).split
+    assert_equal [1, 1234, -2],  BinNum(+1, 1234, -2, :xxx=>3).split
+  end
+
+  def test_conversion
+    assert_equal [1, 3333333333333333333333333333, -28], DecNum(Rational(1,3)).split
+    assert_equal [1, 33333, -5], DecNum(Rational(1,3), @dprec5).split
+    assert_equal [1, 33333, -5], DecNum(Rational(1,3), :precision=>5).split
+    assert_equal [1, 3333333333333333333333333333, -28], DecNum(Rational(1,3), nil).split
+
+    assert_equal [1, 6004799503160661, -54], BinNum(Rational(1,3)).split
+    assert_equal [1, 21, -6], BinNum(Rational(1,3), @bprec5).split
+    assert_equal [1, 21, -6], BinNum(Rational(1,3), :precision=>5).split
+    assert_equal [1, 6004799503160661, -54], BinNum(Rational(1,3), nil).split
+  end
+
+  def test_literal_free
+    assert_equal [1, 1234567, -8], DecNum('1.234567E-2', :free).split
+    assert_equal [1, 1234567, -8], DecNum('1.234567E-2', :free, :precision=>5).split
+    assert_equal [1, 1, -1], DecNum('0.1', :free).split
+    assert_equal [1, 1000, -4], DecNum('0.1000', :free).split
+    assert_equal [1, 1, -1],  DecNum('0.1',:short).split
+    assert_equal [1, 1000, -4], DecNum('0.1000',:short).split
+
+    assert_equal [1, 1, -3], BinNum('0.1E-2', :free, :base=>2).split
+    assert_equal [1, 1, -1], BinNum('0.1', :free, :base=>2).split
+    assert_equal [1, 8, -4], BinNum('0.1000', :free, :base=>2).split
+    assert_equal [1, 1, -1], BinNum('0.1',:short, :base=>2).split
+    assert_equal [1, 8, -4], BinNum('0.1000',:short, :base=>2).split
+  end
+
+  def test_literal_free_base
+
+    assert_equal [1, 12, -2], DecNum('0.1E-2', :free, :base=>2).split
+    assert_equal [1, 13, -2], DecNum('0.1E-2', :free, :base=>2, :rounding=>:half_up).split
+    assert_equal [1, 1250, -4], DecNum('0.1000000E-2', :free, :base=>2).split
+    assert_equal [1, 125, -3], DecNum('0.1000000E-2', :short, :base=>2).split
+
+    assert_equal [1, 26, -8], BinNum('0.1', :free).split
+    assert_equal [1, 13107, -17], BinNum('0.1000', :free).split
+    assert_equal [1, 1, -3], BinNum('0.1',:short).split
+    assert_equal [1, 1639, -14], BinNum('0.1000',:short).split
+  end
+
+  def test_fixed
+
+    assert_equal [1, 1000000000000000000000000000, -28], DecNum('0.1',:fixed).split
+    assert_equal [1, 1000000000000000000000000000, -28], DecNum('0.1000',:fixed).split
+    assert_equal [1, 10000, -5], DecNum('0.1',:fixed,:precision=>5).split
+    assert_equal [1, 10000, -5], DecNum('0.1000',:fixed,:precision=>5).split
+    assert_equal [1, 10000, -5], DecNum('0.1',:fixed,@dprec5).split
+    assert_equal [1, 10000, -5], DecNum('0.1000',:fixed,@dprec5).split
+    DecNum.context(:precision=>5) do
+      assert_equal [1, 10000, -5], DecNum('0.1',:fixed).split
+      assert_equal [1, 10000, -5], DecNum('0.1000',:fixed).split
+    end
+
+    assert_equal [1, 4503599627370496, -53], BinNum('0.1',:fixed,:base=>2).split
+    assert_equal [1, 4503599627370496, -53], BinNum('0.1000',:fixed,:base=>2).split
+    assert_equal [1, 16, -5], BinNum('0.1',:fixed,:precision=>5,:base=>2).split
+    assert_equal [1, 16, -5], BinNum('0.1000',:fixed,:precision=>5,:base=>2).split
+    context = BinNum::Context(:precision=>5)
+    assert_equal [1, 16, -5], BinNum('0.1',:fixed,context,:base=>2).split
+    assert_equal [1, 16, -5], BinNum('0.1000',:fixed,context,:base=>2).split
+    BinNum.context(:precision=>5) do
+      assert_equal [1, 16, -5], BinNum('0.1',:fixed,:base=>2).split
+      assert_equal [1, 16, -5], BinNum('0.1000',:fixed,:base=>2).split
+    end
+  end
+
+  def test_fixed_base
+    assert_equal [1, 7205759403792794, -56], BinNum('0.1',:fixed).split
+    assert_equal [1, 7205759403792794, -56], BinNum('0.1000',:fixed).split
+    assert_equal [1, 26, -8], BinNum('0.1',:fixed,:precision=>5).split
+    assert_equal [1, 26, -8], BinNum('0.1000',:fixed,:precision=>5).split
+    assert_equal [1, 26, -8], BinNum('0.1',:fixed,@bprec5).split
+    assert_equal [1, 26, -8], BinNum('0.1000',:fixed,@bprec5).split
+    BinNum.context(:precision=>5) do
+      assert_equal [1, 26, -8], BinNum('0.1',:fixed).split
+      assert_equal [1, 26, -8], BinNum('0.1000',:fixed).split
+    end
+
+    assert_equal [1, 5000000000000000000000000000, -28], DecNum('0.1',:fixed,:base=>2).split
+    assert_equal [1, 5000000000000000000000000000, -28], DecNum('0.1000',:fixed,:base=>2).split
+    assert_equal [1, 50000, -5], DecNum('0.1',:fixed,:precision=>5,:base=>2).split
+    assert_equal [1, 50000, -5], DecNum('0.1000',:fixed,:precision=>5,:base=>2).split
+    assert_equal [1, 50000, -5], DecNum('0.1',:fixed,@dprec5,:base=>2).split
+    assert_equal [1, 50000, -5], DecNum('0.1000',:fixed,@dprec5,:base=>2).split
+    DecNum.context(:precision=>5) do
+      assert_equal [1, 50000, -5], DecNum('0.1',:fixed,:base=>2).split
+      assert_equal [1, 50000, -5], DecNum('0.1000',:fixed,:base=>2).split
+    end
+
+  end
+
+  def test_default
+    assert_equal [1, 1234567, -8], DecNum('1.234567E-2').split
+    assert_equal [1, 1234567, -8], DecNum('1.234567E-2', :precision=>5).split
+    assert_equal [1, 1, -1], DecNum('0.1').split
+    assert_equal [1, 1000, -4], DecNum('0.1000').split
+    assert_equal [1, 1, -3], BinNum('0.1E-2', :base=>2).split
+    assert_equal [1, 1, -1], BinNum('0.1', :base=>2).split
+    assert_equal [1, 8, -4], BinNum('0.1000', :base=>2).split
+    # base conversion
+    assert_equal [1, 12, -2], DecNum('0.1E-2', :base=>2, :rounding=>:half_even).split
+    assert_equal [1, 13, -2], DecNum('0.1E-2', :base=>2, :rounding=>:half_up).split
+    assert_equal [1, 26, -8], BinNum('0.1').split
+    assert_equal [1, 13107, -17], BinNum('0.1000').split
+  end
+
+
+end