nio 0.2.0

data/lib/nio/fmt.rb

@@ -0,0 +1,1872 @@
+# Formatting numbers as text
+
+# Copyright (C) 2003-2005, Javier Goizueta <javier@goizueta.info>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+
+require 'nio/tools'
+
+require 'nio/repdec'
+
+require 'nio/rtnlzr'
+
+require 'rational'
+
+require 'bigdecimal'
+
+module Nio
+  
+  # positional notation, unformatted numeric literal: used as intermediate form
+  class NeutralNum 
+    include StateEquivalent
+    def initialize(s='',d='',p=nil,r=nil,dgs=DigitsDef.base(10), inexact=false, round=:inf)
+      set s,d,p,r,dgs,dgs, inexact, round
+    end
+    attr_reader :sign, :digits, :dec_pos, :rep_pos, :special, :inexact, :rounding
+    attr_writer :sign, :digits, :dec_pos, :rep_pos, :special, :inexact, :rounding
+    
+    # set number
+    def set(s,d,p=nil,r=nil,dgs=DigitsDef.base(10),inexact=false,rounding=:inf,normalize=true)
+      @sign = s # sign: '+','-',''
+      @digits = d # digits string
+      @dec_pos = p==nil ? d.length : p # position of decimal point: 0=before first digit...
+      @rep_pos = r==nil ? d.length : r # first repeated digit (0=first digit...)
+      @dgs = dgs
+      @base = @dgs.radix
+      @inexact = inexact
+      @special = nil
+      @rounding = rounding
+      trimZeros unless inexact  
+      self
+    end
+    # set infinite (:inf) and invalid (:nan) numbers
+    def set_special(s,sgn='') # :inf, :nan
+      @special = s
+      @sign = sgn
+      self
+    end
+    
+    def base
+      @base
+    end
+    def base_digits
+      @dgs
+    end
+    def base_digits=(dd)
+      @dgs = dd
+      @base = @dgs.radix
+    end
+    def base=(b)
+      @dgs = DigitsDef.base(b)
+      @base=@dgs.radix
+    end
+    
+    # check for special numbers (which have only special and sign attributes)
+    def special?
+      special != nil
+    end
+    
+    # check for special numbers (which have only special and sign attributes)
+    def inexact?
+      @inexact
+    end
+    
+    def dup
+      n = NeutralNum.new
+      if special?
+        n.set_special @special.dup, @sign.dup
+      else
+        #n.set @sign.dup, @digits.dup, @dec_pos.dup, @rep_pos.dup, @dgs.dup
+        # in Ruby 1.6.8 Float,BigNum,Fixnum doesn't respond to dup
+        n.set @sign.dup, @digits.dup, @dec_pos, @rep_pos, @dgs.dup, @inexact, @rounding
+      end
+      return n 
+    end
+    
+    def zero?
+      z = false
+      if !special
+        if digits==''
+          z = true
+        else
+          z = true
+          for i in (0...@digits.length)
+            if dig_value(i)!=0
+              z = false
+              break
+            end
+          end
+        end
+      end
+      z
+    end
+    
+    def round!(n, mode=:fix, dir=nil)
+      dir ||= rounding
+      trimLeadZeros
+      if n==:exact
+        return unless @inexact
+        n = @digits.size
+      end
+      
+      n += @dec_pos if mode==:fix
+      n = [n,@digits.size].min if @inexact
+
+      adj = 0
+      dv = :tie
+      if @inexact && n==@digits.size
+        dv = @inexact==:roundup ? :hi : :lo
+      else
+        v = dig_value(n)
+        v2 = 2*v
+        if v2 < @base # v<((@base+1)/2)
+          dv = :lo
+        elsif v2 > @base # v>(@base/2)
+          dv = :hi
+        else
+         
+         (n+1...@digits.length).each do |i|
+           if dig_value(i)>0
+             dv = :hi
+             break
+           end        
+         end
+          
+          dv = :hi if dv==:tie && @rep_pos<=n                  
+        end
+      end
+      
+      if dv==:hi
+        adj = +1
+      elsif dv==:tie
+        if dir==:inf # towards nearest +/-infinity
+          adj = +1
+        elsif dir==:even # to nearest even digit (IEEE unbiased rounding)
+          adj = +1 if (dig_value(n-1)%2)!=0
+        elsif dir==:zero # towards zero
+          adj=0
+      #  elsif dir==:odd 
+      #    adj = +1 unless (dig_value(n-1)%2)!=0
+        end
+      end    
+      
+      if n>@digits.length
+        (@digits.length...n).each do |i|
+          @digits << dig_char(dig_value(i))
+          @rep_pos += 1
+        end
+      end
+      
+      prefix = ''
+      i = n-1
+      while adj!=0
+        v = dig_value(i)
+        v += adj
+        adj = 0
+        if v<0
+          v += @base
+          adj = -1
+        elsif v>=@base
+          v -= @base
+          adj = +1
+        end
+        if i<0
+          prefix = dig_char(v)+prefix 
+        elsif i<@digits.length
+          @digits[i] = dig_char(v)
+        end
+        i += -1
+      end 
+      
+      if n<0
+        @digits = ""  
+      else
+        @digits = @digits[0...n]  
+      end
+      @rep_pos = @digits.length
+
+      if prefix!=''
+        @digits = prefix + @digits
+        @dec_pos += prefix.length
+        @rep_pos += prefix.length
+      end
+      
+      
+    end
+    
+    def round(n, mode=:fix, dir=nil)
+      dir ||= rounding
+      nn = dup
+      nn.round!(n,mode,dir)
+      return nn
+    end
+    
+    def trimTrailZeros()    
+      i = @digits.length
+      while i>0 && dig_value(i-1)==0
+        i -= 1    
+      end
+      if @rep_pos>=i
+        @digits = @digits[0...i]
+        @rep_pos = i
+      end
+      
+      if @digits==''
+        @digits = dig_char(0) # '0'
+        @rep_pos = 1
+        @dec_pos = 1
+      end
+      
+    end
+    
+    def trimLeadZeros()
+      i = 0
+      while i<@digits.length && dig_value(i)==0
+        i += 1
+      end
+      @digits = @digits[i...@digits.length]
+      @dec_pos -= i
+      @rep_pos -= i
+      
+      if @digits==''
+        @digits = dig_char(0) # '0'
+        @rep_pos = 1
+        @dec_pos = 1
+      end
+      
+    end
+    
+    def trimZeros()    
+      trimLeadZeros
+      trimTrailZeros
+    end
+    
+    protected
+    
+    def dig_value(i)
+      v = 0
+      if i>=@rep_pos 
+        i -= @digits.length
+        i %= @digits.length - @rep_pos if @rep_pos<@digits.length
+        i += @rep_pos
+      end        
+      if i>=0 && i<@digits.length
+        v = @dgs.digit_value(@digits[i]) #digcode_value(@digits[i])
+      end
+      return v>=0 && v<@base ? v : nil
+    end
+    #def digcode_value(c)
+    #  v = c-?0
+    #  if v>9
+    #    v = 10 + c.chr.downcase[0] - ?a
+    #  end
+    #  v
+    #  @dgs.digit_value(c)
+    #end
+    
+    def dig_char(v)
+      c = ''
+      if v!=nil && v>=0 && v<@base
+        c = @dgs.digit_char(v).chr
+      end
+      c
+    end
+    
+  end
+  
+  class NeutralNum
+    public
+    def to_RepDec
+      n = RepDec.new(@base)
+      if special?
+        
+        case special
+          when :nan
+            n.ip = :indeterminate
+          when :inf
+            if sign=='-'
+              n.ip = :posinfinity
+            else
+              n.ip  :neginfinity
+            end
+          else
+            n = nil
+        end
+        
+      else
+        if dec_pos<=0
+          n.ip = 0
+          n.d =  text_to_digits(dig_char(0)*(-dec_pos) + digits)
+        elsif dec_pos >= digits.length
+          n.ip = digits.to_i(@base)        
+          if rep_pos<dec_pos          
+            i=0
+            (dec_pos-digits.length).times do
+              n.ip *= @base
+              n.ip += @dgs.digit_value(digits[rep_pos+i]) if rep_pos+i<digits.length
+              i += 1
+              i=0 if i>=digits.length-rep_pos
+            end
+            n.d = []
+            while i<digits.length-rep_pos
+              n.d << @dgs.digit_value(digits[rep_pos+i])
+              i += 1
+            end
+            new_rep_pos = n.d.size + dec_pos
+            n.d += text_to_digits(digits[rep_pos..-1])
+            self.rep_pos = new_rep_pos
+          else
+            n.ip *= @base**(dec_pos-digits.length)
+            n.d = []
+          end
+        else
+          n.ip = digits[0...dec_pos].to_i(@base)
+          n.d = text_to_digits(digits[dec_pos..-1])
+          if rep_pos<dec_pos 
+            new_rep_pos = n.d.size + dec_pos
+            n.d += text_to_digits(digits[rep_pos..-1])
+            self.rep_pos = new_rep_pos
+            puts "--rep_pos=#{rep_pos}"
+          end        
+        end
+        n.sign = -1 if sign=='-'
+        n.rep_i = rep_pos - dec_pos     
+      end
+      n.normalize!(!inexact) # keep trailing zeros for inexact numbers
+      return n
+    end
+    protected
+    def text_to_digits(txt)
+      #txt.split('').collect{|c| @dgs.digit_value(c)}    
+      ds = []
+      txt.each_byte{|b| ds << @dgs.digit_value(b)}
+      ds
+    end
+  end
+  
+  class RepDec
+    public
+    def to_NeutralNum(base_dgs=nil)
+      num = NeutralNum.new
+      if !ip.is_a?(Integer)
+        
+        case ip
+          when :indeterminate
+            num.set_special :nan
+          when :posinfinity
+            num.set_special :inf,'+'
+          when :neginfinity
+            num.set_special :inf,'-'
+          else
+            num = nil
+        end
+            
+      else
+        base_dgs ||= DigitsDef.base(@radix)
+        # assert base_dgs.radix == @radix
+        signch = sign<0 ? '-' : '+'
+        decimals = ip.to_s(@radix)
+        dec_pos = decimals.length
+        d.each {|dig| decimals << base_dgs.digit_char(dig) }
+        rep_pos = rep_i==nil ? decimals.length : dec_pos + rep_i
+        num.set signch, decimals, dec_pos, rep_pos, base_dgs
+      end
+      return num
+   end
+  end
+  
+  # A Fmt object defines a numeric format.
+  #
+  # The formatting aspects managed by Fmt are:
+  # * mode and precision
+  #   - #mode() and #orec() set the main paramters
+  #   - see also #show_all_digits(), #approx_mode(), #insignificant_digits(),
+  #     #sci_digits() and #show_plus()
+  # * separators
+  #   - see #sep() and #grouping()
+  # * field justfification
+  #   - #width() and the shortcut #pad0s()
+  # * numerical base
+  #   - #base()
+  # * repeating numerals 
+  #   - #rep()
+  #
+  # Note that for every aspect there are also corresponding _mutator_
+  # methos (its name ending with a bang) that modify an object in place,
+  # instead of returning an altered copy.
+  #
+  # This class also contains class methods for numeric conversion:
+  # * Fmt.convert
+  # and for default and other predefined formats:
+  # * Fmt.default / Fmt.default=
+  # * Fmt.[] / Fmt.[]=
+  #
+  # The actual formatted reading and writting if performed by
+  # * #nio_write() (Nio::Formattable#nio_write)
+  # * #nio_read() (Nio::Formattable::ClassMethods#nio_read)
+  # Finally numerical objects can be rounded according to a format:
+  # * #nio_round() (Nio::Formattable#nio_round)
+  class Fmt
+    include StateEquivalent
+    
+    class Error < StandardError # :nodoc:
+    end
+    class InvalidOption < Error # :nodoc:
+    end
+    class InvalidFormat < Error # :nodoc:
+    end
+    
+    @@default_rounding_mode = :even
+    def initialize()
+      
+      @dec_sep = '.'
+      @grp_sep = ','
+      @grp = []
+      
+      @ndig = :exact
+      @mode=:gen
+      @round=Fmt.default_rounding_mode
+      @all_digits = false
+      @approx = :only_sig
+      @non_sig = '' # marker for insignificant digits of inexact values e.g. '#','0'
+      @sci_format = 1 # number of integral digits in the mantissa: -1 for all
+      
+      @show_plus = false
+      
+      @rep_begin = '<'
+      @rep_end   = '>'
+      @rep_auto  = '...'
+      @rep_n  = 2
+      @rep_in   = true
+      
+      @width = 0
+      @fill_char = ' '
+      @adjust=:right
+      
+      @base_radix = 10
+      @base_uppercase = true
+      @base_digits = DigitsDef.base(@base_radix, !@base_uppercase)
+      @show_base = false
+      @base_indicators = { 2=>'b', 8=>'o', 10=>'', 16=>'h', 0=>'r'} # 0: generic (used with radix)
+      @base_prefix = false
+      
+      @nan_txt = 'NAN'
+      @inf_txt = 'Infinity'
+      
+      yield self if block_given?  
+    end
+    
+    # Defines the separators used in numerals. This is relevant to
+    # both input and output. 
+    # 
+    # The first argument is the radix point separator (usually
+    # a point or a comma; by default it is a point.)
+    #
+    # The second argument is the group separator.
+    #
+    # Finally, the third argument is an array that defines the groups
+    # of digits to separate.
+    # By default it's [], which means that no grouping will be produced on output
+    # (but the group separator defined will be ignored in input.)
+    # To produce the common thousands separation a value of [3] must be passed,
+    # which means that groups of 3 digits are used.
+    def sep(dec_sep,grp_sep=nil,grp=nil)
+      dup.sep!(dec_sep,grp_sep,grp)
+    end
+    # This is the mutator version of #sep().
+    def sep!(dec_sep,grp_sep=nil,grp=nil)
+      set! :dec_sep=>dec_sep, :grp_sep=>grp_sep, :grp=>grp
+    end
+    
+    # This defines the grouping of digits (which can also be defined in #sep()
+    def grouping(grp=[3],grp_sep=nil)
+      dup.grouping!(grp,grp_sep)
+    end
+    # This is the mutator version of #grouping().
+    def grouping!(grp=[3],grp_sep=nil)
+      set! :grp_sep=>grp_sep, :grp=>grp
+    end
+    
+    # This is a shortcut to return a new default Fmt object 
+    # and define the separators as with #sep().
+    def Fmt.sep(dec_sep,grp_sep=nil,grp=nil)
+      Fmt.default.sep(dec_sep,grp_sep,grp)
+    end
+    # This is a shortcut to return a new default Fmt object 
+    # and define the grouping as with #grouping().
+    def Fmt.grouping(grp=[3],grp_sep=nil)
+      Fmt.default.grouping(grp,grp_sep)
+    end
+    
+    # Define the formatting mode. There are two fixed parameters:
+    # - <tt>mode</tt> (only relevant for output)
+    #   [<tt>:gen</tt>]
+    #      (general) chooses automatically the shortes format
+    #   [<tt>:fix</tt>]
+    #      (fixed precision) is a simple format with a fixed number of digits
+    #      after the point
+    #   [<tt>:sig</tt>]
+    #      (significance precision) is like :fix but using significant digits
+    #   [<tt>:sci</tt>]
+    #      (scientific) is the exponential form 1.234E2
+    # - <tt>precision</tt> (number of digits or :exact, only used for output)
+    #   [<tt>exact</tt>]
+    #      means that as many digits as necessary to unambiguosly define the
+    #      value are used; this is the default.
+    #
+    # Other paramters can be passed in a hash after <tt>precision</tt>
+    # - <tt>:round</tt> rounding mode applied to conversions
+    #   (this is relevant for both input and output). It must be one of:
+    #   [<tt>:inf</tt>]
+    #     rounds towards infinite; 1.5 is rounded to 2, -1.5 to -2
+    #   [<tt>:zero</tt>]
+    #     rounds towards zero; 1.5 is rounded to 1, -1.5 to 2
+    #   [<tt>:even</tt>]
+    #     rounds to the nearest even digit 1.5 rounds to 2, 2.5 to 2
+    # - <tt>:approx</tt> approximate mode
+    #   [<tt>:only_sig</tt>]
+    #     (the default) treats the value as an approximation and only
+    #     significant digits (those that cannot take an arbitrary value without
+    #     changing the specified value) are shown.
+    #   [<tt>:exact</tt>]
+    #     the value is interpreted as exact, there's no distinction between
+    #     significant and insignificant digits.
+    #   [<tt>:simplify</tt>]
+    #     the value is simplified, if possible to a simpler (rational) value.
+    # - <tt>:show_all_digits</tt> if true, this forces to show digits that 
+    #   would otherwise not be shown in the <tt>:gen</tt> format: trailing
+    #   zeros of exact types or non-signficative digits of inexact types.
+    # - <tt>:nonsignficative_digits</tt> assigns a character to display
+    #   insignificant digits, # by default
+    def mode(mode,precision=nil,options={})
+      dup.mode!(mode,precision,options)
+    end
+    # This is the mutator version of #mode().
+    def mode!(mode,precision=nil,options={})
+      set! options.merge(:mode=>mode, :ndig=>precision)
+    end
+    
+    # Defines the formatting mode like #mode() but using a different
+    # order of the first two parameters parameters, which is useful
+    # to change the precision only. Refer to #mode().
+    def prec(precision,mode=nil, options={})
+      dup.prec! precision, mode, options
+    end  
+    # This is the mutator version of #prec().
+    def prec!(precision,mode=:gen, options={})
+      set! options.merge(:mode=>mode, :ndig=>precision)
+    end
+    
+    # This is a shortcut to return a new default Fmt object 
+    # and define the formatting mode as with #mode()
+    def Fmt.mode(mode,ndig=nil,options={})
+      Fmt.default.mode(mode,ndig,options)
+    end
+    # This is a shortcut to return a new default Fmt object 
+    # and define the formatting mode as with #prec()
+    def Fmt.prec(ndig,mode=nil,options={})
+      Fmt.default.prec(ndig,mode,options)
+    end
+    
+    # Rounding mode used when not specified otherwise
+    def Fmt.default_rounding_mode
+      @@default_rounding_mode
+    end
+    # The default rounding can be changed here; it starts with the value :even.
+    # See the rounding modes available in the description of method #mode().
+    def Fmt.default_rounding_mode=(m)
+      @@default_rounding_mode=m
+      Fmt.default = Fmt.default.round(m)
+    end
+    
+    # This controls the display of the digits that are not necessary
+    # to specify the value unambiguosly (e.g. trailing zeros).
+    # 
+    # The true (default) value forces the display of the requested number of digits
+    # and false will display only necessary digits.
+    def show_all_digits(ad=true)
+      dup.show_all_digits! ad
+    end
+    # This is the mutator version of #show_all_digits().
+    def show_all_digits!(ad=true)
+      set! :all_digits=>ad
+    end
+    # This defines the approximate mode (:only_sig, :exact, :simplify)
+    # just like the last parameter of #mode()
+    def approx_mode(mode)
+      dup.approx_mode! mode
+    end
+    # This is the mutator version of #approx_mode().
+    def approx_mode!(mode)
+      set! :approx=>mode
+    end
+    # Defines a character to stand for insignificant digits when
+    # a specific number of digits has been requested greater than then
+    # number of significant digits (for approximate types).
+    def insignificant_digits(ch='#')
+      dup.insignificant_digits! ch
+    end
+    # This is the mutator version of #insignificant_digits().
+    def insignificant_digits!(ch='#')
+      ch ||= ''
+      set! :non_sig=>ch
+    end
+    # Defines the number of significan digits before the radix separator
+    # in scientific notation. A negative value will set all significant digits
+    # before the radix separator. The special value <tt>:eng</tt> activates
+    # _engineering_ mode, in which the exponents are multiples of 3.
+    #
+    # For example:
+    #   0.1234.nio_write(Fmt.mode(:sci,4).sci_digits(0)    ->  0.1234E0
+    #   0.1234.nio_write(Fmt.mode(:sci,4).sci_digits(3)    ->  123.4E-3
+    #   0.1234.nio_write(Fmt.mode(:sci,4).sci_digits(-1)   ->  1234.E-4
+    #   0.1234.nio_write(Fmt.mode(:sci,4).sci_digits(:eng) ->  123.4E-3
+    def sci_digits(n=-1)
+      dup.sci_digits! n
+    end
+    # This is the mutator version of #sci_digits().
+    def sci_digits!(n=-1)
+      set! :sci_format=>n
+    end
+    
+    # This is a shortcut to return a new default Fmt object 
+    # and define show_all_digits
+    def Fmt.show_all_digits(v=true)
+      Fmt.default.show_all_digits(v)
+    end
+    # This is a shortcut to return a new default Fmt object 
+    # and define approx_mode
+    def Fmt.approx_mode(v)
+      Fmt.default.approx_mode(v)
+    end
+    # This is a shortcut to return a new default Fmt object 
+    # and define insignificant digits
+    def Fmt.insignificant_digits(v='#')
+      Fmt.default.insignificant_digits(v)
+    end
+    # This is a shortcut to return a new default Fmt object 
+    # and define sci_digits
+    def Fmt.sci_digits(v=-1)
+      Fmt.default.sci_digits(v)
+    end
+    
+    # Controls the display of the sign for positive numbers
+    def show_plus(sp=true)
+      dup.show_plus! sp
+    end
+    # This is the mutator version of #show_plus().
+    def show_plus!(sp=true)
+      set! :show_plus=>sp
+    end
+    
+    # This is a shortcut to return a new default Fmt object 
+    # and define show_plus
+    def Fmt.show_plus(v=true)
+      Fmt.default.show_plus(v)
+    end
+    
+    # Defines the handling and notation for repeating numerals. The parameters
+    # can be passed in order or in a hash:
+    # [<tt>:begin</tt>] is the beginning delimiter of repeating section (<)
+    # [<tt>:end</tt>] is the ending delimiter of repeating section (<)
+    # [<tt>:suffix</tt>] is the suffix used to indicate a implicit repeating decimal
+    # [<tt>:rep</tt>]
+    #    if this parameter is greater than zero, on output the repeating section
+    #    is repeated the indicated number of times followed by the suffix; 
+    #    otherwise the delimited notation is used.
+    # [<tt>:read</tt>]
+    #    (true/false) determines if repeating decimals are
+    #    recognized on input (true)
+    def rep(*params)
+      dup.rep!(*params)
+    end
+    # This is the mutator version of #rep().
+    def rep!(*params)  
+      
+      params << {} if params.size==0
+      if params[0].kind_of?(Hash)
+        params = params[0]
+      else  
+        begch,endch,autoch,rep,read = *params  
+        params = {:begin=>begch,:end=>endch,:suffix=>autoch,:nreps=>rep,:read=>read}
+      end
+      
+      set! params
+    end
+    
+    # This is a shortcut to return a new default Fmt object 
+    # and define the repeating decimals mode as with #rep()
+    def Fmt.rep(*params)
+      Fmt.default.rep(*params)
+    end
+    
+    # Sets the justificaton width, mode and fill character
+    #
+    # The mode accepts these values:
+    # [<tt>:right</tt>] (the default) justifies to the right (adds padding at the left)
+    # [<tt>:left</tt>] justifies to the left (adds padding to the right)
+    # [<tt>:internal</tt>] like :right, but the sign is kept to the left, outside the padding.
+    # [<tt>:center</tt>] centers the number in the field
+    def width(w,adj=nil,ch=nil)
+      dup.width! w,adj,ch
+    end
+    # This is the mutator version of #width().
+    def width!(w,adj=nil,ch=nil)
+      set! :width=>w, :adjust=>adj, :fill_char=>ch
+    end
+    # Defines the justification (as #width()) with the given
+    # width, internal mode and filling with zeros.
+    #
+    # Note that if you also use grouping separators, the filling 0s
+    # will not be separated.
+    def pad0s(w)
+      dup.pad0s! w
+    end
+    # This is the mutator version of #pad0s().
+    def pad0s!(w)
+      width! w, :internal, '0'
+    end
+    # This is a shortcut to create a new Fmt object and define the width
+    # parameters as with #widht()
+    def Fmt.width(w,adj=nil,ch=nil)
+      Fmt.default.width(w,adj,ch)
+    end
+    # This is a shortcut to create a new Fmt object and define numeric
+    # padding as with #pad0s()
+    def Fmt.pad0s(w)
+      Fmt.default.pad0s(w)
+    end
+    
+    # defines the numerical base; the second parameters forces the use
+    # of uppercase letters for bases greater than 10.
+    def base(b, uppercase=nil)
+      dup.base! b, uppercase
+    end
+    # This is the mutator version of #base().
+    def base!(b, uppercase=nil)
+      set! :base_radix=>b, :base_uppercase=>uppercase
+    end
+    # This is a shortcut to create a new Fmt object and define the base
+    def Fmt.base(b, uppercase=nil)
+      Fmt.default.base(b, uppercase)
+    end
+    # returns the exponent char used with the specified base
+    def get_exp_char(base) # :nodoc:
+      base ||= @base_radix
+      base<=10 ? 'E' : '^'
+    end
+    
+    # returns the base
+    def get_base # :nodoc:
+      @base_radix
+    end
+    # returns the digit characters used for a base
+    def get_base_digits(b=nil) # :nodoc:
+      (b.nil? || b==@base_radix) ? @base_digits : DigitsDef.base(b,!@base_uppercase)
+    end
+    # returns true if uppercase digits are used
+    def get_base_uppercase? # :nodoc:
+      @base_uppercase
+    end
+    
+    # returns the formatting mode
+    def get_mode # :nodoc:
+      @mode
+    end
+    # returns the precision (number of digits)
+    def get_ndig # :nodoc:
+      @ndig
+    end
+    # return the show_all_digits state
+    def get_all_digits? # :nodoc:
+      @all_digits
+    end
+    # returns the approximate mode
+    def get_approx # :nodoc:
+      @approx
+    end
+    
+    # returns the rounding mode
+    def get_round # :nodoc:
+      @round
+    end
+    
+    # Method used internally to format a neutral numeral
+    def nio_write_formatted(neutral) # :nodoc:
+      str = ''     
+      if neutral.special?
+        str << neutral.sign
+        case neutral.special
+          when :inf
+            str << @inf_txt
+          when :nan
+            str << @nan_txt
+        end    
+      else
+        zero = get_base_digits(neutral.base).digit_char(0).chr 
+        neutral = neutral.dup
+        round! neutral
+        if neutral.zero?
+          str << neutral.sign if neutral.sign=='-' # show - if number was <0 before rounding
+          str << zero
+          if @ndig.kind_of?(Numeric) && @ndig>0 && @mode==:fix
+            str << @dec_sep << zero*@ndig
+          end
+        else
+          
+          neutral.trimLeadZeros
+          actual_mode = @mode
+          trim_trail_zeros = !@all_digits # false
+
+          integral_digits = @sci_format
+          if integral_digits == :eng
+            integral_digits = 1
+            while (neutral.dec_pos - integral_digits).modulo(3) != 0
+              integral_digits += 1
+            end
+          elsif integral_digits==:all || integral_digits < 0
+            if neutral.inexact? && @non_sig!='' && @ndig.kind_of?(Numeric)
+              integral_digits = @ndig
+            else
+              integral_digits = neutral.digits.length
+            end
+          end
+          exp = neutral.dec_pos - integral_digits
+              
+          case actual_mode
+            when :gen # general (automatic)
+              # @ndig means significant digits
+              actual_mode = :sig
+              actual_mode = :sci if use_scientific?(neutral, exp)
+              trim_trail_zeros = !@all_digits # true
+          end
+          
+          case actual_mode  
+            when :fix, :sig #, :gen
+              
+              str << neutral.sign if @show_plus || neutral.sign!='+'
+
+              if @show_base && @base_prefix
+                b_prefix = @base_indicators[neutral.base]
+                str << b_prefix if b_prefix
+              end
+              
+              if @ndig==:exact
+                neutral.sign = '+'
+                str << neutral.to_RepDec.getS(@rep_n, getRepDecOpt(neutral.base))
+              else
+                #zero = get_base_digits.digit_char(0).chr
+                ns_digits = ''
+                
+                nd = neutral.digits.length
+                if actual_mode==:fix
+                  nd -= neutral.dec_pos
+                end
+                if neutral.inexact? && @ndig>nd # assert no rep-dec.
+                  ns_digits = @non_sig*(@ndig-nd)
+                end
+                
+                digits = neutral.digits + ns_digits
+                if neutral.dec_pos<=0
+                  str << zero+@dec_sep+zero*(-neutral.dec_pos) + digits
+                elsif neutral.dec_pos >= digits.length 
+                  str << group(digits + zero*(neutral.dec_pos-digits.length))
+                else
+                  str << group(digits[0...neutral.dec_pos]) + @dec_sep + digits[neutral.dec_pos..-1]
+                end
+              end
+
+              #str = str.chomp(zero).chomp(@dec_sep) if trim_trail_zeros && str.include?(@dec_sep)
+              if trim_trail_zeros && str.include?(@dec_sep) &&  str[-@rep_auto.size..-1]!=@rep_auto
+                str.chop! while str[-1]==zero[0]
+                str.chomp!(@dec_sep)
+                #puts str
+              end
+              
+                
+            when :sci
+              
+              str << neutral.sign if @show_plus || neutral.sign!='+'
+
+              if @show_base && @base_prefix
+                b_prefix = @base_indicators[neutral.base]
+                str << b_prefix if b_prefix
+              end
+              
+              #zero = get_base_digits.digit_char(0).chr
+              if @ndig==:exact
+                neutral.sign = '+'
+                neutral.dec_pos-=exp
+                str << neutral.to_RepDec.getS(@rep_n, getRepDecOpt(neutral.base))  
+              else
+                ns_digits = ''
+                
+                nd = neutral.digits.length
+                if actual_mode==:fix
+                  nd -= neutral.dec_pos
+                end
+                if neutral.inexact? && @ndig>nd # assert no rep-dec.
+                  ns_digits = @non_sig*(@ndig-nd)
+                end
+                
+                digits = neutral.digits + ns_digits
+                str << ((integral_digits<1) ? zero : digits[0...integral_digits])
+                str << @dec_sep
+                str << digits[integral_digits...@ndig]
+                pad_right =(@ndig+1-str.length) 
+                str << zero*pad_right if pad_right>0 && !neutral.inexact? # maybe we didn't have enought digits
+              end
+
+              #str = str.chomp(zero).chomp(@dec_sep) if trim_trail_zeros && str.include?(@dec_sep)
+              if trim_trail_zeros && str.include?(@dec_sep) &&  str[-@rep_auto.size..-1]!=@rep_auto
+                str.chop! while str[-1]==zero[0]
+                str.chomp!(@dec_sep)
+                #puts str
+              end
+              
+              str << get_exp_char(neutral.base)
+              str << exp.to_s
+                  
+          end
+          
+        end
+      end
+      
+      if @show_base && !@base_prefix
+        b_prefix = @base_indicators[neutral.base]
+        str << b_prefix if b_prefix
+      end
+      
+      
+      if @width>0 && @fill_char!=''
+        l = @width - str.length
+        if l>0
+          case @adjust
+            when :internal
+              sign = ''
+              if str[0,1]=='+' || str[0,1]=='-' 
+                sign = str[0,1]
+                str = str[1...str.length]
+              end
+              str = sign + @fill_char*l + str
+            when :center
+              str = @fill_char*(l/2) + str + @fill_char*(l-l/2)
+            when :right
+              str = @fill_char*l + str
+            when :left
+              str = str + @fill_char*l
+          end
+        end    
+      end
+      
+      return str
+    end
+    
+    # round a neutral numeral according to the format options
+    def round!(neutral) # :nodoc:
+      neutral.round! @ndig, @mode, @round
+    end
+    
+    @@sci_fmt = nil
+    
+    def nio_read_formatted(txt) # :nodoc:
+      txt = txt.dup
+      num = nil
+       
+      base = nil
+      
+      base ||= get_base
+     
+      zero = get_base_digits(base).digit_char(0).chr 
+      txt.tr!(@non_sig,zero) # we don't simply remove it because it may be before the radix point 
+      
+      exp = 0
+      x_char = get_exp_char(base)
+      
+      exp_i = txt.index(x_char)
+      exp_i = txt.index(x_char.downcase) if exp_i===nil
+      if exp_i!=nil
+        exp = txt[exp_i+1...txt.length].to_i
+        txt = txt[0...exp_i] 
+      end    
+      
+
+      opt = getRepDecOpt(base)
+      if @rep_in
+        #raise InvalidFormat,"Invalid numerical base" if base!=10
+        rd = RepDec.new # get_base not necessary: setS sets it from options
+        rd.setS txt, opt
+        num = rd.to_NeutralNum(opt.digits)
+      else
+        # to do: use RepDec.parse; then build NeutralNum directly
+        opt.set_delim '',''
+        opt.set_suffix ''
+        rd = RepDec.new # get_base not necessary: setS sets it from options
+        rd.setS txt, opt
+        num = rd.to_NeutralNum(opt.digits)
+      end
+      num.rounding = get_round
+      num.dec_pos += exp
+      return num
+    end
+    
+          
+    @@fmts = {
+      :def=>Fmt.new.freeze
+    }
+    # Returns the current default format.
+    def self.default
+      d = self[:def]
+      if block_given?
+        d = d.dup
+        yield d
+      end
+      d
+    end
+    # Defines the current default format.
+    def self.default=(fmt)
+      self[:def] = fmt
+    end
+    # Assigns a format to a name in the formats repository.
+    def self.[]=(tag,fmt_def)
+      @@fmts[tag.to_sym]=fmt_def.freeze
+    end
+    # Retrieves a named format from the repository.
+    def self.[](tag)
+      @@fmts[tag.to_sym]
+    end
+        
+    protected
+    
+    @@valid_properties = nil
+    ALIAS_PROPERTIES = {
+      :show_all_digits=>:all_digits,
+      :rounding_mode=>:round,
+      :approx_mode=>:approx,
+      :sci_digits=>:sci_format,
+      :non_signitificative_digits=>:non_sig,
+      :begin=>:rep_begin,
+      :end=>:rep_end,
+      :suffix=>:rep_auto,
+      :nreps=>:rep_n,
+      :read=>:rep_in
+    }
+    def set!(properties={}) # :nodoc:
+
+     
+     @@valid_properties ||= instance_variables.collect{|v| v[1..-1].to_sym}
+     
+     
+     properties.each do |k,v|
+       al = ALIAS_PROPERTIES[k]
+       if al
+         properties[al] = v
+         properties.delete k
+       elsif !@@valid_properties.include?(k)
+         raise InvalidOption, "Invalid option: #{k}"
+       end
+     end
+        
+     
+     if properties[:grp_sep].nil? && !properties[:dec_sep].nil? && properties[:dec_sep]!=@dec_sep && properties[:dec_sep]==@grp_sep    
+       properties[:grp_sep] = properties[:dec_sep]=='.' ? ',' : '.'    
+     end
+     
+     if properties[:all_digits].nil? && (properties[:ndig] || properties[:mode])
+        ndig = properties[:ndig] || @ndig
+        mode = properties[:mode] || @mode
+        properties[:all_digits] = ndig!=:exact && mode!=:gen   
+     end
+     
+     if !properties[:all_digits].nil? && properties[:non_sig].nil?
+       properties[:non_sig] = '' unless properties[:all_digits]
+     elsif !properties[:non_sig].nil? && properties[:all_digits].nil?
+       properties[:all_digits] = true if properties[:non_sig]!=''
+     end
+     
+     if !properties[:base_radix].nil? || !properties[:base_uppercase].nil?
+        base = properties[:base_radix] || @base_radix
+        uppercase = properties[:base_uppercase] || @base_uppercase
+        properties[:base_digits] = DigitsDef.base(base, !uppercase)
+     end
+     
+     
+     properties.each do |k,v|
+       instance_variable_set "@#{k}", v unless v.nil?
+     end
+     
+     self 
+    end
+    
+    def set(properties={}) # :nodoc:
+      self.dup.set!(properties)
+    end
+    
+    def use_scientific?(neutral,exp) # :nodoc:
+      nd = @ndig.kind_of?(Numeric) ? @ndig : [neutral.digits.length,10].max
+      if @@sci_fmt==:hp
+        puts "  #{nd} ndpos=#{neutral.dec_pos} ndlen=#{neutral.digits.length}"
+        neutral.dec_pos>nd || ([neutral.digits.length,nd].min-neutral.dec_pos)>nd
+      else
+        exp<-4 || exp>=nd 
+      end
+    end
+    
+    def getRepDecOpt(base=nil) # :nodoc:
+      rd_opt = RepDec::Opt.new
+      rd_opt.begin_rep = @rep_begin
+      rd_opt.end_rep = @rep_end
+      rd_opt.auto_rep = @rep_auto
+      rd_opt.dec_sep = @dec_sep
+      rd_opt.grp_sep = @grp_sep
+      rd_opt.grp = @grp
+      rd_opt.inf_txt = @inf_txt
+      rd_opt.nan_txt = @nan_txt    
+      rd_opt.set_digits(get_base_digits(base))
+    #  if base && (base != get_base_digits.radix)
+    #    rd_opt.set_digits(get_base_digits(base))
+    #  else
+    #    rd_opt.set_digits get_base_digits
+    #  end
+      return rd_opt
+    end
+    
+    def group(digits) # :nodoc:
+      RepDec.group_digits(digits, getRepDecOpt)
+    end
+    
+  end
+  
+  # This is a mix-in module to add formatting capabilities no numerical classes.
+  # A class that includes this module should provide the methods
+  # nio_write_neutral(fmt):: an instance method to write the value to
+  #                          a neutral numeral. The format is passed so that
+  #                          the base, for example, is available.
+  # nio_read_neutral(neutral):: a class method to create a value from a neutral
+  #                             numeral.
+  module Formattable
+    
+    # This is the method available in all formattable objects
+    # to format the value into a text string according
+    # to the optional format passed.
+    def nio_write(fmt=Fmt.default)
+      neutral = nio_write_neutral(fmt)
+      fmt.nio_write_formatted(neutral)
+    end
+    
+    module ClassMethods
+      # This is the method available in all formattable clases
+      # to read a formatted value from a text string into 
+      # a value the class, according to the optional format passed.
+      def nio_read(txt,fmt=Fmt.default)
+        neutral = fmt.nio_read_formatted(txt)
+        nio_read_neutral neutral      
+      end
+    end
+    
+    # Round a formattable object according to the rounding mode and
+    # precision of a format.
+    def nio_round(fmt=Fmt.default)
+      neutral = nio_write_neutral(fmt)
+      fmt.round! neutral
+      self.class.nio_read_neutral neutral      
+    end
+    
+    def self.append_features(mod) # :nodoc:
+      super
+      mod.extend ClassMethods
+    end
+      
+  end
+  
+  Fmt[:comma] = Fmt.sep(',','.')
+  Fmt[:comma_th] = Fmt.sep(',','.',[3])
+  Fmt[:dot] = Fmt.sep('.',',')
+  Fmt[:dot_th] = Fmt.sep('.',',',[3])
+  Fmt[:code] = Fmt.new.prec(20) # don't use :exact to avoid repeating numerals
+  
+  class Fmt
+    # Intermediate conversion format for simplified conversion
+    CONV_FMT = Fmt.prec(:exact).rep('<','>','...',0).approx_mode(:simplify)
+    # Intermediate conversion format for exact conversion
+    CONV_FMT_STRICT = Fmt.prec(:exact).rep('<','>','...',0).approx_mode(:exact)
+    # Numerical conversion: converts the quantity +x+ to an object
+    # of class +type+.
+    #
+    # The third parameter is the kind of conversion:
+    # [<tt>:approx</tt>]
+    #     Tries to find an approximate simpler value if possible for inexact
+    #     numeric types. This is the default. This is slower in general and
+    #     may take some seconds in some cases.
+    # [<tt>:exact</tt>]
+    #     Performs a conversion as exact as possible.
+    # The third parameter is true for approximate
+    # conversion (inexact values are simplified if possible) and false
+    # for conversions as exact as possible.
+    def Fmt.convert(x, type, mode=:approx)
+      fmt = mode==:approx ? CONV_FMT : CONV_FMT_STRICT
+      # return x.prec(type)
+      if !(x.is_a?(type))
+        # return type.nio_read(x.nio_write(fmt),fmt)
+        
+        x = x.nio_write_neutral(fmt)
+        x = type.nio_read_neutral(x)
+        
+      end
+      x
+    end
+  end
+  
+  module_function
+  
+  def nio_float_to_bigdecimal(x,prec) # :nodoc:
+    if prec.nil?
+      x = Nio.convert(x,BigDecimal,:approx)          
+    elsif prec==:exact
+      x = Nio.convert(x,BigDecimal,:exact) 
+    else
+      x = BigDecimal(x.nio_write(Nio::Fmt.new.prec(prec,:sig)))
+    end
+    x
+  end
+    
+  
+  module Clinger # :nodoc: all
+  module_function
+
+  def algM(f,e,round_mode,eb=10,beta=Float::RADIX,n=Float::MANT_DIG,min_e=Float::MIN_EXP-Float::MANT_DIG,max_e=Float::MAX_EXP-Float::MANT_DIG)
+
+    if e<0
+     u,v,k = f,eb**(-e),0
+    else
+      u,v,k = f*(eb**e),1,0
+    end
+    
+    loop do
+       x = u.div(v)
+       # overflow if k>=max_e 
+       if (x>=beta**(n-1) && x<beta**n) || k==min_e || k==max_e
+          return ratio_float(u,v,k,round_mode,beta,n)
+       elsif x<beta**(n-1)
+         u *= beta
+         k -= 1
+       elsif x>=beta**n
+         v *= beta
+         k += 1         
+       end     
+    end
+
+  end
+  
+  def ratio_float(u,v,k,round_mode,beta=Float::RADIX,n=Float::MANT_DIG)
+    q = u.div v
+    r = u-q*v
+    v_r = v-r
+    z = Math.ldexp(q,k)
+    if r<v_r
+      z
+    elsif r>v_r
+      nextfloat z
+    elsif (round_mode==:even && q.even?) || (round_mode==:zero)
+      z
+    else
+      nextfloat z
+    end
+  end
+  
+  def nextfloat(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)  
+    x + dx
+  end
+
+  def prevfloat(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)  
+    if e==Float::MIN_EXP || f!=0.5 #0.5==Math.ldexp(2**(bits-1),-Float::MANT_DIG)
+      x - dx
+    else
+      x - dx/2 # x - Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e-1)  
+    end
+  end
+  
+  end
+  
+  module BurgerDybvig # :nodoc: all
+  module_function
+
+  def float_to_digits(v,f,e,round_mode,min_e,p,b,_B)
+   
+   case round_mode
+     when :even
+       roundl = roundh = f.even?
+     when :inf
+       roundl = true
+       roundh = false
+     when :zero
+       roundl = false
+       roundh = true
+     else
+       # here we don't assume any rounding in the floating point numbers
+       # the result is valid for any rounding
+       roundl = false
+       roundh = false
+   end
+    
+      if e >= 0
+        if f != exptt(b,p-1)
+          be = exptt(b,e)
+          r,s,m_p,m_m,k = scale(f*be*2,2,be,be,0,_B,roundl ,roundh,v)
+        else
+          be = exptt(b,e)
+          be1 = be*b
+          r,s,m_p,m_m,k = scale(f*be1*2,b*2,be1,be,0,_B,roundl ,roundh,v)
+        end
+      else
+        if e==min_e or f != exptt(b,p-1)
+          r,s,m_p,m_m,k = scale(f*2,exptt(b,-e)*2,1,1,0,_B,roundl ,roundh,v)
+        else
+          r,s,m_p,m_m,k = scale(f*b*2,exptt(b,1-e)*2,b,1,0,_B,roundl ,roundh,v)
+        end
+      end
+      [k]+generate(r,s,m_p,m_m,_B,roundl ,roundh)
+  end
+  
+  def scale(r,s,m_p,m_m,k,_B,low_ok ,high_ok,v)
+    return scale2(r,s,m_p,m_m,k,_B,low_ok ,high_ok) if v==0
+    est = (logB(_B,v)-1E-10).ceil.to_i
+    if est>=0 
+      fixup(r,s*exptt(_B,est),m_p,m_m,est,_B,low_ok,high_ok)
+    else
+      sc = exptt(_B,-est)
+      fixup(r*sc,s,m_p*sc,m_m*sc,est,_B,low_ok,high_ok)
+    end
+  end
+
+  def fixup(r,s,m_p,m_m,k,_B,low_ok,high_ok)
+    if (high_ok ? (r+m_p >= s) : (r+m_p > s)) # too low?
+      [r,s*_B,m_p,m_m,k+1]
+    else
+      [r,s,m_p,m_m,k]
+    end
+  end
+  
+  def scale2(r,s,m_p,m_m,k,_B,low_ok ,high_ok)
+    loop do
+      if (high_ok ? (r+m_p >= s) : (r+m_p > s)) # k is too low
+        s *= _B
+        k += 1
+      elsif (high_ok ? ((r+m_p)*_B<s) : ((r+m_p)*_B<=s)) # k is too high
+        r *= _B
+        m_p *= _B
+        m_m *= _B
+        k -= 1
+      else
+        break
+      end
+    end
+    [r,s,m_p,m_m,k]
+  end
+  
+  def generate(r,s,m_p,m_m,_B,low_ok ,high_ok)
+    list = []
+    loop do
+      d,r = (r*_B).divmod(s)
+      m_p *= _B
+      m_m *= _B
+      tc1 = low_ok ? (r<=m_m) : (r<m_m)
+      tc2 = high_ok ? (r+m_p >= s) : (r+m_p > s)
+
+       if not tc1
+        if not tc2
+          list << d
+        else
+          list << d+1
+          break
+        end
+      else
+        if not tc2
+          list << d
+          break
+        else
+          if r*2 < s
+            list << d
+            break
+          else
+            list << d+1
+            break
+          end
+        end
+      end
+      
+    end
+    list
+  end
+  
+  $exptt_table = Array.new(326)
+  (0...326).each{|i| $exptt_table[i]=10**i}
+  def exptt(_B, k)
+    if _B==10 && k>=0 && k<326 
+      $exptt_table[k]
+    else
+      _B**k
+    end
+  end
+
+  $logB_table = Array.new(37)
+  (2...37).each{|b| $logB_table[b]=1.0/Math.log(b)}
+  def logB(_B, x)
+    if _B>=2 && _B<37
+      Math.log(x)*$logB_table[_B]
+    else
+      Math.log(x)/Math.log(_B)
+    end
+  end
+  
+  def float_to_digits_max(v,f,e,round_mode,min_e,p,b,_B)
+   
+   case round_mode
+     when :even
+       roundl = roundh = f.even?
+     when :inf
+       roundl = true
+       roundh = false
+     when :zero
+       roundl = false
+       roundh = true
+     else
+       # here we don't assume any rounding in the floating point numbers
+       # the result is valid for any rounding
+       roundl = false
+       roundh = false
+   end
+    
+      if e >= 0
+        if f != exptt(b,p-1)
+          be = exptt(b,e)
+          r,s,m_p,m_m,k = scale(f*be*2,2,be,be,0,_B,roundl ,roundh,v)
+        else
+          be = exptt(b,e)
+          be1 = be*b
+          r,s,m_p,m_m,k = scale(f*be1*2,b*2,be1,be,0,_B,roundl ,roundh,v)
+        end
+      else
+        if e==min_e or f != exptt(b,p-1)
+          r,s,m_p,m_m,k = scale(f*2,exptt(b,-e)*2,1,1,0,_B,roundl ,roundh,v)
+        else
+          r,s,m_p,m_m,k = scale(f*b*2,exptt(b,1-e)*2,b,1,0,_B,roundl ,roundh,v)
+        end
+      end
+      [k]+generate_max(r,s,m_p,m_m,_B,roundl ,roundh)
+  end
+  
+  def generate_max(r,s,m_p,m_m,_B,low_ok ,high_ok)
+    list = [false]
+    loop do
+      d,r = (r*_B).divmod(s)
+      m_p *= _B
+      m_m *= _B
+      
+      list << d
+          
+      tc1 = low_ok ? (r<=m_m) : (r<m_m)
+      tc2 = high_ok ? (r+m_p >= s) : (r+m_p > s)
+          
+      if tc1 && tc2
+        list[0] = true if r*2 >= s
+        break
+      end    
+    end
+    list
+  end
+  
+  end
+    
+end
+
+class Float
+  include Nio::Formattable
+  def self.nio_read_neutral(neutral)   
+    x = nil
+    
+    honor_rounding = true
+    
+    if neutral.special?
+      case neutral.special
+        when :nan
+          x = 0.0/0.0
+        when :inf
+          x = (neutral.sign=='-' ? -1.0 : +1.0)/0.0
+      end
+    elsif neutral.rep_pos<neutral.digits.length  
+      
+      x,y = neutral.to_RepDec.getQ
+      x = Float(x)/y
+      
+    else
+      nd = neutral.base==10 ? Float::DIG : ((Float::MANT_DIG-1)*Math.log(2)/Math.log(neutral.base)).floor 
+      k = neutral.dec_pos-neutral.digits.length
+      if !honor_rounding && (neutral.digits.length<=nd && k.abs<=15)
+        x = neutral.digits.to_i(neutral.base).to_f
+        if k<0
+          x /= Float(neutral.base**-k)
+        else
+          x *= Float(neutral.base**k)
+        end
+        x = -x if neutral.sign=='-'
+      elsif !honor_rounding && (k>0 && (k+neutral.digits.length < 2*nd))
+        j = k-neutral.digits.length
+        x = neutral.digits.to_i(neutral.base).to_f * Float(neutral.base**(j))
+        x *= Float(neutral.base**(k-j))
+        x = -x if neutral.sign=='-'
+      elsif neutral.base.modulo(Float::RADIX)==0
+       
+       f = neutral.digits.to_i(neutral.base)
+       e = neutral.dec_pos-neutral.digits.length
+
+       rounding = neutral.rounding
+       
+       x = Nio::Clinger::algM(f,e,rounding,neutral.base,Float::RADIX,Float::MANT_DIG,Float::MIN_EXP-Float::MANT_DIG,Float::MAX_EXP-Float::MANT_DIG)
+       x = -x if neutral.sign=='-'
+       
+      else
+       
+       f = neutral.digits.to_i(neutral.base)
+       e = neutral.dec_pos-neutral.digits.length
+
+       rounding = neutral.rounding
+       
+       x = Nio::Clinger::algM(f,e,rounding,neutral.base,Float::RADIX,Float::MANT_DIG,Float::MIN_EXP-Float::MANT_DIG,Float::MAX_EXP-Float::MANT_DIG)
+       x = -x if neutral.sign=='-'
+       
+      end
+    end
+     
+    return x
+  end
+  def nio_write_neutral(fmt)
+    neutral = Nio::NeutralNum.new
+    x = self
+    
+    if x.nan?
+      neutral.set_special(:nan)
+    elsif x.infinite?
+      neutral.set_special(:inf, x<0 ? '-' : '+')
+    else
+      converted = false
+      if fmt.get_ndig==:exact && fmt.get_approx==:simplify
+        
+        if x!=0
+          q = x.nio_r(Nio::Tolerance.decimals(Float::DIG,:sig))
+          if q!=0
+            neutral = q.nio_write_neutral(fmt)
+            converted = true if neutral.digits.length<=Float::DIG
+          end
+        end
+        
+      elsif fmt.get_approx==:exact
+        neutral = x.nio_xr.nio_write_neutral(fmt)
+        converted = true
+      end
+      if !converted  
+        if fmt.get_base==10 && false
+          txt = format "%.*e",Float::DECIMAL_DIG-1,x # note that spec. e output precision+1 significant digits
+          
+          sign = '+'    
+          if txt[0,1]=='-'
+            sign = '-'
+            txt = txt[1...txt.length]
+          end
+          exp = 0
+          x_char = fmt.get_exp_char(fmt.get_base)
+
+          exp_i = txt.index(x_char)
+          exp_i = txt.index(x_char.downcase) if exp_i===nil
+          if exp_i!=nil
+            exp = txt[exp_i+1...txt.length].to_i
+            txt = txt[0...exp_i] 
+          end    
+          
+          dec_pos = txt.index '.'
+          if dec_pos==nil
+            dec_pos = txt.length 
+          else
+            txt[dec_pos]=''
+          end
+          dec_pos += exp
+          neutral.set sign, txt, dec_pos, nil, fmt.get_base_digits(10), true, fmt.get_round
+          
+          converted = true
+        end
+      end
+      if !converted
+        
+        sign = x<0 ? '-' : '+'
+        x = -x if sign=='-'
+        f,e = Math.frexp(x)
+        if e < Float::MIN_EXP
+          # denormalized number
+          f = Math.ldexp(f,e-Float::MIN_EXP+Float::MANT_DIG)
+          e = Float::MIN_EXP-Float::MANT_DIG
+        else
+          # normalized number
+          f = Math.ldexp(f,Float::MANT_DIG)
+          e -= Float::MANT_DIG
+        end
+        f = f.to_i
+        inexact = true
+
+        rounding = fmt.get_round
+        
+        if fmt.get_all_digits?
+          # use as many digits as possible
+          dec_pos,r,*digits = Nio::BurgerDybvig::float_to_digits_max(x,f,e,rounding,Float::MIN_EXP-Float::MANT_DIG,Float::MANT_DIG,Float::RADIX,fmt.get_base)
+          inexact = :roundup if r
+        else
+          # use as few digits as possible
+          dec_pos,*digits = Nio::BurgerDybvig::float_to_digits(x,f,e,rounding,Float::MIN_EXP-Float::MANT_DIG,Float::MANT_DIG,Float::RADIX,fmt.get_base)
+        end
+        txt = ''
+        digits.each{|d| txt << fmt.get_base_digits.digit_char(d)}
+        neutral.set sign, txt, dec_pos, nil, fmt.get_base_digits, inexact, fmt.get_round
+        
+      end
+    end
+         
+    return neutral
+  end  
+end
+
+class Numeric
+  unless method_defined?(:even?)
+    def even?
+      self.modulo(2)==0
+    end
+  end
+  unless method_defined?(:odd?)
+    def odd?
+      self.modulo(2)!=0
+    end
+  end
+end
+
+class Integer
+  include Nio::Formattable
+  def self.nio_read_neutral(neutral)   
+    x = nil
+    
+    if neutral.special?
+      raise Nio::InvalidFormat,"Invalid integer numeral"
+    elsif neutral.rep_pos<neutral.digits.length  
+      return Rational.nio_read_neutral(neutral).to_i
+    else
+      digits = neutral.digits
+      
+      if neutral.dec_pos <= 0
+        digits = '0'
+      elsif neutral.dec_pos <= digits.length
+        digits = digits[0...neutral.dec_pos]
+      else
+        digits = digits + '0'*(neutral.dec_pos-digits.length)  
+      end
+      
+      x = digits.to_i(neutral.base)
+    # this was formely needed because we didn't adust the digits
+    #  if neutral.dec_pos != neutral.digits.length
+    #    # with rational included, negative powers of ten are rational numbers
+    #    x = (x*((neutral.base)**(neutral.dec_pos-neutral.digits.length))).to_i   
+    #  end
+      x = -x if neutral.sign=='-'
+    end
+     
+    return x
+  end
+  def nio_write_neutral(fmt)
+    neutral = Nio::NeutralNum.new
+    x = self
+    
+    sign = x<0 ? '-' : '+'
+    txt = x.abs.to_s(fmt.get_base)
+    dec_pos = rep_pos = txt.length  
+    neutral.set sign, txt, dec_pos, nil, fmt.get_base_digits, false ,fmt.get_round
+         
+    return neutral
+  end
+end
+
+class Rational
+  include Nio::Formattable
+  def self.nio_read_neutral(neutral)   
+    x = nil
+    
+    if neutral.special?
+      case neutral.special
+        when :nan
+          x = Rational(0,0)
+        when :inf
+          x = Rational((neutral.sign=='-' ? -1 : +1),0)
+      end
+    else
+      x = Rational(*neutral.to_RepDec.getQ)
+    end
+     
+    return x
+  end
+  def nio_write_neutral(fmt)
+    neutral = Nio::NeutralNum.new
+    x = self
+    
+    if x.denominator==0
+      if x.numerator>0    
+        neutral.set_special(:inf)
+      elsif x.numerator<0
+        neutral.set_special(:inf,'-')
+      else
+        neutral.set_special(:nan)
+      end
+    else
+      if fmt.get_base==10
+        rd = Nio::RepDec.new.setQ(x.numerator,x.denominator)
+      else
+        opt = Nio::RepDec::DEF_OPT.dup.set_digits(fmt.get_base_digits)
+        rd = Nio::RepDec.new.setQ(x.numerator,x.denominator, opt)
+      end
+      neutral = rd.to_NeutralNum(fmt.get_base_digits)
+      neutral.rounding = fmt.get_round
+    end
+         
+    return neutral
+  end
+end
+
+if defined? BigDecimal
+class BigDecimal
+  include Nio::Formattable
+  def self.nio_read_neutral(neutral)   
+    x = nil
+    
+    if neutral.special?
+      case neutral.special
+        when :nan
+          x = BigDecimal('NaN') # BigDecimal("0")/0
+        when :inf
+          x = BigDecimal(neutral.sign=='-' ? '-1.0' : '+1.0')/0
+      end
+    elsif neutral.rep_pos<neutral.digits.length  
+      
+      x,y = neutral.to_RepDec.getQ
+      x = BigDecimal(x.to_s)/y
+      
+    else
+      if neutral.base==10
+        #x = BigDecimal(neutral.digits)
+        #x *= BigDecimal("1E#{(neutral.dec_pos-neutral.digits.length)}")
+        #x = -x if neutral.sign=='-'
+        str = neutral.sign
+        str += neutral.digits
+        str += "E#{(neutral.dec_pos-neutral.digits.length)}"
+        x = BigDecimal(str)
+      else
+        x = BigDecimal(neutral.digits.to_i(neutral.base).to_s)    
+        x *= BigDecimal(neutral.base.to_s)**(neutral.dec_pos-neutral.digits.length)
+        x = -x if neutral.sign=='-'
+      end
+    end
+     
+    return x
+  end
+  def nio_write_neutral(fmt)
+    neutral = Nio::NeutralNum.new
+    x = self
+    
+    if x.nan?
+      neutral.set_special(:nan)
+    elsif x.infinite?
+      neutral.set_special(:inf, x<0 ? '-' : '+')
+    else  
+      converted = false
+      if fmt.get_ndig==:exact && fmt.get_approx==:simplify
+        
+        prc = [x.precs[0],20].max
+        neutral = x.nio_r(Nio::BigTolerance.decimals(prc,:sig)).nio_write_neutral(fmt)
+        converted = true if neutral.digits.length<prc
+        
+      elsif fmt.get_approx==:exact && fmt.get_base!=10
+        neutral = x.nio_xr.nio_write_neutral(fmt)
+        converted = true
+      end
+      if !converted 
+        if fmt.get_base==10 
+          txt = x.to_s
+          
+          sign = '+'    
+          if txt[0,1]=='-'
+            sign = '-'
+            txt = txt[1...txt.length]
+          end
+          exp = 0
+          x_char = fmt.get_exp_char(fmt.get_base)
+
+          exp_i = txt.index(x_char)
+          exp_i = txt.index(x_char.downcase) if exp_i===nil
+          if exp_i!=nil
+            exp = txt[exp_i+1...txt.length].to_i
+            txt = txt[0...exp_i] 
+          end    
+          
+          dec_pos = txt.index '.'
+          if dec_pos==nil
+            dec_pos = txt.length 
+          else
+            txt[dec_pos]=''
+          end
+          dec_pos += exp
+          neutral.set sign, txt, dec_pos, nil, fmt.get_base_digits(10), true, fmt.get_round
+          
+        end
+      end  
+      if !converted
+        
+        min_prec = 24
+        min_exp  = -1000
+        s,f,b,e = x.split
+        e -= f.size
+        sign = s<0 ? '-' : '+'
+        x = -x if sign=='-'
+        f_i = f.to_i
+        prc = [x.precs[0],min_prec].max
+        f_i *= 10**(prc-f.size)
+        e -= (prc-f.size)
+
+        inexact = true
+
+        rounding = fmt.get_round
+        
+        if fmt.get_all_digits?
+          # use as many digits as possible
+          dec_pos,r,*digits = Nio::BurgerDybvig::float_to_digits_max(x,f_i,e,rounding,[e,min_exp].min,prc,b,fmt.get_base)
+          inexact = :roundup if r
+        else
+          # use as few digits as possible
+          dec_pos,*digits = Nio::BurgerDybvig::float_to_digits(x,f_i,e,rounding,[e,min_exp].min,prc,b,fmt.get_base)
+        end
+        txt = ''
+        digits.each{|d| txt << fmt.get_base_digits.digit_char(d)}
+        neutral.set sign, txt, dec_pos, nil, fmt.get_base_digits, inexact, fmt.get_round
+        
+      end
+    end
+         
+    return neutral
+  end
+end
+end
+