nio 0.2.3 → 0.2.4

data/lib/nio/sugar.rb

@@ -1,99 +1,69 @@
-# This file provides some syntactic sugar for the Nio module.
-# Some methods here: #to_r(), #to_xr, may collide with methods in other
-# libraries.
-#
-# This non mondule-function is equivalent to +Nio::Fmt.convert+
-#   Nio.convert(x, type, arpx=true)
-# There's also a module-function synonim useful for including the Nio namespace:
-#   Nio.nio_convert(x, type, aprx=true)
-# (the convert() method seems too likely for name collisions)
-# Some aliases for nio_write and nio_read:
-#   fmt << x      ->  x.nio_write(fmt)
-#   fmt.write(x)  ->  x.nio_write(fmt)
-#   Fmt << x      ->  x.nio_write()
-#   Fmt.write(x)  ->  x.nio_write()
-#   fmt >> [cls,txt] -> cls.nio_read(txt, fmt)
-#   fmt.read(cls,txt) -> cls.nio_read(txt, fmt)
-#   Fmt >> [cls,txt] -> cls.nio_read(txt)
-#   Fmt.read(cls,txt) -> cls.nio_read(txt)
-# Also methods #to_r and #to_xr are added to Float,BigDecimal, etc. as
-# synonims for #nio_r, #nio_xr
-
-require 'nio/rtnlzr'
-require 'nio/fmt'
-
-# This is not a module function: this provides a shorthand access to Nio::Fmt.convert
-def Nio.convert(x, type, mode=:approx)
-  Nio::Fmt.convert x, type, mode
-end
-
-module Nio
-  module_function
-  # This module function can be used after <tt>import Nio</tt>
-  def nio_convert(x, type, mode=:approx)
-    Nio::Fmt.convert x, type, mode
-  end 
-  # :stopdoc:  
-  class Fmt
-    def <<(x)
-      x.nio_write(self)
-    end
-    def write(x)
-      x.nio_write(self)
-    end
-    def Fmt.<<(x)
-      x.nio_write
-    end
-    def Fmt.write(x)
-      x.nio_write
-    end
-    def >>(cls_txt)
-      cls,txt = cls_txt
-      cls.nio_read(txt,self)      
-    end
-    def read(cls,txt)
-      cls.nio_read(txt,self)
-    end
-    def Fmt.>>(cls_txt)
-      cls,txt = cls_txt
-      cls.nio_read(txt)
-    end
-    def Fmt.read(cls,txt)
-      cls.nio_read(txt)
-    end
-  end
-  # :startdoc:
-end
-
-# to be considered: for cls in [Float,BigDecimal,Integer,Rational]
-# def cls.<<(txt_fmt); txt,fmt=txt_fmt; cls.nio_read(txt,fmt); end
-
-# :stopdoc:
-
-#~ class Numeric
-  #~ def to_xr
-    #~ nio_xr
-  #~ end
-#~ end
-
-for cls in [Integer,Rational,Float,BigDecimal]
-  cls.class_eval {
-    def to_xr
-      nio_xr
-    end
-  }
-end
-
-class Float
-  def to_r(tol = Nio::Tolerance.big_epsilon)
-    nio_r(tol)
-  end
-end
-class BigFloat
-  def to_r(tol = nil)
-    nio_r(tol)
-  end
-end
-
-# :startdoc:
-
+# This file provides some syntactic sugar for the Nio module.
+# Some methods here: #to_r(), #to_xr, may collide with methods in other
+# libraries.
+#
+# This non mondule-function is equivalent to +Nio::Fmt.convert+
+#   Nio.convert(x, type, arpx=true)
+# There's also a module-function synonim useful for including the Nio namespace:
+#   Nio.nio_convert(x, type, aprx=true)
+# (the convert() method seems too likely for name collisions)
+# Some aliases for nio_write and nio_read:
+#   fmt << x      ->  x.nio_write(fmt)
+#   fmt.write(x)  ->  x.nio_write(fmt)
+#   Fmt << x      ->  x.nio_write()
+#   Fmt.write(x)  ->  x.nio_write()
+#   fmt >> [cls,txt] -> cls.nio_read(txt, fmt)
+#   fmt.read(cls,txt) -> cls.nio_read(txt, fmt)
+#   Fmt >> [cls,txt] -> cls.nio_read(txt)
+#   Fmt.read(cls,txt) -> cls.nio_read(txt)
+# Also methods #to_r and #to_xr are added to Float,BigDecimal, etc. as
+# synonims for #nio_r, #nio_xr
+
+require 'nio/rtnlzr'
+require 'nio/fmt'
+
+# This is not a module function: this provides a shorthand access to Nio::Fmt.convert
+def Nio.convert(x, type, mode=:approx)
+  Nio::Fmt.convert x, type, mode
+end
+
+module Nio
+  module_function
+  # This module function can be used after <tt>import Nio</tt>
+  def nio_convert(x, type, mode=:approx)
+    Nio::Fmt.convert x, type, mode
+  end
+  # :stopdoc:
+  class Fmt
+    def <<(x)
+      x.nio_write(self)
+    end
+    def write(x)
+      x.nio_write(self)
+    end
+    def Fmt.<<(x)
+      x.nio_write
+    end
+    def Fmt.write(x)
+      x.nio_write
+    end
+    def >>(cls_txt)
+      cls,txt = cls_txt
+      cls.nio_read(txt,self)
+    end
+    def read(cls,txt)
+      cls.nio_read(txt,self)
+    end
+    def Fmt.>>(cls_txt)
+      cls,txt = cls_txt
+      cls.nio_read(txt)
+    end
+    def Fmt.read(cls,txt)
+      cls.nio_read(txt)
+    end
+  end
+  # :startdoc:
+end
+
+# to be considered: for cls in [Float,BigDecimal,Integer,Rational]
+# def cls.<<(txt_fmt); txt,fmt=txt_fmt; cls.nio_read(txt,fmt); end

data/lib/nio/version.rb

@@ -2,7 +2,7 @@ module Nio #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 3
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/tasks/nuweb.rake

@@ -1,37 +1,67 @@
 # nuweb build tasks
 namespace :nuweb do
 
+  NUWEB_PRODUCTS = []
+  NUWEB_SOURCES = Dir['source/**/*.w']
+
+  NUWEB_SOURCES.each do |input_fn|
+    products = []
+    File.open(input_fn) do |input|
+      meta = '@'
+      input.each_line do |line|
+        if /^\s*%#{meta}r(.)%/.match(line)
+          meta = $1
+        elsif /^\s*[^#{meta}]?#{meta}(?:o|O)\s*(\S.*)\s*$/.match(line)
+          products << $1
+        end
+      end
+    end
+    NUWEB_PRODUCTS.concat products
+    products.each do |product|
+      file product => [input_fn] do |t|
+        puts "nuweb -t #{input_fn}"
+        puts `nuweb -t #{input_fn}`
+        touch product
+      end
+    end
+  end
+
+  %w{lib test}.each do |dir|
+    sources = Dir["source/#{dir}/**/*"]
+    NUWEB_SOURCES.concat sources
+    NUWEB_PRODUCTS.concat sources.map{|s| s.sub("source/#{dir}/","#{dir}/")}
+    rule(/\A#{dir}\/.*/ =>[proc{|tn| tn.sub(/\A#{dir}\//, "source/#{dir}/") }])  do |t|
+      if t.source
+        if File.directory?(t.source)
+          cp_r t.source, t.name
+        else
+          cp t.source, t.name
+        end
+      end
+    end
+  end
+
   desc "Generate Ruby code from nuweb source"
-  task :tangle => Dir['source/*.w'].collect{|fn| fn.gsub /\.w/,'.ws'}+
-                  Dir['source/lib/**/*.rb'].collect{|fn| fn.gsub('source/lib/','lib/')}+
-                  Dir['source/test/**/*'].collect{|fn| fn.gsub('source/test/','test/')}+
-                  [:test]
+  task :tangle => NUWEB_PRODUCTS + [:test]
 
   # directory 'lib'
   # directory 'lib/nio'
   # directory 'source/pdf'
 
-  rule '.ws' => ['.w'] do |t|
-    puts "build dir: #{Dir.pwd}"
-    puts "nuweb -t #{t.source}"
-    puts `nuweb -t #{t.source}`
-     File.open(t.name,'w'){|f| f.puts "sentinel"}
-  end
-
-  clean_exts = ['*.tex','*.dvi','*.log','*.aux','*.out','*.ws']
-  clobber_dirs = ['lib', 'source/pdf', 'test']
-  clobber_exceptions = ['test/data.yaml', 'test/test_helper.rb']
+  clean_exts = ['*.tex','*.dvi','*.log','*.aux','*.out']
+  clobber_exts = []
+  generated_dirs = ['lib', 'test', 'source/pdf']
 
   desc "Remove all nuweb generated files"
-  task :clobber=>[:clean] do |t|
-    clobber_dirs.map{|dir| Dir["#{dir}/**/*"]}.flatten.each do |fn|
+  task :clobber=>['^clobber'] do |t|
+    generated_dirs.map{|dir| Dir["#{dir}/**/*"]}.flatten.each do |fn|
       rm fn unless File.directory?(fn)
     end
   end
 
-  desc "Clean up nuweb temporary files"
+  desc "Clean up nuweb weave temporary files"
   task :clean do |t|
-    rm_r clean_exts.collect{|x| Dir.glob('*'+x)+Dir.glob('source/*'+x)+Dir.glob('source/pdf/*'+x)}.flatten
+    rm_r clean_exts.collect{|x| Dir.glob('source/*'+x)+Dir.glob('source/pdf/*'+x)}.flatten
   end
 
   desc "Generate nuweb source code documentation"
@@ -75,22 +105,14 @@ namespace :nuweb do
     w_to_pdf t.source
   end
 
-  rule /\Alib\/.*\.rb/ =>[proc{|tn| tn.sub(/\Alib\//, 'source/lib/') }]  do |t|
-    cp t.source, t.name  if t.source
-  end
-
-  rule /\Atest\/.*/ =>[proc{|tn| tn.sub(/\Atest\//, 'source/test/') }]  do |t|
-    cp t.source, t.name  if t.source
-  end
-
   namespace :docs do
 
-    task :package=>['nuweb:weave']
     Rake::PackageTask.new('nio-source-pdf', Nio::VERSION::STRING) do |p|
       # generate same formats as for the gem contents
       p.need_tar = PROJ.gem.need_tar
       p.need_zip = PROJ.gem.need_zip
-      p.package_files.include "source/pdf/**/*.pdf"
+      pdf_files = Dir['source/**/*.w'].map{|fn| File.join 'source','pdf',File.basename(fn,'.w')+'.pdf'}
+      p.package_files.include *pdf_files
     end
 
   end
@@ -113,13 +135,11 @@ namespace :nuweb do
 
 end
 
-task :clobber=>'nuweb:clobber'
+task :clobber=>'nuweb:clean'
 task :clean=>'nuweb:clean'
 
-Rake::Task['gem:package'].enhance ['nuweb:tangle']
-Rake::Task['gem:release'].clear_prerequisites.enhance ['gem'] # remove clobber prerequisite
+gem_package_prerequisites = Rake::Task['gem:package'].prerequisites.dup
+Rake::Task['gem:package'].clear_prerequisites.enhance ['nuweb:tangle']+gem_package_prerequisites
 
 desc 'Generate code and documentation from nuweb sources'
 task :nuweb => ['nuweb:tangle', 'nuweb:weave']
-
-STDERR.puts "TTT #{Rake::Task['gem:package'].prerequisites.inspect}"

data/test/{test_helper.rb → helper.rb}

@@ -1,5 +1,6 @@
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/nio'
+require File.dirname(__FILE__) + '/../lib/nio/sugar'
 require 'yaml'
 
 module PrepareData
@@ -30,3 +31,7 @@ module PrepareData
 end
 
 PrepareData.init
+
+def BigDec(x)
+  BigDecimal.new(x.to_s)
+end

data/test/test_fmt.rb

@@ -7,26 +7,24 @@
 # as published by the Free Software Foundation; either version 2
 # of the License, or (at your option) any later version.
 
-#require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/helper.rb'
 require 'test/unit'
-require 'nio/rtnlzr'
-require 'nio/repdec'
-require 'nio/fmt'
+require 'flt/bigdecimal'
 include Nio
 require 'yaml'
 
 def neighbours(x)
-  f,e = Math.frexp(x)  
+  f,e = Math.frexp(x)
   e = Float::MIN_EXP if f==0
   e = [Float::MIN_EXP,e].max
-  dx = Math.ldexp(1,e-Float::MANT_DIG) #Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e)  
+  dx = Math.ldexp(1,e-Float::MANT_DIG) #Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e)
   high = x + dx
   if e==Float::MIN_EXP || f!=0.5 #0.5==Math.ldexp(2**(bits-1),-Float::MANT_DIG)
     low = x - dx
   else
-    low = x - dx/2 # x - Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e-1)  
+    low = x - dx/2 # x - Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e-1)
   end
-  [low, high]  
+  [low, high]
 end
 
 def prv(x)
@@ -55,59 +53,59 @@ class TestFmt < Test::Unit::TestCase
         Fmt.default = Fmt.new
     
   end
-  
+
   
     def test_basic_fmt
       # test correct rounding: 1.448997445238699 -> 6525704354437805*2^-52
       assert_equal Rational(6525704354437805,4503599627370496), Float.nio_read('1.448997445238699').nio_xr
-      
-      assert_equal "0",0.0.nio_write    
-      assert_equal "0",0.nio_write    
-      assert_equal "0",BigDecimal('0').nio_write    
-      assert_equal "0",Rational(0,1).nio_write    
-
-      assert_equal "123456789",123456789.0.nio_write    
-      assert_equal "123456789",123456789.nio_write    
-      assert_equal "123456789",BigDecimal('123456789').nio_write    
-      assert_equal "123456789",Rational(123456789,1).nio_write    
-      assert_equal "123456789.25",123456789.25.nio_write    
-      assert_equal "123456789.25",BigDecimal('123456789.25').nio_write    
-      assert_equal "123456789.25",(Rational(123456789)+Rational(1,4)).nio_write    
+
+      assert_equal "0",0.0.nio_write
+      assert_equal "0",0.nio_write
+      assert_equal "0",BigDecimal('0').nio_write
+      assert_equal "0",Rational(0,1).nio_write
+
+      assert_equal "123456789",123456789.0.nio_write
+      assert_equal "123456789",123456789.nio_write
+      assert_equal "123456789",BigDecimal('123456789').nio_write
+      assert_equal "123456789",Rational(123456789,1).nio_write
+      assert_equal "123456789.25",123456789.25.nio_write
+      assert_equal "123456789.25",BigDecimal('123456789.25').nio_write
+      assert_equal "123456789.25",(Rational(123456789)+Rational(1,4)).nio_write
     end
   
     def test_basic_fmt_float
 
       assert_equal 2,Float::RADIX
       assert_equal 53,Float::MANT_DIG
-          
+
       fmt = Fmt.new {|f|
-        f.rep! '[','','...',0,true  
+        f.rep! '[','','...',0,true
         f.width! 20,:right,'*'
       }
-      fmt.sep! '.',',',[3]    
-      
+      fmt.sep! '.',',',[3]
+
       assert_equal "0.1",0.1.nio_write
       assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact).show_all_digits)
       assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact).show_all_digits(true))
       assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact,:show_all_digits=>true))
       assert_equal "0.1000000000000000055511151231257827021181583404541015625",0.1.nio_write(Fmt.mode(:gen,:exact,:approx=>:exact))
-      
-      
-      assert_equal "******643,454,333.32",fmt.nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))        
-      assert_equal "******643.454.333,32",fmt.sep(',').nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))        
+
+
+      assert_equal "******643,454,333.32",fmt.nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
+      assert_equal "******643.454.333,32",fmt.sep(',').nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
       fmt.pad0s! 10
       num = fmt.nio_read_formatted("0.3333...")
       assert_equal "0000000.[3",fmt.nio_write_formatted(num)
       fmt.mode! :fix, 3
       assert_equal "000000.333",fmt.nio_write_formatted(num)
-      num = fmt.nio_read_formatted("-0.666...")  
+      num = fmt.nio_read_formatted("-0.666...")
       fmt.prec! :exact
       fmt.sep! ',','.'
       assert_equal "-000000,[6",fmt.nio_write_formatted(num)
       fmt.width! 20,:center,'*'
       fmt.mode! :fix,3
       assert_equal "*******-0,667*******",fmt.nio_write_formatted(num)
-      num = fmt.nio_read_formatted("0,5555")  
+      num = fmt.nio_read_formatted("0,5555")
       fmt.prec! :exact
       assert_equal "*******0,5555*******",fmt.nio_write_formatted(num)
 
@@ -116,15 +114,15 @@ class TestFmt < Test::Unit::TestCase
       assert_equal 11123.2343,x
       assert_equal "11.123,2343", x.nio_write
       assert_equal "11123,2343", x.nio_write(Fmt[:comma])
-      
+
       x = Float.nio_read("-1234,5678901234e-33")
       # assert_equal -1.2345678901234e-030, x
       assert_equal "-1,2345678901234E-30", x.nio_write()
       assert_equal "-0,0000000000000000000000000000012346",x.nio_write(Fmt[:comma].mode(:sig,5))
 
-      assert_equal "0,333...", 
+      assert_equal "0,333...",
                    (1.0/3).nio_write(Fmt.prec(:exact).show_all_digits(true).approx_mode(:simplify))
-                   
+
       fmt = Fmt.default
       if RUBY_VERSION>='1.9.0'
         assert_raises RuntimeError do fmt.prec! 4 end
@@ -134,42 +132,28 @@ class TestFmt < Test::Unit::TestCase
       fmt = Fmt.default {|f| f.prec! 4 }
       assert_equal "1,235", 1.23456.nio_write(fmt)
       assert_equal "1,23456", 1.23456.nio_write()
-                         
+
       Fmt.default = Fmt.new
       assert_equal '11123.2343', 11123.2343.nio_write
     end
   
     def test_tol_fmt_float
-      tol = Tolerance.new.decimals(12,:sig)
+      tol = Flt.Tolerance(12, :sig_decimals)
       fmt = Fmt.prec(12,:sig)
       $data.each do |x|
-         assert tol.equals?(x, Float.nio_read(x.nio_write(fmt),fmt)), "out of tolerance: #{x.inspect} #{Float.nio_read(x.nio_write(fmt),fmt)}"
-         assert tol.equals?(-x, Float.nio_read((-x).nio_write(fmt),fmt)), "out of tolerance: #{(-x).inspect} #{Float.nio_read((-x).nio_write(fmt),fmt)}"
+         assert tol.eq?(x, Float.nio_read(x.nio_write(fmt),fmt)), "out of tolerance: #{x.inspect} #{Float.nio_read(x.nio_write(fmt),fmt)}"
+         assert tol.eq?(-x, Float.nio_read((-x).nio_write(fmt),fmt)), "out of tolerance: #{(-x).inspect} #{Float.nio_read((-x).nio_write(fmt),fmt)}"
       end
     end
   
-    def test_BigDec
-      assert_equal "0",BigDec(0).nio_write        
-      fmt = Fmt.mode(:gen,:exact)
-      assert_equal "0",BigDec(0).nio_write(fmt)
-      $data.each do |x|
-        x = BigDecimal(x.to_s)
-        assert_equal x,BigDecimal.nio_read(x.nio_write(fmt),fmt)
-      end
-      assert_equal "1E500",BigDec('1E500').nio_write        
-      assert_equal "1E-500",BigDec('1E-500').nio_write        
-      assert_equal "-1E500",BigDec('-1E500').nio_write        
-      assert_equal "-1E-500",BigDec('-1E-500').nio_write            
-    end
-  
     def test_Rational
-      assert_equal "0",Rational(0,1).nio_write        
+      assert_equal "0",Rational(0,1).nio_write
       fmt = Fmt.mode(:gen,:exact)
       assert_equal "0",Rational(0,1).nio_write(fmt)
       $data.each do |x|
         x = x.nio_xr # nio_r
         assert_equal x,Rational.nio_read(x.nio_write(fmt),fmt)
-      end    
+      end
     end
   
     def test_float_bases
@@ -185,7 +169,7 @@ class TestFmt < Test::Unit::TestCase
         assert_equal(-x,Float.nio_read((-x).nio_write(nfmt2),nfmt2))
         assert_equal(-x,Float.nio_read((-x).nio_write(nfmt8),nfmt8))
         assert_equal(-x,Float.nio_read((-x).nio_write(nfmt10),nfmt10))
-        assert_equal(-x,Float.nio_read((-x).nio_write(nfmt16),nfmt16))      
+        assert_equal(-x,Float.nio_read((-x).nio_write(nfmt16),nfmt16))
       end
     end
   
@@ -194,31 +178,29 @@ class TestFmt < Test::Unit::TestCase
     end
   
     def test_big_decimal_bases
-      
-      assert_equal "0.1999A",(BigDec(1)/10).nio_write(Fmt.new.base(16).prec(5))
-      assert_equal "0.1999...",(BigDec(1)/10).nio_write(Fmt.mode(:gen,:exact,:round=>:inf,:approx=>:simplify).base(16))
-      
+
+      assert_equal "0.1999A",(Flt.DecNum(1)/10).normalize.nio_write(Fmt.new.base(16).prec(5))
+      assert_equal "0.1999...",(Flt.DecNum(1)/10).nio_write(Fmt.mode(:gen,:exact,:round=>:inf,:approx=>:simplify).base(16))
+
       nfmt2 = Fmt[:comma].base(2).prec(:exact)
       nfmt8 = Fmt[:comma].base(8).prec(:exact)
       nfmt10 = Fmt[:comma].base(10).prec(:exact)
       nfmt16 = Fmt[:comma].base(16).prec(:exact)
-      $data.each do |x|      
-        x = BigDec(x.to_s)
-        xs,xdig,xb,xe = x.split
-        ndig = xdig.size
-        round_dig = ndig-xe
+      $data.each do |x|
+        x = Flt.DecNum(x.to_s)
+        round_dig = x.number_of_digits - x.adjusted_exponent - 1
         # note that BigDecimal.nio_read produces a BigDecimal with the exact value of the text representation
         # since the representation here is only aproximate (because of the base difference), we must
         # round the results to the precision of the original number
-        assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt2),nfmt2).round(round_dig))
-        assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt8),nfmt8).round(round_dig))
-        assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt10),nfmt10).round(round_dig))
-        assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt16),nfmt16).round(round_dig))
-        assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt2),nfmt2).round(round_dig))
-        assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt8),nfmt8).round(round_dig))
-        assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt10),nfmt10).round(round_dig))
-        assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt16),nfmt16).round(round_dig))
-      end    
+        assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt2),nfmt2).round(round_dig))
+        assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt8),nfmt8).round(round_dig))
+        assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt10),nfmt10).round(round_dig))
+        assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt16),nfmt16).round(round_dig))
+        assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt2),nfmt2).round(round_dig))
+        assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt8),nfmt8).round(round_dig))
+        assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt10),nfmt10).round(round_dig))
+        assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt16),nfmt16).round(round_dig))
+      end
     end
   
     def test_exact_all_float
@@ -231,10 +213,10 @@ class TestFmt < Test::Unit::TestCase
       assert_equal "0.66666666666666662965923251249478198587894439697265625", (2.0/3.0).nio_write(fmt)
       assert_equal "-0.333333333333333314829616256247390992939472198486328125", (-1.0/3.0).nio_write(fmt)
       assert_equal "-0.66666666666666662965923251249478198587894439697265625", (-2.0/3.0).nio_write(fmt)
-      assert_equal "1267650600228229401496703205376",  (2.0**100).nio_write(fmt)    
+      assert_equal "1267650600228229401496703205376",  (2.0**100).nio_write(fmt)
       assert_equal "0.10000000000000001942890293094023945741355419158935546875", nxt(0.1).nio_write(fmt)
       assert_equal "1023.9999999999998863131622783839702606201171875", prv(1024).nio_write(fmt)
-      
+
       assert_equal "2.225073858507201383090232717332404064219215980462331830553327416887204434813918195854283159012511020564067339731035811005152434161553460108856012385377718821130777993532002330479610147442583636071921565046942503734208375250806650616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113537935804992115981085766051992433352114352390148795699609591288891602992641511063466313393663477586513029371762047325631781485664350872122828637642044846811407613911477062801689853244110024161447421618567166150540154285084716752901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678315290680984617210924625396728515625E-308",
                    MIN_N.nio_write(fmt)
       assert_equal "2.2250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375E-308",
@@ -248,8 +230,24 @@ class TestFmt < Test::Unit::TestCase
 
     end
   
+    def test_float_bin_num_coherence
+      Flt::BinNum.context(Flt::BinNum::FloatContext) do
+        [0.1, Float::MIN_D, Float::MIN_N, Float::MAX, 0.0, 1.0, 1.0/3].each do |x|
+          y = Flt::BinNum(x)
+          c = Float.context
+          assert_equal c.split(x), c.split(y) unless x.zero?
+          assert_equal x.nio_write(Fmt.prec(:exact)), y.nio_write(Fmt.prec(:exact))
+          assert_equal x.nio_write(Fmt.prec(:exact).show_all_digits), y.nio_write(Fmt.prec(:exact).show_all_digits)
+          assert_equal x.nio_write(Fmt.prec(:exact).approx_mode(:exact)), y.nio_write(Fmt.prec(:exact).approx_mode(:exact))
+          assert_equal x.nio_write(Fmt.mode(:fix,20).insignificant_digits('#')), y.nio_write(Fmt.mode(:fix,20).insignificant_digits('#'))
+          assert_equal x.nio_write(Fmt.mode(:fix,20)), y.nio_write(Fmt.mode(:fix,20))
+          assert_equal x.nio_write(Fmt.mode(:fix,20,:approx_mode=>:exact)), y.nio_write(Fmt.mode(:fix,20,:approx_mode=>:exact))
+        end
+      end
+    end
+  
     def test_float_nonsig
-      
+
       assert_equal "100.000000000000000#####", 100.0.nio_write(Fmt.prec(20,:fix).insignificant_digits('#'))
 
       fmt = Fmt.mode(:sci,20).insignificant_digits('#').sci_digits(1)
@@ -265,12 +263,12 @@ class TestFmt < Test::Unit::TestCase
       assert_equal "333.33333333333331###E-3", (1.0/3).nio_write(fmt)
       assert_equal "3.3333333333333335###E6", (1E7/3).nio_write(fmt)
       assert_equal "33.333333333333334###E-9",(1E-7/3).nio_write(fmt)
-      
+
       fmt = Fmt[:comma].mode(:sci,20).insignificant_digits('#').sci_digits(0)
       assert_equal "0,33333333333333331###E0",(1.0/3).nio_write(fmt)
       assert_equal "0,33333333333333335###E7",(1E7/3).nio_write(fmt)
       assert_equal "0,33333333333333334###E-7",(1E-7/3).nio_write(fmt)
-      
+
       fmt = Fmt.mode(:sci,20).insignificant_digits('#').sci_digits(0)
       assert_equal "0.10000000000000001###E0",(1E-1).nio_write(fmt)
       assert_equal "0.50000000000000000###E0",(0.5).nio_write(fmt)
@@ -281,65 +279,65 @@ class TestFmt < Test::Unit::TestCase
       assert_equal "0.5###################E-323",MIN_D.nio_write(fmt)
       assert_equal "0.64000000000000000###E2",(64.0).nio_write(fmt)
       assert_equal "0.6400000000000001####E2",(nxt(64.0)).nio_write(fmt)
-      assert_equal "0.6409999999999999####E2",(64.1).nio_write(fmt) 
+      assert_equal "0.6409999999999999####E2",(64.1).nio_write(fmt)
       assert_equal "0.6412312300000001####E2",(64.123123).nio_write(fmt)
       assert_equal "0.10000000000000001###E0",(0.1).nio_write(fmt)
-      assert_equal "0.6338253001141148####E30",nxt(Math.ldexp(0.5,100)).nio_write(fmt) 
+      assert_equal "0.6338253001141148####E30",nxt(Math.ldexp(0.5,100)).nio_write(fmt)
       assert_equal "0.39443045261050599###E-30",nxt(Math.ldexp(0.5,-100)).nio_write(fmt)
       assert_equal "0.10##################E-322",nxt(MIN_D).nio_write(fmt)
       assert_equal "0.15##################E-322",nxt(nxt(MIN_D)).nio_write(fmt)
-      
+
       # note: 1E23 is equidistant from 2 Floats; one or the other will be chosen based on the rounding mode
       x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:even))
       assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
-      assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
+      assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
 
       x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
-      assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
+      assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
 
       x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:inf))
       assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
       assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
-      assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
+      assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
 
       x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:even))
       assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "-9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
-      assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
+      assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
 
       x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
       assert_equal "-9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
-      assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
+      assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
 
       x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:inf))
       assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
       assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
-      assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))    
-      
-      # note: for 64.1 there's only one closest Float; 
+      assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
+
+      # note: for 64.1 there's only one closest Float;
       #   but it can be univocally expressed in decimal either as 64.09999999999999 or 64.1
       x = Float.nio_read('64.1',Fmt.prec(:exact,:gen,:round=>:even))
       assert_equal "64.09999999999999",x.nio_write(Fmt.prec(:exact,:gen).show_all_digits(true))
       assert_equal "64.1",x.nio_write(Fmt.prec(:exact,:gen))
-      
+
       # to do:  exact conversion of Rational(32095022417, 54517) should throw and exception
       #         (unless RepDec.max_d is greater than 27300 or so)
-      
-      
+
+
     end
   
     def test_special
       assert BigDecimal.nio_read("NaN").nan?
       assert Float.nio_read("NaN").nan?
-      assert_equal "NAN", BigDec("NaN").nio_write.upcase
+      assert_equal "NAN", Flt.DecNum("NaN").nio_write.upcase
       assert_equal "NAN", BigDecimal.nio_read("NaN").nio_write.upcase
       assert_equal "NAN", Float.nio_read("NaN").nio_write.upcase
       assert_raises ZeroDivisionError do Rational.nio_read("NaN") end
-      
+
       assert !BigDecimal.nio_read('Infinity').finite?
       assert !BigDecimal.nio_read('+Infinity').finite?
       assert !BigDecimal.nio_read('-Infinity').finite?
@@ -357,7 +355,7 @@ class TestFmt < Test::Unit::TestCase
       assert_equal '+Infinity', Float.nio_read('Infinity').nio_write
       assert_equal '+Infinity', Float.nio_read('+Infinity').nio_write
       assert_equal '-Infinity', Float.nio_read('-Infinity').nio_write
-      
+
     end
   
     def test_conversions
@@ -368,12 +366,12 @@ class TestFmt < Test::Unit::TestCase
       assert_equal BigDecimal(x_txt), x_d
       assert_equal Fmt.convert(x_d,Float,:exact), x_f
       assert_equal Fmt.convert(x_d,Float,:approx), x_f
-      
-      x_d = BigDec(355)/226
+
+      x_d = BigDecimal('355')/226
       x_f = Float(355)/226
       assert_equal Fmt.convert(x_d,Float,:exact), x_f
       assert_equal Fmt.convert(x_d,Float,:approx), x_f
-      
+
     end
   
     def test_sign
@@ -405,6 +403,6 @@ class TestFmt < Test::Unit::TestCase
       assert_equal '+1.23E+5', 1.23E5.nio_write(Fmt.mode(:sci).show_exp_plus.show_plus)
       assert_equal '-1.23E+5', -1.23E5.nio_write(Fmt.mode(:sci).show_exp_plus.show_plus)
     end
-     
+    
 
 end