bigdecimal 3.3.1 → 4.1.3

data/ext/bigdecimal/missing.h

@@ -58,7 +58,7 @@ char *BigDecimal_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, c
 
 #ifndef HAVE_RB_COMPLEX_REAL
 static inline VALUE
-rb_complex_real(VALUE cmp)
+rb_complex_real_fallback(VALUE cmp)
 {
 #ifdef RCOMPLEX
   return RCOMPLEX(cmp)->real;
@@ -66,11 +66,12 @@ rb_complex_real(VALUE cmp)
   return rb_funcall(cmp, rb_intern("real"), 0);
 #endif
 }
+#define rb_complex_real rb_complex_real_fallback
 #endif
 
 #ifndef HAVE_RB_COMPLEX_IMAG
 static inline VALUE
-rb_complex_imag(VALUE cmp)
+rb_complex_imag_fallback(VALUE cmp)
 {
 # ifdef RCOMPLEX
   return RCOMPLEX(cmp)->imag;
@@ -78,6 +79,7 @@ rb_complex_imag(VALUE cmp)
   return rb_funcall(cmp, rb_intern("imag"), 0);
 # endif
 }
+#define rb_complex_imag rb_complex_imag_fallback
 #endif
 
 /* st */

data/ext/bigdecimal/ntt.h

@@ -0,0 +1,191 @@
+// NTT (Number Theoretic Transform) implementation for BigDecimal multiplication
+
+#define NTT_PRIMITIVE_ROOT 17
+#define NTT_PRIME_BASE1 24
+#define NTT_PRIME_BASE2 26
+#define NTT_PRIME_BASE3 29
+#define NTT_PRIME_SHIFT 27
+#define NTT_PRIME1 (((uint32_t)NTT_PRIME_BASE1 << NTT_PRIME_SHIFT) | 1)
+#define NTT_PRIME2 (((uint32_t)NTT_PRIME_BASE2 << NTT_PRIME_SHIFT) | 1)
+#define NTT_PRIME3 (((uint32_t)NTT_PRIME_BASE3 << NTT_PRIME_SHIFT) | 1)
+#define MAX_NTT32_BITS 27
+#define NTT_DECDIG_BASE 1000000000
+
+// Calculates base**ex % mod
+static uint32_t
+mod_pow(uint32_t base, uint32_t ex, uint32_t mod) {
+    uint32_t res = 1;
+    uint32_t bit = 1;
+    while (true) {
+        if (ex & bit) {
+            ex ^= bit;
+            res = ((uint64_t)res * base) % mod;
+        }
+        if (!ex) break;
+        base = ((uint64_t)base * base) % mod;
+        bit <<= 1;
+    }
+    return res;
+}
+
+// Recursively performs butterfly operations of NTT
+static void
+ntt_recursive(int size_bits, uint32_t *input, uint32_t *output, uint32_t *tmp, int depth, uint32_t r, uint32_t prime) {
+    if (depth > 0) {
+        ntt_recursive(size_bits, input, tmp, output, depth - 1, ((uint64_t)r * r) % prime, prime);
+    } else {
+        tmp = input;
+    }
+    uint32_t size_half = (uint32_t)1 << (size_bits - 1);
+    uint32_t stride = (uint32_t)1 << (size_bits - depth - 1);
+    uint32_t n = size_half / stride;
+    uint32_t rn = 1, rm = prime - 1;
+    for (uint32_t i = 0; i < n; i++) {
+        uint32_t *aptr = tmp + i * 2 * stride;
+        uint32_t *bptr = aptr + stride;
+        uint32_t *out1 = output + stride * i;
+        uint32_t *out2 = out1 + size_half;
+        for (uint32_t k = 0; k < stride; k++) {
+            uint32_t a = aptr[k], b = bptr[k];
+            out1[k] = (a + (uint64_t)rn * b) % prime;
+            out2[k] = (a + (uint64_t)rm * b) % prime;
+        }
+        rn = ((uint64_t)rn * r) % prime;
+        rm = ((uint64_t)rm * r) % prime;
+    }
+}
+
+/* Perform NTT on input array.
+ * base, shift: Represent the prime number as (base << shift | 1)
+ * r_base: Primitive root of unity modulo prime
+ * size_bits: log2 of the size of the input array. Should be less or equal to shift
+ * input: input array of size (1 << size_bits)
+ */
+static void
+ntt(int size_bits, uint32_t *input, uint32_t *output, uint32_t *tmp, int r_base, int base, int shift, int dir) {
+    uint32_t size = (uint32_t)1 << size_bits;
+    uint32_t prime = ((uint32_t)base << shift) | 1;
+
+    // rmax**(1 << shift) % prime == 1
+    // r**size % prime == 1
+    uint32_t rmax = mod_pow((uint32_t)r_base, (uint32_t)base, prime);
+    uint32_t r = mod_pow(rmax, (uint32_t)1 << (shift - size_bits), prime);
+
+    if (dir < 0) r = mod_pow(r, prime - 2, prime);
+    ntt_recursive(size_bits, input, output, tmp, size_bits - 1, r, prime);
+    if (dir < 0) {
+        uint32_t n_inv = mod_pow((uint32_t)size, prime - 2, prime);
+        for (uint32_t i = 0; i < size; i++) {
+            output[i] = ((uint64_t)output[i] * n_inv) % prime;
+        }
+    }
+}
+
+/* Calculate c that satisfies: c % PRIME1 == mod1 && c % PRIME2 == mod2 && c % PRIME3 == mod3
+ * c = (mod1 * 35002755423056150739595925972 + mod2 * 14584479687667766215746868453 + mod3 * 37919651490985126265126719818) % (PRIME1 * PRIME2 * PRIME3)
+ * Assume c <= 999999999**2*(1<<27)
+ */
+static inline void
+mod_restore_prime_24_26_29_shift_27(uint32_t mod1, uint32_t mod2, uint32_t mod3, uint32_t *digits) {
+    // Use mixed radix notation to eliminate modulo by PRIME1 * PRIME2 * PRIME3
+    // [DIG0, DIG1, DIG2] = DIG0 + DIG1 * PRIME1 + DIG2 * PRIME1 * PRIME2
+    // DIG0: 0...PRIME1, DIG1: 0...PRIME2, DIG2: 0...PRIME3
+    // 35002755423056150739595925972 = [1, 3489660916, 3113851359]
+    // 14584479687667766215746868453 = [0, 13, 1297437912]
+    // 37919651490985126265126719818 = [0, 0, 3373338954]
+    uint64_t c0 = mod1;
+    uint64_t c1 = (uint64_t)mod2 * 13 + (uint64_t)mod1 * 3489660916;
+    uint64_t c2 = (uint64_t)mod3 * 3373338954 % NTT_PRIME3 + (uint64_t)mod2 * 1297437912 % NTT_PRIME3 + (uint64_t)mod1 * 3113851359 % NTT_PRIME3;
+    c2 += c1 / NTT_PRIME2;
+    c1 %= NTT_PRIME2;
+    c2 %= NTT_PRIME3;
+    // Base conversion. c fits in 3 digits.
+    c1 += c2 % NTT_DECDIG_BASE * NTT_PRIME2;
+    c0 += c1 % NTT_DECDIG_BASE * NTT_PRIME1;
+    c1 /= NTT_DECDIG_BASE;
+    digits[0] = c0 % NTT_DECDIG_BASE;
+    c0 /= NTT_DECDIG_BASE;
+    c1 += c2 / NTT_DECDIG_BASE % NTT_DECDIG_BASE * NTT_PRIME2;
+    c0 += c1 % NTT_DECDIG_BASE * NTT_PRIME1;
+    c1 /= NTT_DECDIG_BASE;
+    digits[1] = c0 % NTT_DECDIG_BASE;
+    digits[2] = (uint32_t)(c0 / NTT_DECDIG_BASE + c1 % NTT_DECDIG_BASE * NTT_PRIME1);
+}
+
+/*
+ * NTT multiplication
+ * Uses three NTTs with mod (24 << 27 | 1), (26 << 27 | 1), and (29 << 27 | 1)
+ */
+static void
+ntt_multiply(size_t a_size, size_t b_size, uint32_t *a, uint32_t *b, uint32_t *c) {
+    if (a_size < b_size) {
+      ntt_multiply(b_size, a_size, b, a, c);
+      return;
+    }
+
+    int ntt_size_bits = (int)bit_length(b_size - 1) + 1;
+    if (ntt_size_bits > MAX_NTT32_BITS) {
+      rb_raise(rb_eArgError, "Multiply size too large");
+    }
+
+    // To calculate large_a * small_b faster, split into several batches.
+    uint32_t ntt_size = (uint32_t)1 << ntt_size_bits;
+    uint32_t batch_size = ntt_size - (uint32_t)b_size;
+    uint32_t batch_count = (uint32_t)((a_size + batch_size - 1) / batch_size);
+
+    uint32_t *mem = ruby_xcalloc(ntt_size * 9, sizeof(uint32_t));
+    uint32_t *ntt1 = mem;
+    uint32_t *ntt2 = mem + ntt_size;
+    uint32_t *ntt3 = mem + ntt_size * 2;
+    uint32_t *tmp1 = mem + ntt_size * 3;
+    uint32_t *tmp2 = mem + ntt_size * 4;
+    uint32_t *tmp3 = mem + ntt_size * 5;
+    uint32_t *conv1 = mem + ntt_size * 6;
+    uint32_t *conv2 = mem + ntt_size * 7;
+    uint32_t *conv3 = mem + ntt_size * 8;
+
+    // Calculate NTT for b in three primes. Result is reused for each batch of a.
+    memcpy(tmp1, b, b_size * sizeof(uint32_t));
+    memset(tmp1 + b_size, 0, (ntt_size - b_size) * sizeof(uint32_t));
+    ntt(ntt_size_bits, tmp1, ntt1, tmp2, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE1, NTT_PRIME_SHIFT, +1);
+    ntt(ntt_size_bits, tmp1, ntt2, tmp2, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE2, NTT_PRIME_SHIFT, +1);
+    ntt(ntt_size_bits, tmp1, ntt3, tmp2, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE3, NTT_PRIME_SHIFT, +1);
+
+    memset(c, 0, (a_size + b_size) * sizeof(uint32_t));
+    for (uint32_t idx = 0; idx < batch_count; idx++) {
+        uint32_t len = idx == batch_count - 1 ? (uint32_t)a_size - idx * batch_size : batch_size;
+        memcpy(tmp1, a + idx * batch_size, len * sizeof(uint32_t));
+        memset(tmp1 + len, 0, (ntt_size - len) * sizeof(uint32_t));
+        // Calculate convolution for this batch in three primes
+        ntt(ntt_size_bits, tmp1, tmp2, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE1, NTT_PRIME_SHIFT, +1);
+        for (uint32_t i = 0; i < ntt_size; i++) tmp2[i] = ((uint64_t)tmp2[i] * ntt1[i]) % NTT_PRIME1;
+        ntt(ntt_size_bits, tmp2, conv1, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE1, NTT_PRIME_SHIFT, -1);
+        ntt(ntt_size_bits, tmp1, tmp2, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE2, NTT_PRIME_SHIFT, +1);
+        for (uint32_t i = 0; i < ntt_size; i++) tmp2[i] = ((uint64_t)tmp2[i] * ntt2[i]) % NTT_PRIME2;
+        ntt(ntt_size_bits, tmp2, conv2, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE2, NTT_PRIME_SHIFT, -1);
+        ntt(ntt_size_bits, tmp1, tmp2, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE3, NTT_PRIME_SHIFT, +1);
+        for (uint32_t i = 0; i < ntt_size; i++) tmp2[i] = ((uint64_t)tmp2[i] * ntt3[i]) % NTT_PRIME3;
+        ntt(ntt_size_bits, tmp2, conv3, tmp3, NTT_PRIMITIVE_ROOT, NTT_PRIME_BASE3, NTT_PRIME_SHIFT, -1);
+
+        // Restore the original convolution value from three convolutions calculated in three primes.
+        // Each convolution value is maximum 999999999**2*(1<<27)/2
+        for (uint32_t i = 0; i < ntt_size; i++) {
+            uint32_t dig[3];
+            mod_restore_prime_24_26_29_shift_27(conv1[i], conv2[i], conv3[i], dig);
+            // Maximum values of dig[0], dig[1], and dig[2] are 999999999, 999999999 and 67108863 respectively
+            // Maximum overlapped sum (considering overlaps between 2 batches) is less than 4134217722
+            // so this sum doesn't overflow uint32_t.
+            for (int j = 0; j < 3; j++) {
+                // Index check: if dig[j] is non-zero, assign index is within valid range.
+                if (dig[j]) c[idx * batch_size + i + 1 - (uint32_t)j] += dig[j];
+            }
+        }
+    }
+    uint32_t carry = 0;
+    for (int32_t i = (int32_t)(a_size + b_size - 1); i >= 0; i--) {
+        uint32_t v = c[i] + carry;
+        c[i] = v % NTT_DECDIG_BASE;
+        carry = v / NTT_DECDIG_BASE;
+    }
+    ruby_xfree(mem);
+}

data/lib/bigdecimal/jacobian.rb

@@ -2,6 +2,8 @@
 
 require 'bigdecimal'
 
+warn "'bigdecimal/jacobian' is deprecated and will be removed in a future release."
+
 # require 'bigdecimal/jacobian'
 #
 # Provides methods to compute the Jacobian matrix of a set of equations at a

data/lib/bigdecimal/ludcmp.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: false
 require 'bigdecimal'
 
+warn "'bigdecimal/ludcmp' is deprecated and will be removed in a future release."
+
 #
 # Solves a*x = b for x, using LU decomposition.
 #

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