BigMath.exp overflow/underflow check

`BigMath.exp(BigDecimal('1e100000000'), 20)` was slow.
Skip calculation when x.exponent >= 21 which always result in overflow or underflow.

Author: tompng

lib/bigdecimal.rb

@@ -57,6 +57,13 @@ def self.infinity_computation_result # :nodoc:
       BigDecimal::INFINITY
     end
 
+    def self.underflow_computation_result # :nodoc:
+      if BigDecimal.mode(BigDecimal::EXCEPTION_ALL).anybits?(BigDecimal::EXCEPTION_UNDERFLOW)
+        raise FloatDomainError, "Computation results in 'Underflow'"
+      end
+      BigDecimal(0)
+    end
+
     def self.nan_computation_result # :nodoc:
       if BigDecimal.mode(BigDecimal::EXCEPTION_ALL).anybits?(BigDecimal::EXCEPTION_NaN)
         raise FloatDomainError, "Computation results to 'NaN'"
@@ -359,7 +366,17 @@ def exp(x, prec)
     prec = BigDecimal::Internal.coerce_validate_prec(prec, :exp)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :exp)
     return BigDecimal::Internal.nan_computation_result if x.nan?
-    return x.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0) if x.infinite?
+    if x.infinite? || x.exponent >= 21 # exp(10**20) and exp(-10**20) overflows/underflows 64-bit exponent  
+      if x.positive?
+        return BigDecimal::Internal.infinity_computation_result
+      elsif x.infinite?
+        # exp(-Infinity) is +0 by definition, this is not an underflow.
+        return BigDecimal(0)
+      else
+        return BigDecimal::Internal.underflow_computation_result
+      end
+    end
+
     return BigDecimal(1) if x.zero?
 
     # exp(x * 10**cnt) = exp(x)**(10**cnt)

test/bigdecimal/helper.rb

@@ -71,7 +71,7 @@ def assert_infinite_calculation(positive:)
       BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
       positive ? assert_positive_infinite(yield) : assert_negative_infinite(yield)
       BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)
-      assert_raise_with_message(FloatDomainError, /Infinity/) { yield }
+      assert_raise_with_message(FloatDomainError, /infinity|overflow/i) { yield }
     end
   end
 
@@ -83,6 +83,15 @@ def assert_negative_infinite_calculation(&block)
     assert_infinite_calculation(positive: false, &block)
   end
 
+  def assert_underflow_calculation
+    BigDecimal.save_exception_mode do
+      BigDecimal.mode(BigDecimal::EXCEPTION_UNDERFLOW, false)
+      assert_equal(BigDecimal(0), yield)
+      BigDecimal.mode(BigDecimal::EXCEPTION_UNDERFLOW, true)
+      assert_raise_with_message(FloatDomainError, /underflow/i) { yield }
+    end
+  end
+
   def assert_nan_calculation(&block)
     BigDecimal.save_exception_mode do
       BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)

test/bigdecimal/test_bigdecimal.rb

@@ -2296,13 +2296,24 @@ def test_exp_with_negative
   end
 
   def test_exp_with_negative_infinite
+    # exp(-infinity) is exactly zero. This is not an underflow.
     assert_equal(0, BigMath.exp(NEGATIVE_INFINITY, 20))
   end
 
   def test_exp_with_positive_infinite
     assert_positive_infinite_calculation { BigMath.exp(BigDecimal::INFINITY, 20) }
   end
 
+  def test_exp_with_overflow_underflow
+    assert_underflow_calculation { BigMath.exp(-1e+100, 20) }
+    assert_underflow_calculation { BigMath.exp(-0.9e+20, 20) }
+    assert_positive_infinite_calculation { BigMath.exp(1e+100, 20) }
+    assert_positive_infinite_calculation { BigMath.exp(0.9e+20, 20) }
+    huge = BigDecimal("0.1e#{EXPONENT_MAX / 100}")
+    assert_positive_infinite_calculation { BigMath.exp(huge, 20) }
+    assert_underflow_calculation { BigMath.exp(-huge, 20) }
+  end
+
   def test_exp_with_nan
     assert_nan_calculation { BigMath.exp(BigDecimal::NAN, 20) }
   end