flt 1.5.0 → 1.5.1

data/expand.rb

@@ -1,3 +1,5 @@
+# TODO: adapt for Github-Flavored-Markdown
+
 require 'irb/ruby-lex'
 require 'stringio'
 

data/flt.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.10"
 end

data/lib/flt.rb

@@ -6,9 +6,9 @@ require 'flt/support/flag_values'
 require 'flt/support/reader'
 require 'flt/support/formatter'
 require 'flt/support/rationalizer'
+require 'flt/num'
 require 'flt/float'
 require 'flt/bigdecimal'
-require 'flt/num'
 require 'flt/dec_num'
 require 'flt/bin_num'
 require 'flt/tolerance'

data/lib/flt/bigdecimal.rb

@@ -1,8 +1,5 @@
 # Support classes for homogeneous treatment of BigDecimal and Num values by defining BigDecimal.context
 
-require 'flt/num'
-require 'flt/dec_num'
-
 require 'bigdecimal'
 require 'bigdecimal/math'
 require 'singleton'
@@ -109,13 +106,13 @@ class Flt::BigDecimalContext
   end
 
   def split(x)
-    sgn, d, b, e = x.split
+    sgn, d, _b, e = x.split
     [sgn<0 ? -1 : +1, d.to_i, e-d.size]
   end
 
   # Return the value of the number as an signed integer and a scale.
   def to_int_scale(x)
-    sgn, d, b, e = x.split
+    sgn, d, _b, e = x.split
     c = d.to_i
     [sgn<0 ? -1 : c, -c, e-d.size]
   end

data/lib/flt/bin_num.rb

@@ -1,6 +1,3 @@
-require 'flt/num'
-require 'flt/float'
-
 module Flt
 
 class BinNum < Num
@@ -206,7 +203,7 @@ class BinNum < Num
   # Specific to_f conversion TODO: check if it represents an optimization
   if Float::RADIX==2
     def to_f
-      if special?
+      if special? || zero?
         super
       else
         ::Math.ldexp(@sign*@coeff, @exp)

data/lib/flt/complex.rb

@@ -93,9 +93,9 @@ module Flt
         define_method mth do |*args|
           is_complex = args.detect{|z| z.kind_of?(Complex)}
           if is_complex || (negative_arg_to_complex && args.first<0)
-            num_class.context(:extra_precision=>extra_prec) do |mth|
-              #Complex.rectangular *blk[mth, *args].map{|v| @context.plus(v)}
-              Complex.rectangular *instance_exec(mth,*args,&blk).map{|v| @context.plus(v)}
+            num_class.context(:extra_precision => extra_prec) do |extra_context|
+              #Complex.rectangular(*blk[extra_context, *args].map{|v| @context.plus(v)})
+              Complex.rectangular(*instance_exec(extra_context, *args, &blk).map{|v| @context.plus(v)})
             end
           else
             @context.send(mth, *args) # Num(@context.send(mth, *args)) ?
@@ -238,7 +238,7 @@ module Flt
       z_is_complex = z.kind_of?(Complex)
       if z_is_complex || z.abs>1
         # z = Complex(1) unless z_is_complex
-        i = Complex(0,@context.num_class[1])
+        # i = Complex(0, @context.num_class[1])
         fix num_class.context(:extra_precision=>3).cmath{ num_class.one_half*ln((1+z)/(1-z)) }
       else
         @context.atanh(z)
@@ -256,6 +256,7 @@ module Flt
     end
 
     def fix_polar(r, theta)
+      re = im = nil
       num_class.context(:extra_precision=>3) do |mth|
         re = r*mth.cos(theta)
         im = r*mth.sin(theta)
@@ -264,7 +265,7 @@ module Flt
     end
 
     def fix(z)
-      fix_rect *z.rectangular
+      fix_rect(*z.rectangular)
     end
 
   end # ComplexContext
@@ -280,9 +281,9 @@ module Flt
         # if ComplexContext is derived from ContextBase: return ComplexContext(self).math(*parameters, &blk)
         num_class.context(self) do
           if parameters.empty?
-            Flt.ComplexContext(num_class.context).instance_eval &blk
+            Flt.ComplexContext(num_class.context).instance_eval(&blk)
           else
-            Flt.xiComplexContext(num_class.context).instance_exec *parameters, &blk
+            Flt.xiComplexContext(num_class.context).instance_exec(*parameters, &blk)
           end
         end
       end
@@ -298,14 +299,14 @@ module Flt
   module DecNum::CMath
     include MathBase
     num_class(DecNum){num_class.ccontext}
-    math_function *Trigonometry.public_instance_methods
+    math_function(*Trigonometry.public_instance_methods)
     math_function :exp, :log, :log2, :log10, :sqrt
   end
 
   module BinNum::CMath
     include MathBase
     num_class(BinNum){num_class.ccontext}
-    math_function *Trigonometry.public_instance_methods
+    math_function(*Trigonometry.public_instance_methods)
     math_function :exp, :log, :log2, :log10, :sqrt
   end
 

data/lib/flt/dec_num.rb

@@ -1,6 +1,3 @@
-require 'flt/num'
-require 'flt/bigdecimal'
-
 module Flt
 
 # DecNum arbitrary precision floating point number.
@@ -1185,18 +1182,20 @@ class DecNum < Num
       return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3
     end
 
-    # number of bits in a nonnegative integer
+    # number of decimal digits in a nonnegative integer
     def _number_of_digits(i)
       raise  TypeError, "The argument to _number_of_digits should be nonnegative." if i < 0
-      if i.is_a?(Fixnum) || (i > NUMBER_OF_DIGITS_MAX_VALID_LOG)
-        # for short integers this is faster
-        # note that here we return 1 for 0
-        i.to_s.length
+      return 1 if i.zero?
+      nb = _nbits(i)
+      nd1 = ((nb-1)*LOG10_2).floor + 1
+      nd2 = (nb*LOG10_2).floor + 1
+      if nd1 == nd2
+        nd1
       else
-        (::Math.log10(i)+1).floor
+        i >= 10**nd1 ? nd2 : nd1
       end
     end
-    NUMBER_OF_DIGITS_MAX_VALID_LOG = 10**(Float::DIG-1)
+    LOG10_2 = Math.log10(2)
 
   end # AuxiliarFunctions
 

data/lib/flt/float.rb

@@ -2,10 +2,8 @@
 #
 # The set of constants with Float metadata is also augmented.
 
-require 'flt/num'
 require 'singleton'
 
-
 # Float constants.
 #
 # Note that this uses the "fractional significand" interpretation,
@@ -80,8 +78,8 @@ class Float
   # Minimum non zero positive denormal number == 0.0.next
   MIN_D = Math.ldexp(1,Float::MIN_EXP-Float::MANT_DIG);
 
-  # Maximum significand  == Math.ldexp(Math.ldexp(1,Float::MANT_DIG)-1,-Float::MANT_DIG)
-  MAX_F = Math.frexp(Float::MAX)[0]   == Math.ldexp(Math.ldexp(1,Float::MANT_DIG)-1,-Float::MANT_DIG)
+  # Maximum significand == Math.ldexp(Math.ldexp(1,Float::MANT_DIG)-1,-Float::MANT_DIG)
+  MAX_F = Math.frexp(Float::MAX)[0]
 
 end
 
@@ -491,10 +489,10 @@ class Flt::FloatContext
 
   def math(*parameters, &blk)
     if parameters.empty?
-      self.instance_eval &blk
+      self.instance_eval(&blk)
     else
       # needs instance_exe (available in Ruby 1.9, ActiveRecord; TODO: include implementation here)
-      self.instance_exec *parameters, &blk
+      self.instance_exec(*parameters, &blk)
     end
   end
 

data/lib/flt/math.rb

@@ -1,5 +1,4 @@
-require 'flt/dec_num'
-require 'flt/bin_num'
+require 'flt'
 require 'flt/trigonometry'
 
 module Flt
@@ -52,7 +51,7 @@ module Flt
   module DecNum::Math
     include MathBase
     num_class DecNum
-    math_function *Trigonometry.public_instance_methods
+    math_function(*Trigonometry.public_instance_methods)
     math_function :exp, :log, :log2, :log10, :sqrt
   end
 
@@ -60,7 +59,7 @@ module Flt
   module BinNum::Math
     include MathBase
     num_class BinNum
-    math_function *Trigonometry.public_instance_methods
+    math_function(*Trigonometry.public_instance_methods)
     math_function :exp, :log, :log2, :log10, :sqrt
   end
 

data/lib/flt/num.rb

@@ -18,7 +18,6 @@ require 'flt/support/reader'
 require 'flt/support/formatter'
 require 'flt/support/rationalizer'
 
-require 'bigdecimal'
 require 'forwardable'
 require 'rational'
 require 'monitor'
@@ -216,7 +215,7 @@ class Num < Numeric
   class InvalidOperation < Exception
     def self.handle(context, *args)
       if args.size>0
-        sign, coeff, exp = args.first.split
+        sign, coeff, _exp = args.first.split
         context.num_class.new([sign, coeff, :nan])._fix_nan(context)
       else
         context.num_class.nan
@@ -472,10 +471,10 @@ class Num < Numeric
       # TODO: consider renaming this to eval
       num_class.context(self) do
         if parameters.empty?
-          num_class.context.instance_eval &blk
+          num_class.context.instance_eval(&blk)
         else
           # needs instance_exe (available in Ruby 1.9, ActiveRecord; TODO: include implementation here)
-          num_class.context.instance_exec *parameters, &blk
+          num_class.context.instance_exec(*parameters, &blk)
         end
       end
     end
@@ -2418,7 +2417,7 @@ class Num < Numeric
       exp = self.exponent
       dgs = self.digits
       nd = dgs.size # self.number_of_digits
-        while dgs[nd-1]==0
+      while dgs[nd-1]==0
         exp += 1
         nd -= 1
       end
@@ -2703,10 +2702,24 @@ class Num < Numeric
       else
         0.0/0.0
       end
+    elsif zero?
+      @sign*0.0
     else
-      # to_rational.to_f
-      # to_s.to_f
-      (@sign*@coeff*(num_class.radix.to_f**@exp)).to_f
+      f = nil
+      f ||= to_s.to_f if num_class.radix == 10 # very precise, but slow
+      unless f
+        c = @coeff.to_f
+        if c.finite?
+          # This is fast to compute but may introduce roundoff error, and overflow or yield NaN
+          f = if @exp >= 0
+                @sign*c*(num_class.radix.to_f**@exp)
+              else
+                @sign*c/(num_class.radix.to_f**(-@exp))
+              end
+        end
+        f = nil unless f && f.finite?
+      end
+      f ||= to_r.to_f # not so slow, also may introduce roundoff error due to arithmetic
     end
   end
 
@@ -2884,8 +2897,14 @@ class Num < Numeric
   end
 
   # Digits of the significand as an array of integers
-  def digits
-    @coeff.to_s(num_class.radix).split('').map{|d| d.to_i} # TODO: optimize in derivided classes
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
+    def digits
+      @coeff.is_a?(Integer) ? @coeff.digits(num_class.radix).reverse! : []
+    end
+  else
+    def digits
+      @coeff.to_s(num_class.radix).split('').map{|d| d.to_i}
+    end
   end
 
   # Significand as an integer, unsigned. Synonym of coefficient
@@ -3124,21 +3143,36 @@ class Num < Numeric
   #   :power    1E3 1E2  10   1   0.1 1E-2 1E-3 1E-4
   #   :index      0   1   2   3     4    5    6    7
   #   :rindex     7   6   5   4     3    2    1    0
-  def round(opt={})
-    opt = { :places=>opt } if opt.kind_of?(Integer)
+  def round(*args)
+    # Admit first integer argument
+    places = args.shift if args.first.is_a?(Integer)
+    opt = args.shift || {}
+    raise "Invalid arguments for round"  unless args.empty?
+
+    # Support Ruby 2.4-style parameters:
+    half_rounding = opt.delete(:half)
+    case half_rounding
+    when :even
+      opt[:rounding] = :half_even
+    when :up
+      opt[:rounding] = :half_up
+    when :down
+      opt[:rounding] = :half_down
+    end
+
     r = opt[:rounding] || :half_up
     as_int = false
-    if v=(opt[:precision] || opt[:significant_digits])
+    if v = opt[:precision] || opt[:significant_digits]
       prec = v
-    elsif v=(opt[:places])
+    elsif v = opt[:places] || places
       prec = adjusted_exponent + 1 + v
-    elsif v=(opt[:exponent])
+    elsif v = opt[:exponent]
       prec = adjusted_exponent + 1 - v
-    elsif v=(opt[:power])
+    elsif v = opt[:power]
       prec = adjusted_exponent + 1 - num_class.Num(v).adjusted_exponent
-    elsif v=(opt[:index])
+    elsif v = opt[:index]
       prec = i+1
-    elsif v=(opt[:rindex])
+    elsif v = opt[:rindex]
       prec = number_of_digits - v
     else
       prec = adjusted_exponent + 1
@@ -3203,7 +3237,7 @@ class Num < Numeric
 
   # Representation as text of a number: this is an alias of Num#format
   def to_s(*args)
-    format *args
+    format(*args)
   end
 
   # Raises to the power of x, to modulo if given.
@@ -3886,7 +3920,6 @@ class Num < Numeric
     end
 
     context = define_context(num_context)
-    inexact = true
     rounding ||= context.rounding
     output_rounding ||= rounding
 
@@ -3937,7 +3970,7 @@ class Num < Numeric
       formatter.format(self, @coeff, @exp, rounding, p, all_digits)
       dec_pos,digits = formatter.adjusted_digits(output_rounding)
 
-      ds = digits.map{|d| d.to_s(output_radix)}.join
+      ds = digits.map{|digit| digit.to_s(output_radix)}.join
       n_ds = ds.size
       exp = dec_pos - n_ds
       leftdigits = dec_pos

data/lib/flt/sugar.rb

@@ -26,8 +26,7 @@
 #    puts sin(BigDecimal('0.1'), 20)
 #
 
-require 'flt/float'
-require 'flt/bigdecimal'
+require 'flt'
 require 'flt/d'
 require 'flt/b'
 

data/lib/flt/support.rb

@@ -74,7 +74,9 @@ module Flt
       # Number of bits in binary representation of the positive integer n, or 0 if n == 0.
       def _nbits(x)
         raise  TypeError, "The argument to _nbits should be nonnegative." if x < 0
-        if x.is_a?(Fixnum)
+        # Ruby 2.1 introduced Integer#bit_length
+        return x.bit_length if x.respond_to? :bit_length
+        if x <= MAXIMUM_SMALLISH_INTEGER
           return 0 if x==0
           x.to_s(2).length
         elsif x <= NBITS_LIMIT
@@ -92,13 +94,14 @@ module Flt
       end
       NBITS_BLOCK = 32
       NBITS_LIMIT = Math.ldexp(1,Float::MANT_DIG).to_i
+      MAXIMUM_SMALLISH_INTEGER = (2 << 63) - 1
 
       # Number of base b digits in an integer
       def _ndigits(x, b)
         raise  TypeError, "The argument to _ndigits should be nonnegative." if x < 0
         return 0 unless x.is_a?(Integer)
         return _nbits(x) if b==2
-        if x.is_a?(Fixnum)
+        if x <= MAXIMUM_SMALLISH_INTEGER
           return 0 if x==0
           x.to_s(b).length
         elsif x <= NDIGITS_LIMIT

data/lib/flt/support/flag_values.rb

@@ -231,7 +231,7 @@ module Flt
       end
 
       # Sets (makes true) one or more flags (passes as an array)
-      def << (flags)
+      def <<(flags)
         if flags.kind_of?(Array)
           set(*flags)
         else

data/lib/flt/support/rationalizer.rb

@@ -115,7 +115,7 @@ module Flt
       end
 
       def self.[](*args)
-        new *args
+        new(*args)
       end
 
       # Rationalization method that finds the fraction with
@@ -129,8 +129,8 @@ module Flt
 
       # This algorithm is derived from exercise 39 of 4.5.3 in
       # "The Art of Computer Programming", by Donald E. Knuth.
-      def rationalize_Knuth(x)
-        rationalization(x) do |x, dx|
+      def rationalize_Knuth(value)
+        rationalization(value) do |x, dx|
           x     = to_r(x)
           dx    = to_r(dx)
           xp,xq = num_den(x-dx)

data/lib/flt/support/rationalizer_extra.rb

@@ -47,8 +47,8 @@ module Flt
       # is the most efficient method as implemented in RPL.
       # Tony Hutchins has come up with PDR6, an improvement over PDQ2;
       # though benchmarking does not show any speed improvement under Ruby.
-      def rationalize_Horn_Hutchins(x)
-        rationalization(x) do |x, dx|
+      def rationalize_Horn_Hutchins(value)
+        rationalization(value) do |x, dx|
           a,b = num_den(dx)
           n,d = num_den(x)
           pc,ce = n,-d
@@ -76,8 +76,8 @@ module Flt
       # less accurate. We can achieve perfect accuracy as the other methods by doing the
       # substraction and addition with rationals, but then this method becomes less efficient than
       # the others for a low number of iterations (low precision required).
-      def rationalize_Knuth_Goizueta(x)
-        rationalization(x) do |x, dx|
+      def rationalize_Knuth_Goizueta(value)
+        rationalization(value) do |x, dx|
           x = to_r(x)
           dx = to_r(dx)
           xp,xq = num_den(x-dx)
@@ -110,8 +110,8 @@ module Flt
 
       # La siguiente variante realiza una iteración menos si xq<xp y una iteración más
       # si xq>xp.
-      def rationalize_Knuth_Goizueta_b(x)
-        rationalization(x) do |x, dx|
+      def rationalize_Knuth_Goizueta_b(value)
+        rationalization(value) do |x, dx|
           x = to_r(x)
           dx = to_r(dx)
           xq,xp = num_den(x-dx)