Fix x**y, x.power(y, 0) and x.sqrt(0) calculates huge digits if precision limit is huge

Author: tompng

lib/bigdecimal.rb

@@ -144,10 +144,10 @@ def power(y, prec = 0)
       return BigDecimal(1)
     end
 
-    prec = BigDecimal.limit if prec.zero?
+    limit = BigDecimal.limit
     frac_part = y.frac
 
-    if frac_part.zero? && prec.zero?
+    if frac_part.zero? && prec.zero? && limit.zero?
       # Infinite precision calculation for `x ** int` and `x.power(int)`
       int_part = y.fix.to_i
       int_part = -int_part if (neg = int_part < 0)
@@ -167,18 +167,19 @@ def power(y, prec = 0)
       return neg ? BigDecimal(1) / ans : ans
     end
 
-    prec = [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig if prec.zero?
+    result_prec = prec.nonzero? || [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    result_prec = [result_prec, limit].min if prec.zero? && limit.nonzero?
+
+    prec2 = result_prec + BigDecimal.double_fig
 
     if y < 0
-      inv = x.power(-y, prec)
+      inv = x.power(-y, prec2)
       return BigDecimal(0) if inv.infinite?
       return BigDecimal::Internal.infinity_computation_result if inv.zero?
-      return BigDecimal(1).div(inv, prec)
+      return BigDecimal(1).div(inv, result_prec)
     end
 
-    prec2 = prec + BigDecimal.double_fig
-
-    if frac_part.zero? && y.exponent < Math.log(prec) * 5 + 20
+    if frac_part.zero? && y.exponent < Math.log(result_prec) * 5 + 20
       # Use exponentiation by squaring if y is an integer and not too large
       pow_prec = prec2 + y.exponent
       n = 1
@@ -191,7 +192,7 @@ def power(y, prec = 0)
         break if n > int_part
         xn = xn.mult(xn, pow_prec)
       end
-      ans.mult(1, prec)
+      ans.mult(1, result_prec)
     else
       if x > 1
         # To calculate exp(z, prec), z needs prec+max(z.exponent, 0) precision if z > 0.
@@ -200,7 +201,7 @@ def power(y, prec = 0)
         ylogx_exponent = y.exponent + logx_exponent
         prec2 += [ylogx_exponent, 0].max
       end
-      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), prec)
+      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), result_prec)
     end
   end
 
@@ -217,7 +218,9 @@ def sqrt(prec)
     return self if zero?
 
     if prec == 0
-      prec = BigDecimal.limit.nonzero? || n_significant_digits + BigDecimal.double_fig
+      limit = BigDecimal.limit
+      prec = n_significant_digits + BigDecimal.double_fig
+      prec = [limit, prec].min if limit.nonzero?
     end
 
     ex = exponent / 2

test/bigdecimal/test_bigdecimal.rb

@@ -2072,14 +2072,17 @@ def test_arithmetic_operation_with_limit
       assert_equal(BigDecimal('0.889'), (BigDecimal('0.8888') - BigDecimal('0')))
       assert_equal(BigDecimal('2.66'), (BigDecimal('0.888') * BigDecimal('3')))
       assert_equal(BigDecimal('0.296'), (BigDecimal('0.8888') / BigDecimal('3')))
+      assert_equal(BigDecimal('0.222e109'), BigDecimal('98.76') ** BigDecimal('54.32'))
       assert_equal(BigDecimal('0.889'), BigDecimal('0.8888').add(BigDecimal('0'), 0))
       assert_equal(BigDecimal('0.889'), BigDecimal('0.8888').sub(BigDecimal('0'), 0))
       assert_equal(BigDecimal('2.66'), BigDecimal('0.888').mult(BigDecimal('3'), 0))
       assert_equal(BigDecimal('0.296'), BigDecimal('0.8888').div(BigDecimal('3'), 0))
+      assert_equal(BigDecimal('0.222e109'), BigDecimal('98.76').power(BigDecimal('54.32'), 0))
       assert_equal(BigDecimal('0.8888'), BigDecimal('0.8888').add(BigDecimal('0'), 5))
       assert_equal(BigDecimal('0.8888'), BigDecimal('0.8888').sub(BigDecimal('0'), 5))
       assert_equal(BigDecimal('2.664'), BigDecimal('0.888').mult(BigDecimal('3'), 5))
       assert_equal(BigDecimal('0.29627'), BigDecimal('0.8888').div(BigDecimal('3'), 5))
+      assert_equal(BigDecimal('0.22164e109'), BigDecimal('98.76').power(BigDecimal('54.32'), 5))
     end
   end
 
@@ -2092,6 +2095,26 @@ def test_div_with_huge_limit
     end
   end
 
+  def test_sqrt_with_huge_limit
+    BigDecimal.save_limit do
+      x = BigDecimal("12.34")
+      sqrt = x.sqrt(0)
+      BigDecimal.limit(1000)
+      assert_equal(sqrt, x.sqrt(0))
+    end
+  end
+
+def test_power_with_huge_limit
+    BigDecimal.save_limit do
+      x = BigDecimal("12.34")
+      y = BigDecimal("56.78")
+      pow = x ** y
+      BigDecimal.limit(1000)
+      assert_equal(pow, x ** y)
+      assert_equal(pow, x.power(y, 0))
+    end
+  end
+
   def test_div_mod_rem_operation_with_limit
     x = -(9 ** 100)
     y = 7 ** 100