bigdecimal 3.3.1 → 4.1.3

data/ext/bigdecimal/bigdecimal.c

@@ -29,12 +29,16 @@
 #endif
 
 #include "bits.h"
+#include "ntt.h"
+#include "div.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "3.3.1"
-
-/* #define ENABLE_NUMERIC_STRING */
+#define BIGDECIMAL_VERSION "4.1.3"
 
+/* 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)
@@ -64,7 +68,6 @@ static ID id_banker;
 static ID id_ceiling;
 static ID id_ceil;
 static ID id_floor;
-static ID id_to_r;
 static ID id_eq;
 static ID id_half;
 
@@ -75,16 +78,6 @@ static struct {
     uint8_t mode;
 } rbd_rounding_modes[RBD_NUM_ROUNDING_MODES];
 
-typedef struct {
-    VALUE bigdecimal;
-    Real *real;
-} BDVALUE;
-
-typedef struct {
-    VALUE bigdecimal_or_nil;
-    Real *real_or_null;
-} NULLABLE_BDVALUE;
-
 static inline BDVALUE
 bdvalue_nonnullable(NULLABLE_BDVALUE v)
 {
@@ -160,42 +153,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,11 +164,9 @@ rbd_allocate_struct_zero(int sign, size_t const digits)
 static unsigned short VpGetException(void);
 static void  VpSetException(unsigned short f);
 static void VpCheckException(Real *p, bool always);
-static int AddExponent(Real *a, SIGNED_VALUE n);
 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);
 
 /*
@@ -226,49 +181,71 @@ 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));
+#endif
 }
 
-#ifndef HAVE_RB_EXT_RACTOR_SAFE
-#   undef RUBY_TYPED_FROZEN_SHAREABLE
-#   define RUBY_TYPED_FROZEN_SHAREABLE 0
+#ifndef RUBY_TYPED_THREAD_SAFE_FREE
+#define RUBY_TYPED_THREAD_SAFE_FREE RUBY_TYPED_FREE_IMMEDIATELY
 #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_THREAD_SAFE_FREE | 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));
@@ -276,9 +253,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,20 +314,11 @@ GetBDValueWithPrecInternal(VALUE v, size_t prec, int must)
         break;
       }
 
-#ifdef ENABLE_NUMERIC_STRING
-      case T_STRING: {
-        const char *c_str = StringValueCStr(v);
-        v = rb_cstr_convert_to_BigDecimal(c_str, must);
-        break;
-      }
-#endif /* ENABLE_NUMERIC_STRING */
-
       default:
 	goto SomeOneMayDoIt;
     }
 
-    Real *vp;
-    TypedData_Get_Struct(v, Real, &BigDecimal_data_type, vp);
+    Real *vp = VpPtr(v);
     return (NULLABLE_BDVALUE) { v, vp };
 
 SomeOneMayDoIt:
@@ -400,37 +369,6 @@ BigDecimal_double_fig(VALUE self)
     return INT2FIX(BIGDECIMAL_DOUBLE_FIGURES);
 }
 
-/*  call-seq:
- *    precs -> array
- *
- *  Returns an Array of two Integer values that represent platform-dependent
- *  internal storage properties.
- *
- *  This method is deprecated and will be removed in the future.
- *  Instead, use BigDecimal#n_significant_digits for obtaining the number of
- *  significant digits in scientific notation, and BigDecimal#precision for
- *  obtaining the number of digits in decimal notation.
- *
- */
-
-static VALUE
-BigDecimal_prec(VALUE self)
-{
-    BDVALUE v;
-    VALUE obj;
-
-    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED,
-                     "BigDecimal#precs is deprecated and will be removed in the future; "
-                     "use BigDecimal#precision instead.");
-
-    v = GetBDValueMust(self);
-    obj = rb_assoc_new(SIZET2NUM(v.real->Prec*VpBaseFig()),
-		       SIZET2NUM(v.real->MaxPrec*VpBaseFig()));
-
-    RB_GC_GUARD(v.bigdecimal);
-    return obj;
-}
-
 static void
 VpCountPrecisionAndScale(Real *p, ssize_t *out_precision, ssize_t *out_scale)
 {
@@ -734,6 +672,7 @@ BigDecimal_load(VALUE self, VALUE str)
         }
     }
     v = bdvalue_nonnullable(CreateFromString((char *)pch, self, true, true));
+    RB_GC_GUARD(str);
     return CheckGetValue(v);
 }
 
@@ -1027,7 +966,7 @@ BigDecimal_mode(int argc, VALUE *argv, VALUE self)
 static size_t
 GetAddSubPrec(Real *a, Real *b)
 {
-    if (!VpIsDef(a) || !VpIsDef(b)) return (size_t)-1L;
+    if (VpIsZero(a) || VpIsZero(b)) return Max(a->Prec, b->Prec);
     ssize_t min_a = a->exponent - a->Prec;
     ssize_t min_b = b->exponent - b->Prec;
     return Max(a->exponent, b->exponent) - Min(min_a, min_b);
@@ -1053,26 +992,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. */
@@ -1112,9 +1043,6 @@ BigDecimal_check_num(Real *p)
     VpCheckException(p, true);
 }
 
-static VALUE BigDecimal_fix(VALUE self);
-static VALUE BigDecimal_split(VALUE self);
-
 /* Returns the value as an Integer.
  *
  * If the BigDecimal is infinity or NaN, raises FloatDomainError.
@@ -1265,7 +1193,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);
 }
@@ -1331,13 +1259,32 @@ BigDecimal_addsub_with_coerce(VALUE self, VALUE r, size_t prec, int operation)
     if (VpIsNaN(a.real)) return CheckGetValue(a);
     if (VpIsNaN(b.real)) return CheckGetValue(b);
 
-    mx = GetAddSubPrec(a.real, b.real);
-    if (mx == (size_t)-1L) {
-        /* a or b is inf */
+    if (VpIsInf(a.real) || VpIsInf(b.real)) {
         c = NewZeroWrap(1, BASE_FIG);
         VpAddSub(c.real, a.real, b.real, operation);
     }
     else {
+
+        // Optimization when exponent difference is large
+        // (1.234e+1000).add(5.678e-1000, 10) == (1.234e+1000).add(0.1e+990, 10) in every rounding mode
+        if (prec && !VpIsZero(a.real) && !VpIsZero(b.real)) {
+            size_t precRoom = roomof(prec, BASE_FIG);
+            if (a.real->exponent - (ssize_t)Max(a.real->Prec, precRoom) - 1 > b.real->exponent) {
+                BDVALUE b2 = NewZeroWrap(1, BASE_FIG);
+                VpSetOne(b2.real)
+                VpSetSign(b2.real, b.real->sign);
+                b2.real->exponent = a.real->exponent - (ssize_t)Max(a.real->Prec, precRoom) - 1;
+                b = b2;
+            } else if (b.real->exponent - (ssize_t)Max(b.real->Prec, precRoom) - 1 > a.real->exponent) {
+                BDVALUE a2 = NewZeroWrap(1, BASE_FIG);
+                VpSetOne(a2.real)
+                VpSetSign(a2.real, a.real->sign);
+                a2.real->exponent = b.real->exponent - (ssize_t)Max(b.real->Prec, precRoom) - 1;
+                a = a2;
+            }
+        }
+
+        mx = GetAddSubPrec(a.real, b.real);
         c = NewZeroWrap(1, (mx + 1) * BASE_FIG);
         size_t pl = VpGetPrecLimit();
         if (prec) VpSetPrecLimit(prec);
@@ -1714,7 +1661,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)) {
@@ -1723,19 +1670,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;
     }
@@ -1749,7 +1696,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;
@@ -1792,13 +1739,13 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE
         *div = bdvalue_nullable(dv);
         *mod = bdvalue_nullable(md);
     }
+    RB_GC_GUARD(dv.bigdecimal);
+    RB_GC_GUARD(md.bigdecimal);
+    RB_GC_GUARD(res.bigdecimal);
 
 Done:
     RB_GC_GUARD(a.bigdecimal);
     RB_GC_GUARD(b.bigdecimal);
-    RB_GC_GUARD(dv.bigdecimal);
-    RB_GC_GUARD(md.bigdecimal);
-    RB_GC_GUARD(res.bigdecimal);
     return true;
 }
 
@@ -1867,7 +1814,7 @@ BigDecimal_divmod(VALUE self, VALUE r)
     NULLABLE_BDVALUE div, mod;
 
     if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
-        return rb_assoc_new(CheckGetValue(bdvalue_nonnullable(div)), CheckGetValue(bdvalue_nonnullable(mod)));
+        return rb_assoc_new(BigDecimal_to_i(CheckGetValue(bdvalue_nonnullable(div))), CheckGetValue(bdvalue_nonnullable(mod)));
     }
     return DoSomeOne(self,r,rb_intern("divmod"));
 }
@@ -2507,7 +2454,7 @@ BigDecimal_decimal_shift(VALUE self, VALUE v)
     prec = a.real->Prec + shiftDown;
     c = NewZeroWrap(1, prec * BASE_FIG);
     if (shift == 0) {
-        VpAsgn(c.real, a.real, 1);
+        VpAsgn(c.real, a.real, 10);
     } else if (shiftDown) {
         DECDIG carry = 0;
         exponentShift++;
@@ -2593,9 +2540,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;
 }
@@ -2603,17 +2548,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);
@@ -2638,14 +2585,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
@@ -2654,8 +2602,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;
@@ -2766,7 +2713,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;
@@ -2862,8 +2809,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;
 
@@ -2900,8 +2846,13 @@ rb_cstr_convert_to_BigDecimal(const char *c_str, int raise_exception)
 static inline VALUE
 rb_str_convert_to_BigDecimal(VALUE val, int raise_exception)
 {
+    StringValue(val);
+    rb_must_asciicompat(val);
+    if (!raise_exception && memchr(RSTRING_PTR(val), '\0', RSTRING_LEN(val))) return Qnil;
     const char *c_str = StringValueCStr(val);
-    return rb_cstr_convert_to_BigDecimal(c_str, raise_exception);
+    VALUE bd = rb_cstr_convert_to_BigDecimal(c_str, raise_exception);
+    RB_GC_GUARD(val);
+    return bd;
 }
 
 static VALUE
@@ -2929,13 +2880,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);
     }
@@ -2951,7 +2904,7 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
     else if (RB_TYPE_P(val, T_COMPLEX)) {
         VALUE im = rb_complex_imag(val);
         if (!is_zero(im)) {
-            /* TODO: handle raise_exception */
+            if (!raise_exception) return Qnil;
             rb_raise(rb_eArgError,
                      "Unable to make a BigDecimal from non-zero imaginary number");
         }
@@ -3061,8 +3014,15 @@ f_BigDecimal(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
 {
+    StringValue(str);
+    rb_must_asciicompat(str);
+    /* Like String#to_f, ignore everything after an embedded NUL */
+    const char *p = RSTRING_PTR(str);
+    const char *nul = memchr(p, '\0', RSTRING_LEN(str));
+    if (nul) str = rb_str_subseq(str, 0, nul - p);
     char const *c_str = StringValueCStr(str);
     NULLABLE_BDVALUE v = CreateFromString(c_str, klass, false, true);
+    RB_GC_GUARD(str);
     if (v.bigdecimal_or_nil == Qnil)
         return Qnil;
     else
@@ -3257,19 +3217,39 @@ BigDecimal_literal(const char *str)
 
 #ifdef BIGDECIMAL_USE_VP_TEST_METHODS
 VALUE
-BigDecimal_vpdivd(VALUE self, VALUE r, VALUE cprec) {
-    BDVALUE a,b,c,d;
+BigDecimal_vpdivd_generic(VALUE self, VALUE r, VALUE cprec, void (*vpdivd_func)(Real*, Real*, Real*, Real*)) {
+    BDVALUE a, b, c, d;
     size_t cn = NUM2INT(cprec);
     a = GetBDValueMust(self);
     b = GetBDValueMust(r);
     c = NewZeroWrap(1, cn * BASE_FIG);
     d = NewZeroWrap(1, VPDIVD_REM_PREC(a.real, b.real, c.real) * BASE_FIG);
-    VpDivd(c.real, d.real, a.real, b.real);
+    vpdivd_func(c.real, d.real, a.real, b.real);
     RB_GC_GUARD(a.bigdecimal);
     RB_GC_GUARD(b.bigdecimal);
     return rb_assoc_new(c.bigdecimal, d.bigdecimal);
 }
 
+void
+VpDivdNormal(Real *c, Real *r, Real *a, Real *b) {
+    VpDivd(c, r, a, b);
+}
+
+VALUE
+BigDecimal_vpdivd(VALUE self, VALUE r, VALUE cprec) {
+  return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNormal);
+}
+
+VALUE
+BigDecimal_vpdivd_newton(VALUE self, VALUE r, VALUE cprec) {
+    return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNewton);
+}
+
+VALUE
+BigDecimal_newton_raphson_inverse(VALUE self, VALUE prec) {
+    return newton_raphson_inverse(self, NUM2SIZET(prec));
+}
+
 VALUE
 BigDecimal_vpmult(VALUE self, VALUE v) {
     BDVALUE a,b,c;
@@ -3281,6 +3261,23 @@ BigDecimal_vpmult(VALUE self, VALUE v) {
     RB_GC_GUARD(b.bigdecimal);
     return c.bigdecimal;
 }
+
+VALUE
+BigDecimal_nttmult(VALUE self, VALUE v) {
+    BDVALUE a,b,c;
+    a = GetBDValueMust(self);
+    b = GetBDValueMust(v);
+    c = NewZeroWrap(1, VPMULT_RESULT_PREC(a.real, b.real) * BASE_FIG);
+    ntt_multiply(a.real->Prec, b.real->Prec, a.real->frac, b.real->frac, c.real->frac);
+    VpSetSign(c.real, a.real->sign * b.real->sign);
+    c.real->exponent = a.real->exponent + b.real->exponent;
+    c.real->Prec = a.real->Prec + b.real->Prec;
+    VpNmlz(c.real);
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return c.bigdecimal;
+}
+
 #endif /* BIGDECIMAL_USE_VP_TEST_METHODS */
 
 /* Document-class: BigDecimal
@@ -3593,7 +3590,6 @@ Init_bigdecimal(void)
     rb_define_const(rb_cBigDecimal, "NAN", BIGDECIMAL_LITERAL(NAN, NaN));
 
     /* instance methods */
-    rb_define_method(rb_cBigDecimal, "precs", BigDecimal_prec, 0);
     rb_define_method(rb_cBigDecimal, "precision", BigDecimal_precision, 0);
     rb_define_method(rb_cBigDecimal, "scale", BigDecimal_scale, 0);
     rb_define_method(rb_cBigDecimal, "precision_scale", BigDecimal_precision_scale, 0);
@@ -3652,7 +3648,10 @@ Init_bigdecimal(void)
 
 #ifdef BIGDECIMAL_USE_VP_TEST_METHODS
     rb_define_method(rb_cBigDecimal, "vpdivd", BigDecimal_vpdivd, 2);
+    rb_define_method(rb_cBigDecimal, "vpdivd_newton", BigDecimal_vpdivd_newton, 2);
+    rb_define_method(rb_cBigDecimal, "newton_raphson_inverse", BigDecimal_newton_raphson_inverse, 1);
     rb_define_method(rb_cBigDecimal, "vpmult", BigDecimal_vpmult, 1);
+    rb_define_method(rb_cBigDecimal, "nttmult", BigDecimal_nttmult, 1);
 #endif /* BIGDECIMAL_USE_VP_TEST_METHODS */
 
 #define ROUNDING_MODE(i, name, value) \
@@ -3675,7 +3674,6 @@ Init_bigdecimal(void)
 
 #undef ROUNDING_MODE
 
-    id_to_r = rb_intern_const("to_r");
     id_eq = rb_intern_const("==");
     id_half = rb_intern_const("half");
 
@@ -3695,7 +3693,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,  /* + */
@@ -4096,8 +4094,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;
@@ -4109,7 +4108,7 @@ VpInit(DECDIG BaseVal)
 VP_EXPORT Real *
 VpOne(void)
 {
-    return VpConstOne;
+    return VpPtr(VpConstOne);
 }
 
 /* If exponent overflows,then raise exception or returns 0 */
@@ -4140,7 +4139,7 @@ overflow:
     return VpException(VP_EXCEPTION_OVERFLOW, "Exponent overflow", 0);
 }
 
-Real *
+NULLABLE_BDVALUE
 bigdecimal_parse_special_string(const char *str)
 {
     static const struct {
@@ -4165,66 +4164,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 };
 }
 
 /*
@@ -4233,25 +4193,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 `#`.
@@ -4405,10 +4365,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);
@@ -4416,11 +4377,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 };
 }
 
 /*
@@ -4892,17 +4854,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 */
 
@@ -4926,61 +4883,57 @@ 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 */
 
     c->exponent = a->exponent;    /* set exponent */
     VpSetSign(c, VpGetSign(a) * VpGetSign(b));    /* set sign  */
     if (!AddExponent(c, b->exponent)) return 0;
-    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);
-	}
 
-	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);
+    if (b->Prec >= NTT_MULTIPLICATION_THRESHOLD) {
+        ntt_multiply(a->Prec, b->Prec, a->frac, b->frac, c->frac);
+        c->Prec = a->Prec + b->Prec;
+        goto Cleanup;
+    }
+
+    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];
+                }
             }
-	    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;
-		    }
-		}
-	    }
-	}
+
+            // 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);
+            }
+
+            // 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:
     VpNmlz(c);
 
 Exit:
@@ -5028,6 +4981,11 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 
     if (word_a > word_r || word_b + word_c - 2 >= word_r) goto space_error;
 
+    if (word_c >= NEWTON_RAPHSON_DIVISION_THRESHOLD && word_b >= NEWTON_RAPHSON_DIVISION_THRESHOLD) {
+        VpDivdNewton(c, r, a, b);
+        goto Exit;
+    }
+
     for (i = 0; i < word_a; ++i) r->frac[i] = a->frac[i];
     for (i = word_a; i < word_r; ++i) r->frac[i] = 0;
     for (i = 0; i < word_c; ++i) c->frac[i] = 0;
@@ -5178,6 +5136,7 @@ VpNmlz(Real *a)
 NoVal:
     a->frac[0] = 0;
     a->Prec = 1;
+    a->exponent = 0;
     return 0;
 }
 
@@ -5453,8 +5412,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 */
                 }
@@ -5506,10 +5465,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;
@@ -5549,10 +5520,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 */
             }
@@ -5571,7 +5541,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:
@@ -6036,7 +6021,7 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
 	y->frac[ix] = div;
 	VpNmlz(y);
     }
-    if (exptoadd > 0) {
+    if (exptoadd > 0 && !VpIsZero(y)) {
 	y->exponent += (SIGNED_VALUE)(exptoadd / BASE_FIG);
 	exptoadd %= (ssize_t)BASE_FIG;
 	for (i = 0; i < exptoadd; i++) {
@@ -6166,7 +6151,7 @@ VpFrac(Real *y, Real *x)
     size_t my, ind_y, ind_x;
 
     if (!VpHasVal(x)) {
-	VpAsgn(y, x, 1);
+	VpAsgn(y, x, 10);
 	goto Exit;
     }
 
@@ -6175,7 +6160,7 @@ VpFrac(Real *y, Real *x)
 	goto Exit;
     }
     else if (x->exponent <= 0) {
-	VpAsgn(y, x, 1);
+	VpAsgn(y, x, 10);
 	goto Exit;
     }