Calculate exp, log, pow with the given prec even if prec limit is set

log and pow is not working with prec limit now. It will be solved when sqrt is fixed.

Author: tompng

lib/bigdecimal.rb

@@ -200,52 +200,55 @@ def self.log(x, prec)
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal(0) if x == 1
 
-    if x > 10 || x < 0.1
-      log10 = log(BigDecimal(10), prec)
-      exponent = x.exponent
-      x = x * BigDecimal("1e#{-x.exponent}")
-      if x < 0.3
-        x *= 10
-        exponent -= 1
+    BigDecimal.save_limit do
+      BigDecimal.limit(0)
+      if x > 10 || x < 0.1
+        log10 = log(BigDecimal(10), prec)
+        exponent = x.exponent
+        x *= BigDecimal("1e#{-x.exponent}")
+        if x < 0.3
+          x *= 10
+          exponent -= 1
+        end
+        return log10 * exponent + log(x, prec)
       end
-      return log10 * exponent + log(x, prec)
-    end
 
-    x_minus_one_exponent = (x - 1).exponent
-    prec += BigDecimal.double_fig
+      x_minus_one_exponent = (x - 1).exponent
+      prec += BigDecimal.double_fig
 
-    # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
-    sqrt_steps = [2 * Integer.sqrt(prec) + 3 * x_minus_one_exponent, 0].max
+      # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
+      sqrt_steps = [2 * Integer.sqrt(prec) + 3 * x_minus_one_exponent, 0].max
 
-    # Reduce sqrt_step until sqrt gets fast
-    # https://github.com/ruby/bigdecimal/pull/323
-    # https://github.com/ruby/bigdecimal/pull/343
-    sqrt_steps /= 10
+      # Reduce sqrt_step until sqrt gets fast
+      # https://github.com/ruby/bigdecimal/pull/323
+      # https://github.com/ruby/bigdecimal/pull/343
+      sqrt_steps /= 10
 
-    lg2 = 0.3010299956639812
-    prec2 = prec + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
+      lg2 = 0.3010299956639812
+      prec2 = prec + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
 
-    sqrt_steps.times do
-      x = x.sqrt(prec2)
+      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)
-    end
+        # Workaround for https://github.com/ruby/bigdecimal/issues/354
+        x = x.mult(1, prec2 + BigDecimal.double_fig)
+      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)
-    y = x
-    x2 = x.mult(x, prec)
-    1.step do |i|
-      n = prec + 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)
-    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)
+      y = x
+      x2 = x.mult(x, prec)
+      1.step do |i|
+        n = prec + 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)
+      end
 
-    y.mult(2 ** (sqrt_steps + 1), prec)
+      y.mult(2 ** (sqrt_steps + 1), prec)
+    end
   end
 
   # call-seq:
@@ -266,30 +269,33 @@ def self.exp(x, prec)
     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
-    prec2 = prec + BigDecimal.double_fig + cnt
-    x *= BigDecimal("1e-#{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
+    BigDecimal.save_limit do
+      BigDecimal.limit(0)
+      # exp(x * 10**cnt) = exp(x)**(10**cnt)
+      cnt = x > 1 ? x.exponent : 0
+      prec2 = prec + BigDecimal.double_fig + cnt
+      x *= BigDecimal("1e-#{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
 
-    # calculate exp(x * 10**cnt) from exp(x)
-    # exp(x * 10**k) = exp(x * 10**(k - 1)) ** 10
-    cnt.times do
-      y2 = y.mult(y, prec2)
-      y5 = y2.mult(y2, prec2).mult(y, prec2)
-      y = y5.mult(y5, prec2)
-    end
+      # calculate exp(x * 10**cnt) from exp(x)
+      # exp(x * 10**k) = exp(x * 10**(k - 1)) ** 10
+      cnt.times do
+        y2 = y.mult(y, prec2)
+        y5 = y2.mult(y2, prec2).mult(y, prec2)
+        y = y5.mult(y5, prec2)
+      end
 
-    y.mult(1, prec)
+      y.mult(1, prec)
+    end
   end
 end

test/bigdecimal/test_bigdecimal.rb

@@ -2420,6 +2420,25 @@ def test_BigMath_log_under_gc_stress
     EOS
   end
 
+  def test_exp_log_pow_with_limit
+    prec = 100
+    limit = 10
+    x = BigDecimal(123).div(7, prec)
+    y = BigDecimal(456).div(11, prec)
+    exp = BigMath.exp(x, prec)
+    log = BigMath.log(x, prec)
+    pow = x.power(y, prec)
+    pow_lim = x.power(y, limit)
+    BigDecimal.save_limit do
+      BigDecimal.limit(limit)
+      assert_equal(exp, BigMath.exp(x, prec))
+      assert_equal(log, BigMath.log(x, prec))
+      assert_equal(pow, x.power(y, prec))
+      assert_equal(pow_lim, x**y)
+      assert_equal(limit, BigDecimal.limit)
+    end
+  end
+
   def test_frozen_p
     x = BigDecimal(1)
     assert(x.frozen?)