bigdecimal 3.2.3 → 4.1.1

data/lib/bigdecimal/newton.rb

@@ -2,6 +2,8 @@
 require "bigdecimal/ludcmp"
 require "bigdecimal/jacobian"
 
+warn "'bigdecimal/newton' is deprecated and will be removed in a future release."
+
 #
 # newton.rb
 #

data/lib/bigdecimal/util.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 #
 #--
 # bigdecimal/util extends various native classes to provide the #to_d method,
@@ -119,8 +119,11 @@ class Rational < Numeric
   #
   # Returns the value as a BigDecimal.
   #
-  # The required +precision+ parameter is used to determine the number of
-  # significant digits for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
@@ -129,7 +132,7 @@ class Rational < Numeric
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(precision)
+  def to_d(precision=0)
     BigDecimal(self, precision)
   end
 end
@@ -141,29 +144,27 @@ class Complex < Numeric
   #     cmp.to_d(precision)  -> bigdecimal
   #
   # Returns the value as a BigDecimal.
+  # If the imaginary part is not +0+, an error is raised
   #
-  # The +precision+ parameter is required for a rational complex number.
-  # This parameter is used to determine the number of significant digits
-  # for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
   #
   #     Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
   #     Complex(Rational(22, 7), 0).to_d(3)   # => 0.314e1
+  #     Complex(1, 1).to_d   # raises ArgumentError
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(*args)
+  def to_d(precision=0)
     BigDecimal(self) unless self.imag.zero? # to raise error
 
-    if args.length == 0
-      case self.real
-      when Rational
-        BigDecimal(self.real) # to raise error
-      end
-    end
-    self.real.to_d(*args)
+    BigDecimal(self.real, precision)
   end
 end
 

data/lib/bigdecimal.rb

@@ -1,12 +1,20 @@
 if RUBY_ENGINE == 'jruby'
   JRuby::Util.load_ext("org.jruby.ext.bigdecimal.BigDecimalLibrary")
-  return
+
+  class BigDecimal
+    def _decimal_shift(i) # :nodoc:
+      to_java.move_point_right(i).to_d
+    end
+  end
 else
   require 'bigdecimal.so'
 end
 
 class BigDecimal
   module Internal # :nodoc:
+    # Default extra precision for intermediate calculations
+    # This value is currently the same as BigDecimal.double_fig, but defined separately for future changes.
+    EXTRA_PREC = 16
 
     # Coerce x to BigDecimal with the specified precision.
     # TODO: some methods (example: BigMath.exp) require more precision than specified to coerce.
@@ -15,20 +23,31 @@ class BigDecimal
       when BigDecimal
         return x
       when Integer, Float
-        return BigDecimal(x)
+        return BigDecimal(x, 0)
       when Rational
         return BigDecimal(x, [prec, 2 * BigDecimal.double_fig].max)
       end
       raise ArgumentError, "#{x.inspect} can't be coerced into BigDecimal"
     end
 
-    def self.validate_prec(prec, method_name, accept_zero: false) # :nodoc:
-      raise ArgumentError, 'precision must be an Integer' unless Integer === prec
+    def self.coerce_validate_prec(prec, method_name, accept_zero: false) # :nodoc:
+      unless Integer === prec
+        original = prec
+        # Emulate Integer.try_convert for ruby < 3.1
+        if prec.respond_to?(:to_int)
+          prec = prec.to_int
+        else
+          raise TypeError, "no implicit conversion of #{original.class} into Integer"
+        end
+        raise TypeError, "can't convert #{original.class} to Integer" unless Integer === prec
+      end
+
       if accept_zero
         raise ArgumentError, "Negative precision for #{method_name}" if prec < 0
       else
         raise ArgumentError, "Zero or negative precision for #{method_name}" if prec <= 0
       end
+      prec
     end
 
     def self.infinity_computation_result # :nodoc:
@@ -44,6 +63,55 @@ class BigDecimal
       end
       BigDecimal::NAN
     end
+
+    # Iteration for Newton's method with increasing precision
+    def self.newton_loop(prec, initial_precision: BigDecimal.double_fig / 2, safe_margin: 2) # :nodoc:
+      precs = []
+      while prec > initial_precision
+        precs << prec
+        prec = (precs.last + 1) / 2 + safe_margin
+      end
+      precs.reverse_each do |p|
+        yield p
+      end
+    end
+
+    # Fast and rough conversion to float for mathematical calculations.
+    # Bigdecimal#to_f is slow when n_significant_digits is large.
+    # This is because to_f internally converts BigDecimal to String
+    # to get the exact nearest float representation.
+    # TODO: Remove this workaround when BigDecimal#to_f is optimized.
+    def self.fast_to_f(x) # :nodoc:
+      x.n_significant_digits < 40 ? x.to_f : x.mult(1, 20).to_f
+    end
+
+    # Calculates Math.log(x.to_f) considering large or small exponent
+    def self.float_log(x) # :nodoc:
+      Math.log(fast_to_f(x._decimal_shift(-x.exponent))) + x.exponent * Math.log(10)
+    end
+
+    # Calculating Taylor series sum using binary splitting method
+    # Calculates f(x) = (x/d0)*(1+(x/d1)*(1+(x/d2)*(1+(x/d3)*(1+...))))
+    # x.n_significant_digits or ds.size must be small to be performant.
+    def self.taylor_sum_binary_splitting(x, ds, prec) # :nodoc:
+      fs = ds.map {|d| [0, BigDecimal(d)] }
+      # fs = [[a0, a1], [b0, b1], [c0, c1], ...]
+      # f(x) = a0/a1+(x/a1)*(1+b0/b1+(x/b1)*(1+c0/c1+(x/c1)*(1+d0/d1+(x/d1)*(1+...))))
+      while fs.size > 1
+        # Merge two adjacent fractions
+        # from: (1 + a0/a1 + x/a1 * (1 + b0/b1 + x/b1 * rest))
+        # to:   (1 + (a0*b1+x*(b0+b1))/(a1*b1) + (x*x)/(a1*b1) * rest)
+        xn = xn ? xn.mult(xn, prec) : x
+        fs = fs.each_slice(2).map do |(a, b)|
+          b ||= [0, BigDecimal(1)._decimal_shift([xn.exponent, 0].max + 2)]
+          [
+            (a[0] * b[1]).add(xn * (b[0] + b[1]), prec),
+            a[1].mult(b[1], prec)
+          ]
+        end
+      end
+      BigDecimal(fs[0][0]).div(fs[0][1], prec)
+    end
   end
 
   #  call-seq:
@@ -78,10 +146,10 @@ class BigDecimal
   #
   # Also available as the operator **.
   #
-  def power(y, prec = nil)
-    Internal.validate_prec(prec, :power) if prec
+  def power(y, prec = 0)
+    prec = Internal.coerce_validate_prec(prec, :power, accept_zero: true)
     x = self
-    y = Internal.coerce_to_bigdecimal(y, prec || n_significant_digits, :power)
+    y = Internal.coerce_to_bigdecimal(y, prec.nonzero? || n_significant_digits, :power)
 
     return Internal.nan_computation_result if x.nan? || y.nan?
     return BigDecimal(1) if y.zero?
@@ -128,10 +196,10 @@ class BigDecimal
       return BigDecimal(1)
     end
 
-    prec ||= BigDecimal.limit.nonzero?
+    limit = BigDecimal.limit
     frac_part = y.frac
 
-    if frac_part.zero? && !prec
+    if frac_part.zero? && prec.zero? && limit.zero?
       # Infinite precision calculation for `x ** int` and `x.power(int)`
       int_part = y.fix.to_i
       int_part = -int_part if (neg = int_part < 0)
@@ -151,31 +219,42 @@ class BigDecimal
       return neg ? BigDecimal(1) / ans : ans
     end
 
-    prec ||= [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    result_prec = prec.nonzero? || [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    result_prec = [result_prec, limit].min if prec.zero? && limit.nonzero?
+
+    prec2 = result_prec + BigDecimal::Internal::EXTRA_PREC
 
     if y < 0
-      inv = x.power(-y, prec)
+      inv = x.power(-y, prec2)
       return BigDecimal(0) if inv.infinite?
       return BigDecimal::Internal.infinity_computation_result if inv.zero?
-      return BigDecimal(1).div(inv, prec)
+      return BigDecimal(1).div(inv, result_prec)
     end
 
-    int_part = y.fix.to_i
-    prec2 = prec + BigDecimal.double_fig
-    pow_prec = prec2 + (int_part > 0 ? y.exponent : 0)
-    ans = BigDecimal(1)
-    n = 1
-    xn = x
-    while true
-      ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
-      n <<= 1
-      break if n > int_part
-      xn = xn.mult(xn, pow_prec)
-    end
-    unless frac_part.zero?
-      ans = ans.mult(BigMath.exp(BigMath.log(x, prec2).mult(frac_part, prec2), prec2), prec2)
+    if frac_part.zero? && y.exponent < Math.log(result_prec) * 5 + 20
+      # Use exponentiation by squaring if y is an integer and not too large
+      pow_prec = prec2 + y.exponent
+      n = 1
+      xn = x
+      ans = BigDecimal(1)
+      int_part = y.fix.to_i
+      while true
+        ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
+        n <<= 1
+        break if n > int_part
+        xn = xn.mult(xn, pow_prec)
+      end
+      ans.mult(1, result_prec)
+    else
+      if x > 1 && x.finite?
+        # To calculate exp(z, prec), z needs prec+max(z.exponent, 0) precision if z > 0.
+        # Estimate (y*log(x)).exponent
+        logx_exponent = x < 2 ? (x - 1).exponent : Math.log10(x.exponent).round
+        ylogx_exponent = y.exponent + logx_exponent
+        prec2 += [ylogx_exponent, 0].max
+      end
+      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), result_prec)
     end
-    ans.mult(1, prec)
   end
 
   # Returns the square root of the value.
@@ -183,36 +262,33 @@ class BigDecimal
   # Result has at least prec significant digits.
   #
   def sqrt(prec)
-    Internal.validate_prec(prec, :sqrt, accept_zero: true)
+    prec = Internal.coerce_validate_prec(prec, :sqrt, accept_zero: true)
     return Internal.infinity_computation_result if infinite? == 1
 
     raise FloatDomainError, 'sqrt of negative value' if self < 0
     raise FloatDomainError, "sqrt of 'NaN'(Not a Number)" if nan?
     return self if zero?
 
-    limit = BigDecimal.limit.nonzero? if prec == 0
-
-    # BigDecimal#sqrt calculates at least n_significant_digits precision.
-    # This feature maybe problematic for some cases.
-    n_digits = n_significant_digits
-    prec = [prec, n_digits].max
+    if prec == 0
+      limit = BigDecimal.limit
+      prec = n_significant_digits + BigDecimal.double_fig
+      prec = [limit, prec].min if limit.nonzero?
+    end
 
     ex = exponent / 2
     x = _decimal_shift(-2 * ex)
-    y = BigDecimal(Math.sqrt(x.to_f))
-    precs = [prec + BigDecimal.double_fig]
-    precs << 2 + precs.last / 2 while precs.last > BigDecimal.double_fig
-    precs.reverse_each do |p|
+    y = BigDecimal(Math.sqrt(BigDecimal::Internal.fast_to_f(x)), 0)
+    Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
       y = y.add(x.div(y, p), p).div(2, p)
     end
-    y = y.mult(1, limit) if limit
-    y._decimal_shift(ex)
+    y._decimal_shift(ex).mult(1, prec)
   end
 end
 
 # Core BigMath methods for BigDecimal (log, exp) are defined here.
 # Other methods (sin, cos, atan) are defined in 'bigdecimal/math.rb'.
 module BigMath
+  module_function
 
   # call-seq:
   #   BigMath.log(decimal, numeric)    -> BigDecimal
@@ -226,60 +302,47 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.log(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :log)
+  def log(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log)
     raise Math::DomainError, 'Complex argument for BigMath.log' if Complex === x
 
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log)
     return BigDecimal::Internal.nan_computation_result if x.nan?
-    raise Math::DomainError, 'Zero or negative argument for log' if x <= 0
+    raise Math::DomainError, 'Negative argument for log' if x < 0
+    return -BigDecimal::Internal.infinity_computation_result if x.zero?
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal(0) if x == 1
 
-    BigDecimal.save_limit do
-      BigDecimal.limit(0)
-      if x > 10 || x < 0.1
-        log10 = log(BigDecimal(10), prec)
-        exponent = x.exponent
-        x = x._decimal_shift(-exponent)
-        if x < 0.3
-          x *= 10
-          exponent -= 1
-        end
-        return log10 * exponent + log(x, prec)
-      end
-
-      x_minus_one_exponent = (x - 1).exponent
-      prec += BigDecimal.double_fig
-
-      # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
-      sqrt_steps = [Integer.sqrt(prec) + 3 * x_minus_one_exponent, 0].max
-
-      lg2 = 0.3010299956639812
-      prec2 = prec + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
-
-      sqrt_steps.times do
-        x = x.sqrt(prec2)
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
 
-        # Workaround for https://github.com/ruby/bigdecimal/issues/354
-        x = x.mult(1, prec2 + BigDecimal.double_fig)
-      end
-
-      # Taylor series for log(x) around 1
-      # log(x) = -log((1 + X) / (1 - X)) where X = (x - 1) / (x + 1)
-      # log(x) = 2 * (X + X**3 / 3 + X**5 / 5 + X**7 / 7 + ...)
-      x = (x - 1).div(x + 1, prec2)
-      y = x
-      x2 = x.mult(x, prec)
-      1.step do |i|
-        n = prec + x.exponent - y.exponent + x2.exponent
-        break if n <= 0 || x.zero?
-        x = x.mult(x2.round(n - x2.exponent), n)
-        y = y.add(x.div(2 * i + 1, n), prec)
-      end
+    # Reduce x to near 1
+    if x > 1.01 || x < 0.99
+      # log(x) = log(x/exp(logx_approx)) + logx_approx
+      logx_approx = BigDecimal(BigDecimal::Internal.float_log(x), 0)
+      x = x.div(exp(logx_approx, prec2), prec2)
+    else
+      logx_approx = BigDecimal(0)
+    end
 
-      y.mult(2 ** (sqrt_steps + 1), prec)
+    # Solve exp(y) - x = 0 with Newton's method
+    # Repeat: y -= (exp(y) - x) / exp(y)
+    y = BigDecimal(BigDecimal::Internal.float_log(x), 0)
+    exp_additional_prec = [-(x - 1).exponent, 0].max
+    BigDecimal::Internal.newton_loop(prec2) do |p|
+      expy = exp(y, p + exp_additional_prec)
+      y = y.sub(expy.sub(x, p).div(expy, p), p)
     end
+    y.add(logx_approx, prec)
+  end
+
+  private_class_method def _exp_binary_splitting(x, prec) # :nodoc:
+    return BigDecimal(1) if x.zero?
+    # Find k that satisfies x**k / k! < 10**(-prec)
+    log10 = Math.log(10)
+    logx = BigDecimal::Internal.float_log(x.abs)
+    step = (1..).bsearch { |k| Math.lgamma(k + 1)[0] - k * logx > prec * log10 }
+    # exp(x)-1 = x*(1+x/2*(1+x/3*(1+x/4*(1+x/5*(1+...)))))
+    1 + BigDecimal::Internal.taylor_sum_binary_splitting(x, [*1..step], prec)
   end
 
   # call-seq:
@@ -292,28 +355,32 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.exp(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :exp)
+  def exp(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :exp)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :exp)
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return x.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0) if x.infinite?
     return BigDecimal(1) if x.zero?
-    return BigDecimal(1).div(exp(-x, prec), prec) if x < 0
 
     # exp(x * 10**cnt) = exp(x)**(10**cnt)
-    cnt = x > 1 ? x.exponent : 0
-    prec2 = prec + BigDecimal.double_fig + cnt
+    cnt = x < -1 || x > 1 ? x.exponent : 0
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC + cnt
     x = x._decimal_shift(-cnt)
-    xn = BigDecimal(1)
-    y = BigDecimal(1)
 
-    # Taylor series for exp(x) around 0
-    1.step do |i|
-      n = prec2 + xn.exponent
-      break if n <= 0 || xn.zero?
-      x = x.mult(1, n)
-      xn = xn.mult(x, n).div(i, n)
-      y = y.add(xn, prec2)
+    # Decimal form of bit-burst algorithm
+    # Calculate exp(x.xxxxxxxxxxxxxxxx) as
+    # exp(x.xx) * exp(0.00xx) * exp(0.0000xxxx) * exp(0.00000000xxxxxxxx)
+    x = x.mult(1, prec2)
+    n = 2
+    y = BigDecimal(1)
+    BigDecimal.save_limit do
+      BigDecimal.limit(0)
+      while x != 0 do
+        partial_x = x.truncate(n)
+        x -= partial_x
+        y = y.mult(_exp_binary_splitting(partial_x, prec2), prec2)
+        n *= 2
+      end
     end
 
     # calculate exp(x * 10**cnt) from exp(x)

data/sample/linear.rb

@@ -1,6 +1,3 @@
-#!/usr/local/bin/ruby
-# frozen_string_literal: false
-
 #
 # linear.rb
 #
@@ -13,62 +10,101 @@
 
 # :stopdoc:
 require "bigdecimal"
-require "bigdecimal/ludcmp"
 
-#
-# NOTE:
-#   Change following BigDecimal.limit() if needed.
-BigDecimal.limit(100)
-#
+# Requires gem matrix
+require "matrix"
+
+class PrecisionSpecifiedValue
+  # NOTE:
+  #   Change following PREC if needed.
+
+  attr_reader :value
+  def initialize(value, prec)
+    @value = BigDecimal(value)
+    @prec = prec
+  end
+
+  def unwrap(value)
+    PrecisionSpecifiedValue === value ? value.value : value
+  end
+
+  def coerce(other)
+    [self.class.new(unwrap(other), @prec), self]
+  end
+
+  def abs
+    self.class.new(@value.abs, @prec)
+  end
+
+  def >(other)
+    @value > unwrap(other)
+  end
+
+  def <(other)
+    @value < unwrap(other)
+  end
+
+  def -(other)
+    self.class.new(@value.sub(unwrap(other), @prec), @prec)
+  end
+
+  def +(other)
+    self.class.new(@value.add(unwrap(other), @prec), @prec)
+  end
+
+  def *(other)
+    self.class.new(@value.mult(unwrap(other), @prec), @prec)
+  end
+
+  def quo(other)
+    self.class.new(@value.div(unwrap(other), @prec), @prec)
+  end
+end
+
+return if __FILE__ != $0
 
-include LUSolve
 def rd_order(na)
-   printf("Number of equations ?") if(na <= 0)
-   n = ARGF.gets().to_i
+  printf("Number of equations ?") if(na <= 0)
+  ARGF.gets().to_i
 end
 
-na   = ARGV.size
-zero = BigDecimal("0.0")
-one  = BigDecimal("1.0")
+na = ARGV.size
 
 while (n=rd_order(na))>0
   a = []
-  as= []
   b = []
   if na <= 0
      # Read data from console.
      printf("\nEnter coefficient matrix element A[i,j]\n")
      for i in 0...n do
-       for j in 0...n do
+       a << n.times.map do |j|
          printf("A[%d,%d]? ",i,j); s = ARGF.gets
-         a  << BigDecimal(s)
-         as << BigDecimal(s)
+         BigDecimal(s)
        end
        printf("Contatant vector element b[%d] ? ",i)
        b << BigDecimal(ARGF.gets)
      end
   else
-     # Read data from specified file.
-     printf("Coefficient matrix and constant vector.\n")
-     for i in 0...n do
-       s = ARGF.gets
-       printf("%d) %s",i,s)
-       s = s.split
-       for j in 0...n do
-         a  << BigDecimal(s[j])
-         as << BigDecimal(s[j])
-       end
-       b << BigDecimal(s[n])
-     end
+    # Read data from specified file.
+    printf("Coefficient matrix and constant vector.\n")
+    for i in 0...n do
+      s = ARGF.gets
+      printf("%d) %s",i,s)
+      s = s.split
+      a << n.times.map {|j| BigDecimal(s[j]) }
+      b << BigDecimal(s[n])
+    end
   end
-  x = lusolve(a,b,ludecomp(a,n,zero,one),zero)
+
+  prec = 100
+  matrix = Matrix[*a.map {|row| row.map {|v| PrecisionSpecifiedValue.new(v, prec) } }]
+  vector = b.map {|v| PrecisionSpecifiedValue.new(v, prec) }
+  x = matrix.lup.solve(vector).map(&:value)
+
   printf("Answer(x[i] & (A*x-b)[i]) follows\n")
   for i in 0...n do
      printf("x[%d]=%s ",i,x[i].to_s)
-     s = zero
-     for j in 0...n do
-       s = s + as[i*n+j]*x[j]
-     end
-     printf(" & %s\n",(s-b[i]).to_s)
+     diff = a[i].zip(x).sum {|aij, xj| aij*xj }.sub(b[i], 10)
+     printf(" & %s\n", diff.to_s)
   end
 end