bigdecimal 4.1.2 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 922981a841d43e8269ac09725757bd02512ba596903b2da2ab2458e842957833
-  data.tar.gz: 34b59473beafbb51888ef2700b0c44ee721025952c1b578c4affa6cb60e91d90
+  metadata.gz: 1e3b015d4eafc3c72fda5a95b949fb4413a8fa068cbdad6b4ab9c8f18244dba6
+  data.tar.gz: d6f6639c3560978f79e43d3943881e9ad5fb01a9b03cf98c0c056f8f18614cc1
 SHA512:
-  metadata.gz: 00e7aedfc9b90c0e82297880c750010e37b8aa427c122343418bbbc3b656a94583a818b0980d2a91b9a7c22aa9c5cc26d621536c33f0d5ec70b87bf9585feed7
-  data.tar.gz: 0b54105583917681020ed7d451f9a39c68f9805e9079b48cc83b7031d43ab5e070945dd4899d73e99925022f4a3462c6f9f277062af0281b1455ed16b0a76f49
+  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.2"
+#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;
 }
 
@@ -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;
 }
 
@@ -6005,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,
@@ -60,14 +94,10 @@ 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 - (ssize_t)rshift - (ssize_t)length;
-    if (start >= (ssize_t)src->Prec) return;
-    if (start < 0) {
-        dest -= start;
-        length -= (size_t)(-start);
-        start = 0;
-    }
-    size_t max_length = (size_t)((ssize_t)src->Prec - start);
-    memcpy(dest, src->frac + start, Min(length, max_length) * sizeof(DECDIG));
+    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.
@@ -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;
@@ -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, -(ssize_t)div_prec);
-    AddExponent(r, a->exponent);
-    AddExponent(r, -(ssize_t)(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);
 }

data/lib/bigdecimal/math/erf.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module BigMath
+  # Bit-burst implementation of BigMath.erf and BigMath.erfc.
+  #
+  # Both functions share the same incremental update: given erf(x0+...+xk) (or erfc),
+  # extend to erf(x0+...+xk+x_{k+1}) by adding (or, for erfc, subtracting) the Taylor
+  # expansion of the difference function
+  #   g(t) := (erf(t + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2     with a = x0+...+xk
+  # which satisfies the homogeneous ODE g''(t) + 2*(t+a)*g'(t) = 0.
+  # Each step uses binary splitting on the 3-term recurrence of g's Taylor coefficients;
+  # split widths x1, x2, ... double in digits, giving quasi-linear total cost.
+  #
+  # Only the bit-burst seed differs between the two:
+  #   erf  : seed = erf(x0) via Taylor expansion at 0
+  #   erfc : seed = erfc(x0) via asymptotic expansion (requires x0 large enough;
+  #          returns nil if asymptotic cannot reach the requested precision, in which
+  #          case erfc(x) is recovered from 1 - erf(x) with extra digits to absorb
+  #          cancellation)
+  #
+  # Edge cases (after symmetry erf(-x) = -erf(x)):
+  #   x == 0  : erf = 0
+  #   x > 5e9 : erf = 1, erfc underflows
+  #   x < 0.5 (erfc only) : compute via 1 - erf to avoid unnecessary work
+  module Erf # :nodoc:
+
+    # Calculates erf with given precision.
+    def self.erf(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :erf)
+      x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :erf)
+      return BigDecimal::Internal.nan_computation_result if x.nan?
+      return BigDecimal(x.infinite?) if x.infinite?
+      return BigDecimal(0) if x == 0
+      return -erf(-x, prec) if x < 0
+      return BigDecimal(1) if x > 5000000000 # erf(5000000000) > 1 - 1e-10000000000000000000
+      if x > 8
+        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_bit_burst(x, erfc_prec + BigDecimal::Internal::EXTRA_PREC)
+        return BigDecimal(1).sub(erfc, prec) if erfc
+      end
+
+      erf_bit_burst(x, prec + BigDecimal::Internal::EXTRA_PREC).mult(1, prec)
+    end
+
+    # Calculates erfc with given precision.
+    def self.erfc(x, prec)
+      prec = BigDecimal::Internal.coerce_validate_prec(prec, :erfc)
+      x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :erfc)
+      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::Internal.underflow_computation_result if x > 5000000000 # erfc(5000000000) < 1e-10000000000000000000 (underflow)
+
+      if x > 8
+        y = erfc_bit_burst(x, prec + BigDecimal::Internal::EXTRA_PREC)
+        return y.mult(1, prec) if y
+      end
+
+      # 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
+      high_prec = prec + BigDecimal::Internal::EXTRA_PREC + ((xf**2 + Math.log(xf) + Math.log(Math::PI)/2) / log10).ceil
+      BigDecimal(1).sub(erf_bit_burst(x, high_prec), prec)
+    end
+
+    # Matrix multiplication. m1 and m2 are size*size length array that represents size*size matrix
+    def self.matrix_mult(m1, m2, size, prec)
+      (size * size).times.map do |i|
+        size.times.map do |k|
+          m1[i / size * size + k].mult(m2[size * k + i % size], prec)
+        end.reduce {|a, b| a.add(b, prec) }
+      end
+    end
+
+    # Returns (erf(x + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2 calculated with binary splitting method.
+    def self.erf_binary_splitting_diff(x, a, prec)
+      # Let f(x) = (erf(x + a) - erf(a)) * exp(a**2) * sqrt(pi) / 2
+      # f(x) satisfies the following differential equation:
+      #   2*(x+a)*f'(x) + f''(x) = 0
+      # We can derive the following recurrence for the Taylor coefficients of f:
+      # f(x) = x * (c0 + c1*x + c2*x**2 + c3*x**3 + ...)
+      # c(0) = 1
+      # c(1) = -a
+      # c(i) = -2 * (a * c(i - 1) + c(i - 2) * (i - 1) / i) / (i + 1)
+
+      # Estimate required number of terms by calculating c(i) with low precision
+      low_prec = 10
+      a_low = a.mult(1, low_prec)
+      x_low = x.mult(1, low_prec)
+      coefs = [BigDecimal(1), -a_low]
+      xn = BigDecimal(1)
+      threshold = BigDecimal(1)._decimal_shift(-prec)
+      steps = (2..).find do |n|
+        prevprev, prev = coefs
+        xn = xn.mult(x_low, low_prec)
+        coefs = prev, (a_low * prev + (prevprev * (n - 1)).div(n, low_prec)).mult(-2, low_prec).div(n + 1, low_prec)
+        coefs[0].mult(xn, low_prec).abs < threshold && coefs[1].mult(xn * x_low, low_prec).abs < threshold
+      end
+
+      # Let M(i) be a 2x2 matrix that generates the next coefficients vector (c(i-1), c(i))
+      # from the previous two coefficients (c(i-2), c(i-1)).
+      # M(i) = | 0,                1          |
+      #        | -2*(i-1)/i/(i+1), -2*a/(i+1) |
+      #
+      # Then, we can calculate (c(steps-1), c(steps)) as M(steps)*M(steps-1)*...*M(2)*Vector(c0, c1).
+      #
+      # Calculate a matrix that represents the sum of the Taylor series:
+      #   SumMatrix = ((((...+I)x*M4+I)*x*M3+I)*M2*x+I)
+      # Actual sum can be calculated as:
+      #   SumMatrix * Vector(c0, c1) = Vector(c0+c1*x+c2*x**2+c3*x**3+..., _)
+      # In this binary splitting method, adjacent two operations are combined into one repeatedly.
+      # ((...) * x * A + B) / C is the form of each operation. A and B are 2x2 matrices, C is a scalar.
+
+      zero = BigDecimal(0)
+      operations = (2..steps + 2).map do |i|
+        d = BigDecimal(i * (i + 1))
+        [[zero, d, BigDecimal(-2 * (i - 1)), a * (-2 * i)], [d, zero, zero, d], d]
+      end
+
+      while operations.size > 1
+        xpow = xpow ? xpow.mult(xpow, prec) : x.mult(1, prec)
+        operations = operations.each_slice(2).map do |op1, op2|
+          # Combine two operations into one:
+          # (((Remaining * x * A2 + B2) / C2) * x * A1 + B1) / C1
+          # ((Remaining * (x*x) * (A2*A1) + (x*B2*A1+B1*C2)) / (C1*C2)
+          # Therefore, combined operation can be represented as:
+          # Anext = A2 * A1
+          # Bnext = x * B2 * A1 + B1 * C2
+          # Cnext = C1 * C2
+          # xnext = x * x
+          a1, b1, c1 = op1
+          a2, b2, c2 = op2 || [[zero] * 4, [zero] * 4, BigDecimal(1)]
+          [
+            matrix_mult(a2, a1, 2, prec),
+            array_weighted_sum(matrix_mult(b2, a1, 2, prec), xpow, b1, c2, prec),
+            c1.mult(c2, prec),
+          ]
+        end
+      end
+      _, sum_matrix, denominator = operations.first
+      sum = (sum_matrix[0] - a * sum_matrix[1]).div(denominator, prec)
+      x.mult(sum, prec)
+    end
+
+    # Calculates erfc(x) using bit-burst algorithm.
+    # Returns nil if the asymptotic expansion does not reach the requested precision.
+    def self.erfc_bit_burst(x, prec)
+      # By bounding the relative error via |d(erfc)/erfc| <= 2*x*|dx| (erfc(x) decays as exp(-x**2)/x),
+      # truncate x to the minimum digits sufficient for prec-digit accuracy of the result.
+      x = x.mult(1, prec + Math.log10(2 * x.to_f**2).ceil)
+      erf_erfc_bit_burst(x, prec, start_digits: 40, mode: :erfc)
+    end
+
+    # Calculates erf(x) using bit-burst algorithm.
+    def self.erf_bit_burst(x, prec)
+      # By bounding the error via erf'(x) = (2/sqrt(pi)) * exp(-x**2),
+      # truncate x to the minimum digits sufficient for prec-digit accuracy of the result.
+      x = x.mult(1, [(prec - x.floor**2 / Math.log(10) + Math.log10(x.ceil)).ceil, 10].max)
+      erf_erfc_bit_burst(x, prec, start_digits: 8, mode: :erf)
+    end
+
+    # Calculates erf or erfc using bit-burst algorithm.
+    # Returns nil if erfc mode cannot reach the requested precision.
+    def self.erf_erfc_bit_burst(x, prec, start_digits:, mode:)
+      digits = [-x.exponent * 2, start_digits].max
+      partial = x.truncate(digits)
+      case mode
+      when :erf
+        f = erf_exp2_binary_splitting(partial, prec)
+      when :erfc
+        f = erfc_exp2_asymptotic_binary_splitting(partial, prec)
+        return unless f
+      end
+
+      exp_scale = BigMath.exp(-partial * partial, prec)
+      f = f.mult(exp_scale, prec)
+
+      calculated_x = partial
+      x -= partial
+
+      until x.zero?
+        digits *= 2
+        partial = x.truncate(digits)
+        next if partial.zero?
+
+        diff_prec = [prec - f.exponent + exp_scale.exponent + partial.exponent, 1].max
+        diff = erf_binary_splitting_diff(partial, calculated_x, diff_prec)
+        case mode
+        when :erf
+          f = f.add(diff.mult(exp_scale, prec), prec)
+        when :erfc
+          f = f.sub(diff.mult(exp_scale, prec), prec)
+        end
+
+        calculated_x += partial
+        x -= partial
+        exp_scale = exp_scale.mult(BigMath.exp(partial * (partial - 2 * calculated_x), diff_prec), diff_prec) unless x.zero?
+      end
+      f.mult(BigDecimal(2).div(BigMath::PI(prec).sqrt(prec), prec), prec)
+    end
+
+    # Matrix/Vector weighted sum
+    def self.array_weighted_sum(m1, w1, m2, w2, prec)
+      m1.zip(m2).map {|v1, v2| (v1 * w1).add(v2 * w2, prec) }
+    end
+
+    # Calculates Taylor expansion of erf(x)*exp(x**2)*sqrt(pi)/2 with binary splitting method.
+    def self.erf_exp2_binary_splitting(x, prec)
+      # Let f(x) = erf(x)*exp(x**2)*sqrt(pi)/2
+      #            = c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...
+      # f(x) is designed to make all coefficients positive so that we don't need to consider cancellation error.
+      #
+      # f(x) satisfies the following differential equation:
+      # f'(x) = 1 + 2 * x * f(x)
+      # f'(x) = c1 + 2*c2*x + 3*c3*x**2 + 4*c4*x**3 + 5*c5*x**4 + ...
+      #         = 1+2*x*(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + ...)
+      # therefore,
+      # c0 = 0
+      # c1 = 1
+      # c2 = 2 * (c0 + c1) / 2
+      # c3 = 2 * (c1 + c2) / 3
+      # c4 = 2 * (c2 + c3) / 4
+
+      # Find the smallest n where the n-th Taylor term |c_n * x^n| falls below the precision
+      # threshold, using a Stirling-based upper bound on |c_n|.
+      log10f = Math.log(10)
+      cexponent = Math.log10(Math.sqrt(2)) + BigDecimal::Internal.float_log(x.abs) / log10f
+
+      x_to_f = x < 1e-300 ? 1e-300 : x.to_f # x.to_f may underflow when x is very small (e.g. 1e-400)
+      steps = (2..).bsearch do |n|
+        x_to_f ** 2 < n && n * cexponent + Math.lgamma(n / 2)[0] / log10f + n * Math.log10(2) - Math.lgamma(n - 1)[0] / log10f < -prec + x_to_f**2 / log10f
+      end
+
+      denominators = (steps / 2).times.map {|i| 2 * i + 3 }
+      x.mult(1 + BigDecimal::Internal.taylor_sum_binary_splitting(2 * x * x, denominators, prec), prec)
+    end
+
+    # Calculates asymptotic expansion of erfc(x)*exp(x**2)*sqrt(pi)/2 with binary splitting method
+    def self.erfc_exp2_asymptotic_binary_splitting(x, prec)
+      # Let f(x) = erfc(x)*sqrt(pi)*exp(x**2)/2
+      # f(x) satisfies the following differential equation:
+      # 2*x*f(x) = f'(x) + 1
+      # From the above equation, we can derive the following asymptotic expansion:
+      # f(x) = (0..kmax).sum { (-1)**k * (2*k)! / 4**k / k! / x**(2*k) } / x / 2
+
+      # This asymptotic expansion does not converge.
+      # But if there is a k that satisfies (2*k)! / 4**k / k! / x**(2*k) < 10**(-prec),
+      # It is enough to calculate erfc within the given precision.
+      # Using Stirling's approximation, we can simplify this condition to:
+      # log(2)/2 + k*log(k) - k - 2*k*log(x) < -prec*log(10)
+      # and the left side is minimized when k = x**2.
+      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
+      return unless kmax
+
+      # Convert asymptotic expansion to nested form:
+      # 1 + a/x + a*b/x/x + a*b*c/x/x/x + a*b*c/x/x/x*rest
+      # = 1 + (a/x) * (1 + (b/x) * (1 + (c/x) * (1 + rest)))
+      #
+      # And calculate it with binary splitting:
+      # (a1/d + b1/d * (a2/d + b2/d * (rest)))
+      # = ((a1*d+b1*a2)/(d*d) + b1*b2/(d*denominator) * (rest)))
+      denominator = x.mult(x, prec).mult(2, prec)
+      fractions = (1..kmax).map do |k|
+        [denominator, BigDecimal(1 - 2 * k)]
+      end
+      while fractions.size > 1
+        fractions = fractions.each_slice(2).map do |fraction1, fraction2|
+          a1, b1 = fraction1
+          a2, b2 = fraction2 || [BigDecimal(0), denominator]
+          [
+            a1.mult(denominator, prec).add(b1.mult(a2, prec), prec),
+            b1.mult(b2, prec),
+          ]
+        end
+        denominator = denominator.mult(denominator, prec)
+      end
+      # Plug rest = 1 into the merged form: the innermost "(1 + rest)" of the nested expansion
+      # evaluates to 1 at truncation (rest = 0).
+      sum = fractions[0][0].add(fractions[0][1], prec).div(denominator, prec)
+      sum.div(x, prec) / 2
+    end
+  end
+
+  private_constant :Erf
+end