bigdecimal 4.1.2-java → 4.1.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44ae86902ea163c37539fb69ed9510c61829bdfbcb6e1ba02f90ca8aa4c25603
-  data.tar.gz: c7aa4d33cf57cf5a78f1dd23ffeb3fab30ea423189c77873904c5e059922708b
+  metadata.gz: e2513e3ca1694eeafb719fc68e0b3fbddc8d358db7308e08d1877e4e50183eb5
+  data.tar.gz: 332693659e236e971b66264b8710690b2d80f9b8e517f70a8cf6843d471c5a0b
 SHA512:
-  metadata.gz: '0183b35444f3360f1a04ca9895efb7fb8d943fff443fe8f08381125b5fa8d3b3270d4b1099d3545c30899ed4cee1dec6f37377cf8f6a9f0dbd5f559b35b4fb51'
-  data.tar.gz: f1b848b5219995f13ac18e90cd4cdc8f0a780d4b536984d5c55d41cdefc7eb19571f0e2ac06afda3b1a82fecb1c00f99c11ea50742953ef59f156febfd914840
+  metadata.gz: aa23abeaadf3797702ce3887b657871d669cf0cbd66d3c38cd7ca6fcbcd9b394ac2e6d8f1ddf887e619f3f627e78f05168dc9958d2860de5fc44edecd0d427c3
+  data.tar.gz: 8360c5dfa48f212fa033ad69f7eccfe5b321d8b9c7736980ce4140952d39f04b03069d441c5f59c77dec0250ed2e786b32c1a973712c4e2e9ff6f70a624bdae7

data/bigdecimal.gemspec

@@ -29,6 +29,8 @@ Gem::Specification.new do |s|
     lib/bigdecimal/jacobian.rb
     lib/bigdecimal/ludcmp.rb
     lib/bigdecimal/math.rb
+    lib/bigdecimal/math/erf.rb
+    lib/bigdecimal/math/gamma.rb
     lib/bigdecimal/newton.rb
     lib/bigdecimal/util.rb
     sample/linear.rb

data/lib/bigdecimal/math/erf.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module BigMath
+  # Bit-burst implementation of BigMath.erf and BigMath.erfc.
+  #
+  # Both functions share the same incremental update: given erf(x0+...+xk) (or erfc),
+  # extend to erf(x0+...+xk+x_{k+1}) by adding (or, for erfc, subtracting) the Taylor
+  # expansion of the difference function
+  #   g(t) := (erf(t + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2     with a = x0+...+xk
+  # which satisfies the homogeneous ODE g''(t) + 2*(t+a)*g'(t) = 0.
+  # Each step uses binary splitting on the 3-term recurrence of g's Taylor coefficients;
+  # split widths x1, x2, ... double in digits, giving quasi-linear total cost.
+  #
+  # Only the bit-burst seed differs between the two:
+  #   erf  : seed = erf(x0) via Taylor expansion at 0
+  #   erfc : seed = erfc(x0) via asymptotic expansion (requires x0 large enough;
+  #          returns nil if asymptotic cannot reach the requested precision, in which
+  #          case erfc(x) is recovered from 1 - erf(x) with extra digits to absorb
+  #          cancellation)
+  #
+  # Edge cases (after symmetry erf(-x) = -erf(x)):
+  #   x == 0  : erf = 0
+  #   x > 5e9 : erf = 1, erfc underflows
+  #   x < 0.5 (erfc only) : compute via 1 - erf to avoid unnecessary work
+  module Erf # :nodoc:
+
+    # Calculates erf with given precision.
+    def self.erf(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :erf)
+      x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :erf)
+      return BigDecimal::Internal.nan_computation_result if x.nan?
+      return BigDecimal(x.infinite?) if x.infinite?
+      return BigDecimal(0) if x == 0
+      return -erf(-x, prec) if x < 0
+      return BigDecimal(1) if x > 5000000000 # erf(5000000000) > 1 - 1e-10000000000000000000
+      if x > 8
+        xf = x.to_f
+        log10_erfc = -xf ** 2 / Math.log(10) - Math.log10(xf * Math::PI ** 0.5)
+        erfc_prec = [prec + log10_erfc.ceil, 1].max
+        erfc = erfc_bit_burst(x, erfc_prec + BigDecimal::Internal::EXTRA_PREC)
+        return BigDecimal(1).sub(erfc, prec) if erfc
+      end
+
+      erf_bit_burst(x, prec + BigDecimal::Internal::EXTRA_PREC).mult(1, prec)
+    end
+
+    # Calculates erfc with given precision.
+    def self.erfc(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :erfc)
+      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::Internal::EXTRA_PREC), prec) if x < 0.5
+      return BigDecimal::Internal.underflow_computation_result if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
+
+      if x > 8
+        y = erfc_bit_burst(x, prec + BigDecimal::Internal::EXTRA_PREC)
+        return y.mult(1, prec) if y
+      end
+
+      # erfc(x) = 1 - erf(x) < exp(-x**2)/x/sqrt(pi)
+      # Precision of erf(x) needs about log10(exp(-x**2)/x/sqrt(pi)) extra digits
+      log10 = 2.302585092994046
+      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_bit_burst(x, high_prec), prec)
+    end
+
+    # Matrix multiplication. m1 and m2 are size*size length array that represents size*size matrix
+    def self.matrix_mult(m1, m2, size, prec)
+      (size * size).times.map do |i|
+        size.times.map do |k|
+          m1[i / size * size + k].mult(m2[size * k + i % size], prec)
+        end.reduce {|a, b| a.add(b, prec) }
+      end
+    end
+
+    # Returns (erf(x + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2 calculated with binary splitting method.
+    def self.erf_binary_splitting_diff(x, a, prec)
+      # Let f(x) = (erf(x + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2
+      # f(x) satisfies the following differential equation:
+      #   2*(x+a)*f'(x) + f''(x) = 0
+      # We can derive the following recurrence for the Taylor coefficients of f:
+      # f(x) = x * (c0 + c1*x + c2*x**2 + c3*x**3 + ...)
+      # c(0) = 1
+      # c(1) = -a
+      # c(i) = -2 * (a * c(i - 1) + c(i - 2) * (i - 1) / i) / (i + 1)
+
+      # Estimate required number of terms by calculating c(i) with low precision
+      low_prec = 10
+      a_low = a.mult(1, low_prec)
+      x_low = x.mult(1, low_prec)
+      coefs = [BigDecimal(1), -a_low]
+      xn = BigDecimal(1)
+      threshold = BigDecimal(1)._decimal_shift(-prec)
+      steps = (2..).find do |n|
+        prevprev, prev = coefs
+        xn = xn.mult(x_low, low_prec)
+        coefs = prev, (a_low * prev + (prevprev * (n - 1)).div(n, low_prec)).mult(-2, low_prec).div(n + 1, low_prec)
+        coefs[0].mult(xn, low_prec).abs < threshold && coefs[1].mult(xn * x_low, low_prec).abs < threshold
+      end
+
+      # Let M(i) be a 2x2 matrix that generates the next coefficients vector (c(i-1), c(i))
+      # from the previous two coefficients (c(i-2), c(i-1)).
+      # M(i) = | 0,                1          |
+      #        | -2*(i-1)/i/(i+1), -2*a/(i+1) |
+      #
+      # Then, we can calculate (c(steps-1), c(steps)) as M(steps)*M(steps-1)*...*M(2)*Vector(c0, c1).
+      #
+      # Calculate a matrix that represents the sum of the Taylor series:
+      #   SumMatrix = ((((...+I)x*M4+I)*x*M3+I)*M2*x+I)
+      # Actual sum can be calculated as:
+      #   SumMatrix * Vector(c0, c1) = Vector(c0+c1*x+c2*x**2+c3*x**3+..., _)
+      # In this binary splitting method, adjacent two operations are combined into one repeatedly.
+      # ((...) * x * A + B) / C is the form of each operation. A and B are 2x2 matrices, C is a scalar.
+
+      zero = BigDecimal(0)
+      operations = (2..steps + 2).map do |i|
+        d = BigDecimal(i * (i + 1))
+        [[zero, d, BigDecimal(-2 * (i - 1)), a * (-2 * i)], [d, zero, zero, d], d]
+      end
+
+      while operations.size > 1
+        xpow = xpow ? xpow.mult(xpow, prec) : x.mult(1, prec)
+        operations = operations.each_slice(2).map do |op1, op2|
+          # Combine two operations into one:
+          # (((Remaining * x * A2 + B2) / C2) * x * A1 + B1) / C1
+          # ((Remaining * (x*x) * (A2*A1) + (x*B2*A1+B1*C2)) / (C1*C2)
+          # Therefore, combined operation can be represented as:
+          # Anext = A2 * A1
+          # Bnext = x * B2 * A1 + B1 * C2
+          # Cnext = C1 * C2
+          # xnext = x * x
+          a1, b1, c1 = op1
+          a2, b2, c2 = op2 || [[zero] * 4, [zero] * 4, BigDecimal(1)]
+          [
+            matrix_mult(a2, a1, 2, prec),
+            array_weighted_sum(matrix_mult(b2, a1, 2, prec), xpow, b1, c2, prec),
+            c1.mult(c2, prec),
+          ]
+        end
+      end
+      _, sum_matrix, denominator = operations.first
+      sum = (sum_matrix[0] - a * sum_matrix[1]).div(denominator, prec)
+      x.mult(sum, prec)
+    end
+
+    # Calculates erfc(x) using bit-burst algorithm.
+    # Returns nil if the asymptotic expansion does not reach the requested precision.
+    def self.erfc_bit_burst(x, prec)
+      # By bounding the relative error via |d(erfc)/erfc| <= 2*x*|dx| (erfc(x) decays as exp(-x**2)/x),
+      # truncate x to the minimum digits sufficient for prec-digit accuracy of the result.
+      x = x.mult(1, prec + Math.log10(2 * x.to_f**2).ceil)
+      erf_erfc_bit_burst(x, prec, start_digits: 40, mode: :erfc)
+    end
+
+    # Calculates erf(x) using bit-burst algorithm.
+    def self.erf_bit_burst(x, prec)
+      # By bounding the error via erf'(x) = (2/sqrt(pi)) * exp(-x**2),
+      # truncate x to the minimum digits sufficient for prec-digit accuracy of the result.
+      x = x.mult(1, [(prec - x.floor**2 / Math.log(10) + Math.log10(x.ceil)).ceil, 10].max)
+      erf_erfc_bit_burst(x, prec, start_digits: 8, mode: :erf)
+    end
+
+    # Calculates erf or erfc using bit-burst algorithm.
+    # Returns nil if erfc mode cannot reach the requested precision.
+    def self.erf_erfc_bit_burst(x, prec, start_digits:, mode:)
+      digits = [-x.exponent * 2, start_digits].max
+      partial = x.truncate(digits)
+      case mode
+      when :erf
+        f = erf_exp2_binary_splitting(partial, prec)
+      when :erfc
+        f = erfc_exp2_asymptotic_binary_splitting(partial, prec)
+        return unless f
+      end
+
+      exp_scale = BigMath.exp(-partial * partial, prec)
+      f = f.mult(exp_scale, prec)
+
+      calculated_x = partial
+      x -= partial
+
+      until x.zero?
+        digits *= 2
+        partial = x.truncate(digits)
+        next if partial.zero?
+
+        diff_prec = [prec - f.exponent + exp_scale.exponent + partial.exponent, 1].max
+        diff = erf_binary_splitting_diff(partial, calculated_x, diff_prec)
+        case mode
+        when :erf
+          f = f.add(diff.mult(exp_scale, prec), prec)
+        when :erfc
+          f = f.sub(diff.mult(exp_scale, prec), prec)
+        end
+
+        calculated_x += partial
+        x -= partial
+        exp_scale = exp_scale.mult(BigMath.exp(partial * (partial - 2 * calculated_x), diff_prec), diff_prec) unless x.zero?
+      end
+      f.mult(BigDecimal(2).div(BigMath::PI(prec).sqrt(prec), prec), prec)
+    end
+
+    # Matrix/Vector weighted sum
+    def self.array_weighted_sum(m1, w1, m2, w2, prec)
+      m1.zip(m2).map {|v1, v2| (v1 * w1).add(v2 * w2, prec) }
+    end
+
+    # Calculates Taylor expansion of erf(x)*exp(x**2)*sqrt(pi)/2 with binary splitting method.
+    def self.erf_exp2_binary_splitting(x, prec)
+      # Let f(x) = erf(x)*exp(x**2)*sqrt(pi)/2
+      #            = c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...
+      # f(x) is designed to make all coefficients positive so that we don't need to consider cancellation error.
+      #
+      # f(x) satisfies the following differential equation:
+      # f'(x) = 1 + 2 * x * f(x)
+      # f'(x) = c1 + 2*c2*x + 3*c3*x**2 + 4*c4*x**3 + 5*c5*x**4 + ...
+      #         = 1+2*x*(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...)
+      # therefore,
+      # c0 = 0
+      # c1 = 1
+      # c2 = 2 * (c0 + c1) / 2
+      # c3 = 2 * (c1 + c2) / 3
+      # c4 = 2 * (c2 + c3) / 4
+
+      # Find the smallest n where the n-th Taylor term |c_n * x^n| falls below the precision
+      # threshold, using a Stirling-based upper bound on |c_n|.
+      log10f = Math.log(10)
+      cexponent = Math.log10(Math.sqrt(2)) + BigDecimal::Internal.float_log(x.abs) / log10f
+
+      x_to_f = x < 1e-300 ? 1e-300 : x.to_f # x.to_f may underflow when x is very small (e.g. 1e-400)
+      steps = (2..).bsearch do |n|
+        x_to_f ** 2 < n && n * cexponent + Math.lgamma(n / 2)[0] / log10f + n * Math.log10(2) - Math.lgamma(n - 1)[0] / log10f < -prec + x_to_f**2 / log10f
+      end
+
+      denominators = (steps / 2).times.map {|i| 2 * i + 3 }
+      x.mult(1 + BigDecimal::Internal.taylor_sum_binary_splitting(2 * x * x, denominators, prec), prec)
+    end
+
+    # Calculates asymptotic expansion of erfc(x)*exp(x**2)*sqrt(pi)/2 with binary splitting method
+    def self.erfc_exp2_asymptotic_binary_splitting(x, prec)
+      # Let f(x) = erfc(x)*sqrt(pi)*exp(x**2)/2
+      # f(x) satisfies the following differential equation:
+      # 2*x*f(x) = f'(x) + 1
+      # From the above equation, we can derive the following asymptotic expansion:
+      # f(x) = (0..kmax).sum { (-1)**k * (2*k)! / 4**k / k! / x**(2*k) } / x / 2
+
+      # This asymptotic expansion does not converge.
+      # But if there is a k that satisfies (2*k)! / 4**k / k! / x**(2*k) < 10**(-prec),
+      # It is enough to calculate erfc within the given precision.
+      # Using Stirling's approximation, we can simplify this condition to:
+      # log(2)/2 + k*log(k) - k - 2*k*log(x) < -prec*log(10)
+      # and the left side is minimized when k = x**2.
+      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)
+      end
+      return unless kmax
+
+      # Convert asymptotic expansion to nested form:
+      # 1 + a/x + a*b/x/x + a*b*c/x/x/x + a*b*c/x/x/x*rest
+      # = 1 + (a/x) * (1 + (b/x) * (1 + (c/x) * (1 + rest)))
+      #
+      # And calculate it with binary splitting:
+      # (a1/d + b1/d * (a2/d + b2/d * (rest)))
+      # = ((a1*d+b1*a2)/(d*d) + b1*b2/(d*denominator) * (rest)))
+      denominator = x.mult(x, prec).mult(2, prec)
+      fractions = (1..kmax).map do |k|
+        [denominator, BigDecimal(1 - 2 * k)]
+      end
+      while fractions.size > 1
+        fractions = fractions.each_slice(2).map do |fraction1, fraction2|
+          a1, b1 = fraction1
+          a2, b2 = fraction2 || [BigDecimal(0), denominator]
+          [
+            a1.mult(denominator, prec).add(b1.mult(a2, prec), prec),
+            b1.mult(b2, prec),
+          ]
+        end
+        denominator = denominator.mult(denominator, prec)
+      end
+      # Plug rest = 1 into the merged form: the innermost "(1 + rest)" of the nested expansion
+      # evaluates to 1 at truncation (rest = 0).
+      sum = fractions[0][0].add(fractions[0][1], prec).div(denominator, prec)
+      sum.div(x, prec) / 2
+    end
+  end
+
+  private_constant :Erf
+end

data/lib/bigdecimal/math/gamma.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+require 'bigdecimal/math'
+
+module BigMath
+
+  # Calculates gamma/lgamma
+  # Algorithm overview:
+  #
+  # Lagrange interpolation of f(x) = b**x / x! at integer nodes x_i = b-l, ..., b+l.
+  #   BSM(Binary Splitting Method) version for small digit numbers, O(PREC*log(PREC)^3)
+  #   BSGS(Baby-Step Giant-Step) version for full digit numbers, O(PREC^2*log(log(PREC)))
+  #   Both orders of magnitude faster than Spouge's approximation which is O(PREC^2*log(PREC))
+  #   (Complexities assume quasi-linear multiplication, counting large-by-small products
+  #   as (n/m) * M(m) = n * log(m) bit ops. BigDecimal multiplies the small coefficients
+  #   by schoolbook instead: an extra log factor asymptotically, but faster at any feasible PREC.)
+  #   Requires fast factorial of an integer near x (see Factorial Doubling below).
+  #
+  # Factorial Doubling for fast calculation of large factorials:
+  #   Using Legendre duplication formula, we can calculate factorial(2n) from factorial(n) and factorial(n + 0.5).
+  #   Calculating factorial(n + 0.5) is done by the BSM version of Lagrange interpolation in quasi-linear time.
+  #   This will drastically reduce the cost of calculating large factorials.
+  #   O(PREC*log(PREC)^3*log(factorial_argument))
+  #
+  # Stirling's approximation with Bernoulli numbers
+  #   Only used when x is extremely large.
+
+  module Gamma # :nodoc:
+
+    # Calculates gamma function with given precision.
+    def self.gamma(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :gamma)
+      x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :gamma)
+      prec2 = prec + BigDecimal::Internal::EXTRA_PREC
+
+      if x < 0.5
+        raise Math::DomainError, 'Numerical argument is out of domain - gamma' if x.frac.zero?
+
+        # Euler's reflection formula: gamma(z) * gamma(1-z) = pi/sin(pi*z)
+        pi = BigMath::PI(prec2)
+        sin = sinpix(x, pi, prec2)
+        pi.div(gamma(1 - x, prec2).mult(sin, prec2), prec)
+      else
+        # Digits of x beyond the working precision cannot affect the result.
+        # Rounding must happen before the integer test: an x indistinguishable from
+        # an integer must take the exact integer path, because gamma_lagrange
+        # requires a non-integer x (an integer x makes a node distance exactly zero).
+        x = x.mult(1, prec2 + x.exponent + 10)
+        if x.frac.zero?
+          integer_factorial(x.to_i - 1, prec2).mult(1, prec)
+        else
+          base, large_factorial_arg, small_factorial_arg, exp2 = gamma_lagrange(x, prec2)
+          ans = base.mult(integer_factorial(small_factorial_arg, prec2), prec2)
+          ans = ans.mult(BigDecimal(2).power(exp2, prec2), prec2) unless exp2.zero?
+          ans.mult(integer_factorial(large_factorial_arg, prec2), prec)
+        end
+      end
+    end
+
+    # Calculates log gamma and its sign with given precision.
+    def self.lgamma(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :lgamma)
+      x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :lgamma)
+      prec2 = prec + BigDecimal::Internal::EXTRA_PREC
+      if x < 0.5
+        return [BigDecimal::INFINITY, 1] if x.frac.zero?
+
+        loop do
+          # Euler's reflection formula: gamma(z) * gamma(1-z) = pi/sin(pi*z)
+          pi = BigMath::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 log_gamma != 0 && prec2 + log_gamma.exponent > prec + BigDecimal::Internal::EXTRA_PREC
+
+          # Retry with higher precision if loss of significance is too large
+          prec2 = prec2 * 3 / 2
+        end
+      else
+        # if x is close to 1 or 2, increase precision to reduce loss of significance
+        diff1_exponent = x < 3 ? (x - 1).exponent : 0
+        diff2_exponent = x < 3 ? (x - 2).exponent : 0
+        extremely_near_one = diff1_exponent < -prec2
+        extremely_near_two = diff2_exponent < -prec2
+
+        if extremely_near_one || extremely_near_two
+          # If x is extremely close to base = 1 or 2, linear interpolation is accurate enough.
+          # Taylor expansion at x = base is: (x - base) * digamma(base) + (x - base) ** 2 * trigamma(base) / 2 + ...
+          # And we can ignore (x - base) ** 2 and higher order terms.
+          base = extremely_near_one ? 1 : 2
+          d = BigDecimal(1)._decimal_shift(1 - prec2)
+          log_gamma_d, sign = lgamma(base + d, prec2)
+          return [log_gamma_d.mult(x - base, prec2).div(d, prec), sign]
+        end
+
+        prec2 += [-diff1_exponent, -diff2_exponent, 0].max
+
+        # Same rounding as in Gamma.gamma. Must come after the near 1 and 2 handling
+        # above, which needs the exact distance from x to 1 or 2.
+        x = x.mult(1, prec2 + x.exponent + 10)
+
+        # When x is extremely large, the cost of Bernoulli number generation for Stirling's
+        # asymptotic expansion is smaller than the cost of multiple steps of doubling method.
+        # The condition is based on heuristic cost estimation and empirical tuning.
+        if x > prec2 && x.exponent > Integer.sqrt(prec2) / 6
+          [lgamma_stirling(x, prec2).mult(1, prec), 1]
+        elsif x.frac.zero?
+          [integer_factorial_log(x.to_i - 1, prec2).mult(1, prec), 1]
+        else
+          base, large_factorial_arg, small_factorial_arg, exp2 = gamma_lagrange(x, prec2)
+          lgamma = BigMath.log(base, prec2)
+          lgamma = lgamma.add(BigMath.log(2, prec2) * exp2, prec2) unless exp2.zero?
+          lgamma = lgamma.add(integer_factorial_log(small_factorial_arg, prec2), prec2)
+          lgamma = lgamma.add(integer_factorial_log(large_factorial_arg, prec2), prec)
+          [lgamma, 1]
+        end
+      end
+    end
+
+    # Calculates prod { x - k } for k in ks and the coefficients of the expanded polynomial.
+    # xn is an array of precalculated powers of x: [1, x, x**2, x**3, ...]
+    def self.x_minus_k_prod_coef(ks, xn, prec)
+      coef = [1]
+      ks.each do |k|
+        coef_next = [0] * (coef.size + 1)
+        coef.each_with_index do |c, i|
+          coef_next[i] -= k * c
+          coef_next[i + 1] += c
+        end
+        coef = coef_next
+      end
+
+      prod = coef.each_with_index.map do |c, i|
+        xn[i].mult(c, prec)
+      end.reduce do |sum, value|
+        sum.add(value, prec)
+      end
+      [prod, coef]
+    end
+
+    # Bit length to keep in bit-dropping integer products and fraction merges.
+    # Only about prec * log2(10) bits are needed. 10 / 3 slightly exceeds log2(10),
+    # and 64 extra bits absorb the ~1 bit lost per truncation over the tree depth.
+    def self.drop_cap_bits(prec)
+      (prec * 10 + 192) / 3
+    end
+
+    # Calculate numbers.reduce(:*) of integers by Binary Splitting Method.
+    # Returns [mantissa, exp2] representing mantissa * 2**exp2.
+    # With cap, lower bits of intermediate products are dropped to keep each
+    # multiplication cost bounded by the target precision. Without cap, the product is exact.
+    def self.int_bsm_prod(numbers, cap = nil)
+      numbers = numbers.to_a
+      exp2 = 0
+      while numbers.size > 1
+        numbers = numbers.each_slice(2).map do |a, b|
+          next a unless b
+          v = a * b
+          if cap && (s = v.bit_length - cap) > 0
+            exp2 += s
+            v >>= s
+          end
+          v
+        end
+      end
+      [numbers.first || 1, exp2]
+    end
+
+    # Calculate factorial for integer n
+    def self.integer_factorial(n, prec)
+      power_part, exp2, exp_sqrtpi = integer_factorial_parameter(n, prec)
+      ans = BigDecimal(2).power(exp2, prec)
+      power_part.each_with_index do |base, index|
+        ans = ans.mult(base.power(1 << index, prec), prec)
+      end
+      if exp_sqrtpi != 0
+        pi = BigMath::PI(doubling_level_prec(prec, power_part.size - 1))
+        # exp_sqrtpi is 2**k - 1 (odd): the doubling recursion squares the child's
+        # sqrt(pi) exponent and adds one, so only the last level's sqrt survives
+        pipow = pi.power(exp_sqrtpi / 2, prec).mult(pi.sqrt(prec), prec)
+        ans = ans.div(pipow, prec)
+      end
+      ans
+    end
+
+    # Precision for values that integer_factorial raises to the power 2**index.
+    # The power multiplies their relative error by 2**index, so they need
+    # index * log10(2) more digits than the result.
+    def self.doubling_level_prec(prec, index)
+      prec + (index * Math.log10(2)).ceil + 1
+    end
+
+    # Calculate log factorial for integer n
+    def self.integer_factorial_log(n, prec)
+      power_part, exp2, exp_sqrtpi = integer_factorial_parameter(n, prec)
+      ans = exp2.zero? ? BigDecimal(0) : BigMath.log(2, prec) * exp2
+      power_part.each_with_index do |base, index|
+        ans = ans.add(BigMath.log(base, prec) * (1 << index), prec)
+      end
+      if exp_sqrtpi != 0
+        pi = BigMath::PI(prec)
+        ans = ans.sub(BigMath.log(pi, prec) * (BigDecimal(exp_sqrtpi) / 2), prec)
+      end
+      ans
+    end
+
+    # Calculates parameters for integer factorial calculation.
+    # Returns [base_power_part, exp2, exp_sqrtpi] that can produce factorial(n) as:
+    #   factorial(n) = prod { base_power_part[i]**(1 << i) } * 2**exp2 / sqrt(pi)**exp_sqrtpi
+    # These parameters are used to avoid overflow when calculating log factorial and lgamma for large n.
+    def self.integer_factorial_parameter(n, prec)
+      base_power_part, factorial_power_part, exp2, exp_sqrtpi = integer_factorial_recursive(n, prec)
+      fact_x = 1
+      fact_y = BigDecimal(1)
+      # factorial_power_part is non-decreasing (deeper recursion levels have smaller b,
+      # and gamma_lagrange_l grows as b shrinks), so fact_y can be extended incrementally.
+      # fact_y is carried over to every later index, so it needs the precision
+      # of the deepest level from the start.
+      level_prec = doubling_level_prec(prec, factorial_power_part.size - 1)
+      factorial_power_part.each_with_index do |factorial_arg, index|
+        # Exact product (no bit drop): these ranges total only O(prec * log(prec)) digits,
+        # and a dropped 2**s here would be raised to 2**index, exceeding the representable
+        # exponent range while base_power_part[index] underflows by the same amount.
+        mantissa, = int_bsm_prod(fact_x + 1..factorial_arg)
+        fact_y = fact_y.mult(mantissa, level_prec)
+        fact_x = factorial_arg
+        base_power_part[index] = base_power_part[index].mult(fact_y, level_prec)
+      end
+      [base_power_part, exp2, exp_sqrtpi]
+    end
+
+    # Returns [base_power_part, factorial_power_part, exp2, exp_sqrtpi] that can produce factorial(n) as:
+    # factorial(n) = prod { base_power_part[i]**(1 << i) } * prod { factorial(factorial_power_part[i])**(1 << i) } * 2**exp2 / sqrt(pi)**(exp_sqrtpi)
+    # If n is large, this method recursively calculates factorial for smaller n by Legendre duplication formula.
+    # index is the recursion depth, which is also the position in the returned arrays.
+    def self.integer_factorial_recursive(n, prec, index = 0)
+      level_prec = doubling_level_prec(prec, index)
+      if n < 4 * prec
+        mantissa, exp2 = int_bsm_prod(1..n, drop_cap_bits(level_prec))
+        return [[BigDecimal(mantissa)], [], exp2, 0]
+      end
+
+      # Use Legendre duplication formula to reduce factorial(n) to half-size factorials:
+      #   factorial(n) = factorial(n/2.0) * factorial((n-1)/2.0) * 2**n / sqrt(pi)
+      # gamma_lagrange((n + 1) / 2 + 0.5, prec) computes the half-integer factorial
+      # (whichever of the two factors above is a half-integer).
+      half_arg = BigDecimal((n + 1) / 2) + BigDecimal('0.5')
+      base, large_factorial_arg, small_factorial_arg, lagrange_exp2 = gamma_lagrange(half_arg, level_prec)
+
+      range_mantissa, = int_bsm_prod(large_factorial_arg + 1..n / 2) # exact: total size is O(prec) digits
+      base = base.mult(range_mantissa, level_prec)
+      base_power_part, factorial_power_part, exp2, exp_sqrtpi = integer_factorial_recursive(large_factorial_arg, prec, index + 1)
+      [
+        [base] + base_power_part,
+        [small_factorial_arg] + factorial_power_part,
+        exp2 * 2 + n + lagrange_exp2,
+        exp_sqrtpi * 2 + 1
+      ]
+    end
+
+    # Estimate the required number of interpolation points `l` to achieve `prec` digits.
+    #
+    # Assuming the nodes stay strictly positive, the function b^x/x! approximates a
+    # Gaussian curve e^(-y^2 / 2b) around its peak (x=b).
+    # The Taylor coefficient of degree 2l is roughly c_2l = 1 / (l! * (2b)^l).
+    # Multiplying this by the distance product of 2l+1 nodes (approx (l/e)^(2l)),
+    # the overall truncation error E is bounded by: E ~ (l / 2eb)^l.
+    #
+    # Setting E <= 10^-prec gives the implicit equation:
+    #   l * log10(2 * e * b / l) = prec  =>  l = prec / log10(2 * e * b / l)
+    def self.gamma_lagrange_l(b, prec)
+      # Initial guess of l. When b >= 2 * prec - 1 (guaranteed by the shift in gamma_lagrange),
+      # this is safely larger than the actual l.
+      l = prec
+
+      # Solves the implicit equation via fixed-point iteration.
+      # Due to the slow growth of the logarithm, 2 iterations are practically sufficient.
+      2.times { l = prec / Math.log10(2 * Math::E * b / l) }
+      l.ceil + 10 # Adds safety margin
+    end
+
+    # Calculate approximate gamma by Lagrange interpolation of f(x) = b**x / x!
+    # Nodes are placed at x_i = b-l, b-l+1, ..., b+l.
+    # b: x.round, l: number of nodes on one side (total nodes = 2*l+1)
+    #
+    # Mathematically, we use the barycentric interpolation form:
+    # f(x) \approx \omega(x) \sum_{i} \frac{w_i f(x_i)}{x - x_i}
+    # Therefore, \Gamma(x+1) = x! = b**x / f(x)
+    #
+    # Time complexity:
+    # - O(PREC*log(PREC)^3) for small-digit x (Binary Splitting)
+    # - O(PREC^2*log(log(PREC))) for full-digit x (Baby-step Giant-step).
+    #   Measured time grows like PREC^2.
+    #
+    # Returns [base, large_factorial_arg, small_factorial_arg, exp2] that can produce gamma(x) as:
+    #   gamma(x) = base * 2**exp2 * factorial(large_factorial_arg) * factorial(small_factorial_arg)
+    def self.gamma_lagrange(x, prec)
+      # Shift x to establish a safe center (b) for the barycentric interpolation.
+      #
+      # We must keep all interpolation nodes strictly positive (b - l > 0). Approaching
+      # x = 0 breaks the Gaussian approximation used to estimate `l` and provides no
+      # useful information for the interpolation.
+      #
+      # While b =~ 1.36 * prec is the strict theoretical minimum to stay positive, we
+      # heuristically use b = 2 * prec. This moves the nodes safely away from x = 0,
+      # stabilizes the curve, and empirically yields the optimal total computation cost.
+      # (See `gamma_lagrange_l` for the mathematical derivation of the approximation).
+      shift = x < 2 * prec ? 2 * prec - x.floor : 0
+      x += shift
+
+      x = BigDecimal(x) - 1
+      b = x.round
+      l = gamma_lagrange_l(b, prec)
+      exp2 = 0
+
+      # --- Reference: Naive interpolation logic ---
+      # The two branches below optimize this calculation for the full-digit and small-digit x cases.
+      # sum = BigDecimal(0)
+      # prod = [*(b - l..b + l), *(0...shift)].map {|i| x - i }.reduce { _1.mult(_2, prec) }
+      # c = BigDecimal(1) # represents w_i * f(x_i) (normalized)
+      # (b - l..b + l).each do |i|
+      #   if i != b - l
+      #     c = c.mult(-b * (b + l - i + 1), prec).div((i - b + l) * i, prec)
+      #   end
+      #   sum = sum.add(c.div(x - i, prec), prec)
+      # end
+      # --------------------------------------------
+
+      # Choose between BSM and BSGS based on total bit cost:
+      #   BSM:  (l * n_sig / prec) full-digit multiplications, each costing prec * log(prec)
+      #         bit ops, total l * n_sig * log(prec).
+      #   BSGS: l * prec bit ops with batch_size = log2(prec) (see below).
+      # Cross-over: n_sig * log(prec) > prec.
+      if x.n_significant_digits * prec.bit_length > prec
+        # Reduce full-precision multiplications/divisions using a Batched Evaluation
+        # inspired by the Baby-Step Giant-Step (BSGS) method.
+
+        # Normal BSGS uses batch_size = sqrt(l), but here the integer coefficients of the
+        # expanded prod { x - k } over a batch grow like (b + l)**batch_size, so a smaller
+        # batch keeps both the coefficient size and the per-batch evaluation cost low.
+        # batch_size = log2(prec) brings the total BSGS bit cost down to O(l * prec * log(log(prec))).
+        batch_size = prec.bit_length
+
+        # When expanding prod { x - k }, the coefficient of x**n might be huge.
+        # Increase internal calculation precision to avoid catastrophic cancellation.
+        # When x is within 10**-q of a node, batch_prod cancels by q more digits;
+        # without the extra digits the computed batch_prod can even collapse to
+        # exactly zero, and the division below would raise or produce NaN.
+        nearest_node_distance = x - x.round(0, BigDecimal::ROUND_HALF_UP)
+        near_node_digits = [1 - nearest_node_distance.exponent, 0].max
+        internal_xn_prec = prec + (Math.log10(b + l) * batch_size).ceil + near_node_digits
+        xn = [BigDecimal(1)]
+        xn << xn.last.mult(x, internal_xn_prec) while xn.size <= batch_size
+
+        c = BigDecimal(1)
+        sum = BigDecimal(0)
+        prod = BigDecimal(1)
+
+        # sum, c and prod are updated once per batch, so their rounding errors
+        # accumulate in proportion to the number of batches.
+        batch_count = (2 * l + 1 + shift) / batch_size + 1
+        accumulate_prec = prec + Math.log10(batch_count).ceil + 1
+
+        ((b - l)..(b + l)).to_a.each_slice(batch_size) do |batch_ks|
+          # Calculate prod{ x - k } in this batch
+          batch_prod, prod_coef = x_minus_k_prod_coef(batch_ks, xn, internal_xn_prec)
+
+          # Calculate coefficients of batch_prod / (x - k) using Synthetic Division (Ruffini's rule)
+          batch_coef = [0] * batch_ks.size
+          c_scale = 1r
+          batch_ks.each do |k|
+            c_scale = c_scale * (-b * (b + l - k + 1)) / ((k - b + l) * k) if k != b - l
+            rem = 0
+            (batch_ks.size - 1).downto(0) do |i|
+              quo = prod_coef[i + 1] + rem
+              rem = quo * k
+              batch_coef[i] += c_scale * quo
+            end
+          end
+
+          batch_sum = BigDecimal(0)
+          batch_coef.each_with_index do |coef, i|
+            batch_sum = batch_sum.add(xn[i].mult(coef.numerator, internal_xn_prec).div(coef.denominator, internal_xn_prec), internal_xn_prec)
+          end
+          # batch_prod loses relative accuracy when x is extremely close to a node in this
+          # batch. This is harmless: the same computed value is divided into sum here and
+          # multiplied into prod below, so the error cancels in the final prod * sum.
+          sum = sum.add(batch_sum.mult(c, accumulate_prec).div(batch_prod, accumulate_prec), accumulate_prec)
+          c = c.mult(c_scale.numerator, accumulate_prec).div(c_scale.denominator, accumulate_prec)
+          prod = prod.mult(batch_prod, accumulate_prec)
+        end
+
+        # Perform shift.times {|i| prod = prod.mult(x - i, prec) } with batch processing
+        shift.times.to_a.each_slice(batch_size) do |batch_ks|
+          shift_prod, _prod_coef = x_minus_k_prod_coef(batch_ks, xn, internal_xn_prec)
+          prod = prod.mult(shift_prod, accumulate_prec)
+        end
+      else
+        # Binary Splitting Method (BSM) for short-digit inputs.
+        # Scaling x by 10**frac_digits makes every node term x - i an exact integer,
+        # so the whole tree runs on Integer arithmetic. The scale cancels inside the
+        # fraction merges; only prod and sum need explicit rescaling.
+        frac_digits = [x.n_significant_digits - x.exponent, 0].max
+        s10 = 10**frac_digits
+        xs = x._decimal_shift(frac_digits).to_i
+        cap = drop_cap_bits(prec)
+
+        prod_factors = (b - l..b + l).map {|i| xs - i * s10 } + shift.times.map {|i| xs - i * s10 }
+        mantissa, dropped_exp2 = int_bsm_prod(prod_factors, cap)
+        prod = BigDecimal(mantissa)._decimal_shift(-frac_digits * prod_factors.size)
+        # prod is missing the dropped 2**dropped_exp2 factor and gamma is proportional
+        # to 1 / prod. Returning the compensation as exp2 lets the factorial doubling
+        # fold it into its own 2**exp2 channel instead of paying a power here.
+        exp2 = -dropped_exp2
+
+        # State represents a partial evaluation of the series as: [sum_num, mult_num, den]
+        # Conceptually, each state translates to the following mathematical expression:
+        #   (sum_num / den) + (mult_num / den) * (rest_of_the_series)
+        #
+        # The initial state [denominator, numerator, denominator] simply represents:
+        #   (denominator / denominator) + (numerator / denominator) * rest
+        #   = 1 + (numerator / denominator) * rest
+        #
+        fractions = (b - l + 1..b + l).map do |i|
+          denominator = (xs - i * s10) * ((i - b + l) * i)
+          numerator = (xs - (i - 1) * s10) * (-b * (b + l - i + 1))
+          [denominator, numerator, denominator]
+        end
+
+        while fractions.size > 1
+          fractions = fractions.each_slice(2).map do |a, c|
+            c ||= [1, 0, 1]
+            # Merge operation for BSM:
+            # a[0]/a[2] + a[1]/a[2] * (c[0]/c[2] + c[1]/c[2] * rest)
+            # = (a[0]*c[2] + a[1]*c[0]) / (a[2]*c[2]) + (a[1]*c[1]) / (a[2]*c[2]) * rest
+            v0 = a[0] * c[2] + a[1] * c[0]
+            v1 = a[1] * c[1]
+            v2 = a[2] * c[2]
+            # Drop lower bits to avoid the integers growing too large; see drop_cap_bits.
+            # All three components share the shift, so the represented ratios are unchanged.
+            s = v2.bit_length - cap
+            if s > 0
+              v0 >>= s
+              v1 >>= s
+              v2 >>= s
+            end
+            [v0, v1, v2]
+          end
+        end
+        fraction = fractions.first
+        sum = BigDecimal((fraction[0] + fraction[1]) * s10).div(fraction[2] * (xs - (b - l) * s10), prec)
+      end
+
+      # Reconstruct Gamma(x_original) by reversing the scaling and applying shift formula
+      e = x - (b - l)
+      if e.frac == 0.5
+        # The factorial doubling path always has x = integer + 0.5. For this exponent shape,
+        # integer power and sqrt are much cheaper than the exp/log based fractional power.
+        power_part = BigDecimal(b).power(e.to_i, prec).mult(BigDecimal(b).sqrt(prec), prec)
+      else
+        power_part = BigDecimal(b).power(e, prec)
+      end
+      base = power_part.div(prod.mult(sum, prec), prec)
+      large_factorial_arg = b - l
+      small_factorial_arg = 2 * l
+      [base, large_factorial_arg, small_factorial_arg, exp2]
+    end
+
+    # Calculates bernoulli number.
+    # bns: calculated bernoulli numbers for memoization
+    def self.bernoulli(n, bns, prec)
+      return bns[0] ||= BigDecimal(1) if n == 0
+      return bns[1] ||= BigDecimal(-0.5) if n == 1
+      return bns[n] ||= BigDecimal(0) if n.odd?
+      bns[n] ||= (
+        comb = 1
+        sum = BigDecimal(0)
+        n.times do |i|
+          sum = sum.add(comb * bernoulli(i, bns, prec), prec)
+          comb = comb * (n - i + 1) / (i + 1)
+        end
+        sum.div(-n - 1, prec)
+      )
+    end
+
+    # Calculate log gamma using Stirling's asymptotic expansion.
+    # While the condition of this asymptotic expansion is x > prec * log(10) / 2 / pi,
+    # we'll use this method only when x is extremely large to reduce the cost of Bernoulli number generation.
+    def self.lgamma_stirling(x, prec)
+      x = BigDecimal(x)
+      y = (x * (BigMath.log(x, prec) - 1)).add(BigMath.log(2 * BigMath::PI(prec).div(x, prec), prec) / 2, prec)
+      bns = []
+      xn = x
+      x2 = x.mult(x, prec)
+      (1..).each do |k|
+        xn = xn.mult(x2, prec) if k != 1
+        d = bernoulli(2 * k, bns, prec).div(xn, prec).div(2 * k * (2 * k - 1), prec)
+        y = y.add(d, prec)
+        break if d.exponent < y.exponent - prec
+      end
+      y
+    end
+
+    # Returns sin(pi * x), for gamma reflection formula calculation
+    def self.sinpix(x, pi, prec)
+      x = x % 2
+      sign = x > 1 ? -1 : 1
+      x %= 1
+      x = 1 - x if x > 0.5 # to avoid sin(pi*x) loss of precision for x close to 1
+      sign * BigMath.sin(x.mult(pi, prec), prec)
+    end
+  end
+
+  private_constant :Gamma
+end

data/lib/bigdecimal/math.rb

@@ -596,28 +596,8 @@ module BigMath
   #   #=> "0.84270079294971486934122063508261e0"
   #
   def erf(x, prec)
-    prec = BigDecimal::Internal.coerce_validate_prec(prec, :erf)
-    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :erf)
-    return BigDecimal::Internal.nan_computation_result if x.nan?
-    return BigDecimal(x.infinite?) if x.infinite?
-    return BigDecimal(0) if x == 0
-    return -erf(-x, prec) if x < 0
-    return BigDecimal(1) if x > 5000000000 # erf(5000000000) > 1 - 1e-10000000000000000000
-
-    if x > 8
-      xf = x.to_f
-      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)
-      return BigDecimal(1).sub(erfc, prec) if erfc
-    end
-
-    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)
-    # Taylor series converges quickly for small x
-    _erf_taylor(x - x_smallprec, x_smallprec, erf1, prec2).mult(1, prec)
+    require 'bigdecimal/math/erf'
+    Erf.erf(x, prec)
   end
 
   # call-seq:
@@ -632,87 +612,8 @@ module BigMath
   #   #=> "0.20884875837625447570007862949578e-44"
   #
   def erfc(x, prec)
-    prec = BigDecimal::Internal.coerce_validate_prec(prec, :erfc)
-    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::Internal::EXTRA_PREC), prec) if x < 0.5
-    return BigDecimal::Internal.underflow_computation_result if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
-
-    if x >= 8
-      y = _erfc_asymptotic(x, prec)
-      return y.mult(1, prec) if y
-    end
-
-    # erfc(x) = 1 - erf(x) < exp(-x**2)/x/sqrt(pi)
-    # Precision of erf(x) needs about log10(exp(-x**2)/x/sqrt(pi)) extra digits
-    log10 = 2.302585092994046
-    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
-
-  # Calculates erf(x + a)
-  private_class_method def _erf_taylor(x, a, erf_a, prec) # :nodoc:
-    return erf_a if x.zero?
-    # Let f(x+a) = erf(x+a)*exp((x+a)**2)*sqrt(pi)/2
-    #            = c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...
-    # f'(x+a) = 1+2*(x+a)*f(x+a)
-    # f'(x+a) = c1 + 2*c2*x + 3*c3*x**2 + 4*c4*x**3 + 5*c5*x**4 + ...
-    #         = 1+2*(x+a)*(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...)
-    # therefore,
-    # c0 = f(a)
-    # c1 = 2 * a * c0 + 1
-    # c2 = (2 * c0 + 2 * a * c1) / 2
-    # c3 = (2 * c1 + 2 * a * c2) / 3
-    # c4 = (2 * c2 + 2 * a * c3) / 4
-    #
-    # All coefficients are positive when a >= 0
-
-    scale = BigDecimal(2).div(sqrt(PI(prec), prec), prec)
-    c_prev = erf_a.div(scale.mult(exp(-a*a, prec), prec), prec)
-    c_next = (2 * a * c_prev).add(1, prec).mult(x, prec)
-    sum = c_prev.add(c_next, prec)
-
-    2.step do |k|
-      cn = (c_prev.mult(x, prec) + a * c_next).mult(2, prec).mult(x, prec).div(k, prec)
-      sum = sum.add(cn, prec)
-      c_prev, c_next = c_next, cn
-      break if [c_prev, c_next].all? { |c| c.zero?  || (c.exponent < sum.exponent - prec) }
-    end
-    value = sum.mult(scale.mult(exp(-(x + a).mult(x + a, prec), prec), prec), prec)
-    value > 1 ? BigDecimal(1) : value
-  end
-
-  private_class_method def _erfc_asymptotic(x, prec) # :nodoc:
-    # Let f(x) = erfc(x)*sqrt(pi)*exp(x**2)/2
-    # f(x) satisfies the following differential equation:
-    # 2*x*f(x) = f'(x) + 1
-    # From the above equation, we can derive the following asymptotic expansion:
-    # f(x) = (0..kmax).sum { (-1)**k * (2*k)! / 4**k / k! / x**(2*k)) } / x
-
-    # This asymptotic expansion does not converge.
-    # But if there is a k that satisfies (2*k)! / 4**k / k! / x**(2*k) < 10**(-prec),
-    # It is enough to calculate erfc within the given precision.
-    # 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::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)
-    end
-    return unless kmax
-
-    sum = BigDecimal(1)
-    # 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)
-      sum = sum.add(d, prec)
-    end
-    sum.div(exp(x2, prec).mult(PI(prec).sqrt(prec), prec), prec).div(x, prec)
+    require 'bigdecimal/math/erf'
+    Erf.erfc(x, prec)
   end
 
   # call-seq:
@@ -725,22 +626,8 @@ module BigMath
   #   #=> "0.17724538509055160272981674833411e1"
   #
   def gamma(x, prec)
-    prec = BigDecimal::Internal.coerce_validate_prec(prec, :gamma)
-    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :gamma)
-    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
-    if x < 0.5
-      raise Math::DomainError, 'Numerical argument is out of domain - gamma' if x.frac.zero?
-
-      # Euler's reflection formula: gamma(z) * gamma(1-z) = pi/sin(pi*z)
-      pi = PI(prec2)
-      sin = _sinpix(x, pi, prec2)
-      return pi.div(gamma(1 - x, prec2).mult(sin, prec2), prec)
-    elsif x.frac.zero? && x < 1000 * prec
-      return _gamma_positive_integer(x, prec2).mult(1, prec)
-    end
-
-    a, sum = _gamma_spouge_sum_part(x, prec2)
-    (x + (a - 1)).power(x - 0.5, prec2).mult(BigMath.exp(1 - x, prec2), prec2).mult(sum, prec)
+    require 'bigdecimal/math/gamma'
+    Gamma.gamma(x, prec)
   end
 
   # call-seq:
@@ -753,106 +640,8 @@ module BigMath
   #   #=> [0.57236494292470008707171367567653e0, 1]
   #
   def lgamma(x, prec)
-    prec = BigDecimal::Internal.coerce_validate_prec(prec, :lgamma)
-    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :lgamma)
-    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
-    if x < 0.5
-      return [BigDecimal::INFINITY, 1] if x.frac.zero?
-
-      loop do
-        # Euler's reflection formula: gamma(z) * gamma(1-z) = pi/sin(pi*z)
-        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::Internal::EXTRA_PREC
-
-        # Retry with higher precision if loss of significance is too large
-        prec2 = prec2 * 3 / 2
-      end
-    elsif x.frac.zero? && x < 1000 * prec
-      log_gamma = BigMath.log(_gamma_positive_integer(x, prec2), prec)
-      [log_gamma, 1]
-    else
-      # if x is close to 1 or 2, increase precision to reduce loss of significance
-      diff1_exponent = (x - 1).exponent
-      diff2_exponent = (x - 2).exponent
-      extremely_near_one = diff1_exponent < -prec2
-      extremely_near_two = diff2_exponent < -prec2
-
-      if extremely_near_one || extremely_near_two
-        # If x is extreamely close to base = 1 or 2, linear interpolation is accurate enough.
-        # Taylor expansion at x = base is: (x - base) * digamma(base) + (x - base) ** 2 * trigamma(base) / 2 + ...
-        # And we can ignore (x - base) ** 2 and higher order terms.
-        base = extremely_near_one ? 1 : 2
-        d = BigDecimal(1)._decimal_shift(1 - prec2)
-        log_gamma_d, sign = lgamma(base + d, prec2)
-        return [log_gamma_d.mult(x - base, prec2).div(d, prec), sign]
-      end
-
-      prec2 += [-diff1_exponent, -diff2_exponent, 0].max
-      a, sum = _gamma_spouge_sum_part(x, prec2)
-      log_gamma = BigMath.log(sum, prec2).add((x - 0.5).mult(BigMath.log(x.add(a - 1, prec2), prec2), prec2) + 1 - x, prec)
-      [log_gamma, 1]
-    end
-  end
-
-  # Returns sum part: sqrt(2*pi) and c[k]/(x+k) terms of Spouge's approximation
-  private_class_method def _gamma_spouge_sum_part(x, prec) # :nodoc:
-    x -= 1
-    # Spouge's approximation
-    # x! = (x + a)**(x + 0.5) * exp(-x - a) * (sqrt(2 * pi)  + (1..a - 1).sum{|k| c[k] / (x + k) } + epsilon)
-    # where c[k] = (-1)**k * (a - k)**(k - 0.5) * exp(a - k) / (k - 1)!
-    # and epsilon is bounded by a**(-0.5) * (2 * pi) ** (-a - 0.5)
-
-    # Estimate required a for given precision
-    a = (prec / Math.log10(2 * Math::PI)).ceil
-
-    # Calculate exponent of c[k] in low precision to estimate required precision
-    low_prec = 16
-    log10f = Math.log(10)
-    x_low_prec = x.mult(1, low_prec)
-    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) - BigDecimal::Internal.float_log(x_low_prec.add(k, low_prec)) / log10f
-    end
-
-    # Estimate exponent of sum by Stirling's approximation
-    approx_sum_exponent = x < 1 ? -Math.log10(a) / 2 : Math.log10(2 * Math::PI) / 2 + x_low_prec.add(0.5, low_prec) * Math.log10(x_low_prec / x_low_prec.add(a, low_prec))
-
-    # Determine required precision of c[k]
-    prec2 = [ck_exponents.max.ceil - approx_sum_exponent.floor, 0].max + prec
-
-    einv = BigMath.exp(-1, prec2)
-    sum = (PI(prec) * 2).sqrt(prec).mult(BigMath.exp(-a, prec), prec)
-    y = BigDecimal(1)
-    (1..a - 1).each do |k|
-      # c[k] = (-1)**k * (a - k)**(k - 0.5) * exp(-k) / (k-1)! / (x + k)
-      y = y.div(1 - k, prec2) if k > 1
-      y = y.mult(einv, prec2)
-      z = y.mult(BigDecimal((a - k) ** k), prec2).div(BigDecimal(a - k).sqrt(prec2).mult(x.add(k, prec2), prec2), prec2)
-      # sum += c[k] / (x + k)
-      sum = sum.add(z, prec2)
-    end
-    [a, sum]
-  end
-
-  private_class_method def _gamma_positive_integer(x, prec) # :nodoc:
-    return x if x == 1
-    numbers = (1..x - 1).map {|i| BigDecimal(i) }
-    while numbers.size > 1
-      numbers = numbers.each_slice(2).map {|a, b| b ? a.mult(b, prec) : a }
-    end
-    numbers.first
-  end
-
-  # Returns sin(pi * x), for gamma reflection formula calculation
-  private_class_method def _sinpix(x, pi, prec) # :nodoc:
-    x = x % 2
-    sign = x > 1 ? -1 : 1
-    x %= 1
-    x = 1 - x if x > 0.5 # to avoid sin(pi*x) loss of precision for x close to 1
-    sign * sin(x.mult(pi, prec), prec)
+    require 'bigdecimal/math/gamma'
+    Gamma.lgamma(x, prec)
   end
 
   # call-seq:

data/sig/big_decimal.rbs

@@ -1237,7 +1237,9 @@ module Kernel
   # Raises an exception if `value` evaluates to a Float and `digits` is larger
   # than Float::DIG + 1.
   #
-  def self?.BigDecimal: (real | string | BigDecimal initial, ?int digits, ?exception: bool) -> BigDecimal
+  def self?.BigDecimal: (real | string | BigDecimal initial, ?int digits, ?exception: true) -> BigDecimal
+                      | (real | string | BigDecimal initial, ?int digits, exception: bool) -> BigDecimal?
+                      | (untyped initial, ?untyped digits, ?exception: bool) -> BigDecimal?
 end
 
 %a{annotate:rdoc:skip}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bigdecimal
 version: !ruby/object:Gem::Version
-  version: 4.1.2
+  version: 4.1.3
 platform: java
 authors:
 - Kenta Murata
@@ -25,6 +25,8 @@ files:
 - lib/bigdecimal/jacobian.rb
 - lib/bigdecimal/ludcmp.rb
 - lib/bigdecimal/math.rb
+- lib/bigdecimal/math/erf.rb
+- lib/bigdecimal/math/gamma.rb
 - lib/bigdecimal/newton.rb
 - lib/bigdecimal/util.rb
 - sample/linear.rb