bigdecimal 4.1.0 → 4.1.2

data/ext/bigdecimal/ntt.h

@@ -68,7 +68,7 @@ ntt(int size_bits, uint32_t *input, uint32_t *output, uint32_t *tmp, int r_base,
 
     // rmax**(1 << shift) % prime == 1
     // r**size % prime == 1
-    uint32_t rmax = mod_pow(r_base, base, prime);
+    uint32_t rmax = mod_pow((uint32_t)r_base, (uint32_t)base, prime);
     uint32_t r = mod_pow(rmax, (uint32_t)1 << (shift - size_bits), prime);
 
     if (dir < 0) r = mod_pow(r, prime - 2, prime);
@@ -123,7 +123,7 @@ ntt_multiply(size_t a_size, size_t b_size, uint32_t *a, uint32_t *b, uint32_t *c
       return;
     }
 
-    int ntt_size_bits = bit_length(b_size - 1) + 1;
+    int ntt_size_bits = (int)bit_length(b_size - 1) + 1;
     if (ntt_size_bits > MAX_NTT32_BITS) {
       rb_raise(rb_eArgError, "Multiply size too large");
     }
@@ -133,7 +133,7 @@ ntt_multiply(size_t a_size, size_t b_size, uint32_t *a, uint32_t *b, uint32_t *c
     uint32_t batch_size = ntt_size - (uint32_t)b_size;
     uint32_t batch_count = (uint32_t)((a_size + batch_size - 1) / batch_size);
 
-    uint32_t *mem = ruby_xcalloc(sizeof(uint32_t), ntt_size * 9);
+    uint32_t *mem = ruby_xcalloc(ntt_size * 9, sizeof(uint32_t));
     uint32_t *ntt1 = mem;
     uint32_t *ntt2 = mem + ntt_size;
     uint32_t *ntt3 = mem + ntt_size * 2;
@@ -177,12 +177,12 @@ ntt_multiply(size_t a_size, size_t b_size, uint32_t *a, uint32_t *b, uint32_t *c
             // so this sum doesn't overflow uint32_t.
             for (int j = 0; j < 3; j++) {
                 // Index check: if dig[j] is non-zero, assign index is within valid range.
-                if (dig[j]) c[idx * batch_size + i + 1 - j] += dig[j];
+                if (dig[j]) c[idx * batch_size + i + 1 - (uint32_t)j] += dig[j];
             }
         }
     }
     uint32_t carry = 0;
-    for (int32_t i = (uint32_t)(a_size + b_size - 1); i >= 0; i--) {
+    for (int32_t i = (int32_t)(a_size + b_size - 1); i >= 0; i--) {
         uint32_t v = c[i] + carry;
         c[i] = v % NTT_DECDIG_BASE;
         carry = v / NTT_DECDIG_BASE;

data/lib/bigdecimal/math.rb

@@ -637,7 +637,7 @@ module BigMath
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return BigDecimal(1 - x.infinite?) if x.infinite?
     return BigDecimal(1).sub(erf(x, prec + BigDecimal::Internal::EXTRA_PREC), prec) if x < 0.5
-    return BigDecimal(0) if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
+    return BigDecimal::Internal.underflow_computation_result if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
 
     if x >= 8
       y = _erfc_asymptotic(x, prec)

data/lib/bigdecimal.rb

@@ -57,6 +57,13 @@ class BigDecimal
       BigDecimal::INFINITY
     end
 
+    def self.underflow_computation_result # :nodoc:
+      if BigDecimal.mode(BigDecimal::EXCEPTION_ALL).anybits?(BigDecimal::EXCEPTION_UNDERFLOW)
+        raise FloatDomainError, 'Exponent 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'"
@@ -350,7 +357,17 @@ module BigMath
     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)

metadata

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