bigdecimal 4.1.2 → 4.1.3

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: ruby
 authors:
 - Kenta Murata
@@ -37,6 +37,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