bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/internal/algo/bigmath/csech/branch.h

@@ -0,0 +1,38 @@
+VALUE
+csech_branch(VALUE z, VALUE prec, bigmath_func1 csech_cb)
+{
+	VALUE w = Qundef;
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_Complex(BIG_ZERO, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_cos = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, NULL, &v_cos) &&
+		    rb_num_zero_p(real))
+		{
+			v_cos = rb_num_canonicalize(v_cos, prec, ARG_REAL, ARG_RECIPROCAL);
+			w = rb_Complex(BIG_ZERO, v_cos);
+		}
+		else
+		{
+			w = csech_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csech/eulerf.h

@@ -0,0 +1,11 @@
+VALUE
+csech_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_cos, z, prec);
+
+	return rb_num_canonicalize(w, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csin/branch.h

@@ -0,0 +1,44 @@
+VALUE
+csin_branch(VALUE z, VALUE prec, bigmath_func1 csin_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_nan_p(z) || rb_num_finite_p(rb_num_imag(z)))
+		{
+			if (rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_NAN, BIG_ZERO);
+			else
+				w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else if (rb_num_finite_p(rb_num_real(z)))
+		{
+			if (rb_num_negative_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_ZERO, BIG_MINUS_INF);
+			else
+				w = rb_Complex(BIG_ZERO, BIG_INF);
+		}
+		else
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef;
+		real = rb_bigmath_to_rad(real, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL) &&
+		    rb_num_zero_p(imag))
+		{
+			w = rb_Complex(v_sin, BIG_ZERO);
+		}
+		else
+		{
+			w = csin_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csin/eulerf.h

@@ -0,0 +1,11 @@
+VALUE
+csin_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csinh/branch.h

@@ -0,0 +1,41 @@
+VALUE
+csinh_branch(VALUE z, VALUE prec, bigmath_func1 csinh_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_num_negative_p(rb_num_real(z)) ? BIG_MINUS_INF : BIG_INF;
+			w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL) &&
+		    rb_num_zero_p(real))
+		{
+			w = rb_Complex(BIG_ZERO, v_sin);
+		}
+		else
+		{
+			w = csinh_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csinh/eulerf.h

@@ -0,0 +1,11 @@
+VALUE
+csinh_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = rb_ImaginaryZ(trig_f_euler(mf_sin, z, prec), SIGN_PLUS);
+
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csqrt/formula.h

@@ -0,0 +1,66 @@
+static VALUE
+csqrt_term(VALUE abs, VALUE a, VALUE prec, ID ops)
+{
+	const ID div = rb_intern("div");
+	const ID round = rb_intern("round");
+	VALUE t;
+	t = rb_funcall(abs, ops, 2, a, prec);
+	t = rb_funcall(t, div, 2, INT2FIX(2), prec);
+	if (rb_num_negative_p(t))
+		return BIG_ZERO;
+	t = rb_bigmath_sqrt(t, prec);
+	t = rb_funcall(t, round, 1, prec);
+	return t;
+}
+
+VALUE
+csqrt_formula(VALUE z, VALUE prec)
+{
+	VALUE w = Qundef;
+
+	rb_check_precise(prec);
+
+	if (!rb_num_finite_p(z))
+	{
+		int re_sgn, im_sgn;
+		if ((re_sgn = rb_num_infinite_p(rb_num_real(z)) != 0) &&
+		    (rb_num_infinite_p(rb_num_imag(z))) != 0)
+		{
+			switch (re_sgn) {
+			case 1:
+				w = rb_Complex1(BIG_INF);
+				break;
+			case -1:
+				w = rb_Complex(BIG_ZERO, BIG_INF);
+				break;
+			}
+		}
+		else if ((im_sgn = rb_num_infinite_p(rb_num_imag(z))) != 0)
+		{
+			w = rb_Complex(
+				BIG_INF,
+				rb_num_coerce_bin(im_sgn, BIG_INF, '*')
+			);
+		}
+		else
+		{
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+	}
+	else // if (rb_num_finite_p(z))
+	{
+		const ID add = rb_intern("add"), sub = rb_intern("sub");
+		VALUE abs = rb_bigmath_cabs(z, prec),
+		      re = csqrt_term(abs, rb_num_real(z), prec, add),
+		      im = csqrt_term(abs, rb_num_real(z), prec, sub),
+		      sgn = rb_num_cmpeql(rb_num_imag(z), INT2NUM(0));
+		if (rb_num_nonzero_p(sgn))
+			w = rb_Complex(re, rb_num_coerce_bin(sgn, im, '*'));
+		else
+			w = rb_Complex(re, im);
+	}
+	if (w == Qundef)
+		rb_raise(rb_eRuntimeError, "no solution");
+
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/ctan/branch.h

@@ -0,0 +1,46 @@
+VALUE
+ctan_branch(VALUE z, VALUE prec, bigmath_func1 ctan_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_nan_p(z) || rb_num_finite_p(rb_num_imag(z)))
+		{
+			if (rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_NAN, BIG_ZERO);
+			else
+				w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else if (rb_num_finite_p(rb_num_real(z)))
+		{
+			if (rb_num_negative_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_ZERO, BIG_MINUS_ONE);
+			else
+				w = rb_Complex(BIG_ZERO, BIG_ONE);
+		}
+		else
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef, v_cos = Qundef;
+		real = rb_bigmath_to_rad(real, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, &v_cos) &&
+		    rb_num_zero_p(imag))
+		{
+			const ID div = rb_intern("div");
+			w = rb_funcall(v_sin, div, 2, v_cos, prec);
+			w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			w = ctan_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/ctan/eulerf.h

@@ -0,0 +1,11 @@
+VALUE
+ctan_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_tan, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/ctanh/branch.h

@@ -0,0 +1,43 @@
+VALUE
+ctanh_branch(VALUE z, VALUE prec, bigmath_func1 ctanh_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_num_negative_p(rb_num_real(z)) ? BIG_MINUS_ONE : BIG_ONE;
+			w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef, v_cos = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, &v_cos) &&
+		    rb_num_zero_p(real))
+		{
+			const ID div = rb_intern("div");
+			w = rb_funcall(v_sin, div, 2, v_cos, prec);
+			w = rb_Complex(BIG_ZERO, w);
+		}
+		else
+		{
+			w = ctanh_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/ctanh/eulerf.h

@@ -0,0 +1,11 @@
+VALUE
+ctanh_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = rb_ImaginaryZ(trig_f_euler(mf_tan, z, prec), SIGN_PLUS);
+
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/cuberoot/newton.h

@@ -0,0 +1,42 @@
+VALUE
+cuberoot_newton(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE s = Qundef, t = Qundef, prev = Qundef;
+	VALUE two, three;
+	bool positive;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	rb_check_precise(prec);
+
+	if (!rb_num_finite_p(x) || rb_num_zero_p(x))
+		return x;
+	positive = rb_num_positive_p(x) ? true : false;
+
+	if (!positive)
+		x = rb_num_uminus(x);
+
+	if (RTEST(rb_num_coerce_cmp(x, INT2FIX(1), '>')))
+		s = x;
+	else
+		s = BIG_ONE;
+
+	two = rb_BigDecimal1(INT2FIX(2));
+	three = rb_BigDecimal1(INT2FIX(3));
+
+	do {
+		prev = s;
+		t = rb_funcall1(s, '*', s);
+		t = rb_funcall1(x, '/', t);
+		t = rb_funcall1(t, '+', rb_funcall1(two, '*', s));
+		s = rb_funcall(t, div, 2, three, prec);
+	} while (RTEST(rb_num_coerce_cmp(s, prev, '<')));
+
+	RB_GC_GUARD(s);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(prev);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(three);
+
+	return positive ? prev : rb_num_uminus(prev);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erf/algo911.h

@@ -0,0 +1,41 @@
+VALUE
+erf_algo911(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID leq = rb_intern("<=");
+	const ID pow = rb_intern("**");
+	VALUE absx, bc, n, y = Qundef;
+	VALUE zero_six = rb_BigDecimal1(rb_str_new_cstr("0.6"));
+	VALUE four_one = rb_BigDecimal1(rb_str_new_cstr("4.1"));
+
+	n = rb_numdiff_make_n(prec);
+
+	absx = rb_num_abs(x);
+	bc = rb_BigDecimal1(rb_funcall1(prec, '+', INT2FIX(21)));
+	bc = rb_funcall1(bc, '*', rb_bigmath_log(INT2FIX(10), n));
+	bc = rb_bigmath_sqrt(bc, n);
+	bc = rb_funcall(bc, div, 2, INT2FIX(5), n);
+	if (rb_num_coerce_cmp(absx, bc, leq))
+	{
+		y = erf_ser_zero(absx, prec);
+		goto retval;
+	}
+	bc = rb_funcall1(prec, '+', INT2FIX(6));
+	bc = rb_funcall1(bc, '*', rb_bigmath_log(INT2FIX(10), n));
+	bc = rb_funcall1(bc, pow, zero_six);
+	bc = rb_funcall(bc, div, 2, four_one, n);
+       if (rb_num_coerce_cmp(absx, bc, leq))
+        {
+                y = erf_ser_inf(absx, prec);
+		goto retval;
+        }
+	else
+	{
+		y = erf_cf(absx, prec);
+		goto retval;
+	}
+retval:
+	if (rb_num_negative_p(x))
+		y = rb_num_uminus(y);
+	return y;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erf/branch.h

@@ -0,0 +1,18 @@
+VALUE
+erf_branch(VALUE x, VALUE prec, bigmath_func1 erf_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+	{
+		if (rb_num_nan_p(x))
+			y = BIG_NAN;
+		else
+			y = rb_num_negative_p(x) ? BIG_MINUS_ONE : BIG_ONE;
+	}
+	if (y == Qundef)
+		y = erf_cb(x, prec);
+	return y;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erf/cf.h

@@ -0,0 +1,51 @@
+VALUE
+erf_cf(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, zero, one, two, c, b, p1, q1, p2, q2, i, prev, t;
+
+	n = rb_numdiff_make_n(prec);
+
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+
+	c = rb_num_uminus(rb_bigmath_exp(rb_funcall1(rb_num_uminus(x), '*', x), n));
+	if (rb_num_zero_p(rb_num_round(c, prec)))
+		return rb_num_negative_p(x) ? BIG_MINUS_ONE : BIG_ONE;
+	c = rb_funcall1(c, '/', rb_bigmath_sqrt(rb_bigmath_const_pi(n), n));
+	b = x;
+
+	p1 = one;  q1 = zero;  p2 = one;  q2 = one;
+	i = one;
+	do {
+		prev = p2;
+		t = rb_funcall1(rb_funcall1(p1, '*', c), '+', rb_funcall1(p2, '*', b));  p1 = p2;  p2 = t;
+                t = rb_funcall1(rb_funcall1(q1, '*', c), '+', rb_funcall1(q2, '*', b));  q1 = q2;  q2 = t;
+		if (rb_num_nonzero_p(q2))
+		{
+			p1 = rb_funcall(p1, div, 2, q2, n);  q1 = rb_funcall(q1, div, 2, q2, n);
+			p2 = rb_funcall(p2, div, 2, q2, n);  q2 = one;
+		}
+		i = rb_funcall1(i, '+', one);
+		c = rb_funcall1(i, '-', one);
+		b = rb_num_equal_p(rb_funcall1(i, '%', two), one) ? x : rb_funcall1(two, '*', x);
+	} while (rb_num_nonzero_p(q2) && rb_num_notequal_p(prev, p2));
+	if (rb_num_negative_p(x))
+		p2 = rb_num_uminus(p2);
+
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(c);
+	RB_GC_GUARD(b);
+	RB_GC_GUARD(p1);
+	RB_GC_GUARD(q1);
+	RB_GC_GUARD(p2);
+	RB_GC_GUARD(q2);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(prev);
+	RB_GC_GUARD(t);
+
+	return rb_num_round(p2, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erf/ser_inf.h

@@ -0,0 +1,53 @@
+VALUE
+erf_ser_inf(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE n, m, s, zero, one, two, x2, f, r, i, i2, d, y;
+
+	n = rb_numdiff_make_n(prec);
+
+	s = rb_bigmath_exp(rb_funcall1(rb_num_uminus(x), '*', x), n);
+	if (rb_num_zero_p(rb_num_round(s, prec)))
+		return rb_num_negative_p(x) ? BIG_MINUS_ONE : BIG_ONE;
+	s = rb_funcall(s, div, 2, rb_bigmath_sqrt(rb_bigmath_const_pi(n), n), n);
+
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+
+	x = rb_funcall1(two, '*', x);
+	x2 = rb_funcall1(x, '*', x);
+	f = one;
+	r = one;
+	i = zero;
+	i2 = one;
+	d = x;
+	y = zero;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall(rb_funcall1(f, '*', x), div, 2, r, m);
+		y = rb_funcall1(y, '+', d);
+		x = rb_funcall(x, mult, 2, x2, n);
+		f = rb_funcall1(f, '*', i = rb_funcall1(i, '+', one));
+		r = rb_funcall1(r, '*', rb_funcall1(
+			i2 = rb_funcall1(i2, '+', one), '*', 
+			i2 = rb_funcall1(i2, '+', one)));
+	}
+
+	RB_GC_GUARD(s);
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(x2);
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(f);
+	RB_GC_GUARD(r);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(i2);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(y);
+
+	return rb_funcall(s, mult, 2, y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erf/ser_zero.h

@@ -0,0 +1,45 @@
+VALUE
+erf_ser_zero(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE n, m, zero, one, two, x2, f, r, i, d, y;
+
+	n = rb_numdiff_make_n(prec);
+
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+
+	x2 = rb_funcall1(x, '*', x);
+	f = one;
+	r = one;
+	i = one;
+	d = x;
+	y = zero;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall(x, div, 2, rb_funcall1(f, '*', r), m);
+		y = rb_funcall1(y, '+', d);
+		x = rb_num_uminus(rb_funcall(x, mult, 2, x2, n));
+		f = rb_funcall1(f, '*', i);
+		r = rb_funcall1(r, '+', two);
+		i = rb_funcall1(i, '+', one);
+	}
+
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(x2);
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(f);
+	RB_GC_GUARD(r);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(y);
+
+	return rb_funcall(
+		rb_funcall1(INT2FIX(2), '/', rb_bigmath_sqrt(rb_bigmath_const_pi(n), n)),
+		mult, 2, y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erfc/algo911.h

@@ -0,0 +1,27 @@
+VALUE
+erfc_algo911(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID leq = rb_intern("<=");
+	const ID pow = rb_intern("**");
+	VALUE bc, n, y = Qundef;
+	VALUE zero_seven = rb_BigDecimal1(rb_str_new_cstr("0.7"));
+	VALUE nine = rb_BigDecimal1(INT2FIX(9));
+
+	n = rb_numdiff_make_n(prec);
+
+	bc = rb_funcall1(prec, '+', INT2FIX(6));
+	bc = rb_funcall1(bc, '*', rb_bigmath_log(INT2FIX(10), n));
+	bc = rb_funcall1(bc, pow, zero_seven);
+	bc = rb_funcall(bc, div, 2, nine, n);
+	if (rb_num_coerce_cmp(x, bc, leq))
+	{
+		y = erf_algo911(x, prec);
+		y = rb_funcall1(BIG_ONE, '-', y);
+	}
+	else
+	{
+		y = erfc_cf(x, prec);
+	}
+	return y;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erfc/branch.h

@@ -0,0 +1,18 @@
+VALUE
+erfc_branch(VALUE x, VALUE prec, bigmath_func1 erfc_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+	{
+		if (rb_num_nan_p(x))
+			y = BIG_NAN;
+		else
+			y = rb_num_negative_p(x) ? rb_BigDecimal1(INT2FIX(2)) : BIG_ZERO;
+	}
+	if (y == Qundef)
+		y = erfc_cb(x, prec);
+	return y;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/erfc/cf.h

@@ -0,0 +1,49 @@
+VALUE
+erfc_cf(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, zero, one, two, c, b, p1, q1, p2, q2, i, prev, t;
+
+	n = rb_numdiff_make_n(prec);
+
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+
+	c = rb_bigmath_exp(rb_funcall1(rb_num_uminus(x), '*', x), n);
+	if (rb_num_zero_p(rb_num_round(c, prec)))
+		return rb_num_negative_p(x) ? rb_BigDecimal1(INT2FIX(2)) : BIG_ZERO;
+	c = rb_funcall1(c, '/', rb_bigmath_sqrt(rb_bigmath_const_pi(n), n));
+	b = x;
+
+	p1 = one;  q1 = zero;  p2 = zero;  q2 = one;
+	i = one;
+	do {
+		prev = p2;
+		t = rb_funcall1(rb_funcall1(p1, '*', c), '+', rb_funcall1(p2, '*', b));  p1 = p2;  p2 = t;
+                t = rb_funcall1(rb_funcall1(q1, '*', c), '+', rb_funcall1(q2, '*', b));  q1 = q2;  q2 = t;
+		if (rb_num_nonzero_p(q2))
+		{
+			p1 = rb_funcall(p1, div, 2, q2, n);  q1 = rb_funcall(q1, div, 2, q2, n);
+			p2 = rb_funcall(p2, div, 2, q2, n);  q2 = one;
+		}
+		i = rb_funcall1(i, '+', one);
+		c = rb_funcall1(i, '-', one);
+		b = rb_num_equal_p(rb_funcall1(i, '%', two), one) ? x : rb_funcall1(two, '*', x);
+	} while (rb_num_nonzero_p(q2) && rb_num_notequal_p(prev, p2));
+
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(c);
+	RB_GC_GUARD(b);
+	RB_GC_GUARD(p1);
+	RB_GC_GUARD(q1);
+	RB_GC_GUARD(p2);
+	RB_GC_GUARD(q2);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(prev);
+	RB_GC_GUARD(t);
+
+	return rb_num_round(p2, prec);
+}