bigdecimal 4.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4356e024d6f3144b6d788ea32ad1832dab72203834e2a91484edc75e7c6c08c
-  data.tar.gz: 7847d9f86e86e3f9be90a51fbfa6e6045bcdb6c1886ab1559b3fe2ebfe107356
+  metadata.gz: 937928a0baf09e4c2e5bf45b2fa608e1aa20601cf7cd27a8ebaf679874e6196f
+  data.tar.gz: a053c6e868c7e55ad9a35262bfd645314fd908dbae5969935c44530a124cfcc4
 SHA512:
-  metadata.gz: 4bc5ce4f4fe5a041d83d8eec1d662bf35c50f8e2d2e317d659f833a9a2ee15280b6e8c3a4fa09dbaf177ad2daf34c9c15076819fb1bd4bf22b72efa8a1e9c6f5
-  data.tar.gz: d1a8c638bd997d8a882f9d2409dca84853cb6e2af768c79143554a6a316d5dd2a99f7b247fcf496079bba33faec31f93fcc4d78df5913b2350eb9655b91a2834
+  metadata.gz: 4a4a41830aab00fd3bef041c64f9f6357891706ca11004696c5d815b7582f6f4f2cbd00a606900cfe4a5bce57585d46523e25da8085c2bf18aa95bbe9afd27ec
+  data.tar.gz: fe5b587431cca8921613367e236a9844fd3c65f8f53d8b2ae16fe1ed54aac455bfff9a50783256ec2d9e0f5523bc01a3eb9ce0ffc16482cded6026cc03b8c2c0

data/ext/bigdecimal/bigdecimal.c

@@ -33,10 +33,12 @@
 #include "div.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "4.1.0"
+#define BIGDECIMAL_VERSION "4.1.1"
 
-#define NTT_MULTIPLICATION_THRESHOLD 100
-#define NEWTON_RAPHSON_DIVISION_THRESHOLD 200
+/* Make sure VPMULT_BATCH_SIZE*BASE*BASE does not overflow DECDIG_DBL */
+#define VPMULT_BATCH_SIZE 16
+#define NTT_MULTIPLICATION_THRESHOLD 450
+#define NEWTON_RAPHSON_DIVISION_THRESHOLD 100
 #define SIGNED_VALUE_MAX INTPTR_MAX
 #define SIGNED_VALUE_MIN INTPTR_MIN
 #define MUL_OVERFLOW_SIGNED_VALUE_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, SIGNED_VALUE_MIN, SIGNED_VALUE_MAX)
@@ -77,11 +79,6 @@ static struct {
     uint8_t mode;
 } rbd_rounding_modes[RBD_NUM_ROUNDING_MODES];
 
-typedef struct {
-    VALUE bigdecimal_or_nil;
-    Real *real_or_null;
-} NULLABLE_BDVALUE;
-
 static inline BDVALUE
 bdvalue_nonnullable(NULLABLE_BDVALUE v)
 {
@@ -157,42 +154,6 @@ rbd_struct_size(size_t const internal_digits)
     return offsetof(Real, frac) + frac_len * sizeof(DECDIG);
 }
 
-static inline Real *
-rbd_allocate_struct(size_t const internal_digits)
-{
-    size_t const size = rbd_struct_size(internal_digits);
-    Real *real = ruby_xcalloc(1, size);
-    atomic_allocation_count_inc();
-    real->MaxPrec = internal_digits;
-    return real;
-}
-
-static inline Real *
-rbd_allocate_struct_decimal_digits(size_t const decimal_digits)
-{
-    return rbd_allocate_struct(roomof(decimal_digits, BASE_FIG));
-}
-
-static void
-rbd_free_struct(Real *real)
-{
-    if (real != NULL) {
-        check_allocation_count_nonzero();
-        ruby_xfree(real);
-        atomic_allocation_count_dec_nounderflow();
-    }
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_zero(int sign, size_t const digits));
-#define NewZero rbd_allocate_struct_zero
-static inline Real *
-rbd_allocate_struct_zero(int sign, size_t const digits)
-{
-    Real *real = rbd_allocate_struct_decimal_digits(digits);
-    VpSetZero(real, sign);
-    return real;
-}
-
 /*
  * ================== Ruby Interface part ==========================
  */
@@ -207,7 +168,6 @@ static void VpCheckException(Real *p, bool always);
 static VALUE CheckGetValue(BDVALUE v);
 static void  VpInternalRound(Real *c, size_t ixDigit, DECDIG vPrev, DECDIG v);
 static int   VpLimitRound(Real *c, size_t ixDigit);
-static Real *VpCopy(Real *pv, Real const* const x);
 static int VPrint(FILE *fp,const char *cntl_chr,Real *a);
 
 /*
@@ -222,49 +182,67 @@ static VALUE BigDecimal_negative_zero(void);
 static VALUE BigDecimal_addsub_with_coerce(VALUE self, VALUE r, size_t prec, int operation);
 static VALUE BigDecimal_mult_with_coerce(VALUE self, VALUE r, size_t prec);
 
-static void
-BigDecimal_delete(void *pv)
-{
-    rbd_free_struct(pv);
-}
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#   undef RUBY_TYPED_FROZEN_SHAREABLE
+#   define RUBY_TYPED_FROZEN_SHAREABLE 0
+#endif
+
+#ifdef RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+#else
+# ifdef HAVE_CONST_RUBY_TYPED_EMBEDDABLE
+#  define RUBY_TYPED_EMBEDDABLE RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+# else
+#  define RUBY_TYPED_EMBEDDABLE 0
+# endif
+#endif
 
 static size_t
 BigDecimal_memsize(const void *ptr)
 {
+#ifdef HAVE_RUBY_TYPED_EMBEDDABLE
+    return 0; // Entirely embedded
+#else
     const Real *pv = ptr;
     return (sizeof(*pv) + pv->MaxPrec * sizeof(DECDIG));
-}
-
-#ifndef HAVE_RB_EXT_RACTOR_SAFE
-#   undef RUBY_TYPED_FROZEN_SHAREABLE
-#   define RUBY_TYPED_FROZEN_SHAREABLE 0
 #endif
+}
 
 static const rb_data_type_t BigDecimal_data_type = {
-    "BigDecimal",
-    { 0, BigDecimal_delete, BigDecimal_memsize, },
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED
-#endif
+    .wrap_struct_name = "BigDecimal",
+    .function = {
+        .dmark = 0,
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = BigDecimal_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
 };
 
-// TypedData_Wrap_Struct may fail if there is no memory, or GC.add_stress_to_class(BigDecimal) is set.
-// We need to first allocate empty struct, allocate Real struct, and then set the data pointer.
-typedef struct { VALUE _obj; } NULL_WRAPPED_VALUE;
-static NULL_WRAPPED_VALUE
-BigDecimal_alloc_empty_struct(VALUE klass)
+static VALUE
+BigDecimal_allocate(size_t const internal_digits)
 {
-    return (NULL_WRAPPED_VALUE) { TypedData_Wrap_Struct(klass, &BigDecimal_data_type, NULL) };
+    const size_t size = rbd_struct_size(internal_digits);
+    VALUE bd = rb_data_typed_object_zalloc(rb_cBigDecimal, size, &BigDecimal_data_type);
+    Real *vp;
+    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+    vp->MaxPrec = internal_digits;
+    RB_OBJ_FREEZE(bd);
+    return bd;
 }
 
 static VALUE
-BigDecimal_wrap_struct(NULL_WRAPPED_VALUE v, Real *real)
+BigDecimal_allocate_decimal_digits(size_t const decimal_digits)
 {
-    VALUE obj = v._obj;
-    assert(RTYPEDDATA_DATA(obj) == NULL);
-    RTYPEDDATA_DATA(obj) = real;
-    RB_OBJ_FREEZE(obj);
-    return obj;
+    return BigDecimal_allocate(roomof(decimal_digits, BASE_FIG));
+}
+
+static Real *
+VpPtr(VALUE obj)
+{
+    Real *vp;
+    TypedData_Get_Struct(obj, Real, &BigDecimal_data_type, vp);
+    return vp;
 }
 
 MAYBE_UNUSED(static inline BDVALUE rbd_allocate_struct_zero_wrap(int sign, size_t const digits));
@@ -272,9 +250,10 @@ MAYBE_UNUSED(static inline BDVALUE rbd_allocate_struct_zero_wrap(int sign, size_
 static BDVALUE
 rbd_allocate_struct_zero_wrap(int sign, size_t const digits)
 {
-    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
-    Real *real = rbd_allocate_struct_zero(sign, digits);
-    return (BDVALUE) { BigDecimal_wrap_struct(null_wrapped, real), real };
+    VALUE obj = BigDecimal_allocate_decimal_digits(digits);
+    Real *real = VpPtr(obj);
+    VpSetZero(real, sign);
+    return (BDVALUE) { obj, real };
 }
 
 static inline int
@@ -336,8 +315,7 @@ GetBDValueWithPrecInternal(VALUE v, size_t prec, int must)
 	goto SomeOneMayDoIt;
     }
 
-    Real *vp;
-    TypedData_Get_Struct(v, Real, &BigDecimal_data_type, vp);
+    Real *vp = VpPtr(v);
     return (NULLABLE_BDVALUE) { v, vp };
 
 SomeOneMayDoIt:
@@ -1010,26 +988,18 @@ check_int_precision(VALUE v)
 static NULLABLE_BDVALUE
 CreateFromString(const char *str, VALUE klass, bool strict_p, bool raise_exception)
 {
-    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(klass);
-    Real *pv = VpAlloc(str, strict_p, raise_exception);
-    if (!pv) return (NULLABLE_BDVALUE) { Qnil, NULL };
-    return (NULLABLE_BDVALUE) { BigDecimal_wrap_struct(null_wrapped, pv), pv };
+    return VpAlloc(str, strict_p, raise_exception);
 }
 
-static Real *
-VpCopy(Real *pv, Real const* const x)
+void
+VpMemCopy(Real *pv, Real const* const x)
 {
-    assert(x != NULL);
-
-    pv = (Real *)ruby_xrealloc(pv, rbd_struct_size(x->MaxPrec));
     pv->MaxPrec = x->MaxPrec;
     pv->Prec = x->Prec;
     pv->exponent = x->exponent;
     pv->sign = x->sign;
     pv->flag = x->flag;
     MEMCPY(pv->frac, x->frac, DECDIG, pv->MaxPrec);
-
-    return pv;
 }
 
 /* Returns True if the value is Not a Number. */
@@ -1219,7 +1189,7 @@ GetCoercePrec(Real *a, size_t prec)
 static VALUE
 BigDecimal_coerce(VALUE self, VALUE other)
 {
-    Real* pv = DATA_PTR(self);
+    Real* pv = VpPtr(self);
     BDVALUE b = GetBDValueWithPrecMust(other, GetCoercePrec(pv, 0));
     return rb_assoc_new(CheckGetValue(b), self);
 }
@@ -1687,7 +1657,7 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE
 
     if (VpIsNaN(a.real) || VpIsNaN(b.real) || (VpIsInf(a.real) && VpIsInf(b.real))) {
         VALUE nan = BigDecimal_nan();
-        *div = *mod = (NULLABLE_BDVALUE) { nan, DATA_PTR(nan) };
+        *div = *mod = (NULLABLE_BDVALUE) { nan, VpPtr(nan) };
         goto Done;
     }
     if (VpIsZero(b.real)) {
@@ -1696,19 +1666,19 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE
     if (VpIsInf(a.real)) {
         if (VpGetSign(a.real) == VpGetSign(b.real)) {
             VALUE inf = BigDecimal_positive_infinity();
-            *div = (NULLABLE_BDVALUE) { inf, DATA_PTR(inf) };
+            *div = (NULLABLE_BDVALUE) { inf, VpPtr(inf) };
         }
         else {
             VALUE inf = BigDecimal_negative_infinity();
-            *div = (NULLABLE_BDVALUE) { inf, DATA_PTR(inf) };
+            *div = (NULLABLE_BDVALUE) { inf, VpPtr(inf) };
         }
         VALUE nan = BigDecimal_nan();
-        *mod = (NULLABLE_BDVALUE) { nan, DATA_PTR(nan) };
+        *mod = (NULLABLE_BDVALUE) { nan, VpPtr(nan) };
         goto Done;
     }
     if (VpIsZero(a.real)) {
         VALUE zero = BigDecimal_positive_zero();
-        *div = (NULLABLE_BDVALUE) { zero, DATA_PTR(zero) };
+        *div = (NULLABLE_BDVALUE) { zero, VpPtr(zero) };
         *mod = bdvalue_nullable(a);
         goto Done;
     }
@@ -1722,7 +1692,7 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE
             *mod = bdvalue_nullable(b);
         } else {
             VALUE zero = BigDecimal_positive_zero();
-            *div = (NULLABLE_BDVALUE) { zero, DATA_PTR(zero) };
+            *div = (NULLABLE_BDVALUE) { zero, VpPtr(zero) };
             *mod = bdvalue_nullable(a);
         }
         goto Done;
@@ -2566,9 +2536,7 @@ check_exception(VALUE bd)
 {
     assert(is_kind_of_BigDecimal(bd));
 
-    Real *vp;
-    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
-    VpCheckException(vp, false);
+    VpCheckException(VpPtr(bd), false);
 
     return bd;
 }
@@ -2576,17 +2544,19 @@ check_exception(VALUE bd)
 static VALUE
 rb_uint64_convert_to_BigDecimal(uint64_t uval)
 {
-    NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
+    VALUE bd;
     Real *vp;
     if (uval == 0) {
-        vp = rbd_allocate_struct(1);
+        bd = BigDecimal_allocate(1);
+        vp = VpPtr(bd);
         vp->Prec = 1;
         vp->exponent = 1;
         VpSetZero(vp, 1);
         vp->frac[0] = 0;
     }
     else if (uval < BASE) {
-        vp = rbd_allocate_struct(1);
+        bd = BigDecimal_allocate(1);
+        vp = VpPtr(bd);
         vp->Prec = 1;
         vp->exponent = 1;
         VpSetSign(vp, 1);
@@ -2611,14 +2581,15 @@ rb_uint64_convert_to_BigDecimal(uint64_t uval)
         }
 
         const size_t exp = len + ntz;
-        vp = rbd_allocate_struct(len);
+        bd = BigDecimal_allocate(len);
+        vp = VpPtr(bd);
         vp->Prec = len;
         vp->exponent = exp;
         VpSetSign(vp, 1);
         MEMCPY(vp->frac, buf + BIGDECIMAL_INT64_MAX_LENGTH - len, DECDIG, len);
     }
 
-    return BigDecimal_wrap_struct(null_wrapped, vp);
+    return bd;
 }
 
 static VALUE
@@ -2627,8 +2598,7 @@ rb_int64_convert_to_BigDecimal(int64_t ival)
     const uint64_t uval = (ival < 0) ? (((uint64_t)-(ival+1))+1) : (uint64_t)ival;
     VALUE bd = rb_uint64_convert_to_BigDecimal(uval);
     if (ival < 0) {
-        Real *vp;
-        TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+        Real *vp = VpPtr(bd);
         VpSetSign(vp, -1);
     }
     return bd;
@@ -2835,8 +2805,7 @@ rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
     }
 
     VALUE bd = rb_inum_convert_to_BigDecimal(inum);
-    Real *vp;
-    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+    Real *vp = VpPtr(bd);
     assert(vp->Prec == prec);
     vp->exponent = exp;
 
@@ -2902,13 +2871,15 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         if (digs == SIZE_MAX)
             return check_exception(val);
 
-        NULL_WRAPPED_VALUE null_wrapped = BigDecimal_alloc_empty_struct(rb_cBigDecimal);
-        Real *vp;
-        TypedData_Get_Struct(val, Real, &BigDecimal_data_type, vp);
-        vp = VpCopy(NULL, vp);
+        Real *vp = VpPtr(val);
+
+        VALUE copy = BigDecimal_allocate(vp->MaxPrec);
+        Real *vp_copy = VpPtr(copy);
+
+        VpMemCopy(vp_copy, vp);
+
         RB_GC_GUARD(val);
 
-        VALUE copy = BigDecimal_wrap_struct(null_wrapped, vp);
         /* TODO: rounding */
         return check_exception(copy);
     }
@@ -3707,7 +3678,7 @@ Init_bigdecimal(void)
 static int gfDebug = 1;         /* Debug switch */
 #endif /* BIGDECIMAL_DEBUG */
 
-static Real *VpConstOne;    /* constant 1.0 */
+static VALUE VpConstOne; /* constant 1.0 */
 
 enum op_sw {
     OP_SW_ADD = 1,  /* + */
@@ -4108,8 +4079,9 @@ VpInit(DECDIG BaseVal)
     VpGetDoubleNegZero();
 
     /* Const 1.0 */
-    VpConstOne = NewZero(1, 1);
-    VpSetOne(VpConstOne);
+    rb_global_variable(&VpConstOne);
+    VpConstOne = NewZeroWrap(1, 1).bigdecimal;
+    VpSetOne(VpPtr(VpConstOne));
 
 #ifdef BIGDECIMAL_DEBUG
     gnAlloc = 0;
@@ -4121,7 +4093,7 @@ VpInit(DECDIG BaseVal)
 VP_EXPORT Real *
 VpOne(void)
 {
-    return VpConstOne;
+    return VpPtr(VpConstOne);
 }
 
 /* If exponent overflows,then raise exception or returns 0 */
@@ -4152,7 +4124,7 @@ overflow:
     return VpException(VP_EXCEPTION_OVERFLOW, "Exponent overflow", 0);
 }
 
-Real *
+NULLABLE_BDVALUE
 bigdecimal_parse_special_string(const char *str)
 {
     static const struct {
@@ -4177,66 +4149,27 @@ bigdecimal_parse_special_string(const char *str)
         p = str + table[i].len;
         while (*p && ISSPACE(*p)) ++p;
         if (*p == '\0') {
-            Real *vp = rbd_allocate_struct(1);
+            VALUE obj = BigDecimal_allocate(1);
+            Real *vp = VpPtr(obj);
             switch (table[i].sign) {
               default:
-                UNREACHABLE; break;
+                UNREACHABLE;
+                return (NULLABLE_BDVALUE) { Qnil, NULL };
               case VP_SIGN_POSITIVE_INFINITE:
                 VpSetPosInf(vp);
-                return vp;
+                break;
               case VP_SIGN_NEGATIVE_INFINITE:
                 VpSetNegInf(vp);
-                return vp;
+                break;
               case VP_SIGN_NaN:
                 VpSetNaN(vp);
-                return vp;
+                break;
             }
+            return (NULLABLE_BDVALUE) { obj, vp };
         }
     }
 
-    return NULL;
-}
-
-struct VpCtoV_args {
-  Real *a;
-  const char *int_chr;
-  size_t ni;
-  const char *frac;
-  size_t nf;
-  const char *exp_chr;
-  size_t ne;
-};
-
-static VALUE
-call_VpCtoV(VALUE arg)
-{
-  struct VpCtoV_args *x = (struct VpCtoV_args *)arg;
-  return (VALUE)VpCtoV(x->a, x->int_chr, x->ni, x->frac, x->nf, x->exp_chr, x->ne);
-}
-
-static int
-protected_VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne, int free_on_error)
-{
-  struct VpCtoV_args args;
-  int state = 0;
-
-  args.a = a;
-  args.int_chr = int_chr;
-  args.ni = ni;
-  args.frac = frac;
-  args.nf = nf;
-  args.exp_chr = exp_chr;
-  args.ne = ne;
-
-  VALUE result = rb_protect(call_VpCtoV, (VALUE)&args, &state);
-  if (state) {
-    if (free_on_error) {
-      rbd_free_struct(a);
-    }
-    rb_jump_tag(state);
-  }
-
-  return (int)result;
+    return (NULLABLE_BDVALUE) { Qnil, NULL };
 }
 
 /*
@@ -4245,25 +4178,25 @@ protected_VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size
  *   szVal ... The value assigned(char).
  *
  * [Returns]
- *   Pointer to the newly allocated variable, or
- *   NULL be returned if memory allocation is failed,or any error.
+ *   NULLABLE_BDVALUE to the newly allocated variable.
+ *   Null is returned if memory allocation failed, or any error occured.
  */
-VP_EXPORT Real *
+VP_EXPORT NULLABLE_BDVALUE
 VpAlloc(const char *szVal, int strict_p, int exc)
 {
     const char *orig_szVal = szVal;
     size_t i, j, ni, ipf, nf, ipe, ne, exp_seen, nalloc;
     char v, *psz;
     int  sign=1;
-    Real *vp = NULL;
     VALUE buf;
 
     /* Skipping leading spaces */
     while (ISSPACE(*szVal)) szVal++;
 
     /* Check on Inf & NaN */
-    if ((vp = bigdecimal_parse_special_string(szVal)) != NULL) {
-        return vp;
+    NULLABLE_BDVALUE special_bd = bigdecimal_parse_special_string(szVal);
+    if (special_bd.real_or_null != NULL) {
+        return special_bd;
     }
 
     /* Skip leading `#`.
@@ -4417,10 +4350,11 @@ VpAlloc(const char *szVal, int strict_p, int exc)
         VALUE str;
       invalid_value:
         if (!strict_p) {
-            return NewZero(1, 1);
+            BDVALUE res = rbd_allocate_struct_zero_wrap(1, 1);
+            return (NULLABLE_BDVALUE) { res.bigdecimal, res.real };
         }
         if (!exc) {
-            return NULL;
+            return (NULLABLE_BDVALUE) { Qnil, NULL };
         }
         str = rb_str_new2(orig_szVal);
         rb_raise(rb_eArgError, "invalid value for BigDecimal(): \"%"PRIsVALUE"\"", str);
@@ -4428,11 +4362,12 @@ VpAlloc(const char *szVal, int strict_p, int exc)
 
     nalloc = (ni + nf + BASE_FIG - 1) / BASE_FIG + 1;    /* set effective allocation  */
     /* units for szVal[]  */
-    vp = rbd_allocate_struct(nalloc);
+    VALUE obj = BigDecimal_allocate(nalloc);
+    Real *vp = VpPtr(obj);
     VpSetZero(vp, sign);
-    protected_VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne, true);
+    VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne);
     rb_str_resize(buf, 0);
-    return vp;
+    return (NULLABLE_BDVALUE) { obj, vp };
 }
 
 /*
@@ -4904,17 +4839,12 @@ VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos,
  *        a0 a1 .... an    * b0
  *      +_____________________________
  *     c0 c1 c2  ......  cl
- *     nc      <---|
- *     MaxAB |--------------------|
  */
 VP_EXPORT size_t
 VpMult(Real *c, Real *a, Real *b)
 {
-    size_t MxIndA, MxIndB, MxIndAB;
-    size_t ind_c, i, ii, nc;
-    size_t ind_as, ind_ae, ind_bs;
-    DECDIG carry;
-    DECDIG_DBL s;
+    ssize_t a_batch_max, b_batch_max;
+    DECDIG_DBL batch[VPMULT_BATCH_SIZE * 2 - 1];
 
     if (!VpIsDefOP(c, a, b, OP_SW_MULT)) return 0; /* No significant digit */
 
@@ -4938,9 +4868,6 @@ VpMult(Real *c, Real *a, Real *b)
 	a = b;
 	b = w;
     }
-    MxIndA = a->Prec - 1;
-    MxIndB = b->Prec - 1;
-    MxIndAB = a->Prec + b->Prec - 1;
 
     /* set LHSV c info */
 
@@ -4954,51 +4881,41 @@ VpMult(Real *c, Real *a, Real *b)
         goto Cleanup;
     }
 
-    carry = 0;
-    nc = ind_c = MxIndAB;
-    memset(c->frac, 0, (nc + 1) * sizeof(DECDIG));        /* Initialize c  */
-    c->Prec = nc + 1;        /* set precision */
-    for (nc = 0; nc < MxIndAB; ++nc, --ind_c) {
-	if (nc < MxIndB) {    /* The left triangle of the Fig. */
-	    ind_as = MxIndA - nc;
-	    ind_ae = MxIndA;
-	    ind_bs = MxIndB;
-	}
-	else if (nc <= MxIndA) {    /* The middle rectangular of the Fig. */
-	    ind_as = MxIndA - nc;
-	    ind_ae = MxIndA - (nc - MxIndB);
-	    ind_bs = MxIndB;
-	}
-	else /* if (nc > MxIndA) */ {    /*  The right triangle of the Fig. */
-	    ind_as = 0;
-	    ind_ae = MxIndAB - nc - 1;
-	    ind_bs = MxIndB - (nc - MxIndA);
-	}
+    c->Prec = a->Prec + b->Prec; /* set precision */
+    memset(c->frac, 0, c->Prec * sizeof(DECDIG)); /* Initialize c  */
+
+    // Process VPMULT_BATCH_SIZE decdigits at a time to reduce the number of carry operations.
+    a_batch_max = (a->Prec - 1) / VPMULT_BATCH_SIZE;
+    b_batch_max = (b->Prec - 1) / VPMULT_BATCH_SIZE;
+    for (ssize_t ibatch = a_batch_max; ibatch >= 0; ibatch--) {
+        int isize = ibatch == a_batch_max ? (a->Prec - 1) % VPMULT_BATCH_SIZE + 1 : VPMULT_BATCH_SIZE;
+        for (ssize_t jbatch = b_batch_max; jbatch >= 0; jbatch--) {
+            int jsize = jbatch == b_batch_max ? (b->Prec - 1) % VPMULT_BATCH_SIZE + 1 : VPMULT_BATCH_SIZE;
+            memset(batch, 0, (isize + jsize - 1) * sizeof(DECDIG_DBL));
+
+            // Perform multiplication without carry calculation.
+            // BASE * BASE * VPMULT_BATCH_SIZE < 2**64 should be satisfied so that
+            // DECDIG_DBL can hold the intermediate sum without overflow.
+            for (int i = 0; i < isize; i++) {
+                for (int j = 0; j < jsize; j++) {
+                    batch[i + j] += (DECDIG_DBL)a->frac[ibatch * VPMULT_BATCH_SIZE + i] * b->frac[jbatch * VPMULT_BATCH_SIZE + j];
+                }
+            }
 
-	for (i = ind_as; i <= ind_ae; ++i) {
-            s = (DECDIG_DBL)a->frac[i] * b->frac[ind_bs--];
-            carry = (DECDIG)(s / BASE);
-            s -= (DECDIG_DBL)carry * BASE;
-            c->frac[ind_c] += (DECDIG)s;
-            if (c->frac[ind_c] >= BASE) {
-                s = c->frac[ind_c] / BASE;
-                carry += (DECDIG)s;
-                c->frac[ind_c] -= (DECDIG)(s * BASE);
+            // Add the batch result to c with carry calculation.
+            DECDIG_DBL carry = 0;
+            for (int k = isize + jsize - 2; k >= 0; k--) {
+                size_t l = (ibatch + jbatch) * VPMULT_BATCH_SIZE + k + 1;
+                DECDIG_DBL s = c->frac[l] + batch[k] + carry;
+                c->frac[l] = (DECDIG)(s % BASE);
+                carry = (DECDIG_DBL)(s / BASE);
             }
-	    if (carry) {
-		ii = ind_c;
-		while (ii-- > 0) {
-		    c->frac[ii] += carry;
-		    if (c->frac[ii] >= BASE) {
-			carry = c->frac[ii] / BASE;
-			c->frac[ii] -= (carry * BASE);
-		    }
-		    else {
-			break;
-		    }
-		}
-	    }
-	}
+
+            // Adding carry may exceed BASE, but it won't cause overflow of DECDIG.
+            // Exceeded value will be resolved in the carry operation of next (ibatch + jbatch - 1) batch.
+            // WARNING: This safety strongly relies on the current nested loop execution order.
+            c->frac[(ibatch + jbatch) * VPMULT_BATCH_SIZE] += (DECDIG)carry;
+        }
     }
 
 Cleanup:

data/ext/bigdecimal/bigdecimal.h

@@ -168,6 +168,11 @@ typedef struct {
     Real *real;
 } BDVALUE;
 
+typedef struct {
+    VALUE bigdecimal_or_nil;
+    Real *real_or_null;
+} NULLABLE_BDVALUE;
+
 /*
  *  ------------------
  *   EXPORTables.
@@ -194,7 +199,7 @@ VP_EXPORT unsigned short VpSetRoundMode(unsigned short n);
 VP_EXPORT int VpException(unsigned short f,const char *str,int always);
 VP_EXPORT size_t VpNumOfChars(Real *vp,const char *pszFmt);
 VP_EXPORT size_t VpInit(DECDIG BaseVal);
-VP_EXPORT Real *VpAlloc(const char *szVal, int strict_p, int exc);
+VP_EXPORT NULLABLE_BDVALUE VpAlloc(const char *szVal, int strict_p, int exc);
 VP_EXPORT size_t VpAsgn(Real *c, Real *a, int isw);
 VP_EXPORT size_t VpAddSub(Real *c,Real *a,Real *b,int operation);
 VP_EXPORT size_t VpMult(Real *c,Real *a,Real *b);

data/ext/bigdecimal/extconf.rb

@@ -46,6 +46,10 @@ have_func("rb_opts_exception_p", "ruby.h")
 have_func("rb_category_warn", "ruby.h")
 have_const("RB_WARN_CATEGORY_DEPRECATED", "ruby.h")
 
+if RUBY_ENGINE == "ruby"
+  have_const("RUBY_TYPED_EMBEDDABLE", "ruby.h") # RUBY_VERSION >= 3.3
+end
+
 if File.file?(File.expand_path('../lib/bigdecimal.rb', __FILE__))
   bigdecimal_rb = "$(srcdir)/lib/bigdecimal.rb"
 else

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(x.to_f), 0)
+    y = BigDecimal(Math.cbrt(BigDecimal::Internal.fast_to_f(x)), 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(x.to_f), 0)
+    y = BigDecimal(Math.atan(BigDecimal::Internal.fast_to_f(x)), 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 = x.to_f
+      xf = BigDecimal::Internal.fast_to_f(x)
       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)
@@ -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 = x.to_f
+    xf = BigDecimal::Internal.fast_to_f(x)
     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 = x.to_f
+    xf = BigDecimal::Internal.fast_to_f(x)
     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

@@ -76,9 +76,18 @@ 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(x._decimal_shift(-x.exponent).to_f) + x.exponent * Math.log(10)
+      Math.log(fast_to_f(x._decimal_shift(-x.exponent))) + x.exponent * Math.log(10)
     end
 
     # Calculating Taylor series sum using binary splitting method
@@ -268,7 +277,7 @@ class BigDecimal
 
     ex = exponent / 2
     x = _decimal_shift(-2 * ex)
-    y = BigDecimal(Math.sqrt(x.to_f), 0)
+    y = BigDecimal(Math.sqrt(BigDecimal::Internal.fast_to_f(x)), 0)
     Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
       y = y.add(x.div(y, p), p).div(2, p)
     end

metadata

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