Coerce rational with the given prec in exp, log and power calculation

Author: tompng

lib/bigdecimal.rb

@@ -44,7 +44,7 @@ def **(y)
   def power(y, prec = nil)
     BigMath._validate_prec(prec, :power) if prec
     x = self
-    y = BigMath._coerce_to_bigdecimal(y, :power)
+    y = BigMath._coerce_to_bigdecimal(y, prec || 0, :power)
 
     return BigMath._nan_computation_result if x.nan? || y.nan?
     return BigDecimal(1) if y.zero?
@@ -145,12 +145,17 @@ def power(y, prec = nil)
 # Core BigMath methods for BigDecimal (log, exp) are defined here.
 # Other methods (sin, cos, atan) are defined in 'bigdecimal/math.rb'.
 module BigMath
-  def self._coerce_to_bigdecimal(x, method_name, complex_domain_error = false) # :nodoc:
+
+  # Coerce x to BigDecimal with the specified precision.
+  # TODO: some methods (example: BigMath.exp) require more precision than specified to coerce.
+  def self._coerce_to_bigdecimal(x, prec, method_name, complex_domain_error = false) # :nodoc:
     case x
     when BigDecimal
       return x
-    when Integer, Float, Rational
-      return BigDecimal(x, 0)
+    when Integer, Float
+      return BigDecimal(x)
+    when Rational
+      return BigDecimal(x, [prec, 2 * BigDecimal.double_fig].max)
     when Complex
       if complex_domain_error
         raise Math::DomainError, "Complex argument for BigMath.#{method_name}"
@@ -192,7 +197,7 @@ def self._nan_computation_result # :nodoc:
   #
   def self.log(x, prec)
     _validate_prec(prec, :log)
-    x = _coerce_to_bigdecimal(x, :log, true)
+    x = _coerce_to_bigdecimal(x, prec, :log, true)
     return _nan_computation_result if x.nan?
     raise Math::DomainError, 'Zero or negative argument for log' if x <= 0
     return _infinity_computation_result if x.infinite?
@@ -258,7 +263,7 @@ def self.log(x, prec)
   #
   def self.exp(x, prec)
     _validate_prec(prec, :exp)
-    x = _coerce_to_bigdecimal(x, :exp)
+    x = _coerce_to_bigdecimal(x, prec, :exp)
     return _nan_computation_result if x.nan?
     return x.positive? ? _infinity_computation_result : BigDecimal(0) if x.infinite?
     return BigDecimal(1) if x.zero?

test/bigdecimal/test_bigdecimal.rb

@@ -1895,6 +1895,12 @@ def test_power_with_prec
     assert_equal(BigDecimal('0.5394221232e-7'), BigDecimal('0.12345').power(8, 10))
   end
 
+  def test_power_with_rational
+    x = BigDecimal(2)
+    assert_in_epsilon(x.power(BigDecimal(3 / 7r, 100), 100), x.power(3 / 7r, 100), 1e-90)
+    assert_in_epsilon(x.power(BigDecimal(3 / 7r, 100), 100), x.power(3 / 7r), 1e-15)
+  end
+
   def test_power_precision
     x = BigDecimal("1.41421356237309504880168872420969807856967187537695")
     y = BigDecimal("3.14159265358979323846264338327950288419716939937511")
@@ -2153,6 +2159,7 @@ def test_BigMath_exp_with_rational
     assert_in_epsilon(Math.exp(40), BigMath.exp(Rational(80,2), prec))
     assert_in_epsilon(Math.exp(-20), BigMath.exp(Rational(-40,2), prec))
     assert_in_epsilon(Math.exp(-40), BigMath.exp(Rational(-80,2), prec))
+    assert_in_epsilon(BigMath.exp(BigDecimal(3 / 7r, 100), 100), BigMath.exp(3 / 7r, 100), 1e-90)
   end
 
   def test_BigMath_exp_under_gc_stress
@@ -2285,6 +2292,10 @@ def test_BigMath_log_with_reciprocal_of_42
     assert_in_delta(Math.log(1e-42), BigMath.log(BigDecimal("1e-42"), 20))
   end
 
+  def test_BigMath_log_with_rational
+    assert_in_epsilon(BigMath.log(BigDecimal(3 / 7r, 100), 100), BigMath.log(3 / 7r, 100), 1e-90)
+  end
+
   def test_BigMath_log_under_gc_stress
     paths = $LOAD_PATH.map{|path| "-I#{path}" }
     assert_in_out_err([*paths, "-rbigdecimal", "--disable-gems"], <<-EOS, [], [])