bigdecimal 4.1.1 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 937928a0baf09e4c2e5bf45b2fa608e1aa20601cf7cd27a8ebaf679874e6196f
-  data.tar.gz: a053c6e868c7e55ad9a35262bfd645314fd908dbae5969935c44530a124cfcc4
+  metadata.gz: 1e3b015d4eafc3c72fda5a95b949fb4413a8fa068cbdad6b4ab9c8f18244dba6
+  data.tar.gz: d6f6639c3560978f79e43d3943881e9ad5fb01a9b03cf98c0c056f8f18614cc1
 SHA512:
-  metadata.gz: 4a4a41830aab00fd3bef041c64f9f6357891706ca11004696c5d815b7582f6f4f2cbd00a606900cfe4a5bce57585d46523e25da8085c2bf18aa95bbe9afd27ec
-  data.tar.gz: fe5b587431cca8921613367e236a9844fd3c65f8f53d8b2ae16fe1ed54aac455bfff9a50783256ec2d9e0f5523bc01a3eb9ce0ffc16482cded6026cc03b8c2c0
+  metadata.gz: b1ce1badb6a615c8a5576e2e5f5a1861dc3ff9e97b0a37b8788470c47e3f2b18329edabcf904e5ad8215ef8b0805a3d02220ed5cc7c856ec9da7231913b2bc80
+  data.tar.gz: 11d06bb5706fc5034cb012f49479095a5d17eabcec8c011956010e13032f228a29b9421abd1fa3f56b7db83b41dc43ecf54bb7b0d60353508c396c169c27ebee

data/bigdecimal.gemspec

@@ -29,6 +29,8 @@ Gem::Specification.new do |s|
     lib/bigdecimal/jacobian.rb
     lib/bigdecimal/ludcmp.rb
     lib/bigdecimal/math.rb
+    lib/bigdecimal/math/erf.rb
+    lib/bigdecimal/math/gamma.rb
     lib/bigdecimal/newton.rb
     lib/bigdecimal/util.rb
     sample/linear.rb

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.3"
 
 /* Make sure VPMULT_BATCH_SIZE*BASE*BASE does not overflow DECDIG_DBL */
 #define VPMULT_BATCH_SIZE 16
@@ -68,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;
 
@@ -209,6 +208,10 @@ BigDecimal_memsize(const void *ptr)
 #endif
 }
 
+#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 = {
     .wrap_struct_name = "BigDecimal",
     .function = {
@@ -216,7 +219,7 @@ static const rb_data_type_t BigDecimal_data_type = {
         .dfree = RUBY_DEFAULT_FREE,
         .dsize = BigDecimal_memsize,
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
+    .flags = RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
 };
 
 static VALUE
@@ -669,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);
 }
 
@@ -1735,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;
 }
 
@@ -2709,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;
@@ -2842,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
@@ -2895,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");
         }
@@ -3005,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
@@ -3658,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");
 
@@ -5121,6 +5136,7 @@ VpNmlz(Real *a)
 NoVal:
     a->frac[0] = 0;
     a->Prec = 1;
+    a->exponent = 0;
     return 0;
 }
 
@@ -5396,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 */
                 }
@@ -5449,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;
@@ -5492,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 */
             }
@@ -5514,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:
@@ -5979,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++) {

data/ext/bigdecimal/bigdecimal.h

@@ -267,21 +267,21 @@ VP_EXPORT inline BDVALUE rbd_allocate_struct_zero_wrap(int sign, size_t const di
 #define VpIsPosZero(a)  ((a)->sign==VP_SIGN_POSITIVE_ZERO)
 #define VpIsNegZero(a)  ((a)->sign==VP_SIGN_NEGATIVE_ZERO)
 #define VpIsZero(a)     (VpIsPosZero(a) || VpIsNegZero(a))
-#define VpSetPosZero(a) ((a)->frac[0]=0,(a)->Prec=1,(a)->sign=VP_SIGN_POSITIVE_ZERO)
-#define VpSetNegZero(a) ((a)->frac[0]=0,(a)->Prec=1,(a)->sign=VP_SIGN_NEGATIVE_ZERO)
+#define VpSetPosZero(a) ((a)->frac[0]=0,(a)->Prec=1,(a)->exponent=0,(a)->sign=VP_SIGN_POSITIVE_ZERO)
+#define VpSetNegZero(a) ((a)->frac[0]=0,(a)->Prec=1,(a)->exponent=0,(a)->sign=VP_SIGN_NEGATIVE_ZERO)
 #define VpSetZero(a,s)  (void)(((s)>0)?VpSetPosZero(a):VpSetNegZero(a))
 
 /* NaN */
 #define VpIsNaN(a)      ((a)->sign==VP_SIGN_NaN)
-#define VpSetNaN(a)     ((a)->frac[0]=0,(a)->Prec=1,(a)->sign=VP_SIGN_NaN)
+#define VpSetNaN(a)     ((a)->frac[0]=0,(a)->Prec=1,(a)->exponent=0,(a)->sign=VP_SIGN_NaN)
 
 /* Infinity */
 #define VpIsPosInf(a)   ((a)->sign==VP_SIGN_POSITIVE_INFINITE)
 #define VpIsNegInf(a)   ((a)->sign==VP_SIGN_NEGATIVE_INFINITE)
 #define VpIsInf(a)      (VpIsPosInf(a) || VpIsNegInf(a))
 #define VpIsDef(a)      ( !(VpIsNaN(a)||VpIsInf(a)) )
-#define VpSetPosInf(a)  ((a)->frac[0]=0,(a)->Prec=1,(a)->sign=VP_SIGN_POSITIVE_INFINITE)
-#define VpSetNegInf(a)  ((a)->frac[0]=0,(a)->Prec=1,(a)->sign=VP_SIGN_NEGATIVE_INFINITE)
+#define VpSetPosInf(a)  ((a)->frac[0]=0,(a)->Prec=1,(a)->exponent=0,(a)->sign=VP_SIGN_POSITIVE_INFINITE)
+#define VpSetNegInf(a)  ((a)->frac[0]=0,(a)->Prec=1,(a)->exponent=0,(a)->sign=VP_SIGN_NEGATIVE_INFINITE)
 #define VpSetInf(a,s)   (void)(((s)>0)?VpSetPosInf(a):VpSetNegInf(a))
 #define VpHasVal(a)     (a->frac[0])
 #define VpIsOne(a)      ((a->Prec==1)&&(a->frac[0]==1)&&(a->exponent==1))

data/ext/bigdecimal/div.h

@@ -1,18 +1,45 @@
+struct vp_settings {
+    size_t prec_limit;
+    unsigned short rounding_mode;
+};
+
+static VALUE
+restore_vp_settings(VALUE saved_ptr)
+{
+    struct vp_settings *saved = (struct vp_settings *)saved_ptr;
+    VpSetPrecLimit(saved->prec_limit);
+    VpSetRoundMode(saved->rounding_mode);
+    return Qnil;
+}
+
 // Calculate the inverse of x using the Newton-Raphson method.
+// Assumes no precision limit and ROUND_HALF_UP. See VpDivdNewton.
 static VALUE
 newton_raphson_inverse(VALUE x, size_t prec) {
     BDVALUE bdone = NewZeroWrap(1, 1);
     VpSetOne(bdone.real);
     VALUE one = bdone.bigdecimal;
 
-    // Initial approximation in 2 digits
+    // Initial approximation: 10^18 / (leading 9 digits of x), calculated in 64-bit integer.
+    // Truncating x to 9 digits and the quotient to an integer keep the relative error below 1.2e-8,
+    // so it has at least 7 correct digits.
+    const size_t initial_digits = 7;
+    const DECDIG_DBL base_sq = (DECDIG_DBL)BIGDECIMAL_BASE * BIGDECIMAL_BASE;
     BDVALUE bdx = GetBDValueMust(x);
+    DECDIG_DBL x_lead = (DECDIG_DBL)bdx.real->frac[0] * BIGDECIMAL_BASE + (bdx.real->Prec >= 2 ? bdx.real->frac[1] : 0);
+    int shift = 0;
+    while (x_lead < base_sq / 10) {
+        x_lead *= 10;
+        shift++;
+    }
+    // Dividing base_sq - 1 instead of base_sq keeps the quotient below 10 * BASE,
+    // so that frac[0] of inv0 never reaches BASE.
+    DECDIG_DBL inv_lead = (base_sq - 1) / (x_lead / BIGDECIMAL_BASE);
+    for (int i = 0; i < shift; i++) inv_lead *= 10;
     BDVALUE inv0 = NewZeroWrap(1, 2 * BIGDECIMAL_COMPONENT_FIGURES);
     VpSetOne(inv0.real);
-    DECDIG_DBL numerator = (DECDIG_DBL)BIGDECIMAL_BASE * 100;
-    DECDIG_DBL denominator = (DECDIG_DBL)bdx.real->frac[0] * 100 + (DECDIG_DBL)(bdx.real->Prec >= 2 ? bdx.real->frac[1] : 0) * 100 / BIGDECIMAL_BASE;
-    inv0.real->frac[0] = (DECDIG)(numerator / denominator);
-    inv0.real->frac[1] = (DECDIG)((numerator % denominator) * (BIGDECIMAL_BASE / 100) / denominator * 100);
+    inv0.real->frac[0] = (DECDIG)(inv_lead / BIGDECIMAL_BASE);
+    inv0.real->frac[1] = (DECDIG)(inv_lead % BIGDECIMAL_BASE);
     inv0.real->Prec = 2;
     inv0.real->exponent = 1 - bdx.real->exponent;
     VpNmlz(inv0.real);
@@ -22,14 +49,21 @@ newton_raphson_inverse(VALUE x, size_t prec) {
     int bl = 1;
     while (((size_t)1 << bl) < prec) bl++;
 
+    // Each iteration doubles the number of correct digits, and the rounding error of
+    // the previous iteration is squared into the new digits. Margin digits keep the
+    // squared error below the last digit, otherwise it can grow over iterations.
+    const size_t margin = 4;
     for (int i = bl; i >= 0; i--) {
-        size_t n = (prec >> i) + 2;
+        size_t n = (prec >> i) + margin;
         if (n > prec) n = prec;
+        // inv0 already has this precision. The last iteration is kept to round inv to prec digits.
+        if (n <= initial_digits && i > 0) continue;
         // Newton-Raphson iteration: inv_next = inv + inv * (1 - x * inv)
+        // (1 - x * inv) is about 10^(-n/2), so calculating it in n/2 digits is enough for inv_next in n digits.
         VALUE one_minus_x_inv = BigDecimal_sub2(
             one,
             BigDecimal_mult(BigDecimal_mult2(x, one, SIZET2NUM(n + 1)), inv),
-            SIZET2NUM(SIZET2NUM(n / 2))
+            SIZET2NUM(n / 2 + margin)
         );
         inv = BigDecimal_add2(
             inv,
@@ -59,15 +93,11 @@ 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;
-    if (start >= (ssize_t)src->Prec) return;
-    if (start < 0) {
-        dest -= start;
-        length += start;
-        start = 0;
-    }
-    size_t max_length = src->Prec - start;
-    memcpy(dest, src->frac + start, Min(length, max_length) * sizeof(DECDIG));
+    ssize_t start = src->exponent - (ssize_t)rshift - (ssize_t)length;
+    ssize_t from = Max(start, 0);
+    ssize_t to = Min(start + (ssize_t)length, (ssize_t)src->Prec);
+    if (from >= to) return;
+    memcpy(dest + (from - start), src->frac + from, (size_t)(to - from) * sizeof(DECDIG));
 }
 
 /* Calculates divmod using Newton-Raphson method.
@@ -101,28 +131,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);
@@ -132,11 +162,15 @@ divmod_newton(VALUE x, VALUE y, VALUE *div_out, VALUE *mod_out) {
     *mod_out = mod;
 }
 
+struct vp_divd_newton_args {
+    Real *c, *r, *a, *b;
+};
+
 static VALUE
 VpDivdNewtonInner(VALUE args_ptr)
 {
-    Real **args = (Real**)args_ptr;
-    Real *c = args[0], *r = args[1], *a = args[2], *b = args[3];
+    struct vp_divd_newton_args *args = (struct vp_divd_newton_args *)args_ptr;
+    Real *c = args->c, *r = args->r, *a = args->a, *b = args->b;
     BDVALUE a2, b2, c2, r2;
     VALUE div, mod, a2_frac = Qnil;
     size_t div_prec = c->MaxPrec - 1;
@@ -148,8 +182,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);
@@ -162,31 +196,24 @@ VpDivdNewtonInner(VALUE args_ptr)
     r2 = GetBDValueMust(mod);
     VpAsgn(c, c2.real, VpGetSign(a) * VpGetSign(b));
     VpAsgn(r, r2.real, VpGetSign(a));
-    AddExponent(c, a->exponent);
-    AddExponent(c, -b->exponent);
-    AddExponent(c, -div_prec);
-    AddExponent(r, a->exponent);
-    AddExponent(r, -base_prec - div_prec);
-    RB_GC_GUARD(a2.bigdecimal);
+    if (!VpIsZero(c)) AddExponent(c, a->exponent - b->exponent - (ssize_t)div_prec);
+    if (!VpIsZero(r)) AddExponent(r, a->exponent - (ssize_t)(base_prec + div_prec));
     RB_GC_GUARD(a2.bigdecimal);
+    RB_GC_GUARD(b2.bigdecimal);
     RB_GC_GUARD(c2.bigdecimal);
     RB_GC_GUARD(r2.bigdecimal);
     return Qnil;
 }
 
-static VALUE
-ensure_restore_prec_limit(VALUE limit)
-{
-    VpSetPrecLimit(NUM2SIZET(limit));
-    return Qnil;
-}
-
+// Newton-Raphson iteration converges from below, so a rounding mode that rounds toward zero
+// (ROUND_DOWN, ROUND_FLOOR) adds error in the same direction at every iteration.
+// Calculate with ROUND_HALF_UP and without precision limit, and restore them even if an exception is raised.
 static void
 VpDivdNewton(Real *c, Real *r, Real *a, Real *b)
 {
-    Real *args[4] = {c, r, a, b};
-    size_t pl = VpGetPrecLimit();
+    struct vp_divd_newton_args args = {c, r, a, b};
+    struct vp_settings saved = {VpGetPrecLimit(), VpGetRoundMode()};
     VpSetPrecLimit(0);
-    // Ensure restoring prec limit because some methods used in VpDivdNewtonInner may raise an exception
-    rb_ensure(VpDivdNewtonInner, (VALUE)args, ensure_restore_prec_limit, SIZET2NUM(pl));
+    VpSetRoundMode(VP_ROUND_HALF_UP);
+    rb_ensure(VpDivdNewtonInner, (VALUE)&args, restore_vp_settings, (VALUE)&saved);
 }