bigdecimal 3.3.1 → 4.1.3

data/lib/bigdecimal/math.rb

@@ -1,19 +1,40 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'bigdecimal'
 
 #
 #--
 # Contents:
 #   sqrt(x, prec)
+#   cbrt(x, prec)
+#   hypot(x, y, prec)
 #   sin (x, prec)
 #   cos (x, prec)
 #   tan (x, prec)
+#   asin(x, prec)
+#   acos(x, prec)
 #   atan(x, prec)
+#   atan2(y, x, prec)
+#   sinh (x, prec)
+#   cosh (x, prec)
+#   tanh (x, prec)
+#   asinh(x, prec)
+#   acosh(x, prec)
+#   atanh(x, prec)
+#   log2 (x, prec)
+#   log10(x, prec)
+#   log1p(x, prec)
+#   expm1(x, prec)
+#   erf (x, prec)
+#   erfc(x, prec)
+#   gamma(x, prec)
+#   lgamma(x, prec)
+#   frexp(x)
+#   ldexp(x, exponent)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
 # where:
-#   x    ... BigDecimal number to be computed.
+#   x, y ... BigDecimal number to be computed.
 #   prec ... Number of digits to be obtained.
 #++
 #
@@ -54,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
@@ -63,16 +84,92 @@ 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
+  #
+  # Computes the cube root of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  #   BigMath.cbrt(BigDecimal('2'), 32).to_s
+  #   #=> "0.12599210498948731647672106072782e1"
+  #
+  def cbrt(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :cbrt)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cbrt)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
+    return BigDecimal(0) if x.zero?
+
+    x = -x if neg = x < 0
+    ex = x.exponent / 3
+    x = x._decimal_shift(-3 * ex)
+    y = BigDecimal(Math.cbrt(x.to_f), 0)
+    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)
+  end
+
+  # call-seq:
+  #   hypot(x, y, numeric) -> BigDecimal
+  #
+  # Returns sqrt(x**2 + y**2) to the specified number of digits of
+  # precision, +numeric+.
+  #
+  #   BigMath.hypot(BigDecimal('1'), BigDecimal('2'), 32).to_s
+  #   #=> "0.22360679774997896964091736687313e1"
+  #
+  def hypot(x, y, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :hypot)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :hypot)
+    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::Internal::EXTRA_PREC
+    sqrt(x.mult(x, prec2) + y.mult(y, prec2), prec)
+  end
+
   # call-seq:
   #   sin(decimal, numeric) -> BigDecimal
   #
@@ -88,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:
@@ -125,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:
@@ -145,7 +226,59 @@ 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:
+  #   asin(decimal, numeric) -> BigDecimal
+  #
+  # Computes the arcsine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.asin(BigDecimal('0.5'), 32).to_s
+  #   #=> "0.52359877559829887307710723054658e0"
+  #
+  def asin(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :asin)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :asin)
+    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::Internal::EXTRA_PREC
+    cos = (1 - x**2).sqrt(prec2)
+    if cos.zero?
+      PI(prec2).div(x > 0 ? 2 : -2, prec)
+    else
+      atan(x.div(cos, prec2), prec)
+    end
+  end
+
+  # call-seq:
+  #   acos(decimal, numeric) -> BigDecimal
+  #
+  # Computes the arccosine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.acos(BigDecimal('0.5'), 32).to_s
+  #   #=> "0.10471975511965977461542144610932e1"
+  #
+  def acos(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :acos)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :acos)
+    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::Internal::EXTRA_PREC
+    return (PI(prec2) / 2).sub(asin(x, prec2), prec) if x < 0
+    return PI(prec2).div(2, prec) if x.zero?
+
+    sin = (1 - x**2).sqrt(prec2)
+    atan(sin.div(x, prec2), prec)
   end
 
   # call-seq:
@@ -163,29 +296,382 @@ 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(prec) == 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 = PI(n) / 2 - y if inv
+    y.mult(neg ? -1 : 1, prec)
+  end
+
+  # call-seq:
+  #   atan2(decimal, decimal, numeric) -> BigDecimal
+  #
+  # Computes the arctangent of y and x to the specified number of digits of
+  # precision, +numeric+.
+  #
+  #   BigMath.atan2(BigDecimal('-1'), BigDecimal('1'), 32).to_s
+  #   #=> "-0.78539816339744830961566084581988e0"
+  #
+  def atan2(y, x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan2)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan2)
+    y = BigDecimal::Internal.coerce_to_bigdecimal(y, prec, :atan2)
+    return BigDecimal::Internal.nan_computation_result if x.nan? || y.nan?
+
+    if x.infinite? || y.infinite?
+      one = BigDecimal(1)
+      zero = BigDecimal(0)
+      x = x.infinite? ? (x > 0 ? one : -one) : zero
+      y = y.infinite? ? (y > 0 ? one : -one) : y.sign * zero
+    end
+
+    return x.sign >= 0 ? BigDecimal(0) : y.sign * PI(prec) if y.zero?
+
+    y = -y if neg = y < 0
+    xlarge = y.abs < x.abs
+    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
+      v = xlarge ? PI(prec2) - atan(-y.div(x, prec2), prec2) : PI(prec2) / 2 + atan(x.div(-y, prec2), prec2)
+    end
+    v.mult(neg ? -1 : 1, prec)
+  end
+
+  # call-seq:
+  #   sinh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic sine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.sinh(BigDecimal('1'), 32).to_s
+  #   #=> "0.11752011936438014568823818505956e1"
+  #
+  def sinh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :sinh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sinh)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
+
+    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)
+  end
+
+  # call-seq:
+  #   cosh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic cosine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.cosh(BigDecimal('1'), 32).to_s
+  #   #=> "0.15430806348152437784779056207571e1"
+  #
+  def cosh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :cosh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cosh)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result if x.infinite?
+
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
+    e = exp(x, prec2)
+    (e + BigDecimal(1).div(e, prec2)).div(2, prec)
+  end
+
+  # call-seq:
+  #   tanh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.tanh(BigDecimal('1'), 32).to_s
+  #   #=> "0.76159415595576488811945828260479e0"
+  #
+  def tanh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :tanh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :tanh)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal(x.infinite?) if x.infinite?
+
+    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)
+  end
+
+  # call-seq:
+  #   asinh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic sine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.asinh(BigDecimal('1'), 32).to_s
+  #   #=> "0.88137358701954302523260932497979e0"
+  #
+  def asinh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :asinh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :asinh)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    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::Internal::EXTRA_PREC
+    log(x + sqrt(x**2 + 1, sqrt_prec), prec)
+  end
+
+  # call-seq:
+  #   acosh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic cosine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.acosh(BigDecimal('2'), 32).to_s
+  #   #=> "0.1316957896924816708625046347308e1"
+  #
+  def acosh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :acosh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :acosh)
+    raise Math::DomainError, "Out of domain argument for acosh" if x < 1
+    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::Internal::EXTRA_PREC), prec)
+  end
+
+  # call-seq:
+  #   atanh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.atanh(BigDecimal('0.5'), 32).to_s
+  #   #=> "0.54930614433405484569762261846126e0"
+  #
+  def atanh(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :atanh)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atanh)
+    raise Math::DomainError, "Out of domain argument for atanh" if x < -1 || x > 1
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result if x == 1
+    return -BigDecimal::Internal.infinity_computation_result if x == -1
+
+    prec2 = prec + BigDecimal::Internal::EXTRA_PREC
+    (log(x + 1, prec2) - log(1 - x, prec2)).div(2, prec)
+  end
+
+  # call-seq:
+  #   BigMath.log2(decimal, numeric)    -> BigDecimal
+  #
+  # Computes the base 2 logarithm of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  # If +decimal+ is zero or negative, raises Math::DomainError.
+  #
+  # If +decimal+ is positive infinity, returns Infinity.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.log2(BigDecimal('3'), 32).to_s
+  #   #=> "0.15849625007211561814537389439478e1"
+  #
+  def log2(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log2)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log2)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
+
+    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::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+    v.mult(1, prec)
+  end
+
+  # call-seq:
+  #   BigMath.log10(decimal, numeric)    -> BigDecimal
+  #
+  # Computes the base 10 logarithm of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  # If +decimal+ is zero or negative, raises Math::DomainError.
+  #
+  # If +decimal+ is positive infinity, returns Infinity.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.log10(BigDecimal('3'), 32).to_s
+  #   #=> "0.47712125471966243729502790325512e0"
+  #
+  def log10(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log10)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log10)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
+
+    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::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+    v.mult(1, prec)
+  end
+
+  # call-seq:
+  #   BigMath.log1p(decimal, numeric)    -> BigDecimal
+  #
+  # Computes log(1 + decimal) to the specified number of digits of precision, +numeric+.
+  #
+  #   BigMath.log1p(BigDecimal('0.1'), 32).to_s
+  #   #=> "0.95310179804324860043952123280765e-1"
+  #
+  def log1p(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log1p)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log1p)
+    raise Math::DomainError, 'Out of domain argument for log1p' if x < -1
+
+    return log(x + 1, prec)
+  end
+
+  # call-seq:
+  #   BigMath.expm1(decimal, numeric)    -> BigDecimal
+  #
+  # Computes exp(decimal) - 1 to the specified number of digits of precision, +numeric+.
+  #
+  #   BigMath.expm1(BigDecimal('0.1'), 32).to_s
+  #   #=> "0.10517091807564762481170782649025e0"
+  #
+  def expm1(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :expm1)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :expm1)
+    return BigDecimal(-1) if x.infinite? == -1
+
+    exp_prec = prec
+    if x < -1
+      # log10(exp(x)) = x * log10(e)
+      lg_e = 0.4342944819032518
+      exp_prec = prec + (lg_e * x).ceil + BigDecimal::Internal::EXTRA_PREC
+    elsif x < 1
+      exp_prec = prec - x.exponent + BigDecimal::Internal::EXTRA_PREC
+    else
+      exp_prec = prec
     end
-    y *= 2 if dbl
-    y = pi / 2 - y if inv
-    y = -y if neg
-    y.mult(1, prec)
+
+    return BigDecimal(-1) if exp_prec <= 0
+
+    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
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.erf(BigDecimal('1'), 32).to_s
+  #   #=> "0.84270079294971486934122063508261e0"
+  #
+  def erf(x, prec)
+    require 'bigdecimal/math/erf'
+    Erf.erf(x, prec)
+  end
+
+  # call-seq:
+  #   erfc(decimal, numeric) -> BigDecimal
+  #
+  # Computes the complementary error function of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.erfc(BigDecimal('10'), 32).to_s
+  #   #=> "0.20884875837625447570007862949578e-44"
+  #
+  def erfc(x, prec)
+    require 'bigdecimal/math/erf'
+    Erf.erfc(x, prec)
+  end
+
+  # call-seq:
+  #   BigMath.gamma(decimal, numeric)    -> BigDecimal
+  #
+  # Computes the gamma function of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  #   BigMath.gamma(BigDecimal('0.5'), 32).to_s
+  #   #=> "0.17724538509055160272981674833411e1"
+  #
+  def gamma(x, prec)
+    require 'bigdecimal/math/gamma'
+    Gamma.gamma(x, prec)
+  end
+
+  # call-seq:
+  #   BigMath.lgamma(decimal, numeric)    -> [BigDecimal, Integer]
+  #
+  # Computes the natural logarithm of the absolute value of the gamma function
+  # of +decimal+ to the specified number of digits of precision, +numeric+ and its sign.
+  #
+  #   BigMath.lgamma(BigDecimal('0.5'), 32)
+  #   #=> [0.57236494292470008707171367567653e0, 1]
+  #
+  def lgamma(x, prec)
+    require 'bigdecimal/math/gamma'
+    Gamma.lgamma(x, prec)
+  end
+
+  # call-seq:
+  #   frexp(x) -> [BigDecimal, Integer]
+  #
+  # Decomposes +x+ into a normalized fraction and an integral power of ten.
+  #
+  #   BigMath.frexp(BigDecimal(123.456))
+  #   #=> [0.123456e0, 3]
+  #
+  def frexp(x)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, 0, :frexp)
+    return [x, 0] unless x.finite?
+
+    exponent = x.exponent
+    [x._decimal_shift(-exponent), exponent]
+  end
+
+  # call-seq:
+  #   ldexp(fraction, exponent) -> BigDecimal
+  #
+  # Inverse of +frexp+.
+  # Returns the value of fraction * 10**exponent.
+  #
+  #   BigMath.ldexp(BigDecimal("0.123456e0"), 3)
+  #   #=> 0.123456e3
+  #
+  def ldexp(x, exponent)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, 0, :ldexp)
+    x.finite? ? x._decimal_shift(exponent) : x
   end
 
   # call-seq:
@@ -198,39 +684,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:
@@ -244,6 +711,6 @@ module BigMath
   #
   def E(prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :E)
-    BigMath.exp(1, prec)
+    exp(1, prec)
   end
 end