bigdecimal 3.2.3 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e0b80297731a8be5b2f5b04c5fab931a45aeee425f52a84afaca1bb34718913
-  data.tar.gz: 63bd3f047a4040d85ad410373b6355860c7445187199e5869e14d18f0bef3626
+  metadata.gz: bbfee49daa3925fcd286952eb946fdf8d2f266d907f208878b9c61f6ee556557
+  data.tar.gz: d7052a600cc71f060331f14e9a9e36e41251239d53640effa2984221d8ce18d7
 SHA512:
-  metadata.gz: a5a4e43d1fd15f8992d2e670015ebd6c690a8ffad8de26c275f6540a09eb99579886d4b2c36b5ec5e04f4253f43990576545238927b78b884102a24b9cda562f
-  data.tar.gz: 983fbf6d37e69908d5a84406983373fd1113243554386ed2531cf3546ffa2e15e311721139da511e7e2db95839da5a062898073557553b4655b090eb29cc57d8
+  metadata.gz: c3850b87c3a249da319665bfbd12a9743f06d844e7315c3d2120ca0c972d5686ba61747cbb9c678ff64dfc94e8c91d7611b58775d5bb6aafe95241e390d802fb
+  data.tar.gz: 9fcb29c1a5abcbb8ab15af42c177f7d55a23695a6c14248718431b73bd019e4e90b51bd038aca6de356e2bf31040e44612b4c2fcbb807d71f2117cef3681a15b

data/ext/bigdecimal/bigdecimal.c

@@ -31,7 +31,7 @@
 #include "bits.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "3.2.3"
+#define BIGDECIMAL_VERSION "3.3.0"
 
 /* #define ENABLE_NUMERIC_STRING */
 
@@ -252,10 +252,21 @@ static const rb_data_type_t BigDecimal_data_type = {
 #endif
 };
 
+// TypedData_Wrap_Struct may fail if there is no memory, or GC.add_stress_to_class(BigDecimal) is set.
+// We need to first allocate empty struct, allocate Real struct, and then set the data pointer.
+typedef struct { VALUE _obj; } NULL_WRAPPED_VALUE;
+static NULL_WRAPPED_VALUE
+BigDecimal_alloc_empty_struct(VALUE klass)
+{
+    return (NULL_WRAPPED_VALUE) { TypedData_Wrap_Struct(klass, &BigDecimal_data_type, NULL) };
+}
+
 static VALUE
-BigDecimal_wrap_struct(VALUE klass, Real *real)
+BigDecimal_wrap_struct(NULL_WRAPPED_VALUE v, Real *real)
 {
-    VALUE obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, real);
+    VALUE obj = v._obj;
+    assert(RTYPEDDATA_DATA(obj) == NULL);
+    RTYPEDDATA_DATA(obj) = real;
     RB_OBJ_FREEZE(obj);
     return obj;
 }
@@ -265,8 +276,9 @@ MAYBE_UNUSED(static inline BDVALUE rbd_allocate_struct_zero_wrap(int sign, size_
 static BDVALUE
 rbd_allocate_struct_zero_wrap(int sign, size_t const digits)
 {
+    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
     Real *real = rbd_allocate_struct_zero(sign, digits);
-    return (BDVALUE) { BigDecimal_wrap_struct(rb_cBigDecimal, real), real };
+    return (BDVALUE) { BigDecimal_wrap_struct(null_wrapped, real), real };
 }
 
 static inline int
@@ -1041,9 +1053,10 @@ check_int_precision(VALUE v)
 static NULLABLE_BDVALUE
 CreateFromString(const char *str, VALUE klass, bool strict_p, bool raise_exception)
 {
+    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(klass);
     Real *pv = VpAlloc(str, strict_p, raise_exception);
     if (!pv) return (NULLABLE_BDVALUE) { Qnil, NULL };
-    return (NULLABLE_BDVALUE) { BigDecimal_wrap_struct(klass, pv), pv };
+    return (NULLABLE_BDVALUE) { BigDecimal_wrap_struct(null_wrapped, pv), pv };
 }
 
 static Real *
@@ -1720,17 +1733,26 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE
         *mod = (NULLABLE_BDVALUE) { nan, DATA_PTR(nan) };
         goto Done;
     }
-    if (VpIsInf(b.real)) {
-        VALUE zero = BigDecimal_positive_zero();
-        *div = (NULLABLE_BDVALUE) { zero, DATA_PTR(zero) };
-        *mod = bdvalue_nullable(a);
-        goto Done;
-    }
     if (VpIsZero(a.real)) {
         VALUE zero = BigDecimal_positive_zero();
         *div = *mod = (NULLABLE_BDVALUE) { zero, DATA_PTR(zero) };
         goto Done;
     }
+    if (VpIsInf(b.real)) {
+        if (!truncate && VpGetSign(a.real) * VpGetSign(b.real) < 0) {
+            BDVALUE minus_one = NewZeroWrap(1, BASE_FIG);
+            VpSetOne(minus_one.real);
+            VpSetSign(minus_one.real, -1);
+            RB_GC_GUARD(minus_one.bigdecimal);
+            *div = bdvalue_nullable(minus_one);
+            *mod = bdvalue_nullable(b);
+        } else {
+            VALUE zero = BigDecimal_positive_zero();
+            *div = (NULLABLE_BDVALUE) { zero, DATA_PTR(zero) };
+            *mod = bdvalue_nullable(a);
+        }
+        goto Done;
+    }
 
     a_exponent = VpExponent10(a.real);
     b_exponent = VpExponent10(b.real);
@@ -2580,6 +2602,7 @@ check_exception(VALUE bd)
 static VALUE
 rb_uint64_convert_to_BigDecimal(uint64_t uval)
 {
+    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
     Real *vp;
     if (uval == 0) {
         vp = rbd_allocate_struct(1);
@@ -2621,7 +2644,7 @@ rb_uint64_convert_to_BigDecimal(uint64_t uval)
         MEMCPY(vp->frac, buf + BIGDECIMAL_INT64_MAX_LENGTH - len, DECDIG, len);
     }
 
-    return BigDecimal_wrap_struct(rb_cBigDecimal, vp);
+    return BigDecimal_wrap_struct(null_wrapped, vp);
 }
 
 static VALUE
@@ -2905,12 +2928,13 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         if (digs == SIZE_MAX)
             return check_exception(val);
 
+        NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
         Real *vp;
         TypedData_Get_Struct(val, Real, &BigDecimal_data_type, vp);
         vp = VpCopy(NULL, vp);
         RB_GC_GUARD(val);
 
-        VALUE copy = BigDecimal_wrap_struct(rb_cBigDecimal, vp);
+        VALUE copy = BigDecimal_wrap_struct(null_wrapped, vp);
         /* TODO: rounding */
         return check_exception(copy);
     }

data/lib/bigdecimal/math.rb

@@ -7,6 +7,7 @@ require 'bigdecimal'
 #   sqrt(x, prec)
 #   sin (x, prec)
 #   cos (x, prec)
+#   tan (x, prec)
 #   atan(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
@@ -24,8 +25,8 @@ require 'bigdecimal'
 #
 #   include BigMath
 #
-#   a = BigDecimal((PI(100)/2).to_s)
-#   puts sin(a,100) # => 0.99999999999999999999......e0
+#   a = BigDecimal((PI(49)/2).to_s)
+#   puts sin(a,100) # => 0.9999999999...9999999986e0
 #
 module BigMath
   module_function
@@ -36,13 +37,42 @@ module BigMath
   # Computes the square root of +decimal+ to the specified number of digits of
   # precision, +numeric+.
   #
-  #   BigMath.sqrt(BigDecimal('2'), 16).to_s
-  #   #=> "0.1414213562373095048801688724e1"
+  #   BigMath.sqrt(BigDecimal('2'), 32).to_s
+  #   #=> "0.14142135623730950488016887242097e1"
   #
   def sqrt(x, prec)
+    BigDecimal::Internal.validate_prec(prec, :sqrt)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sqrt)
     x.sqrt(prec)
   end
 
+
+  # Returns [sign, reduced_x] where reduced_x is in -pi/2..pi/2
+  # and satisfies sin(x) = sign * sin(reduced_x)
+  # If add_half_pi is true, adds pi/2 to x before reduction.
+  # Precision of pi is adjusted to ensure reduced_x has the required precision.
+  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
+    while true
+      pi = PI(mod_prec + pi_extra_prec)
+      half_pi = pi / 2
+      div, mod = (add_half_pi ? x + pi : x + half_pi).divmod(pi)
+      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
+      elsif mod_prec + mod.exponent < prec
+        # Estimate required precision of pi
+        mod_prec = prec - mod.exponent + BigDecimal.double_fig
+      else
+        return [div % 2 == 0 ? 1 : -1, mod.mult(1, prec)]
+      end
+    end
+  end
+
   # call-seq:
   #   sin(decimal, numeric) -> BigDecimal
   #
@@ -51,42 +81,33 @@ module BigMath
   #
   # If +decimal+ is Infinity or NaN, returns NaN.
   #
-  #   BigMath.sin(BigMath.PI(5)/4, 5).to_s
-  #   #=> "0.70710678118654752440082036563292800375e0"
+  #   BigMath.sin(BigMath.PI(5)/4, 32).to_s
+  #   #=> "0.70710807985947359435812921837984e0"
   #
   def sin(x, prec)
-    raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
+    BigDecimal::Internal.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")
-    x = -x if neg = x < 0
-    if x > 6
-      twopi = two * BigMath.PI(prec + x.exponent)
-      if x > 30
-        x %= twopi
-      else
-        x -= twopi while x > twopi
-      end
-    end
+    sign, x = _sin_periodic_reduction(x, n)
     x1   = x
     x2   = x.mult(x,n)
-    sign = 1
     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
-      sign = -sign
-      x1  = x2.mult(x1,n)
+      x1  = -x2.mult(x1,n)
       i  += two
       z  *= (i-one) * i
-      d   = sign * x1.div(z,m)
+      d   = x1.div(z,m)
       y  += d
     end
     y = BigDecimal("1") if y > 1
-    neg ? -y : y
+    y.mult(sign, prec)
   end
 
   # call-seq:
@@ -97,41 +118,34 @@ module BigMath
   #
   # If +decimal+ is Infinity or NaN, returns NaN.
   #
-  #   BigMath.cos(BigMath.PI(4), 16).to_s
-  #   #=> "-0.999999999999999999999999999999856613163740061349e0"
+  #   BigMath.cos(BigMath.PI(16), 32).to_s
+  #   #=> "-0.99999999999999999999999999999997e0"
   #
   def cos(x, prec)
-    raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
-    n    = prec + BigDecimal.double_fig
-    one  = BigDecimal("1")
-    two  = BigDecimal("2")
-    x = -x if x < 0
-    if x > 6
-      twopi = two * BigMath.PI(prec + x.exponent)
-      if x > 30
-        x %= twopi
-      else
-        x -= twopi while x > twopi
-      end
-    end
-    x1 = one
-    x2 = x.mult(x,n)
-    sign = 1
-    y = one
-    d = y
-    i = BigDecimal("0")
-    z = one
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      sign = -sign
-      x1  = x2.mult(x1,n)
-      i  += two
-      z  *= (i-one) * i
-      d   = sign * x1.div(z,m)
-      y  += d
-    end
-    y < -1 ? BigDecimal("-1") : y > 1 ? BigDecimal("1") : y
+    BigDecimal::Internal.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)
+  end
+
+  # call-seq:
+  #   tan(decimal, numeric) -> BigDecimal
+  #
+  # Computes the tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is Infinity or NaN, returns NaN.
+  #
+  #   BigMath.tan(BigDecimal("0.0"), 4).to_s
+  #   #=> "0.0"
+  #
+  #   BigMath.tan(BigMath.PI(24) / 4, 32).to_s
+  #   #=> "0.99999999999999999999999830836025e0"
+  #
+  def tan(x, prec)
+    BigDecimal::Internal.validate_prec(prec, :tan)
+    sin(x, prec + BigDecimal.double_fig).div(cos(x, prec + BigDecimal.double_fig), prec)
   end
 
   # call-seq:
@@ -142,17 +156,18 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  #   BigMath.atan(BigDecimal('-1'), 16).to_s
-  #   #=> "-0.785398163397448309615660845819878471907514682065e0"
+  #   BigMath.atan(BigDecimal('-1'), 32).to_s
+  #   #=> "-0.78539816339744830961566084581988e0"
   #
   def atan(x, prec)
-    raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
-    return BigDecimal("NaN") if x.nan?
-    pi = PI(prec)
+    BigDecimal::Internal.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)
     x = -x if neg = x < 0
     return pi.div(neg ? -2 : 2, prec) if x.infinite?
-    return pi / (neg ? -4 : 4) if x.round(prec) == 1
-    n = prec + BigDecimal.double_fig
+    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
@@ -170,7 +185,7 @@ module BigMath
     y *= 2 if dbl
     y = pi / 2 - y if inv
     y = -y if neg
-    y
+    y.mult(1, prec)
   end
 
   # call-seq:
@@ -179,11 +194,11 @@ module BigMath
   # Computes the value of pi to the specified number of digits of precision,
   # +numeric+.
   #
-  #   BigMath.PI(10).to_s
-  #   #=> "0.3141592653589793238462643388813853786957412e1"
+  #   BigMath.PI(32).to_s
+  #   #=> "0.31415926535897932384626433832795e1"
   #
   def PI(prec)
-    raise ArgumentError, "Zero or negative precision for PI" if prec <= 0
+    BigDecimal::Internal.validate_prec(prec, :PI)
     n      = prec + BigDecimal.double_fig
     zero   = BigDecimal("0")
     one    = BigDecimal("1")
@@ -215,7 +230,7 @@ module BigMath
       pi  = pi + d
       k   = k+two
     end
-    pi
+    pi.mult(1, prec)
   end
 
   # call-seq:
@@ -224,11 +239,11 @@ module BigMath
   # Computes e (the base of natural logarithms) to the specified number of
   # digits of precision, +numeric+.
   #
-  #   BigMath.E(10).to_s
-  #   #=> "0.271828182845904523536028752390026306410273e1"
+  #   BigMath.E(32).to_s
+  #   #=> "0.27182818284590452353602874713527e1"
   #
   def E(prec)
-    raise ArgumentError, "Zero or negative precision for E" if prec <= 0
+    BigDecimal::Internal.validate_prec(prec, :E)
     BigMath.exp(1, prec)
   end
 end

data/lib/bigdecimal/util.rb

@@ -119,8 +119,11 @@ class Rational < Numeric
   #
   # Returns the value as a BigDecimal.
   #
-  # The required +precision+ parameter is used to determine the number of
-  # significant digits for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
@@ -129,7 +132,7 @@ class Rational < Numeric
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(precision)
+  def to_d(precision=0)
     BigDecimal(self, precision)
   end
 end
@@ -141,29 +144,27 @@ class Complex < Numeric
   #     cmp.to_d(precision)  -> bigdecimal
   #
   # Returns the value as a BigDecimal.
+  # If the imaginary part is not +0+, an error is raised
   #
-  # The +precision+ parameter is required for a rational complex number.
-  # This parameter is used to determine the number of significant digits
-  # for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
   #
   #     Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
   #     Complex(Rational(22, 7), 0).to_d(3)   # => 0.314e1
+  #     Complex(1, 1).to_d   # raises ArgumentError
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(*args)
+  def to_d(precision=0)
     BigDecimal(self) unless self.imag.zero? # to raise error
 
-    if args.length == 0
-      case self.real
-      when Rational
-        BigDecimal(self.real) # to raise error
-      end
-    end
-    self.real.to_d(*args)
+    BigDecimal(self.real, precision)
   end
 end
 

data/lib/bigdecimal.rb

@@ -1,6 +1,11 @@
 if RUBY_ENGINE == 'jruby'
   JRuby::Util.load_ext("org.jruby.ext.bigdecimal.BigDecimalLibrary")
-  return
+
+  class BigDecimal
+    def _decimal_shift(i) # :nodoc:
+      to_java.move_point_right(i).to_d
+    end
+  end
 else
   require 'bigdecimal.so'
 end
@@ -15,7 +20,7 @@ class BigDecimal
       when BigDecimal
         return x
       when Integer, Float
-        return BigDecimal(x)
+        return BigDecimal(x, 0)
       when Rational
         return BigDecimal(x, [prec, 2 * BigDecimal.double_fig].max)
       end
@@ -160,22 +165,32 @@ class BigDecimal
       return BigDecimal(1).div(inv, prec)
     end
 
-    int_part = y.fix.to_i
     prec2 = prec + BigDecimal.double_fig
-    pow_prec = prec2 + (int_part > 0 ? y.exponent : 0)
-    ans = BigDecimal(1)
-    n = 1
-    xn = x
-    while true
-      ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
-      n <<= 1
-      break if n > int_part
-      xn = xn.mult(xn, pow_prec)
-    end
-    unless frac_part.zero?
-      ans = ans.mult(BigMath.exp(BigMath.log(x, prec2).mult(frac_part, prec2), prec2), prec2)
+
+    if frac_part.zero? && y.exponent < Math.log(prec) * 5 + 20
+      # Use exponentiation by squaring if y is an integer and not too large
+      pow_prec = prec2 + y.exponent
+      n = 1
+      xn = x
+      ans = BigDecimal(1)
+      int_part = y.fix.to_i
+      while true
+        ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
+        n <<= 1
+        break if n > int_part
+        xn = xn.mult(xn, pow_prec)
+      end
+      ans.mult(1, prec)
+    else
+      if x > 1
+        # To calculate exp(z, prec), z needs prec+max(z.exponent, 0) precision if z > 0.
+        # Estimate (y*log(x)).exponent
+        logx_exponent = x < 2 ? (x - 1).exponent : Math.log10(x.exponent).round
+        ylogx_exponent = y.exponent + logx_exponent
+        prec2 += [ylogx_exponent, 0].max
+      end
+      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), prec)
     end
-    ans.mult(1, prec)
   end
 
   # Returns the square root of the value.
@@ -190,23 +205,19 @@ class BigDecimal
     raise FloatDomainError, "sqrt of 'NaN'(Not a Number)" if nan?
     return self if zero?
 
-    limit = BigDecimal.limit.nonzero? if prec == 0
-
-    # BigDecimal#sqrt calculates at least n_significant_digits precision.
-    # This feature maybe problematic for some cases.
-    n_digits = n_significant_digits
-    prec = [prec, n_digits].max
+    if prec == 0
+      prec = BigDecimal.limit.nonzero? || n_significant_digits + BigDecimal.double_fig
+    end
 
     ex = exponent / 2
     x = _decimal_shift(-2 * ex)
-    y = BigDecimal(Math.sqrt(x.to_f))
+    y = BigDecimal(Math.sqrt(x.to_f), 0)
     precs = [prec + BigDecimal.double_fig]
     precs << 2 + precs.last / 2 while precs.last > BigDecimal.double_fig
     precs.reverse_each do |p|
       y = y.add(x.div(y, p), p).div(2, p)
     end
-    y = y.mult(1, limit) if limit
-    y._decimal_shift(ex)
+    y._decimal_shift(ex).mult(1, prec)
   end
 end
 
@@ -232,56 +243,67 @@ module BigMath
 
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log)
     return BigDecimal::Internal.nan_computation_result if x.nan?
-    raise Math::DomainError, 'Zero or negative argument for log' if x <= 0
+    raise Math::DomainError, 'Negative argument for log' if x < 0
+    return -BigDecimal::Internal.infinity_computation_result if x.zero?
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal(0) if x == 1
 
+    prec2 = prec + BigDecimal.double_fig
     BigDecimal.save_limit do
       BigDecimal.limit(0)
       if x > 10 || x < 0.1
-        log10 = log(BigDecimal(10), prec)
+        log10 = log(BigDecimal(10), prec2)
         exponent = x.exponent
         x = x._decimal_shift(-exponent)
         if x < 0.3
           x *= 10
           exponent -= 1
         end
-        return log10 * exponent + log(x, prec)
+        return (log10 * exponent).add(log(x, prec2), prec)
       end
 
       x_minus_one_exponent = (x - 1).exponent
-      prec += BigDecimal.double_fig
 
       # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
-      sqrt_steps = [Integer.sqrt(prec) + 3 * x_minus_one_exponent, 0].max
+      sqrt_steps = [Integer.sqrt(prec2) + 3 * x_minus_one_exponent, 0].max
 
       lg2 = 0.3010299956639812
-      prec2 = prec + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
+      sqrt_prec = prec2 + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
 
       sqrt_steps.times do
-        x = x.sqrt(prec2)
-
-        # Workaround for https://github.com/ruby/bigdecimal/issues/354
-        x = x.mult(1, prec2 + BigDecimal.double_fig)
+        x = x.sqrt(sqrt_prec)
       end
 
       # Taylor series for log(x) around 1
       # log(x) = -log((1 + X) / (1 - X)) where X = (x - 1) / (x + 1)
       # log(x) = 2 * (X + X**3 / 3 + X**5 / 5 + X**7 / 7 + ...)
-      x = (x - 1).div(x + 1, prec2)
+      x = (x - 1).div(x + 1, sqrt_prec)
       y = x
-      x2 = x.mult(x, prec)
+      x2 = x.mult(x, prec2)
       1.step do |i|
-        n = prec + x.exponent - y.exponent + x2.exponent
+        n = prec2 + x.exponent - y.exponent + x2.exponent
         break if n <= 0 || x.zero?
         x = x.mult(x2.round(n - x2.exponent), n)
-        y = y.add(x.div(2 * i + 1, n), prec)
+        y = y.add(x.div(2 * i + 1, n), prec2)
       end
 
       y.mult(2 ** (sqrt_steps + 1), prec)
     end
   end
 
+  # Taylor series for exp(x) around 0
+  private_class_method def self._exp_taylor(x, prec) # :nodoc:
+    xn = BigDecimal(1)
+    y = BigDecimal(1)
+    1.step do |i|
+      n = prec + xn.exponent
+      break if n <= 0 || xn.zero?
+      xn = xn.mult(x, n).div(i, n)
+      y = y.add(xn, prec)
+    end
+    y
+  end
+
   # call-seq:
   #   BigMath.exp(decimal, numeric)    -> BigDecimal
   #
@@ -298,23 +320,17 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return x.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0) if x.infinite?
     return BigDecimal(1) if x.zero?
-    return BigDecimal(1).div(exp(-x, prec), prec) if x < 0
 
     # exp(x * 10**cnt) = exp(x)**(10**cnt)
-    cnt = x > 1 ? x.exponent : 0
+    cnt = x < -1 || x > 1 ? x.exponent : 0
     prec2 = prec + BigDecimal.double_fig + cnt
     x = x._decimal_shift(-cnt)
-    xn = BigDecimal(1)
-    y = BigDecimal(1)
 
-    # Taylor series for exp(x) around 0
-    1.step do |i|
-      n = prec2 + xn.exponent
-      break if n <= 0 || xn.zero?
-      x = x.mult(1, n)
-      xn = xn.mult(x, n).div(i, n)
-      y = y.add(xn, prec2)
-    end
+    # Calculation of exp(small_prec) is fast because calculation of x**n is fast
+    # Calculation of exp(small_abs) converges fast.
+    # exp(x) = exp(small_prec_part + small_abs_part) = exp(small_prec_part) * exp(small_abs_part)
+    x_small_prec = x.round(Integer.sqrt(prec2))
+    y = _exp_taylor(x_small_prec, prec2).mult(_exp_taylor(x.sub(x_small_prec, prec2), prec2), prec2)
 
     # calculate exp(x * 10**cnt) from exp(x)
     # exp(x * 10**k) = exp(x * 10**(k - 1)) ** 10

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bigdecimal
 version: !ruby/object:Gem::Version
-  version: 3.2.3
+  version: 3.3.0
 platform: ruby
 authors:
 - Kenta Murata