flt 1.3.3 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a623d39842de7043c3004b02fe86bf20b4fb6491
-  data.tar.gz: a21afce102fa26145f8f24b8661d6b9bfddb2ae4
+  metadata.gz: 58bd070debe5638c64334230eb8e5d87176001bd
+  data.tar.gz: 71adc3e996232e211bd521ee64ef14b1e6f3f100
 SHA512:
-  metadata.gz: bfe19f6b32df81f96b39d1b58b8845c402c66fc3f20b0e4e6cbc45cc4593f1d5e3d37aea6c0f3cbf02a15ef30aae75805ffefb740099fd41bc729f99f0de9bf3
-  data.tar.gz: e4077b0fdcd3ecd337af25b8fec87c47cde43003b89dff3c8621fe4f434589a0f73a726aa32389e40251b47c714db07f94d6845de62bc550cdc9f441a85d1321
+  metadata.gz: 19c292ce44adafdf320693681e5e563cf5a73763941ca3de66cf6de654ad50db9b2f69409acb91f78ae1a18f6509399331fd0bf742da51acf28ddc79115c639d
+  data.tar.gz: 6c060e62ce10a9489bfae7d7cb5105845bdc4ff04cfc0e790e64962315690707a3efd8a4b831d63cc2bffc680587315ebb0a72c6643d5f0f191e189e490d31e8

data/History.txt

@@ -1,3 +1,12 @@
+== 1.3.4 2014-10-27
+
+* New features
+  - Context methods necessary_digits and representable_digits
+  - Assign :exact as the precision value to define an :exact context
+  - Constructors for nan, infinite, zero replicated in context
+  - Hexadecimal (%A) representation of binary floating point numbers
+  - Support.adjust_digits (to be used in Numerals gem)
+
 == 1.3.3 2014-10-13
 
   Formatter has a new raise_on_repeat options

data/lib/flt/float.rb

@@ -127,6 +127,10 @@ class Flt::FloatContext
     (sign < 0) ? -1.0/0.0 : 1.0/0.0 # Ruby 1.9.2: (sing < 0) ? -Float::INFINITY : Float::INFINITY
   end
 
+  def one_half
+    0.5
+  end
+
   def int_radix_power(n)
     1 << n
   end
@@ -475,6 +479,25 @@ class Flt::FloatContext
     end
   end
 
+  def representable_digits(b)
+    if b == 10
+      Float::DIG
+    elsif b == radix
+      precision
+    else
+     ((precision-1)*log(radix, b)).floor
+    end
+  end
+
+  def necessary_digits(b)
+    if b == 10
+      Float::DECIMAL_DIG
+    elsif b == radix
+      precision
+    else
+     (precision*log(radix, b)).ceil + 1
+    end
+  end
 
 end
 

data/lib/flt/num.rb

@@ -580,7 +580,7 @@ class Num < Numeric
     # If 0 is set the precision turns to be exact.
     def precision=(n)
       @precision = n
-      @exact = false unless n==0
+      @exact = false
       update_precision
       n
     end
@@ -624,9 +624,12 @@ class Num < Numeric
         @clamp = options[:clamp ] unless options[:clamp ].nil?
         @exact = options[:exact ] unless options[:exact ].nil?
         @angle = options[:angle ] unless options[:angle ].nil?
-        @precision += options[:extra_precision] unless options[:extra_precision].nil?
         update_precision
+        if options[:extra_precision] && !@exact
+          @precision += options[:extra_precision]
+        end
       end
+      self
     end
 
     attr_reader :coercible_type_handlers, :conversions
@@ -1148,6 +1151,56 @@ class Num < Numeric
       _convert(x).zero?
     end
 
+    # Maximum number of base b digits that can be stored in a context floating point number
+    # and then preserved when converted back to base b.
+    #
+    # To store a base b number in a floating point number and be able to get then back exactly
+    # the number cannot have more than these significant digits.
+    def representable_digits(b)
+      unless exact?
+        if b == radix
+          precision
+        else
+          ((precision-1)*log(radix, b)).floor
+        end
+      end
+    end
+
+    # Mininum number of base b digits necessary to store any context floating point number
+    # while being able to convert the digits back to the same exact context floating point number
+    #
+    # To convert any floating point number to base b and be able to round the result back to
+    # the same floating point number, at least this many base b digits are needed.
+    def necessary_digits(b)
+      unless exact?
+        if b == radix
+          precision
+        else
+          (precision*log(radix, b)).ceil + 1
+        end
+      end
+    end
+
+    # A floating-point number with value zero and the specified sign
+    def zero(sign = +1)
+      num_class.zero(sign)
+    end
+
+    # A floating-point infinite number with the specified sign
+    def infinity(sign = +1)
+      num_class.infinity(sign)
+    end
+
+    # A floating-point NaN (not a number)
+    def nan
+      num_class.nan
+    end
+
+    # One half: 1/2
+    def one_half
+      num_class.one_half
+    end
+
     private
 
     def _convert(x)
@@ -1164,13 +1217,14 @@ class Num < Numeric
       elsif @emin && !@emax
         @emax = 1 - @emin
       end
-      if @exact || @precision==0
+      if @exact || @precision == 0 || @precision == :exact
         quiet = (@exact == :quiet)
         @exact = true
         @precision = 0
         @traps << Inexact unless quiet
         @ignored_flags[Inexact] = false
       else
+        @exact = false
         @traps[Inexact] = false
       end
     end
@@ -1398,7 +1452,7 @@ class Num < Numeric
               options.delete(:exponent) || 0]
     end
     mode ||= options && options.delete(:mode)
-    base = (options && options.delete(:base)) || 10
+    base = (options && options.delete(:base))
     context = options if context.nil? && options && !options.empty?
     context = define_context(context)
 
@@ -1434,7 +1488,7 @@ class Num < Numeric
           @sign,@coeff,@exp = context.exception(ConversionSyntax, "no trailing or leading whitespace is permitted").split
           return
         end
-        m = _parser(arg)
+        m = _parser(arg, base: base)
         if m.nil?
           @sign,@coeff,@exp = context.exception(ConversionSyntax, "Invalid literal for DecNum: #{arg.inspect}").split
           return
@@ -1449,12 +1503,18 @@ class Num < Numeric
             intpart = ''
             fracpart = m.onlyfrac
           end
+          fracpart ||= ''
+          base = m.base
           exp = m.exp.to_i
-          if fracpart
-            coeff = (intpart+fracpart).to_i(base)
-            exp -= fracpart.size
+          coeff = (intpart+fracpart).to_i(base)
+          if m.exp_base && m.exp_base != base
+            # The exponent uses a different base;
+            # compute exponent in base; assume base = exp_base**k
+            k = Math.log(base, m.exp_base).round
+            exp -= fracpart.size*k
+            base = m.exp_base
           else
-            coeff = intpart.to_i(base)
+            exp -= fracpart.size
           end
 
           if false
@@ -3656,14 +3716,27 @@ class Num < Numeric
   # If it is not passed and :all_digits is true, then :rounding or the context rounding mode
   # will be used.
   #
-  # Note that when :base=>10 (the default) we're regarding the binary number x
+  # Note that when :base is different from the floating point radix,
+  # we're regarding the floating point number x
   # as an approximation with x.number_of_digits precision and showing that
   # inexact value in decimal without introducing additional precision.
-  # If the exact value of the number expressed in decimal is desired (we consider
+  #
+  # If the exact value of the number expressed in other base is desired (we consider
   # the Flt an exact number), this can be done with Num.convert_exact.
+  #
+  # The :hex_bin option produces the %A/%a format of printf, which sho2 the significand
+  # as an hexadecimal number and the binary exponent in decimal.
+  #
   def format(num_context, options={})
     # TODO: support options (base, all_digits, any_rounding, eng) and context options in the same hash
     output_radix = options[:base] || 10
+    output_exp_radix = options[:exp_base]
+    if output_radix == :hex_bin
+      output_radix = 16
+      output_exp_radix = 2
+      first_digit_1 = true
+    end
+    output_exp_radix ||= output_radix
     rounding = options[:rounding]
     all_digits = options[:all_digits]
     eng = options[:eng]
@@ -3686,12 +3759,40 @@ class Num < Numeric
     rounding ||= context.rounding
     output_rounding ||= rounding
 
-    if output_radix == num_class.radix && !all_digits
+    if output_radix != output_exp_radix
+      k = Math.log(output_radix, output_exp_radix).round
+      if output_radix != output_exp_radix**k
+        raise "When different bases are used for the coefficient and exponent, the first must be a power of the second"
+      end
+    end
+
+    if output_exp_radix == num_class.radix && !all_digits && output_radix != output_exp_radix
+      if first_digit_1
+        # make the first digit a 1
+        c = @coeff
+        exp = integral_exponent
+        nb = _nbits(c)
+        r = (nb % k)
+        d = (k + 1 - r) % k
+        if d != 0
+          c <<= d
+          exp -= d
+        end
+      else
+        c = @coeff
+        exp = integral_exponent
+      end
+      ds = c.to_s(output_radix)
+      n_ds = ds.size
+      leftdigits = exp + n_ds
+      exp_radix = num_class.radix
+    elsif output_radix == num_class.radix && !all_digits && output_radix == output_exp_radix
       # show exactly inner representation and precision
       ds = @coeff.to_s(output_radix)
       n_ds = ds.size
       exp = integral_exponent
       leftdigits = exp + n_ds
+      exp_radix = num_class.radix
     else
       p = self.number_of_digits # context.precision
       formatter = Flt::Support::Formatter.new(num_class.radix, context.etiny, output_radix)
@@ -3702,17 +3803,51 @@ class Num < Numeric
       n_ds = ds.size
       exp = dec_pos - n_ds
       leftdigits = dec_pos
+      exp_radix = output_radix
     end
 
-    # TODO: DRY (this code is duplicated in num_class#format)
-    if exp<=0 && leftdigits>-6
-      dotplace = leftdigits
-    elsif !eng
-      dotplace = 1
-    elsif @coeff==0
-      dotplace = (leftdigits+1)%3 - 1
+    # TODO: this doesn't need to be so ugly...
+    if output_exp_radix == 2 && output_radix == 16
+      a_format = true
+      digits_prefix = "0x"
+      exp_letter = (context.capitals ? 'P' : 'p')
+      show_exp = true
+    else
+      a_format = false
+      digits_prefix = ""
+      exp_letter = (context.capitals ? 'E' : 'e')
+      show_exp = false
+    end
+
+    if output_exp_radix != exp_radix
+      # k = Math.log(exp_radix, output_exp_radix).round
+      if leftdigits != 1
+        exp += (ds.size - 1)
+        leftdigits = 1
+        dotplace = 1
+      end
+      exp *= k
+    elsif a_format
+      # k = Math.log(output_radix, output_exp_radix).round
+      if leftdigits != 1
+        exp += (ds.size - 1)*4
+        leftdigits = 1
+        dotplace = 1
+        ds = ds[0...-1] while ds[-1,1] == '0' && ds.size>1
+        n_ds = ds.size
+      end
     else
-      dotplace = (leftdigits-1)%3 + 1
+      # TODO: DRY (this code is duplicated in num_class#format)
+      if exp<=0 && leftdigits>-6
+        dotplace = leftdigits
+      elsif !eng
+        dotplace = 1
+      elsif @coeff==0
+        dotplace = (leftdigits+1)%3 - 1
+      else
+        dotplace = (leftdigits-1)%3 + 1
+      end
+      exp = leftdigits-dotplace
     end
 
     if dotplace <=0
@@ -3726,14 +3861,13 @@ class Num < Numeric
       fracpart = '.' + ds[dotplace..-1]
     end
 
-    if leftdigits == dotplace
+    if exp == 0 && !show_exp
       e = ''
     else
-      e = (context.capitals ? 'E' : 'e') + "%+d"%(leftdigits-dotplace)
+      e = exp_letter + "%+d"%(exp)
     end
 
-    sgn + intpart + fracpart + e
-
+    sgn + digits_prefix + intpart + fracpart + e
   end
 
   # Auxiliar Methods
@@ -4017,11 +4151,20 @@ class Num < Numeric
     end
 
     # Parse numeric text literals (internal use)
-    def _parser(txt)
+    def _parser(txt, options={})
+      base = options[:base]
       md = /^\s*([-+])?(?:(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:E([-+]?\d+))?|Inf(?:inity)?|(s)?NaN(\d*))\s*$/i.match(txt)
       if md
+        base ||= 10
         OpenStruct.new :sign=>md[1], :int=>md[2], :frac=>md[3], :onlyfrac=>md[4], :exp=>md[5],
-                       :signal=>md[6], :diag=>md[7]
+                       :signal=>md[6], :diag=>md[7], :base=>base
+      else
+        md = /^\s*([-+])?0x(?:(?:([\da-f]+)(?:\.([\da-f]*))?|\.([\da-f]+))(?:P([-+]?\d+))?)\s*$/i.match(txt)
+        if md
+          base = 16
+          OpenStruct.new :sign=>md[1], :int=>md[2], :frac=>md[3], :onlyfrac=>md[4], :exp=>md[5],
+                         :signal=>nil, :diag=>nil, :base=>base, :exp_base=>2
+        end
       end
     end
 

data/lib/flt/support.rb

@@ -357,6 +357,51 @@ module Flt
       round_mode
     end
 
+    # Adjust truncated digits based on the rounding mode (:round_mode option)
+    # and on the information about the following digits contained in the :round_up
+    # parameter (nil for only zeros, :lo for nonzero values below tie, :tie for a :tie
+    # and :hi for nonzero digits over the tie). Other parameters: :negative to consider
+    # the number negative, :base the base of the number.
+    def adjust_digits(dec_pos, digits, options={})
+      round_mode = options[:round_mode]
+      negative   = options[:negative]
+      round_up   = options[:round_up]
+      base       = options[:base]
+      round_mode = simplified_round_mode(round_mode, negative)
+
+      increment = (round_up && (round_mode != :down)) &&
+                    ((round_mode == :up) ||
+                     (round_up == :hi) ||
+                     ((round_up == :tie) &&
+                      ((round_mode==:half_up) ||
+                       ((round_mode==:half_even) && ((digits.last % 2)==1)))))
+
+      if increment
+        digits = digits.dup
+        # carry = increment ? 1 : 0
+        # digits = digits.reverse.map{|d| d += carry; d>=base ? 0 : (carry=0;d)}.reverse
+        # if carry != 0
+        #   digits.unshift carry
+        #   dec_pos += 1
+        # end
+        i = digits.size - 1
+        while i>=0
+          digits[i] += 1
+          if digits[i] == base
+            digits[i] = 0
+          else
+            break
+          end
+          i -= 1
+        end
+        if i<0
+          dec_pos += 1
+          digits.unshift 1
+        end
+      end
+      [dec_pos, digits]
+    end
+
     # Floating-point reading and printing (from/to text literals).
     #
     # Here are methods for floating-point reading, using algorithms by William D. Clinger, and
@@ -1009,47 +1054,14 @@ module Flt
 
       attr_reader :round_up, :repeat
 
-
       # Access rounded result of format operation: scaling (position of radix point) and digits
       def adjusted_digits(round_mode)
-        round_mode = Support.simplified_round_mode(round_mode, @minus)
         if @adjusted_digits.nil? && !@digits.nil?
-          increment = (@round_up && (round_mode != :down)) &&
-                      ((round_mode == :up) ||
-                      (@round_up == :hi) ||
-                      ((@round_up == :tie) &&
-                       ((round_mode==:half_up) || ((round_mode==:half_even) && ((@digits.last % 2)==1)))))
-          # increment = (@round_up == :tie) || (@round_up == :hi) # old behaviour (:half_up)
-          if increment
-            base = @output_b
-            dec_pos = @k
-            digits = @digits.dup
-            # carry = increment ? 1 : 0
-            # digits = digits.reverse.map{|d| d += carry; d>=base ? 0 : (carry=0;d)}.reverse
-            # if carry != 0
-            #   digits.unshift carry
-            #   dec_pos += 1
-            # end
-            i = digits.size - 1
-            while i>=0
-              digits[i] += 1
-              if digits[i] == base
-                digits[i] = 0
-              else
-                break
-              end
-              i -= 1
-            end
-            if i<0
-              dec_pos += 1
-              digits.unshift 1
-            end
-            @adjusted_k = dec_pos
-            @adjusted_digits = digits
-          else
-            @adjusted_k = @k
-            @adjusted_digits = @digits
-          end
+          @adjusted_k, @adjusted_digits = Support.adjust_digits(@k, @digits,
+                                                                :round_mode => round_mode,
+                                                                :negative => @minus,
+                                                                :round_up => @round_up,
+                                                                :base => @output_b)
         end
         return @adjusted_k, @adjusted_digits
       end

data/lib/flt/version.rb

@@ -1,3 +1,3 @@
 module Flt
-  VERSION = "1.3.3"
+  VERSION = "1.3.4"
 end

data/test/test_base_digits.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+class TestBaseDigits < Test::Unit::TestCase
+
+
+  def test_number_of_digits_in_other_base
+
+    assert_equal Float::DIG, Float.context.representable_digits(10)
+    assert_equal Float::DECIMAL_DIG, Float.context.necessary_digits(10)
+
+    if defined?(BinNum::FloatContext)
+      assert_equal Float::DIG, BinNum::FloatContext.representable_digits(10)
+      assert_equal Float::DECIMAL_DIG, BinNum::FloatContext.necessary_digits(10)
+    end
+
+    assert_equal  6, BinNum::IEEESingleContext.representable_digits(10)
+    assert_equal  9, BinNum::IEEESingleContext.necessary_digits(10)
+
+    assert_equal 15, BinNum::IEEEDoubleContext.representable_digits(10)
+    assert_equal 17, BinNum::IEEEDoubleContext.necessary_digits(10)
+
+    assert_equal 18, BinNum::IEEEExtendedContext.representable_digits(10)
+    assert_equal 21, BinNum::IEEEExtendedContext.necessary_digits(10)
+
+
+    [10,15,20,100].each do |precision|
+      DecNum.context(precision: precision) do
+        assert_equal precision, DecNum.context.representable_digits(10)
+        assert_equal precision, DecNum.context.necessary_digits(10)
+      end
+
+      BinNum.context(precision: precision) do
+        assert_equal precision, BinNum.context.representable_digits(2)
+        assert_equal precision, BinNum.context.necessary_digits(2)
+      end
+    end
+
+    DecNum.context(exact: true) do
+      assert_nil DecNum.context.representable_digits(10)
+      assert_nil DecNum.context.necessary_digits(10)
+      assert_nil DecNum.context.representable_digits(2)
+      assert_nil DecNum.context.necessary_digits(2)
+    end
+
+    BinNum.context(exact: true) do
+      assert_nil BinNum.context.representable_digits(10)
+      assert_nil BinNum.context.necessary_digits(10)
+      assert_nil BinNum.context.representable_digits(2)
+      assert_nil BinNum.context.necessary_digits(2)
+    end
+
+  end
+
+end

data/test/test_basic.rb

@@ -381,6 +381,26 @@ class TestBasic < Test::Unit::TestCase
     assert_equal(-1, neg.sign)
   end
 
+  def test_special_constructors
+    [DecNum, BinNum, Float].each do |num_class|
+      context = num_class.context
+      assert context.nan.nan?
+      assert context.zero.zero?
+      assert_equal +1, context.sign(context.zero)
+      assert context.zero(+1).zero?
+      assert_equal +1, context.sign(context.zero(+1))
+      assert context.zero(-1).zero?
+      assert_equal -1, context.sign(context.zero(-1))
+      assert context.infinity.infinite?
+      assert_equal +1, context.sign(context.infinity)
+      assert context.infinity(+1).infinite?
+      assert_equal +1, context.sign(context.infinity(+1))
+      assert context.infinity(-1).infinite?
+      assert_equal -1, context.sign(context.infinity(-1))
+      assert_equal context.Num(1)/2, context.one_half
+    end
+  end
+
   def test_context_parameters
     #DecNum.context = DecNum.Context
     DecNum.context.precision = 3

data/test/test_exact.rb

@@ -144,4 +144,22 @@ class TestExact < Test::Unit::TestCase
 
   end
 
+  def test_exact_precision
+    DecNum.context.precision = 10
+    refute DecNum.context.exact?
+    assert_equal 10, DecNum.context.precision
+    DecNum.context(exact: true) do
+      assert DecNum.context.exact?
+      assert_equal 0, DecNum.context.precision
+    end
+    refute DecNum.context.exact?
+    assert_equal 10, DecNum.context.precision
+    DecNum.context(precision: :exact) do
+      assert DecNum.context.exact?
+      assert_equal 0, DecNum.context.precision
+    end
+    refute DecNum.context.exact?
+    assert_equal 10, DecNum.context.precision
+  end
+
 end

data/test/test_hex_format.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestHexFormat< Test::Unit::TestCase
+
+  def setup
+    @hex_test_data = [0.1, 1.0/3, 0.1e10, 1e10/3.0, 0.1e-10, 1e-10/3.0, 123456.789,
+        -0.1, -1.0/3, -0.1e10, -1e10/3.0, -0.1e-10, -1e-10/3.0, -123456.789,
+        Float::MAX, -Float::MIN, Float::MIN_D, Float::MAX_D, Float::MIN_D,
+        -Float::MIN_D, -Float::MAX_D, -Float::MIN_D,
+        Float.context.next_plus(0.1), Float.context.next_minus(0.1),
+        -Float.context.next_plus(0.1), -Float.context.next_minus(0.1),
+        0.5, Float.context.next_plus(0.5), Float.context.next_minus(0.5),
+        -0.5, -Float.context.next_plus(0.5), -Float.context.next_minus(0.5),
+        1E22, -1E22, 64.1, -64.1]
+  end
+
+  def test_hex_input
+    if RUBY_VERSION >= "1.9.2" # luckily there's no 1.9.10!
+      BinNum.context(BinNum::FloatContext) do
+        @hex_test_data.each do |number|
+          hex_upcase = "%A" % number
+          hex_downcase = "%a" % number
+          assert_equal number, BinNum(hex_upcase).to_f, "Read #{hex_upcase} (number)"
+          assert_equal number, BinNum(hex_downcase).to_f, "Read #{hex_downcase} (number)"
+        end
+      end
+    end
+  end
+
+  def test_hex_output
+    if RUBY_VERSION >= "1.9.2" # luckily there's no 1.9.10!
+      BinNum.context(BinNum::FloatContext) do
+        @hex_test_data.each do |number|
+          hex_upcase = "%A" % number
+          number = BinNum(number)
+          # text = number.to_s(:base => :hex_bin, :all_digits => false,  :output_rounding => BinNum.context.rounding)
+          text = number.to_s(:base => :hex_bin, :all_digits => false,  :output_rounding => nil)
+          assert_equal hex_upcase, text.upcase, "Write #{hex_upcase} (number)"
+        end
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flt
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.4
 platform: ruby
 authors:
 - Javier Goizueta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-13 00:00:00.000000000 Z
+date: 2014-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - test/generate_trig_data.rb
 - test/helper.rb
 - test/reader.rb
+- test/test_base_digits.rb
 - test/test_basic.rb
 - test/test_bin.rb
 - test/test_bin_arithmetic.rb
@@ -88,6 +89,7 @@ files:
 - test/test_exact.rb
 - test/test_flags.rb
 - test/test_formatter.rb
+- test/test_hex_format.rb
 - test/test_multithreading.rb
 - test/test_num_constructor.rb
 - test/test_odd_even.rb
@@ -127,6 +129,7 @@ test_files:
 - test/generate_trig_data.rb
 - test/helper.rb
 - test/reader.rb
+- test/test_base_digits.rb
 - test/test_basic.rb
 - test/test_bin.rb
 - test/test_bin_arithmetic.rb
@@ -139,6 +142,7 @@ test_files:
 - test/test_exact.rb
 - test/test_flags.rb
 - test/test_formatter.rb
+- test/test_hex_format.rb
 - test/test_multithreading.rb
 - test/test_num_constructor.rb
 - test/test_odd_even.rb