float-formats 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2762f17e4a4d466ccfd26ecfa5e4bfc5f72a4de
-  data.tar.gz: 725f2276a8d2352a480738f6b80347afdee5429e
+  metadata.gz: e5c6ebefc05d57a1271453eb0ba460e7f6fa9e9d
+  data.tar.gz: 0bb606a66d28fa34cdf03984c72acf0ecdbb4ce3
 SHA512:
-  metadata.gz: 934167b2462593a9dc91a848b01eabdee00043f63fb92aefa4d265c635aa07efd2b67e53b2d1fc5b7f5efb7365ca079f1d93731acd5d01cadf9de4b5c4973b35
-  data.tar.gz: 811b80dd4a9fb97cf88913a0f480087e71dc4d4ff6bb9a4b6ee032cf5bf56219495fe7249b185caad9af54e4cf1241cfa41ba369364678ba7072643892d36501
+  metadata.gz: dd8490cef4b2aacb6bb06b7fb5e349acf954055499f2bc52000c126a4095163dca2be630d7f27b60b5426e4e43772d1eae6f099423eead7ecf8b257afc59b23e
+  data.tar.gz: 62ce956a3757fb4719e7cf0572ff4698af641275396ba6b5a5f2d95db641e90e35148adc7499dbe0b8bccd157a682585075efab7a561cf708a4c1e9c9b6c3b7e

data/History.txt

@@ -1,3 +1,8 @@
+== 0.3.0 2015-04-05
+
+* Nio dependency replaced by Numerals
+* Ruby 1.8 compatibility dropped
+
 == 0.2.1 2015-03-31
 
 * Compatibility issues with Ruby 1.9/2

data/README.md

@@ -210,9 +210,9 @@ the first bit, which will be hidden:
 
     Flt.define(
       :MY_FP, BinaryFormat,
-      :fields=>[:significand,22,:exponent,9,:sign,1],
-      :bias=>127, :bias_mode=>:scientific_significand,
-      :hidden_bit=>true
+      fields: [:significand,22,:exponent,9,:sign,1],
+      bias: 127, bias_mode: :scientific_significand,
+      hidden_bit: true
     )
 
 Now we can encode values in this format, decode values, convet to other

data/float-formats.gemspec

@@ -18,9 +18,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'flt', ">= 1.1.2"
-  spec.add_dependency 'nio', ">= 0.2.4"
+  spec.add_dependency 'flt', ">= 1.4.7"
+  spec.add_dependency 'numerals', ">= 0.3.0"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency 'nio', ">= 0.2.4"
+
+  spec.required_ruby_version = '>= 1.9.3'
 end

data/lib/float-formats/bytes.rb

@@ -1,7 +1,6 @@
 # Float-Formats
 # Support for binary data representations
-require 'nio'
-require 'nio/sugar'
+require 'numerals'
 
 require 'enumerator'
 require 'delegate'
@@ -10,8 +9,8 @@ module Flt
 
 class Bits
   # Define a bit string given the number of bits and
-  # optinally the initial value (as an integer).
-  def initialize(num_bits,v=0)
+  # optionally the initial value (as an integer).
+  def initialize(num_bits, v=0)
     @n = num_bits
     @v = v
   end
@@ -20,10 +19,9 @@ class Bits
   def to_s(base=2)
     n = Bits.power_of_two(base)
     if n
-      fmt = Nio::Fmt.default.base(base,true).mode(:fix,:exact)
       digits = (size+n-1)/n
-      fmt.pad0s!(digits)
-      @v.nio_write(fmt)
+      #{ }"%0#{digits}d" % @v.to_s(base)
+      Numerals::Format[:fix, base: base].set_leading_zeros(digits).write(@v)
     else
       @v.to_s(base)
     end
@@ -48,7 +46,7 @@ class Bits
   end
 
   # produce bit string from an integer
-  def self.from_i(v,len=nil)
+  def self.from_i(v, len=nil)
     len ||= (Math.log(v)/Math.log(2)).ceil # v.to_s(2).size
     Bits.new(len,v)
   end
@@ -112,9 +110,8 @@ class Bytes < DelegateClass(String)
         @bytes = bytes.pack("C*")
       else
         @bytes = bytes.to_str
-        @bytes.force_encoding("BINARY") if @bytes.respond_to?(:force_encoding)
     end
-    @bytes.force_encoding(Encoding::BINARY) if RUBY_VERSION>="1.9.0"
+    @bytes.force_encoding("BINARY") if @bytes.respond_to?(:force_encoding)
     super @bytes
   end
 

data/lib/float-formats/classes.rb

@@ -35,9 +35,8 @@
 # * minimum encoded exponent reserved for zero (nonzero significands are not used with it)
 # * special all zeros representation: minimun encoded exponent is a regular exponent except for 0
 
-require 'nio'
-require 'nio/sugar'
 require 'flt'
+require 'numerals'
 require 'enumerator'
 require 'float-formats/bytes.rb'
 
@@ -91,59 +90,46 @@ class FormatBase
       @sign,@significand,@exponent = v.to_a
     end
   end
+
   attr_reader :sign, :significand, :exponent
+
   def to_a
     split
   end
+
   def split
     return [@sign,@significand,@exponent]
   end
 
-
   def nan?
     @exponent == :nan
   end
+
   def zero?
     return @exponent==:zero || @significand==0
   end
+
   def infinite?
     return @exponent==:infinity
   end
+
   def subnormal?
     return @exponent==:denormal || (@significand.kind_of?(Integer) && @significand<self.class.minimum_normalized_integral_significand)
   end
+
   def normal?
     @exponend.kind_of?(Integer) && @significand>=self.class.minimum_normalized_integral_significand
   end
 
-  include Nio::Formattable
-
   # from/to integral_sign_significand_exponent
 
-  def nio_write_neutral(fmt)
-    # this always treats the floating-point values as exact quantities
-    case @exponent
-      when :zero
-        v = 0.0/@sign
-      when :infinity
-        v = @sign/0.0
-      when :nan
-        v = 0.0/0.0
-      else
-        case form_class.radix
-        when 10
-          v = Flt.DecNum(@sign, @significand, @exponent)
-        when 2
-          v = Flt.BinNum(@sign, @significand, @exponent)
-        else
-          v = @significand*form_class.radix_power(@exponent)*@sign
-        end
+  def to_text(fmt = Numerals::Format[])
+    if infinite?
+      fmt = fmt[symbols: [show_plus: true]]
     end
-    v.nio_write_neutral(fmt)
-  end
-  def to_text(fmt=Nio::Fmt.default)
-    nio_write(fmt)
+    fmt.write(self)
   end
+
   def to_bytes
     form_class.pack(@sign,@significand,@exponent)
   end
@@ -154,24 +140,29 @@ class FormatBase
       to_bits.to_hex
     end
   end
-  def to(number_class, mode=:approx)
-    if number_class==Bytes
+  def to(number_class, mode = :approx)
+    if number_class == Bytes
       to_bytes
-    elsif number_class==String
-      mode = Nio::Fmt.default if mode==:approx
+    elsif number_class == String
+      mode = Numerals::Format[] if mode == :approx
       to_text(mode)
-    elsif Nio::Fmt===number_class
+    elsif Numerals::Format === number_class
       to_text(number_class)
-    elsif number_class==Array
+    elsif number_class == Array
       split
-    elsif Symbol===number_class
+    elsif Symbol === number_class
       send "to_#{number_class}"
     elsif number_class.is_a?(Flt::Num)  && number_class.radix == form_class.radix
       self.to_num
+    elsif number_class.is_a?(FormatBase)
+      number_class.from_number(self, mode)
     else # assume number_class.ancestors.include?(Numeric) (number_class < Numeric)
-        fmt = mode==:approx ? Nio::Fmt::CONV_FMT : Nio::Fmt::CONV_FMT_STRICT
-        v = nio_write(fmt)
-        number_class.nio_read(v,fmt)
+      options = {
+        type: number_class,
+        exact_input: (mode != :approx),
+        output_mode: :fixed
+      }
+      Numerals::Conversions.convert(self, options)
     end
   end
   def to_bits
@@ -183,13 +174,13 @@ class FormatBase
   def to_bits_text(base)
     to_bits.to_s(base)
     #i = to_bits
-    #fmt = Nio::Fmt.default.base(base,true).mode(:fix,:exact)
+    #fmt = Numerals::Format[base: base]
     #if [2,4,8,16].include?(base)
     #  n = (Math.log(base)/Math.log(2)).round.to_i
     #  digits = (form_class.total_bits+n-1)/n
-    #  fmt.pad0s!(digits)
+    #  fmt.set_trailing_zeros!(digits)
     #end
-    #i.to_i.nio_write(fmt)
+    #fmt.writ(i.to_i)
   end
 
   # Computes the negation of a floating point value (unary minus)
@@ -198,11 +189,10 @@ class FormatBase
   end
 
   # Converts a floating point value to another format
-  def convert_to(fpclass)
-    fpclass.nio_read(nio_write)
+  def convert_to(fpclass, options = {})
+    Numerals::Conversions.convert(self, options.merge(type: fpclass))
   end
 
-
   # Computes the next adjacent floating point value.
   # Accepts either a Value or a byte String.
   # Returns a Value.
@@ -384,7 +374,7 @@ class FormatBase
         # originally, we incremented min_encoded_exp here unconditionally, but
         # now we don't if there's no hidden bit
         # (we assume the minimum exponent can be used for normalized and denormalized numbers)
-        # because of this, IEEE_EXTENDED & 128 formats now specify :min_encoded_exp=>1 in it's definitions
+        # because of this, IEEE_EXTENDED & 128 formats now specify min_encoded_exp: 1 in it's definitions
         @min_encoded_exp += 1 if @hidden_bit
       end
     end
@@ -580,23 +570,60 @@ class FormatBase
     Num[self.radix]
   end
 
+  def self.numerals_conversion(options = {})
+    FltFmtConversion.new(self, options)
+  end
+
   def self.context
     num_class::Context.new(
-      :precision=>significand_digits,
-      :emin=>radix_min_exp(:scientific_significand),
-      :emax=>radix_max_exp(:scientific_significand),
-      :rounding=>@round || :half_even
+      precision: significand_digits,
+      emin: radix_min_exp(:scientific_significand),
+      emax: radix_max_exp(:scientific_significand),
+      rounding:@round || :half_even
     )
   end
 
   def to_num
-    s,c,e = split
-    e = 0 if e == :zero
-    form_class.num_class.Num(s,c,e)
+    s, c, e = split
+    case e
+    when :zero
+      e = 0
+    when :infinity
+      e = :inf
+    when :nan
+      e = :nan
+    end
+    form_class.num_class.Num(s, c, e)
   end
 
+  # def to_num
+  #   # num_class = Flt::Num[form_class.radix]
+  #   num_class = self.class.num_class
+  #   case @exponent
+  #   when :zero
+  #     num_class.zero(@sign)
+  #   when :infinity
+  #     num_class.infinity(@sign)
+  #   when :nan
+  #     num_class.nan
+  #   else
+  #     num_class.new(@sign, @significand, @exponent)
+  #   end
+  # end
+
   def self.num(x)
-    new(*x.split)
+    s, c, e = x.split
+    if x.zero?
+      e = :zero
+    else
+      case e
+      when :inf
+        e = :infinity
+      when :nan
+        e = :nan
+      end
+    end
+    new([s, c, e])
   end
 
   # Endianness of the format (:little_endian, :big_endian or :little_big_endian)
@@ -792,41 +819,6 @@ class FormatBase
 
   # from methods
 
-
-  def self.nio_read_neutral(neutral)
-       if neutral.special?
-          case neutral.special
-            when :nan
-              return nan
-            when :inf
-              return infinity(neutral.sign=='-' ? -1 : +1)
-          end
-       end
-       if neutral.rep_pos<neutral.digits.length
-         nd = neutral.base==10 ? decimal_digits_necessary : (significand_digits*Math.log(radix)/Math.log(fmt.get_base)).ceil+1
-         neutral = neutral.round(nd,:sig)
-       end
-       f = neutral.digits.to_i(neutral.base)
-       e = neutral.dec_pos-neutral.digits.length
-       case neutral.rounding
-       when :even
-         rounding = :half_even
-       when :inf
-         rounding = :half_up
-       when :zero
-         rounding = :half_down
-       when :truncate
-         rounding = :down
-       end
-       s = (neutral.sign=='-') ? -1 : +1
-       if neutral.base!=radix
-         reader = Flt::Support::Reader.new(:mode=>:fixed)
-         s,f,e = reader.read(context, rounding, s, f, e, neutral.base).split
-       end
-       return_value s,f,e
-
-  end
-
   def self.from(*args)
     new(*args)
   end
@@ -839,17 +831,27 @@ class FormatBase
     from_bytes Bytes.from_hex(hex)
   end
 
-  def self.from_number(v, mode=:approx)
+  def self.from_number(v, mode = :approx)
     if v.is_a?(Flt::Num) && v.num_class.radix==self.radix
       self.num(v)
     else
-      fmt = mode==:approx ? Nio::Fmt::CONV_FMT : Nio::Fmt::CONV_FMT_STRICT
-      nio_read(v.nio_write(fmt),fmt)
+      options = {
+        type: self,
+        exact_input: (mode != :approx),
+        output_mode: @normalized ? :fixed : :short
+      }
+      Numerals::Conversions.convert(v, options)
     end
   end
 
-  def self.from_text(txt, fmt=Nio::Fmt.default) # ?
-    nio_read(txt,fmt)
+  def self.from_text(txt, *args)
+    if @normalized
+      fmt = Numerals::Format[exact_input: true]
+    else
+      fmt = Numerals::Format[:short, exact_input: false]
+    end
+    fmt = fmt[*args]
+    fmt.read(txt, type: self)
   end
 
   def self.join(sign,significand,exponent)
@@ -875,8 +877,8 @@ class FormatBase
   # Defines a floating-point number from a text representation of the
   # encoded integral value in a given base.
   # Returns a Value.
-  def self.from_bits_text(txt,base)
-    i = Integer.nio_read(txt,Nio::Fmt.base(base))
+  def self.from_bits_text(txt, base)
+    i = Numerals::Format[].read(txt, type: Integer, base: base)
     from_bits i
   end
 
@@ -934,6 +936,48 @@ class FormatBase
     end
   end
 
+  class FltFmtConversion
+
+    def initialize(form_class, options={})
+      @form_class = form_class
+      @input_rounding = options[:input_rounding]
+    end
+
+    def type
+      @form_class
+    end
+
+    def order_of_magnitude(value, options={})
+      num_conversions.order_of_maginitude(value.to_num, options)
+    end
+
+    def number_of_digits(value, options={})
+      num_conversions.number_of_digits(value.to_num, options)
+    end
+
+    def exact?(value, options={})
+      options[:exact]
+    end
+
+    def write(number, exact_input, output_rounding)
+      # assert_equal @form_class, number.class
+      num_conversions.write(number.to_num, exact_input, output_rounding)
+    end
+
+    def read(numeral, exact_input, approximate_simplified)
+      num = num_conversions.read(numeral, exact_input, approximate_simplified)
+      num = num.normalize(@form_class.context) if exact_input
+      @form_class.num(num)
+    end
+
+    private
+
+    def num_conversions
+      Numerals::Conversions[@form_class.context, input_rounding: @input_rounding]
+    end
+
+  end
+
   # :stopdoc:
   protected
   def self.define_fields(field_definitions)
@@ -1231,7 +1275,7 @@ class BCDFormat < DecimalFormatBase
     end
     s = sign_from_unit(s)
     m,e = neg_significand_exponent(0,m,e) if s%2==1
-    pack_fields_hash :sign=>s, :significand=>m, :exponent=>e
+    pack_fields_hash sign: s, significand: m, exponent: e
   end
   # :startdoc:
 end
@@ -1359,7 +1403,7 @@ class DPDFormat < DecimalFormatBase
         i_combination = sig_msd|(1<<4)|(exp_msb<<1)
       end
     end
-    h = {:sign=>i_sign, :combination=>i_combination, :exponent_continuation=>i_exponent_continuation, :significand_continuation=>i_significand_continuation}
+    h = {sign: i_sign, combination: i_combination, exponent_continuation: i_exponent_continuation, significand_continuation: i_significand_continuation}
     fields =  @internal_field_meaning.collect{|f| h[f]}
     Bytes.from_bitfields(@internal_field_lengths,fields,@endianness)
   end
@@ -1427,7 +1471,7 @@ class DPDFormat < DecimalFormatBase
     end
     s = sign_from_unit(s)
     m,e = neg_significand_exponent(0,m,e) if s%2==1
-    pack_fields_hash :sign=>s, :significand=>m, :exponent=>e, :type=>t
+    pack_fields_hash sign: s, significand: m, exponent: e, type: t
   end
 
   # :startdoc:
@@ -1553,7 +1597,7 @@ class BinaryFormat < FieldsInBitsFormatBase
     end
     s = sign_from_unit(s)
     m,e = neg_significand_exponent(0,m,e) if s%2==1
-    pack_fields_hash :sign=>s, :significand=>m, :exponent=>e
+    pack_fields_hash sign: s, significand: m, exponent: e
   end
   # :startdoc:
 
@@ -1646,7 +1690,7 @@ class HexadecimalFormat < FieldsInBitsFormatBase
     end
     s = sign_from_unit(s)
     m,e = neg_significand_exponent(0,m,e) if s%2==1
-    pack_fields_hash :sign=>s, :significand=>m, :exponent=>e
+    pack_fields_hash sign: s, significand: m, exponent: e
   end
 
 
@@ -1741,7 +1785,7 @@ end
 # by adjusting the sign of the second number. This is enabled by the
 # :extra_prec option.
 # For example, the "double double" format used in PowerPC is this
-#   Flt.define :DoubleDouble, DoubleFormat, :half=>IEEE_binary64, :extra_prec=>true
+#   Flt.define :DoubleDouble, DoubleFormat, half: IEEE_binary64, extra_prec: true
 # Although this has a fixed 107 bits precision, the format as used in
 # the PowerPC can have greater precision for specific values (by having
 # greater separation between the exponents of both halves)