bigdecimal 4.0.1-java → 4.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fa1b65ea52d18df3728073b1a3b78469212549f02de5a8903bf4dc039285d95
-  data.tar.gz: dc2848702fb24e465a42e3f19deb7006e8cb1d6cf89140ce7e828e933e5e3596
+  metadata.gz: dbec3e510145cedb03e4d1813d6e0ab22ff1327ee817ea9d2347e780fe6d5bf1
+  data.tar.gz: 9442152d34a18fd79367606134622d028468edf23d6dbe3404a9eaf239788f20
 SHA512:
-  metadata.gz: 25472e0e989a45ed8dc4e4f91ce1d2dbf1ba598a6513ad20278d41c305bc7341257a37ea5f050854d3a0a1c4344bd7fdadef0eec4ceb9bffcbbfc0eb6067c1ba
-  data.tar.gz: 040b7c0906dc8c4ce3adc4b29d12d19869eb828cdc7fecb48e0f1c9bf830ea5539fe505bfb3fc333071e806eec75ae060178fc5d88800c2a84f0b3783373838b
+  metadata.gz: d315846a325bdba82e62e2fe34b16a8ef01942e4485d6551e835c1739484b854593c33a7d568f10e461a27276ade554d0e80bb75666008d9502538d35867d513
+  data.tar.gz: 7f0bf10269c3c1b3135b8d4b3dff286e5a7ad9c2f13c976f333ce3191c4fbe565f9ba35c19d041b2fbaa7bb2d7ede35e17d816c1cfb7357426f6e798eff471c2

data/bigdecimal.gemspec

@@ -34,6 +34,9 @@ Gem::Specification.new do |s|
     sample/linear.rb
     sample/nlsolve.rb
     sample/pi.rb
+    sig/big_decimal_util.rbs
+    sig/big_decimal.rbs
+    sig/big_math.rbs
   ]
   if Gem::Platform === s.platform and s.platform =~ 'java' or RUBY_ENGINE == 'jruby'
     s.platform      = 'java'
@@ -43,15 +46,17 @@ Gem::Specification.new do |s|
       ext/bigdecimal/bigdecimal.c
       ext/bigdecimal/bigdecimal.h
       ext/bigdecimal/bits.h
+      ext/bigdecimal/div.h
       ext/bigdecimal/feature.h
       ext/bigdecimal/missing.c
       ext/bigdecimal/missing.h
+      ext/bigdecimal/ntt.h
       ext/bigdecimal/missing/dtoa.c
       ext/bigdecimal/static_assert.h
     ]
   end
 
-  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+  s.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   s.metadata["changelog_uri"] = s.homepage + "/blob/master/CHANGES.md"
 end

data/lib/bigdecimal/math.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'bigdecimal'
 
 #
@@ -75,8 +75,8 @@ module BigMath
   private_class_method def _sin_periodic_reduction(x, prec, add_half_pi: false) # :nodoc:
     return [1, x] if -Math::PI/2 <= x && x <= Math::PI/2 && !add_half_pi
 
-    mod_prec = prec + BigDecimal.double_fig
-    pi_extra_prec = [x.exponent, 0].max + BigDecimal.double_fig
+    mod_prec = prec + BigDecimal::Internal::EXTRA_PREC
+    pi_extra_prec = [x.exponent, 0].max + BigDecimal::Internal::EXTRA_PREC
     while true
       pi = PI(mod_prec + pi_extra_prec)
       half_pi = pi / 2
@@ -84,16 +84,47 @@ module BigMath
       mod -= half_pi
       if mod.zero? || mod_prec + mod.exponent <= 0
         # mod is too small to estimate required pi precision
-        mod_prec = mod_prec * 3 / 2 + BigDecimal.double_fig
+        mod_prec = mod_prec * 3 / 2 + BigDecimal::Internal::EXTRA_PREC
       elsif mod_prec + mod.exponent < prec
         # Estimate required precision of pi
-        mod_prec = prec - mod.exponent + BigDecimal.double_fig
+        mod_prec = prec - mod.exponent + BigDecimal::Internal::EXTRA_PREC
       else
         return [div % 2 == 0 ? 1 : -1, mod.mult(1, prec)]
       end
     end
   end
 
+  private_class_method def _sin_binary_splitting(x, prec) # :nodoc:
+    return x if x.zero?
+    x2 = x.mult(x, prec)
+    # Find k that satisfies x2**k / (2k+1)! < 10**(-prec)
+    log10 = Math.log(10)
+    logx = BigDecimal::Internal.float_log(x.abs)
+    step = (1..).bsearch { |k| Math.lgamma(2 * k + 1)[0] - 2 * k * logx > prec * log10 }
+    # Construct denominator sequence for binary splitting
+    # sin(x) = x*(1-x2/(2*3)*(1-x2/(4*5)*(1-x2/(6*7)*(1-x2/(8*9)*(1-...)))))
+    ds = (1..step).map {|i| -(2 * i) * (2 * i + 1) }
+    x.mult(1 + BigDecimal::Internal.taylor_sum_binary_splitting(x2, ds, prec), prec)
+  end
+
+  private_class_method def _sin_around_zero(x, prec) # :nodoc:
+    # Divide x into several parts
+    # sin(x.xxxxxxxx...) = sin(x.xx + 0.00xx + 0.0000xxxx + ...)
+    # Calculate sin of each part and restore sin(0.xxxxxxxx...) using addition theorem.
+    sin = BigDecimal(0)
+    cos = BigDecimal(1)
+    n = 2
+    while x != 0 do
+      partial_x = x.truncate(n)
+      x -= partial_x
+      s = _sin_binary_splitting(partial_x, prec)
+      c = (1 - s * s).sqrt(prec)
+      sin, cos = (sin * c).add(cos * s, prec), (cos * c).sub(sin * s, prec)
+      n *= 2
+    end
+    sin.clamp(BigDecimal(-1), BigDecimal(1))
+  end
+
   # call-seq:
   #   cbrt(decimal, numeric) -> BigDecimal
   #
@@ -114,9 +145,7 @@ module BigMath
     ex = x.exponent / 3
     x = x._decimal_shift(-3 * ex)
     y = BigDecimal(Math.cbrt(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|
+    BigDecimal::Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
       y = (2 * y + x.div(y, p).div(y, p)).div(3, p)
     end
     y._decimal_shift(ex).mult(neg ? -1 : 1, prec)
@@ -137,7 +166,7 @@ module BigMath
     y = BigDecimal::Internal.coerce_to_bigdecimal(y, prec, :hypot)
     return BigDecimal::Internal.nan_computation_result if x.nan? || y.nan?
     return BigDecimal::Internal.infinity_computation_result if x.infinite? || y.infinite?
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     sqrt(x.mult(x, prec2) + y.mult(y, prec2), prec)
   end
 
@@ -156,26 +185,9 @@ module BigMath
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :sin)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sin)
     return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
-    n    = prec + BigDecimal.double_fig
-    one  = BigDecimal("1")
-    two  = BigDecimal("2")
+    n = prec + BigDecimal::Internal::EXTRA_PREC
     sign, x = _sin_periodic_reduction(x, n)
-    x1   = x
-    x2   = x.mult(x,n)
-    y    = x
-    d    = y
-    i    = one
-    z    = one
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      x1  = -x2.mult(x1,n)
-      i  += two
-      z  *= (i-one) * i
-      d   = x1.div(z,m)
-      y  += d
-    end
-    y = BigDecimal("1") if y > 1
-    y.mult(sign, prec)
+    _sin_around_zero(x, n).mult(sign, prec)
   end
 
   # call-seq:
@@ -193,8 +205,9 @@ module BigMath
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :cos)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cos)
     return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
-    sign, x = _sin_periodic_reduction(x, prec + BigDecimal.double_fig, add_half_pi: true)
-    sign * sin(x, prec)
+    n = prec + BigDecimal::Internal::EXTRA_PREC
+    sign, x = _sin_periodic_reduction(x, n, add_half_pi: true)
+    _sin_around_zero(x, n).mult(sign, prec)
   end
 
   # call-seq:
@@ -213,7 +226,8 @@ module BigMath
   #
   def tan(x, prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :tan)
-    sin(x, prec + BigDecimal.double_fig).div(cos(x, prec + BigDecimal.double_fig), prec)
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
+    sin(x, prec2).div(cos(x, prec2), prec)
   end
 
   # call-seq:
@@ -233,7 +247,7 @@ module BigMath
     raise Math::DomainError, "Out of domain argument for asin" if x < -1 || x > 1
     return BigDecimal::Internal.nan_computation_result if x.nan?
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     cos = (1 - x**2).sqrt(prec2)
     if cos.zero?
       PI(prec2).div(x > 0 ? 2 : -2, prec)
@@ -259,7 +273,7 @@ module BigMath
     raise Math::DomainError, "Out of domain argument for acos" if x < -1 || x > 1
     return BigDecimal::Internal.nan_computation_result if x.nan?
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     return (PI(prec2) / 2).sub(asin(x, prec2), prec) if x < 0
     return PI(prec2).div(2, prec) if x.zero?
 
@@ -282,29 +296,22 @@ module BigMath
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan)
     return BigDecimal::Internal.nan_computation_result if x.nan?
-    n = prec + BigDecimal.double_fig
-    pi = PI(n)
+    n = prec + BigDecimal::Internal::EXTRA_PREC
+    return PI(n).div(2 * x.infinite?, prec) if x.infinite?
+
     x = -x if neg = x < 0
-    return pi.div(neg ? -2 : 2, prec) if x.infinite?
-    return pi.div(neg ? -4 : 4, prec) if x.round(n) == 1
-    x = BigDecimal("1").div(x, n) if inv = x > 1
-    x = (-1 + sqrt(1 + x.mult(x, n), n)).div(x, n) if dbl = x > 0.5
-    y = x
-    d = y
-    t = x
-    r = BigDecimal("3")
-    x2 = x.mult(x,n)
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      t = -t.mult(x2,n)
-      d = t.div(r,m)
-      y += d
-      r += 2
+    x = BigDecimal(1).div(x, n) if inv = x < -1 || x > 1
+
+    # Solve tan(y) - x = 0 with Newton's method
+    # Repeat: y -= (tan(y) - x) * cos(y)**2
+    y = BigDecimal(Math.atan(x.to_f), 0)
+    BigDecimal::Internal.newton_loop(n) do |p|
+      s = sin(y, p)
+      c = (1 - s * s).sqrt(p)
+      y = y.sub(c * (s.sub(c * x.mult(1, p), p)), p)
     end
-    y *= 2 if dbl
-    y = pi / 2 - y if inv
-    y = -y if neg
-    y.mult(1, prec)
+    y = PI(n) / 2 - y if inv
+    y.mult(neg ? -1 : 1, prec)
   end
 
   # call-seq:
@@ -333,7 +340,7 @@ module BigMath
 
     y = -y if neg = y < 0
     xlarge = y.abs < x.abs
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     if x > 0
       v = xlarge ? atan(y.div(x, prec2), prec) : PI(prec2) / 2 - atan(x.div(y, prec2), prec2)
     else
@@ -359,7 +366,7 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     prec2 -= x.exponent if x.exponent < 0
     e = exp(x, prec2)
     (e - BigDecimal(1).div(e, prec2)).div(2, prec)
@@ -382,7 +389,7 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     e = exp(x, prec2)
     (e + BigDecimal(1).div(e, prec2)).div(2, prec)
   end
@@ -404,7 +411,7 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal(x.infinite?) if x.infinite?
 
-    prec2 = prec + BigDecimal.double_fig + [-x.exponent, 0].max
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC + [-x.exponent, 0].max
     e = exp(x, prec2)
     einv = BigDecimal(1).div(e, prec2)
     (e - einv).div(e + einv, prec)
@@ -428,7 +435,7 @@ module BigMath
     return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
     return -asinh(-x, prec) if x < 0
 
-    sqrt_prec = prec + [-x.exponent, 0].max + BigDecimal.double_fig
+    sqrt_prec = prec + [-x.exponent, 0].max + BigDecimal::Internal::EXTRA_PREC
     log(x + sqrt(x**2 + 1, sqrt_prec), prec)
   end
 
@@ -450,7 +457,7 @@ module BigMath
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal::Internal.nan_computation_result if x.nan?
 
-    log(x + sqrt(x**2 - 1, prec + BigDecimal.double_fig), prec)
+    log(x + sqrt(x**2 - 1, prec + BigDecimal::Internal::EXTRA_PREC), prec)
   end
 
   # call-seq:
@@ -472,7 +479,7 @@ module BigMath
     return BigDecimal::Internal.infinity_computation_result if x == 1
     return -BigDecimal::Internal.infinity_computation_result if x == -1
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     (log(x + 1, prec2) - log(1 - x, prec2)).div(2, prec)
   end
 
@@ -497,10 +504,10 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
 
-    prec2 = prec + BigDecimal.double_fig * 3 / 2
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC * 3 / 2
     v = log(x, prec2).div(log(BigDecimal(2), prec2), prec2)
     # Perform half-up rounding to calculate log2(2**n)==n correctly in every rounding mode
-    v = v.round(prec + BigDecimal.double_fig - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+    v = v.round(prec + BigDecimal::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
     v.mult(1, prec)
   end
 
@@ -525,10 +532,10 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
 
-    prec2 = prec + BigDecimal.double_fig * 3 / 2
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC * 3 / 2
     v = log(x, prec2).div(log(BigDecimal(10), prec2), prec2)
     # Perform half-up rounding to calculate log10(10**n)==n correctly in every rounding mode
-    v = v.round(prec + BigDecimal.double_fig - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+    v = v.round(prec + BigDecimal::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
     v.mult(1, prec)
   end
 
@@ -565,25 +572,19 @@ module BigMath
     if x < -1
       # log10(exp(x)) = x * log10(e)
       lg_e = 0.4342944819032518
-      exp_prec = prec + (lg_e * x).ceil + BigDecimal.double_fig
+      exp_prec = prec + (lg_e * x).ceil + BigDecimal::Internal::EXTRA_PREC
     elsif x < 1
-      exp_prec = prec - x.exponent + BigDecimal.double_fig
+      exp_prec = prec - x.exponent + BigDecimal::Internal::EXTRA_PREC
     else
       exp_prec = prec
     end
 
     return BigDecimal(-1) if exp_prec <= 0
 
-    exp = exp(x, exp_prec)
-
-    if exp.exponent > prec + BigDecimal.double_fig
-      # Workaroudn for https://github.com/ruby/bigdecimal/issues/464
-      exp
-    else
-      exp.sub(1, prec)
-    end
+    exp(x, exp_prec).sub(1, prec)
   end
 
+  # call-seq:
   #   erf(decimal, numeric) -> BigDecimal
   #
   # Computes the error function of +decimal+ to the specified number of digits of
@@ -608,15 +609,10 @@ module BigMath
       log10_erfc = -xf ** 2 / Math.log(10) - Math.log10(xf * Math::PI ** 0.5)
       erfc_prec = [prec + log10_erfc.ceil, 1].max
       erfc = _erfc_asymptotic(x, erfc_prec)
-      if erfc
-        # Workaround for https://github.com/ruby/bigdecimal/issues/464
-        return BigDecimal(1) if erfc.exponent < -prec - BigDecimal.double_fig
-
-        return BigDecimal(1).sub(erfc, prec)
-      end
+      return BigDecimal(1).sub(erfc, prec) if erfc
     end
 
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     x_smallprec = x.mult(1, Integer.sqrt(prec2) / 2)
     # Taylor series of x with small precision is fast
     erf1 = _erf_taylor(x_smallprec, BigDecimal(0), BigDecimal(0), prec2)
@@ -640,7 +636,7 @@ module BigMath
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :erfc)
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal(1 - x.infinite?) if x.infinite?
-    return BigDecimal(1).sub(erf(x, prec + BigDecimal.double_fig), prec) if x < 0
+    return BigDecimal(1).sub(erf(x, prec + BigDecimal::Internal::EXTRA_PREC), prec) if x < 0.5
     return BigDecimal(0) if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
 
     if x >= 8
@@ -649,9 +645,10 @@ module BigMath
     end
 
     # erfc(x) = 1 - erf(x) < exp(-x**2)/x/sqrt(pi)
-    # Precision of erf(x) needs about log10(exp(-x**2)) extra digits
+    # Precision of erf(x) needs about log10(exp(-x**2)/x/sqrt(pi)) extra digits
     log10 = 2.302585092994046
-    high_prec = prec + BigDecimal.double_fig + (x.ceil**2 / log10).ceil
+    xf = x.to_f
+    high_prec = prec + BigDecimal::Internal::EXTRA_PREC + ((xf**2 + Math.log(xf) + Math.log(Math::PI)/2) / log10).ceil
     BigDecimal(1).sub(erf(x, high_prec), prec)
   end
 
@@ -700,7 +697,7 @@ module BigMath
     # Using Stirling's approximation, we can simplify this condition to:
     # sqrt(2)/2 + k*log(k) - k - 2*k*log(x) < -prec*log(10)
     # and the left side is minimized when k = x**2.
-    prec += BigDecimal.double_fig
+    prec += BigDecimal::Internal::EXTRA_PREC
     xf = x.to_f
     kmax = (1..(xf ** 2).floor).bsearch do |k|
       Math.log(2) / 2 + k * Math.log(k) - k - 2 * k * Math.log(xf) < -prec * Math.log(10)
@@ -708,7 +705,8 @@ module BigMath
     return unless kmax
 
     sum = BigDecimal(1)
-    x2 = x.mult(x, prec)
+    # To calculate `exp(x2, prec)`, x2 needs extra log10(x**2) digits of precision
+    x2 = x.mult(x, prec + (2 * Math.log10(xf)).ceil)
     d = BigDecimal(1)
     (1..kmax).each do |k|
       d = d.div(x2, prec).mult(1 - 2 * k, prec).div(2, prec)
@@ -729,7 +727,7 @@ module BigMath
   def gamma(x, prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :gamma)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :gamma)
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     if x < 0.5
       raise Math::DomainError, 'Numerical argument is out of domain - gamma' if x.frac.zero?
 
@@ -757,7 +755,7 @@ module BigMath
   def lgamma(x, prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :lgamma)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :lgamma)
-    prec2 = prec + BigDecimal.double_fig
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
     if x < 0.5
       return [BigDecimal::INFINITY, 1] if x.frac.zero?
 
@@ -766,7 +764,7 @@ module BigMath
         pi = PI(prec2)
         sin = _sinpix(x, pi, prec2)
         log_gamma = BigMath.log(pi, prec2).sub(lgamma(1 - x, prec2).first + BigMath.log(sin.abs, prec2), prec)
-        return [log_gamma, sin > 0 ? 1 : -1] if prec2 + log_gamma.exponent > prec + BigDecimal.double_fig
+        return [log_gamma, sin > 0 ? 1 : -1] if prec2 + log_gamma.exponent > prec + BigDecimal::Internal::EXTRA_PREC
 
         # Retry with higher precision if loss of significance is too large
         prec2 = prec2 * 3 / 2
@@ -816,7 +814,7 @@ module BigMath
     loggamma_k = 0
     ck_exponents = (1..a-1).map do |k|
       loggamma_k += Math.log10(k - 1) if k > 1
-      -loggamma_k - k / log10f + (k - 0.5) * Math.log10(a - k) - BigMath.log10(x_low_prec.add(k, low_prec), low_prec)
+      -loggamma_k - k / log10f + (k - 0.5) * Math.log10(a - k) - BigDecimal::Internal.float_log(x_low_prec.add(k, low_prec)) / log10f
     end
 
     # Estimate exponent of sum by Stirling's approximation
@@ -897,39 +895,20 @@ module BigMath
   #   #=> "0.31415926535897932384626433832795e1"
   #
   def PI(prec)
+    # Gauss–Legendre algorithm
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :PI)
-    n      = prec + BigDecimal.double_fig
-    zero   = BigDecimal("0")
-    one    = BigDecimal("1")
-    two    = BigDecimal("2")
-
-    m25    = BigDecimal("-0.04")
-    m57121 = BigDecimal("-57121")
-
-    pi     = zero
-
-    d = one
-    k = one
-    t = BigDecimal("-80")
-    while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      t   = t*m25
-      d   = t.div(k,m)
-      k   = k+two
-      pi  = pi + d
-    end
-
-    d = one
-    k = one
-    t = BigDecimal("956")
-    while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      t   = t.div(m57121,n)
-      d   = t.div(k,m)
-      pi  = pi + d
-      k   = k+two
+    n = prec + BigDecimal::Internal::EXTRA_PREC
+    a = BigDecimal(1)
+    b = BigDecimal(0.5, 0).sqrt(n)
+    s = BigDecimal(0.25, 0)
+    t = 1
+    while a != b && (a - b).exponent > 1 - n
+      c = (a - b).div(2, n)
+      a, b = (a + b).div(2, n), (a * b).sqrt(n)
+      s = s.sub(c * c * t, n)
+      t *= 2
     end
-    pi.mult(1, prec)
+    (a * b).div(s, prec)
   end
 
   # call-seq:

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,