bigdecimal 4.1.1 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 937928a0baf09e4c2e5bf45b2fa608e1aa20601cf7cd27a8ebaf679874e6196f
-  data.tar.gz: a053c6e868c7e55ad9a35262bfd645314fd908dbae5969935c44530a124cfcc4
+  metadata.gz: 922981a841d43e8269ac09725757bd02512ba596903b2da2ab2458e842957833
+  data.tar.gz: 34b59473beafbb51888ef2700b0c44ee721025952c1b578c4affa6cb60e91d90
 SHA512:
-  metadata.gz: 4a4a41830aab00fd3bef041c64f9f6357891706ca11004696c5d815b7582f6f4f2cbd00a606900cfe4a5bce57585d46523e25da8085c2bf18aa95bbe9afd27ec
-  data.tar.gz: fe5b587431cca8921613367e236a9844fd3c65f8f53d8b2ae16fe1ed54aac455bfff9a50783256ec2d9e0f5523bc01a3eb9ce0ffc16482cded6026cc03b8c2c0
+  metadata.gz: 00e7aedfc9b90c0e82297880c750010e37b8aa427c122343418bbbc3b656a94583a818b0980d2a91b9a7c22aa9c5cc26d621536c33f0d5ec70b87bf9585feed7
+  data.tar.gz: 0b54105583917681020ed7d451f9a39c68f9805e9079b48cc83b7031d43ab5e070945dd4899d73e99925022f4a3462c6f9f277062af0281b1455ed16b0a76f49

data/ext/bigdecimal/bigdecimal.c

@@ -33,7 +33,7 @@
 #include "div.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "4.1.1"
+#define BIGDECIMAL_VERSION "4.1.2"
 
 /* Make sure VPMULT_BATCH_SIZE*BASE*BASE does not overflow DECDIG_DBL */
 #define VPMULT_BATCH_SIZE 16
@@ -2709,7 +2709,7 @@ rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         len10 = BIGDECIMAL_DOUBLE_FIGURES;
     }
     memcpy(buf, p, len10);
-    xfree(p);
+    free(p);
 
     VALUE inum;
     size_t RB_UNUSED_VAR(prec) = 0;
@@ -5396,8 +5396,8 @@ VpSzMantissa(Real *a, char *buf, size_t buflen)
             while (m) {
                 nn = e / m;
                 if (!ZeroSup || nn) {
-                    snprintf(buf, buflen, "%lu", (unsigned long)nn); /* The leading zero(s) */
-                    buf += strlen(buf);
+                    *buf = (char)('0' + nn);
+                    buf++;
                     /* as 0.00xx will be ignored. */
                     ZeroSup = 0; /* Set to print succeeding zeros */
                 }
@@ -5449,10 +5449,22 @@ VpToSpecialString(Real *a, char *buf, size_t buflen, int fPlus)
     return 0;
 }
 
+#define ULLTOA_BUFFER_SIZE 20
+static size_t Vp_ulltoa(unsigned long long number, char *buf)
+{
+    static const char digits[] = "0123456789";
+    char* tmp = buf;
+
+    do *tmp-- = digits[number % 10]; while (number /= 10);
+    return buf - tmp;
+}
+
 VP_EXPORT void
 VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
 /* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
+    char ulltoa_buf[ULLTOA_BUFFER_SIZE];
+    char *ulltoa_buf_end = ulltoa_buf + ULLTOA_BUFFER_SIZE;
     size_t i, n, ZeroSup;
     DECDIG shift, m, e, nn;
     char *p = buf;
@@ -5492,10 +5504,9 @@ VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
         while (m) {
             nn = e / m;
             if (!ZeroSup || nn) {
-                /* The reading zero(s) */
-                size_t n = (size_t)snprintf(p, plen, "%lu", (unsigned long)nn);
-                if (n > plen) goto overflow;
-                ADVANCE(n);
+                *p = (char)('0' + nn);
+                ADVANCE(1);
+
                 /* as 0.00xx will be ignored. */
                 ZeroSup = 0;    /* Set to print succeeding zeros */
             }
@@ -5514,7 +5525,22 @@ VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
         *(--p) = '\0';
         ++plen;
     }
-    snprintf(p, plen, "e%"PRIdSIZE, ex);
+    *p = 'e';
+    ADVANCE(1);
+
+    if (ex < 0) {
+        *p = '-';
+        ADVANCE(1);
+        ex = -ex;
+    }
+
+    size_t ex_n = Vp_ulltoa(ex, ulltoa_buf_end - 1);
+    if (ex_n > plen) goto overflow;
+    MEMCPY(p, ulltoa_buf_end - ex_n, char, ex_n);
+    ADVANCE(ex_n);
+    *p = '\0';
+    ADVANCE(1);
+
     if (fFmt) VpFormatSt(buf, fFmt);
 
   overflow:

data/ext/bigdecimal/div.h

@@ -59,14 +59,14 @@ divmod_by_inv_mul(VALUE x, VALUE y, VALUE inv, VALUE *res_div, VALUE *res_mod) {
 
 static void
 slice_copy(DECDIG *dest, Real *src, size_t rshift, size_t length) {
-    ssize_t start = src->exponent - rshift - length;
+    ssize_t start = src->exponent - (ssize_t)rshift - (ssize_t)length;
     if (start >= (ssize_t)src->Prec) return;
     if (start < 0) {
         dest -= start;
-        length += start;
+        length -= (size_t)(-start);
         start = 0;
     }
-    size_t max_length = src->Prec - start;
+    size_t max_length = (size_t)((ssize_t)src->Prec - start);
     memcpy(dest, src->frac + start, Min(length, max_length) * sizeof(DECDIG));
 }
 
@@ -101,28 +101,28 @@ divmod_newton(VALUE x, VALUE y, VALUE *div_out, VALUE *mod_out) {
     BDVALUE div_result = NewZeroWrap(1, BIGDECIMAL_COMPONENT_FIGURES * (num_blocks * block_figs + 1));
     BDVALUE bdx = GetBDValueMust(x);
 
-    VALUE mod = BigDecimal_fix(BigDecimal_decimal_shift(x, SSIZET2NUM(-num_blocks * block_digits)));
-    for (ssize_t i = num_blocks - 1; i >= 0; i--) {
+    VALUE mod = BigDecimal_fix(BigDecimal_decimal_shift(x, SSIZET2NUM(-(ssize_t)(num_blocks * block_digits))));
+    for (ssize_t i = (ssize_t)(num_blocks - 1); i >= 0; i--) {
         memset(divident.real->frac, 0, (y_figs + block_figs) * sizeof(DECDIG));
 
         BDVALUE bdmod = GetBDValueMust(mod);
         slice_copy(divident.real->frac, bdmod.real, 0, y_figs);
-        slice_copy(divident.real->frac + y_figs, bdx.real, i * block_figs, block_figs);
+        slice_copy(divident.real->frac + y_figs, bdx.real, (size_t)i * block_figs, block_figs);
         RB_GC_GUARD(bdmod.bigdecimal);
 
         VpSetSign(divident.real, 1);
-        divident.real->exponent = y_figs + block_figs;
+        divident.real->exponent = (ssize_t)(y_figs + block_figs);
         divident.real->Prec = y_figs + block_figs;
         VpNmlz(divident.real);
 
         VALUE div;
         divmod_by_inv_mul(divident.bigdecimal, y, yinv, &div, &mod);
         BDVALUE bddiv = GetBDValueMust(div);
-        slice_copy(div_result.real->frac + (num_blocks - i - 1) * block_figs, bddiv.real, 0, block_figs + 1);
+        slice_copy(div_result.real->frac + (num_blocks - (size_t)i - 1) * block_figs, bddiv.real, 0, block_figs + 1);
         RB_GC_GUARD(bddiv.bigdecimal);
     }
     VpSetSign(div_result.real, 1);
-    div_result.real->exponent = num_blocks * block_figs + 1;
+    div_result.real->exponent = (ssize_t)(num_blocks * block_figs + 1);
     div_result.real->Prec = num_blocks * block_figs + 1;
     VpNmlz(div_result.real);
     RB_GC_GUARD(bdx.bigdecimal);
@@ -148,8 +148,8 @@ VpDivdNewtonInner(VALUE args_ptr)
     VpAsgn(b2.real, b, 1);
     VpSetSign(a2.real, 1);
     VpSetSign(b2.real, 1);
-    a2.real->exponent = base_prec + div_prec;
-    b2.real->exponent = base_prec;
+    a2.real->exponent = (ssize_t)(base_prec + div_prec);
+    b2.real->exponent = (ssize_t)base_prec;
 
     if ((ssize_t)a2.real->Prec > a2.real->exponent) {
         a2_frac = BigDecimal_frac(a2.bigdecimal);
@@ -164,9 +164,9 @@ VpDivdNewtonInner(VALUE args_ptr)
     VpAsgn(r, r2.real, VpGetSign(a));
     AddExponent(c, a->exponent);
     AddExponent(c, -b->exponent);
-    AddExponent(c, -div_prec);
+    AddExponent(c, -(ssize_t)div_prec);
     AddExponent(r, a->exponent);
-    AddExponent(r, -base_prec - div_prec);
+    AddExponent(r, -(ssize_t)(base_prec + div_prec));
     RB_GC_GUARD(a2.bigdecimal);
     RB_GC_GUARD(a2.bigdecimal);
     RB_GC_GUARD(c2.bigdecimal);

data/ext/bigdecimal/missing/dtoa.c

@@ -98,17 +98,6 @@
  *	if memory is available and otherwise does something you deem
  *	appropriate.  If MALLOC is undefined, malloc will be invoked
  *	directly -- and assumed always to succeed.
- * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
- *	memory allocations from a private pool of memory when possible.
- *	When used, the private pool is PRIVATE_MEM bytes long:  2304 bytes,
- *	unless #defined to be a different length.  This default length
- *	suffices to get rid of MALLOC calls except for unusual cases,
- *	such as decimal-to-binary conversion of a very long string of
- *	digits.  The longest string dtoa can return is about 751 bytes
- *	long.  For conversions by strtod of strings of 800 digits and
- *	all dtoa conversions in single-threaded executions with 8-byte
- *	pointers, PRIVATE_MEM >= 7400 appears to suffice; with 4-byte
- *	pointers, PRIVATE_MEM >= 7112 appears adequate.
  * #define INFNAN_CHECK on IEEE systems to cause strtod to check for
  *	Infinity and NaN (case insensitively).  On some systems (e.g.,
  *	some HP systems), it may be necessary to #define NAN_WORD0
@@ -183,7 +172,10 @@
 #undef Long
 #undef ULong
 
+#include <assert.h>
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #if (INT_MAX >> 30) && !(INT_MAX >> 31)
 #define Long int
@@ -195,7 +187,7 @@
 #error No 32bit integer
 #endif
 
-#if HAVE_LONG_LONG
+#if defined(HAVE_LONG_LONG) && (HAVE_LONG_LONG)
 #define Llong LONG_LONG
 #else
 #define NO_LONG_LONG
@@ -218,28 +210,43 @@
 #include <locale.h>
 #endif
 
+#if defined(HAVE_STDCKDINT_H) || !defined(__has_include)
+#elif __has_include(<stdckdint.h>)
+# define HAVE_STDCKDINT_H 1
+#endif
+#ifdef HAVE_STDCKDINT_H
+# include <stdckdint.h>
+#endif
+
+#if !defined(ckd_add)
+static inline int /* bool */
+ckd_add(int *result, int x, int y)
+{
+    if (x < 0) {
+        if (y < INT_MIN - x) return 1;
+    }
+    else if (x > 0) {
+        if (y > INT_MAX - x) return 1;
+    }
+    *result = x + y;
+    return 0;
+}
+#endif
+
 #ifdef MALLOC
 extern void *MALLOC(size_t);
 #else
-#define MALLOC xmalloc
+#define MALLOC malloc
 #endif
 #ifdef FREE
 extern void FREE(void*);
 #else
-#define FREE xfree
+#define FREE free
 #endif
 #ifndef NO_SANITIZE
 #define NO_SANITIZE(x, y) y
 #endif
 
-#ifndef Omit_Private_Memory
-#ifndef PRIVATE_MEM
-#define PRIVATE_MEM 2304
-#endif
-#define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
-static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
-#endif
-
 #undef IEEE_Arith
 #undef Avoid_Underflow
 #ifdef IEEE_BIG_ENDIAN
@@ -502,7 +509,7 @@ extern double rnd_prod(double, double), rnd_quot(double, double);
 #endif
 
 #ifndef ATOMIC_PTR_CAS
-#define ATOMIC_PTR_CAS(var, old, new) ((var) = (new), (old))
+#define ATOMIC_PTR_CAS(var, old, new) ((var) = (new), (void *)(old))
 #endif
 #ifndef LIKELY
 #define LIKELY(x) (x)
@@ -524,76 +531,29 @@ struct Bigint {
 
 typedef struct Bigint Bigint;
 
-static Bigint *freelist[Kmax+1];
-
 static Bigint *
 Balloc(int k)
 {
     int x;
     Bigint *rv;
-#ifndef Omit_Private_Memory
-    size_t len;
-#endif
-
-    rv = 0;
-    ACQUIRE_DTOA_LOCK(0);
-    if (k <= Kmax) {
-        rv = freelist[k];
-        while (rv) {
-            Bigint *rvn = rv;
-            rv = ATOMIC_PTR_CAS(freelist[k], rv, rv->next);
-            if (LIKELY(rvn == rv)) {
-                ASSUME(rv);
-                break;
-            }
-        }
-    }
-    if (!rv) {
-        x = 1 << k;
-#ifdef Omit_Private_Memory
-        rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
-#else
-        len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
-                /sizeof(double);
-        if (k <= Kmax) {
-            double *pnext = pmem_next;
-            while (pnext - private_mem + len <= PRIVATE_mem) {
-                double *p = pnext;
-                pnext = ATOMIC_PTR_CAS(pmem_next, pnext, pnext + len);
-                if (LIKELY(p == pnext)) {
-                    rv = (Bigint*)pnext;
-                    ASSUME(rv);
-                    break;
-                }
-            }
-        }
-        if (!rv)
-            rv = (Bigint*)MALLOC(len*sizeof(double));
-#endif
-        rv->k = k;
-        rv->maxwds = x;
-    }
-    FREE_DTOA_LOCK(0);
+
+    x = 1 << k;
+    rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
+    if (!rv) return NULL;
+    rv->k = k;
+    rv->maxwds = x;
     rv->sign = rv->wds = 0;
     return rv;
 }
 
 static void
-Bfree(Bigint *v)
+Bclear(Bigint **vp)
 {
-    Bigint *vn;
-    if (v) {
-        if (v->k > Kmax) {
-            FREE(v);
-            return;
-        }
-        ACQUIRE_DTOA_LOCK(0);
-        do {
-            vn = v->next = freelist[v->k];
-        } while (UNLIKELY(ATOMIC_PTR_CAS(freelist[v->k], vn, v) != vn));
-        FREE_DTOA_LOCK(0);
-    }
+    Bigint *v = *vp;
+    *vp = NULL;
+    if (v) FREE(v);
 }
+#define Bfree(v) Bclear(&(v))
 
 #define Bcopy(x,y) memcpy((char *)&(x)->sign, (char *)&(y)->sign, \
 (y)->wds*sizeof(Long) + 2*sizeof(int))
@@ -639,6 +599,10 @@ multadd(Bigint *b, int m, int a)   /* multiply by m and add a */
     if (carry) {
         if (wds >= b->maxwds) {
             b1 = Balloc(b->k+1);
+            if (!b1) {
+                Bfree(b);
+                return NULL;
+            }
             Bcopy(b1, b);
             Bfree(b);
             b = b1;
@@ -660,10 +624,12 @@ s2b(const char *s, int nd0, int nd, ULong y9)
     for (k = 0, y = 1; x > y; y <<= 1, k++) ;
 #ifdef Pack_32
     b = Balloc(k);
+    if (!b) return NULL;
     b->x[0] = y9;
     b->wds = 1;
 #else
     b = Balloc(k+1);
+    if (!b) return NULL;
     b->x[0] = y9 & 0xffff;
     b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
 #endif
@@ -673,13 +639,16 @@ s2b(const char *s, int nd0, int nd, ULong y9)
         s += 9;
         do {
             b = multadd(b, 10, *s++ - '0');
+            if (!b) return NULL;
         } while (++i < nd0);
         s++;
     }
     else
         s += 10;
-    for (; i < nd; i++)
+    for (; i < nd; i++) {
         b = multadd(b, 10, *s++ - '0');
+        if (!b) return NULL;
+    }
     return b;
 }
 
@@ -761,11 +730,14 @@ i2b(int i)
     Bigint *b;
 
     b = Balloc(1);
+    if (!b) return NULL;
     b->x[0] = i;
     b->wds = 1;
     return b;
 }
 
+#define Bzero_p(b) (!(b)->x[0] && (b)->wds <= 1)
+
 static Bigint *
 mult(Bigint *a, Bigint *b)
 {
@@ -782,6 +754,14 @@ mult(Bigint *a, Bigint *b)
 #endif
 #endif
 
+    if (Bzero_p(a) || Bzero_p(b)) {
+        c = Balloc(0);
+        if (!c) return NULL;
+        c->wds = 1;
+        c->x[0] = 0;
+        return c;
+    }
+
     if (a->wds < b->wds) {
         c = a;
         a = b;
@@ -794,6 +774,7 @@ mult(Bigint *a, Bigint *b)
     if (wc > a->maxwds)
         k++;
     c = Balloc(k);
+    if (!c) return NULL;
     for (x = c->x, xa = x + wc; x < xa; x++)
         *x = 0;
     xa = a->x;
@@ -873,50 +854,47 @@ static Bigint *
 pow5mult(Bigint *b, int k)
 {
     Bigint *b1, *p5, *p51;
-    Bigint *p5tmp;
     int i;
     static const int p05[3] = { 5, 25, 125 };
 
-    if ((i = k & 3) != 0)
+    if ((i = k & 3) != 0) {
         b = multadd(b, p05[i-1], 0);
+        if (!b) return NULL;
+    }
+
+#define b_cache(var, addr, new_expr) \
+    if ((var = addr) != 0) {} else { \
+        Bigint *tmp = 0; \
+        ACQUIRE_DTOA_LOCK(1); \
+        if (!(var = addr) && (var = (new_expr)) != 0) { \
+            var->next = 0; \
+            tmp = ATOMIC_PTR_CAS(addr, NULL, var); \
+        } \
+        FREE_DTOA_LOCK(1); \
+        if (UNLIKELY(tmp)) { \
+            Bfree(var); \
+            var = tmp; \
+        } \
+        else if (!var) { \
+            Bfree(b); \
+            return NULL; \
+        } \
+    }
 
     if (!(k >>= 2))
         return b;
-    if (!(p5 = p5s)) {
-        /* first time */
-        ACQUIRE_DTOA_LOCK(1);
-        if (!(p5 = p5s)) {
-            p5 = i2b(625);
-            p5->next = 0;
-            p5tmp = ATOMIC_PTR_CAS(p5s, NULL, p5);
-            if (UNLIKELY(p5tmp)) {
-                Bfree(p5);
-                p5 = p5tmp;
-            }
-        }
-        FREE_DTOA_LOCK(1);
-    }
+    /* first time */
+    b_cache(p5, p5s, i2b(625));
     for (;;) {
         if (k & 1) {
             b1 = mult(b, p5);
             Bfree(b);
             b = b1;
+            if (!b) return NULL;
         }
         if (!(k >>= 1))
             break;
-        if (!(p51 = p5->next)) {
-            ACQUIRE_DTOA_LOCK(1);
-            if (!(p51 = p5->next)) {
-                p51 = mult(p5,p5);
-                p51->next = 0;
-                p5tmp = ATOMIC_PTR_CAS(p5->next, NULL, p51);
-                if (UNLIKELY(p5tmp)) {
-                    Bfree(p51);
-                    p51 = p5tmp;
-                }
-            }
-            FREE_DTOA_LOCK(1);
-        }
+        b_cache(p51, p5->next, mult(p5, p5));
         p5 = p51;
     }
     return b;
@@ -929,6 +907,8 @@ lshift(Bigint *b, int k)
     Bigint *b1;
     ULong *x, *x1, *xe, z;
 
+    if (!k || Bzero_p(b)) return b;
+
 #ifdef Pack_32
     n = k >> 5;
 #else
@@ -939,6 +919,10 @@ lshift(Bigint *b, int k)
     for (i = b->maxwds; n1 > i; i <<= 1)
         k1++;
     b1 = Balloc(k1);
+    if (!b1) {
+        Bfree(b);
+        return NULL;
+    }
     x1 = b1->x;
     for (i = 0; i < n; i++)
         *x1++ = 0;
@@ -1024,6 +1008,7 @@ diff(Bigint *a, Bigint *b)
     i = cmp(a,b);
     if (!i) {
         c = Balloc(0);
+        if (!c) return NULL;
         c->wds = 1;
         c->x[0] = 0;
         return c;
@@ -1037,6 +1022,7 @@ diff(Bigint *a, Bigint *b)
     else
         i = 0;
     c = Balloc(a->k);
+    if (!c) return NULL;
     c->sign = i;
     wa = a->wds;
     xa = a->x;
@@ -1222,6 +1208,7 @@ d2b(double d_, int *e, int *bits)
 #else
     b = Balloc(2);
 #endif
+    if (!b) return NULL;
     x = b->x;
 
     z = d0 & Frac_mask;
@@ -1542,9 +1529,10 @@ break2:
 	    aadj = 1.0;
 	    nd0 = -4;
 
-	    if (!*++s || !(s1 = strchr(hexdigit, *s))) goto ret0;
+	    if (!*++s || (!(s1 = strchr(hexdigit, *s)) && *s != '.')) goto ret0;
 	    if (*s == '0') {
 		while (*++s == '0');
+		if (!*s) goto ret;
 		s1 = strchr(hexdigit, *s);
 	    }
 	    if (s1 != NULL) {
@@ -1555,9 +1543,7 @@ break2:
 		} while (*++s && (s1 = strchr(hexdigit, *s)));
 	    }
 
-	    if (*s == '.') {
-		dsign = 1;
-		if (!*++s || !(s1 = strchr(hexdigit, *s))) goto ret0;
+	    if ((*s == '.') && *++s && (s1 = strchr(hexdigit, *s))) {
 		if (nd0 < 0) {
 		    while (*s == '0') {
 			s++;
@@ -1567,14 +1553,11 @@ break2:
 		for (; *s && (s1 = strchr(hexdigit, *s)); ++s) {
 		    adj += aadj * ((s1 - hexdigit) & 15);
 		    if ((aadj /= 16) == 0.0) {
-			while (strchr(hexdigit, *++s));
+			while (*++s && strchr(hexdigit, *s));
 			break;
 		    }
 		}
 	    }
-	    else {
-		dsign = 0;
-	    }
 
 	    if (*s == 'P' || *s == 'p') {
 		dsign = 0x2C - *++s; /* +: 2B, -: 2D */
@@ -1597,9 +1580,6 @@ break2:
 		} while ('0' <= c && c <= '9');
 		nd0 += nd * dsign;
 	    }
-	    else {
-		if (dsign) goto ret0;
-	    }
 	    dval(rv) = ldexp(adj, nd0);
 	    goto ret;
 	}
@@ -1636,9 +1616,9 @@ break2:
     }
 #endif
     if (c == '.') {
-        if (!ISDIGIT(s[1]))
-            goto dig_done;
         c = *++s;
+        if (!ISDIGIT(c))
+            goto dig_done;
         if (!nd) {
             for (; c == '0'; c = *++s)
                 nz++;
@@ -1979,12 +1959,16 @@ undfl:
     /* Put digits into bd: true value = bd * 10^e */
 
     bd0 = s2b(s0, nd0, nd, y);
+    if (!bd0) goto ret;
 
     for (;;) {
         bd = Balloc(bd0->k);
+        if (!bd) goto retfree;
         Bcopy(bd, bd0);
         bb = d2b(dval(rv), &bbe, &bbbits);  /* rv = bb * 2^bbe */
+        if (!bb) goto retfree;
         bs = i2b(1);
+        if (!bs) goto retfree;
 
         if (e >= 0) {
             bb2 = bb5 = 0;
@@ -2041,19 +2025,30 @@ undfl:
         }
         if (bb5 > 0) {
             bs = pow5mult(bs, bb5);
+            if (!bs) goto retfree;
             bb1 = mult(bs, bb);
             Bfree(bb);
             bb = bb1;
+            if (!bb) goto retfree;
         }
-        if (bb2 > 0)
+        if (bb2 > 0) {
             bb = lshift(bb, bb2);
-        if (bd5 > 0)
+            if (!bb) goto retfree;
+        }
+        if (bd5 > 0) {
             bd = pow5mult(bd, bd5);
-        if (bd2 > 0)
+            if (!bd) goto retfree;
+        }
+        if (bd2 > 0) {
             bd = lshift(bd, bd2);
-        if (bs2 > 0)
+            if (!bd) goto retfree;
+        }
+        if (bs2 > 0) {
             bs = lshift(bs, bs2);
+            if (!bs) goto retfree;
+        }
         delta = diff(bb, bd);
+        if (!delta) goto retfree;
         dsign = delta->sign;
         delta->sign = 0;
         i = cmp(delta, bs);
@@ -2086,6 +2081,7 @@ undfl:
 #endif
                         {
                             delta = lshift(delta,Log2P);
+                            if (!delta) goto nomem;
                             if (cmp(delta, bs) <= 0)
                                 adj = -0.5;
                         }
@@ -2175,6 +2171,7 @@ apply_adj:
                 break;
             }
             delta = lshift(delta,Log2P);
+            if (!delta) goto retfree;
             if (cmp(delta, bs) > 0)
                 goto drop_down;
             break;
@@ -2577,6 +2574,7 @@ nrv_alloc(const char *s, char **rve, size_t n)
     char *rv, *t;
 
     t = rv = rv_alloc(n);
+    if (!rv) return NULL;
     while ((*t = *s++) != 0) t++;
     if (rve)
         *rve = t;
@@ -2749,6 +2747,7 @@ dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve)
 #endif
 
     b = d2b(dval(d), &be, &bbits);
+    if (!b) return NULL;
 #ifdef Sudden_Underflow
     i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
 #else
@@ -2868,13 +2867,20 @@ dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve)
         leftright = 0;
         /* no break */
       case 5:
-        i = ndigits + k + 1;
+        if (ckd_add(&i, ndigits, k + 1)) { /* k + 1 should be safe */
+            Bfree(b);
+            return NULL;
+        }
         ilim = i;
         ilim1 = i - 1;
         if (i <= 0)
             i = 1;
     }
     s = s0 = rv_alloc(i+1);
+    if (!s) {
+        Bfree(b);
+        return NULL;
+    }
 
 #ifdef Honor_FLT_ROUNDS
     if (mode > 1 && rounding != 1)
@@ -3055,6 +3061,7 @@ bump_up:
         b2 += i;
         s2 += i;
         mhi = i2b(1);
+        if (!mhi) goto nomem;
     }
     if (m2 > 0 && s2 > 0) {
         i = m2 < s2 ? m2 : s2;
@@ -3066,19 +3073,28 @@ bump_up:
         if (leftright) {
             if (m5 > 0) {
                 mhi = pow5mult(mhi, m5);
+                if (!mhi) goto nomem;
                 b1 = mult(mhi, b);
                 Bfree(b);
                 b = b1;
+                if (!b) goto nomem;
             }
-            if ((j = b5 - m5) != 0)
+            if ((j = b5 - m5) != 0) {
                 b = pow5mult(b, j);
+                if (!b) goto nomem;
+            }
         }
-        else
+        else {
             b = pow5mult(b, b5);
+            if (!b) goto nomem;
+        }
     }
     S = i2b(1);
-    if (s5 > 0)
+    if (!S) goto nomem;
+    if (s5 > 0) {
         S = pow5mult(S, s5);
+        if (!S) goto nomem;
+    }
 
     /* Check for special case that d is a normalized power of 2. */
 
@@ -3126,16 +3142,23 @@ bump_up:
         m2 += i;
         s2 += i;
     }
-    if (b2 > 0)
+    if (b2 > 0) {
         b = lshift(b, b2);
-    if (s2 > 0)
+        if (!b) goto nomem;
+    }
+    if (s2 > 0) {
         S = lshift(S, s2);
+        if (!S) goto nomem;
+    }
     if (k_check) {
         if (cmp(b,S) < 0) {
             k--;
             b = multadd(b, 10, 0);  /* we botched the k estimate */
-            if (leftright)
+            if (!b) goto nomem;
+            if (leftright) {
                 mhi = multadd(mhi, 10, 0);
+                if (!mhi) goto nomem;
+            }
             ilim = ilim1;
         }
     }
@@ -3152,8 +3175,10 @@ one_digit:
         goto ret;
     }
     if (leftright) {
-        if (m2 > 0)
+        if (m2 > 0) {
             mhi = lshift(mhi, m2);
+            if (!mhi) goto nomem;
+        }
 
         /* Compute mlo -- check for special case
          * that d is a normalized power of 2.
@@ -3162,8 +3187,10 @@ one_digit:
         mlo = mhi;
         if (spec_case) {
             mhi = Balloc(mhi->k);
+            if (!mhi) goto nomem;
             Bcopy(mhi, mlo);
             mhi = lshift(mhi, Log2P);
+            if (!mhi) goto nomem;
         }
 
         for (i = 1;;i++) {
@@ -3173,6 +3200,7 @@ one_digit:
              */
             j = cmp(b, mlo);
             delta = diff(S, mhi);
+            if (!delta) goto nomem;
             j1 = delta->sign ? 1 : cmp(b, delta);
             Bfree(delta);
 #ifndef ROUND_BIASED
@@ -3213,6 +3241,7 @@ one_digit:
 #endif /*Honor_FLT_ROUNDS*/
                 if (j1 > 0) {
                     b = lshift(b, 1);
+                    if (!b) goto nomem;
                     j1 = cmp(b, S);
                     if ((j1 > 0 || (j1 == 0 && (dig & 1))) && dig++ == '9')
                         goto round_9_up;
@@ -3241,11 +3270,16 @@ keep_dig:
             if (i == ilim)
                 break;
             b = multadd(b, 10, 0);
-            if (mlo == mhi)
+            if (!b) goto nomem;
+            if (mlo == mhi) {
                 mlo = mhi = multadd(mhi, 10, 0);
+                if (!mlo) goto nomem;
+            }
             else {
                 mlo = multadd(mlo, 10, 0);
+                if (!mlo) goto nomem;
                 mhi = multadd(mhi, 10, 0);
+                if (!mhi) goto nomem;
             }
         }
     }
@@ -3261,6 +3295,7 @@ keep_dig:
             if (i >= ilim)
                 break;
             b = multadd(b, 10, 0);
+            if (!b) goto nomem;
         }
 
     /* Round off last digit */
@@ -3272,6 +3307,7 @@ keep_dig:
     }
 #endif
     b = lshift(b, 1);
+    if (!b) goto nomem;
     j = cmp(b, S);
     if (j > 0 || (j == 0 && (dig & 1))) {
  roundoff:
@@ -3313,6 +3349,16 @@ ret1:
     if (rve)
         *rve = s;
     return s0;
+  nomem:
+    if (S) Bfree(S);
+    if (mhi) {
+        if (mlo && mlo != mhi)
+            Bfree(mlo);
+        Bfree(mhi);
+    }
+    if (b) Bfree(b);
+    FREE(s0);
+    return NULL;
 }
 
 /*-
@@ -3421,6 +3467,7 @@ hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rv
 	 */
 	bufsize = (ndigits > 0) ? ndigits : SIGFIGS;
 	s0 = rv_alloc(bufsize+1);
+        if (!s0) return NULL;
 
 	/* Round to the desired number of digits. */
 	if (SIGFIGS > ndigits && ndigits > 0) {

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

@@ -144,7 +144,7 @@ module BigMath
     x = -x if neg = x < 0
     ex = x.exponent / 3
     x = x._decimal_shift(-3 * ex)
-    y = BigDecimal(Math.cbrt(BigDecimal::Internal.fast_to_f(x)), 0)
+    y = BigDecimal(Math.cbrt(x.to_f), 0)
     BigDecimal::Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
       y = (2 * y + x.div(y, p).div(y, p)).div(3, p)
     end
@@ -304,7 +304,7 @@ module BigMath
 
     # Solve tan(y) - x = 0 with Newton's method
     # Repeat: y -= (tan(y) - x) * cos(y)**2
-    y = BigDecimal(Math.atan(BigDecimal::Internal.fast_to_f(x)), 0)
+    y = BigDecimal(Math.atan(x.to_f), 0)
     BigDecimal::Internal.newton_loop(n) do |p|
       s = sin(y, p)
       c = (1 - s * s).sqrt(p)
@@ -605,7 +605,7 @@ module BigMath
     return BigDecimal(1) if x > 5000000000 # erf(5000000000) > 1 - 1e-10000000000000000000
 
     if x > 8
-      xf = BigDecimal::Internal.fast_to_f(x)
+      xf = x.to_f
       log10_erfc = -xf ** 2 / Math.log(10) - Math.log10(xf * Math::PI ** 0.5)
       erfc_prec = [prec + log10_erfc.ceil, 1].max
       erfc = _erfc_asymptotic(x, erfc_prec)
@@ -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)
@@ -647,7 +647,7 @@ module BigMath
     # erfc(x) = 1 - erf(x) < exp(-x**2)/x/sqrt(pi)
     # Precision of erf(x) needs about log10(exp(-x**2)/x/sqrt(pi)) extra digits
     log10 = 2.302585092994046
-    xf = BigDecimal::Internal.fast_to_f(x)
+    xf = x.to_f
     high_prec = prec + BigDecimal::Internal::EXTRA_PREC + ((xf**2 + Math.log(xf) + Math.log(Math::PI)/2) / log10).ceil
     BigDecimal(1).sub(erf(x, high_prec), prec)
   end
@@ -698,7 +698,7 @@ module BigMath
     # sqrt(2)/2 + k*log(k) - k - 2*k*log(x) < -prec*log(10)
     # and the left side is minimized when k = x**2.
     prec += BigDecimal::Internal::EXTRA_PREC
-    xf = BigDecimal::Internal.fast_to_f(x)
+    xf = x.to_f
     kmax = (1..(xf ** 2).floor).bsearch do |k|
       Math.log(2) / 2 + k * Math.log(k) - k - 2 * k * Math.log(xf) < -prec * Math.log(10)
     end

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'"
@@ -76,18 +83,9 @@ class BigDecimal
       end
     end
 
-    # Fast and rough conversion to float for mathematical calculations.
-    # Bigdecimal#to_f is slow when n_significant_digits is large.
-    # This is because to_f internally converts BigDecimal to String
-    # to get the exact nearest float representation.
-    # TODO: Remove this workaround when BigDecimal#to_f is optimized.
-    def self.fast_to_f(x) # :nodoc:
-      x.n_significant_digits < 40 ? x.to_f : x.mult(1, 20).to_f
-    end
-
     # Calculates Math.log(x.to_f) considering large or small exponent
     def self.float_log(x) # :nodoc:
-      Math.log(fast_to_f(x._decimal_shift(-x.exponent))) + x.exponent * Math.log(10)
+      Math.log(x._decimal_shift(-x.exponent).to_f) + x.exponent * Math.log(10)
     end
 
     # Calculating Taylor series sum using binary splitting method
@@ -277,7 +275,7 @@ class BigDecimal
 
     ex = exponent / 2
     x = _decimal_shift(-2 * ex)
-    y = BigDecimal(Math.sqrt(BigDecimal::Internal.fast_to_f(x)), 0)
+    y = BigDecimal(Math.sqrt(x.to_f), 0)
     Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
       y = y.add(x.div(y, p), p).div(2, p)
     end
@@ -359,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.1
+  version: 4.1.2
 platform: ruby
 authors:
 - Kenta Murata