bigdecimal 3.3.1 → 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,

data/lib/bigdecimal.rb

@@ -12,6 +12,9 @@ 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.
@@ -60,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:
@@ -144,10 +196,10 @@ class BigDecimal
       return BigDecimal(1)
     end
 
-    prec = BigDecimal.limit if prec.zero?
+    limit = BigDecimal.limit
     frac_part = y.frac
 
-    if frac_part.zero? && prec.zero?
+    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)
@@ -167,18 +219,19 @@ 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 if prec.zero?
+    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
 
-    prec2 = prec + BigDecimal.double_fig
-
-    if frac_part.zero? && y.exponent < Math.log(prec) * 5 + 20
+    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
@@ -191,16 +244,16 @@ class BigDecimal
         break if n > int_part
         xn = xn.mult(xn, pow_prec)
       end
-      ans.mult(1, prec)
+      ans.mult(1, result_prec)
     else
-      if x > 1
+      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), prec)
+      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), result_prec)
     end
   end
 
@@ -217,15 +270,15 @@ class BigDecimal
     return self if zero?
 
     if prec == 0
-      prec = BigDecimal.limit.nonzero? || n_significant_digits + BigDecimal.double_fig
+      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), 0)
-    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._decimal_shift(ex).mult(1, prec)
@@ -235,6 +288,7 @@ 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
@@ -248,7 +302,7 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.log(x, prec)
+  def log(x, prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :log)
     raise Math::DomainError, 'Complex argument for BigMath.log' if Complex === x
 
@@ -259,60 +313,36 @@ module BigMath
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal(0) if x == 1
 
-    prec2 = prec + BigDecimal.double_fig
-    BigDecimal.save_limit do
-      BigDecimal.limit(0)
-      if x > 10 || x < 0.1
-        log10 = log(BigDecimal(10), prec2)
-        exponent = x.exponent
-        x = x._decimal_shift(-exponent)
-        if x < 0.3
-          x *= 10
-          exponent -= 1
-        end
-        return (log10 * exponent).add(log(x, prec2), prec)
-      end
-
-      x_minus_one_exponent = (x - 1).exponent
-
-      # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
-      sqrt_steps = [Integer.sqrt(prec2) + 3 * x_minus_one_exponent, 0].max
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
 
-      lg2 = 0.3010299956639812
-      sqrt_prec = prec2 + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
-
-      sqrt_steps.times do
-        x = x.sqrt(sqrt_prec)
-      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, sqrt_prec)
-      y = x
-      x2 = x.mult(x, prec2)
-      1.step do |i|
-        n = prec2 + 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), prec2)
-      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
 
-  # Taylor series for exp(x) around 0
-  private_class_method def self._exp_taylor(x, prec) # :nodoc:
-    xn = BigDecimal(1)
-    y = BigDecimal(1)
-    1.step do |i|
-      n = prec + xn.exponent
-      break if n <= 0 || xn.zero?
-      xn = xn.mult(x, n).div(i, n)
-      y = y.add(xn, prec)
-    end
-    y
+  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:
@@ -325,7 +355,7 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.exp(x, prec)
+  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?
@@ -334,14 +364,24 @@ module BigMath
 
     # exp(x * 10**cnt) = exp(x)**(10**cnt)
     cnt = x < -1 || x > 1 ? x.exponent : 0
-    prec2 = prec + BigDecimal.double_fig + cnt
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC + cnt
     x = x._decimal_shift(-cnt)
 
-    # Calculation of exp(small_prec) is fast because calculation of x**n is fast
-    # Calculation of exp(small_abs) converges fast.
-    # exp(x) = exp(small_prec_part + small_abs_part) = exp(small_prec_part) * exp(small_abs_part)
-    x_small_prec = x.round(Integer.sqrt(prec2))
-    y = _exp_taylor(x_small_prec, prec2).mult(_exp_taylor(x.sub(x_small_prec, prec2), prec2), 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)
     # exp(x * 10**k) = exp(x * 10**(k - 1)) ** 10

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

data/sample/nlsolve.rb

@@ -1,40 +1,57 @@
-#!/usr/local/bin/ruby
-# frozen_string_literal: false
-
 #
 # nlsolve.rb
 # An example for solving nonlinear algebraic equation system.
 #
 
 require "bigdecimal"
-require "bigdecimal/newton"
-include Newton
+require_relative "linear"
 
-class Function # :nodoc: all
-  def initialize()
-    @zero = BigDecimal("0.0")
-    @one  = BigDecimal("1.0")
-    @two  = BigDecimal("2.0")
-    @ten  = BigDecimal("10.0")
-    @eps  = BigDecimal("1.0e-16")
-  end
-  def zero;@zero;end
-  def one ;@one ;end
-  def two ;@two ;end
-  def ten ;@ten ;end
-  def eps ;@eps ;end
-  def values(x) # <= defines functions solved
-    f = []
-    f1 = x[0]*x[0] + x[1]*x[1] - @two # f1 = x**2 + y**2 - 2 => 0
-    f2 = x[0] - x[1]                  # f2 = x    - y        => 0
-    f <<= f1
-    f <<= f2
-    f
+# Requires gem matrix
+require "matrix"
+
+# :stopdoc:
+
+def func((x, y)) # defines functions solved
+  [
+    x**2 + y**2 - 2,
+    (x - 1)**2 + (y + 1)**2 - 3
+  ]
+end
+
+def jacobian(x, f, delta, prec)
+  dim = x.size
+  dim.times.map do |i|
+    xplus = Array.new(dim) {|j| x[i] + (j == i ? delta : 0) }
+    xminus = Array.new(dim) {|j| x[i] - (j == i ? delta : 0) }
+    yplus = f.call(xplus)
+    yminus = f.call(xminus)
+    yplus.zip(yminus).map {|p, m| (p - m).div(2 * delta, prec) }
+  end.transpose
+end
+
+def nlsolve(initial_x, prec:, max_iteration: 100, &f)
+  initial_x = initial_x.map {|v| BigDecimal(v) }
+  x = initial_x
+  delta = BigDecimal(0.01)
+  calc_prec = prec + 10
+  max_iteration.times do |iteration|
+    # Newton step
+    jacobian = jacobian(x, f, delta, calc_prec)
+    matrix = Matrix[*jacobian.map {|row| row.map {|v| PrecisionSpecifiedValue.new(v, calc_prec) } }]
+    y = f.call(x)
+    vector = y.map {|v| PrecisionSpecifiedValue.new(v, calc_prec) }
+    dx = matrix.lup.solve(vector).map(&:value)
+    x_prev = x
+    x = x.zip(dx).map {|xi, di| xi.sub(di, prec) }
+    movement = x_prev.zip(x).map {|xn, xi| (xn - xi).abs }.max
+    delta = [movement, delta].min.mult(1, 10)
+    break if movement.zero? || movement.exponent < -prec
   end
+  x
 end
 
-f = BigDecimal.limit(100)
-f = Function.new
-x = [f.zero,f.zero]      # Initial values
-n = nlsolve(f,x)
-p x
+initial_value = [1, 1]
+ans = nlsolve(initial_value, prec: 100) {|x| func(x) }
+diff = func(ans).map {|v| v.mult(1, 10) }
+p(ans:)
+p(diff:)

data/sample/pi.rb

@@ -1,21 +1,16 @@
-#!/usr/local/bin/ruby
-# frozen_string_literal: false
-
 #
 # pi.rb
 #
 # Calculates 3.1415.... (the number of times that a circle's diameter
-# will fit around the circle) using J. Machin's formula.
+# will fit around the circle)
 #
 
 require "bigdecimal"
 require "bigdecimal/math.rb"
 
-include BigMath
-
 if ARGV.size == 1
     print "PI("+ARGV[0]+"):\n"
-    p PI(ARGV[0].to_i)
+    p BigMath.PI(ARGV[0].to_i)
 else
     print "TRY: ruby pi.rb 1000 \n"
 end