bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,34 @@
+VALUE
+log1p_branch(VALUE x, VALUE prec, bigmath_func1 cb)
+{
+	VALUE y = Qundef;
+	VALUE one_thousand = rb_Rational(INT2FIX(1), INT2FIX(1000));
+	const ID geq = rb_intern_const(">=");
+	const ID gt = rb_intern_const(">");
+
+	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 = log_branch(x, prec, cb);
+	}
+	if (y == Qundef)
+	{
+		if (rb_num_zero_p(x))
+			y = BIG_ZERO;
+		else if (RTEST(rb_num_coerce_cmp(one_thousand, rb_num_abs(x), geq)))
+			y = cb(x, prec);
+		else if (RTEST(rb_num_coerce_cmp(INT2FIX(-1), x, gt)))
+			y = BIG_NAN;
+		else
+		{
+			x = rb_funcall1(x, '+', BIG_ONE);
+			y = rb_bigmath_log(x, prec);
+			y = rb_num_round(y, prec);
+		}
+	}
+	return y;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log1p/p_adic.h

@@ -0,0 +1,37 @@
+VALUE
+log1p_p_adic(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, m, zero, one, t, i, d, y, c;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+
+	t = x;
+	i = one;
+	d = one;
+	y = zero;
+	c = one;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall( rb_funcall1(c, '*', t), div, 2, i, m);
+		y = rb_funcall1(y, '+', d);
+		c = rb_num_uminus(c);
+		i = rb_funcall1(i, '+', one);
+		t = rb_funcall1(t, '*', x);
+	}
+
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(y);
+	RB_GC_GUARD(c);
+
+	return rb_num_round(y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log1p/ser_mercator.h

@@ -0,0 +1,35 @@
+VALUE
+log1p_ser_mercator(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE one = BIG_ONE;
+	VALUE w = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
+	VALUE t = one;
+	VALUE d = BIG_ONE;
+	VALUE y = BIG_ZERO;
+	int sign = 1;
+	VALUE m = Qundef;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall(w, div, 2, t, m);
+		t = rb_funcall1(t, '+', one);
+		w = rb_funcall(w, mult, 2, x, n);
+		if (sign == 1)
+			y = rb_funcall1(y, '+', d);
+		else
+			y = rb_funcall1(y, '-', d);
+		sign *= -1;
+	}
+
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(w);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(y);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,40 @@
+VALUE
+log2_branch(VALUE x, VALUE prec, bigmath_func1 log2_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+	{
+		switch (rb_num_infinite_p(x)) {
+		case 1:
+			y = BIG_INF;
+			break;
+		case -1: case 0:
+		default:
+			y = BIG_NAN;
+			break;
+		}
+	}
+	else if (rb_num_zero_p(x))
+	{
+		y = BIG_MINUS_INF;
+	}
+        else
+        {
+		if (rb_num_positive_p(x))
+		{
+			const ID add = rb_intern("add");
+			VALUE exp, fra;
+			fra = rcm2_edf(x, &exp);
+			exp = rb_BigDecimal1(exp);
+			fra = log2_cb(fra, prec);
+			y = rb_funcall(exp, add, 2, fra, prec);
+		}
+		else
+			y = BIG_NAN;
+	}
+	return y;
+}
+

data/ext/bigdecimal/math_r/internal/algo/bigmath/log2/edf.h

@@ -0,0 +1,11 @@
+VALUE
+log2_edf(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef;
+
+	rb_check_precise(prec);
+
+	y = logxt_edf(x, INT2FIX(2), prec);
+
+	return rb_num_round(y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log2/mercator.h

@@ -0,0 +1,35 @@
+
+#if 0
+static VALUE
+log_ser_mercator_x(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE y;
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	y = rb_funcall1(x, '-', INT2FIX(1));
+	y = rb_funcall(y, div, 2, x, prec);
+	y = rb_num_uminus(y);
+	return y;
+}
+#endif
+
+VALUE
+log2_mercator(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE fra = Qundef, exp = Qundef, y = Qundef;
+
+	rb_check_precise(prec);
+
+	fra = rcm2_edf(x, &exp);
+
+	y = rb_funcall1(fra, '-', INT2FIX(1));
+        fra = rb_funcall(y, div, 2, fra, prec);
+	fra = rb_num_uminus(fra);
+	fra = log1p_ser_mercator(fra, prec);
+	fra = rb_num_uminus(fra);
+	fra = rb_funcall(fra, div, 2, rb_bigmath_const_log2(prec), prec);
+
+	y = rb_funcall1(exp, '+', fra);
+	return rb_num_round(y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/logxt/edf.h

@@ -0,0 +1,33 @@
+VALUE
+logxt_edf(VALUE x, VALUE t, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE a, b, s, one_half, n, m;
+
+	n = rb_numdiff_make_n(prec);
+	a = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
+	b = BIG_ONE;
+	s = BIG_ZERO;
+	one_half = rb_BigDecimal1(rb_str_new_cstr("0.5"));
+
+	if (rb_num_zero_p(x))
+		return BIG_ZERO;
+	else if (rb_num_equal_p(x, INT2FIX(1)))
+		return BIG_ZERO;
+	while (rb_numdiff_condition_p(s, b, n, &m))
+	{
+		a = rb_funcall(a, mult, 2, a, m);
+		b = rb_funcall(one_half, mult, 2, b, m);
+		if (RTEST(rb_num_coerce_cmp(a, t, rb_intern(">="))))
+		{
+			s = rb_funcall1(s, '+', b);
+			a = rb_funcall1(a, '/', t);
+		}
+	}
+
+	RB_GC_GUARD(b);
+	RB_GC_GUARD(s);
+	RB_GC_GUARD(one_half);
+
+	return s;
+}

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

@@ -0,0 +1,30 @@
+VALUE
+pow_formula(VALUE x, VALUE y, VALUE prec)
+{
+	VALUE a = Qundef;
+
+	rb_check_precise(prec);
+	if (!rb_num_real_p(x))
+		rb_raise(rb_eTypeError, "not a Real");
+	if (rb_num_zero_p(rb_num_real(x)))
+		a = BIG_ONE;
+	if (TYPE(y) == T_FIXNUM || TYPE(y) == T_BIGNUM)
+	{
+		if (rb_num_positive_p(rb_num_real(x)))
+			a = ipow_edf(x, y, prec);
+		else // if (rb_num_negative_p(rb_num_real(x)))
+			a = rb_num_uminus(ipow_edf(rb_num_abs(x), y, prec));
+	}
+	else if (rb_num_real_p(y))
+	{
+		a = rb_bigmath_log(rb_num_abs(x), prec);
+		a = rb_funcall1(y, '*', a);
+		a = rb_bigmath_exp(a, prec);
+		if (rb_num_negative_p(x))
+			a = rb_num_uminus(a);
+	}
+	else
+		rb_raise(rb_eTypeError, "not a Real");
+
+	return a;
+}

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

@@ -0,0 +1,352 @@
+
+static inline VALUE
+quadrant_nonfinite(VALUE x, VALUE y, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE w = Qundef, pi = Qundef;
+	int x_sgn, y_sgn;
+	// Ignore non-regular case
+	if (rb_num_nonzero_p(rb_num_imag(x)) ||
+	    rb_num_nonzero_p(rb_num_imag(y)))
+	{
+		goto elsewise;
+	}
+	// The poles of +y+ axis
+	else if ((y_sgn = rb_num_infinite_p(y)) != 0 &&
+	         rb_num_finite_p(x))
+	{
+		VALUE real_x = rb_num_real(x);
+		switch (y_sgn) {
+		case 1: // 0-Deg
+			switch (NUM2INT(rb_num_cmpeql(real_x, INT2FIX(0)))) {
+			case -1:
+				w = BIG_MINUS_ZERO;
+				break;
+			case 0:
+				if (TYPE(real_x) == T_FLOAT)
+					w = rb_BigDecimal_flo(real_x);
+				else if (CLASS_OF(real_x) == rb_cBigDecimal)
+					w = real_x;
+				else
+					w = BIG_ZERO;
+				break;
+			case 1:
+				w = BIG_ZERO;
+				break;
+			}
+			break;
+		case -1: // 180-Deg
+			pi = rb_bigmath_const_pi(prec);
+			switch (NUM2INT(rb_num_cmpeql(real_x, INT2FIX(0)))) {
+			case -1:
+				w = rb_num_uminus(pi);
+				break;
+			case 0:
+				if (TYPE(real_x) == T_FLOAT)
+				{
+					w = rb_BigDecimal_flo(real_x);
+					w = NUM2INT(rb_BigDecimal_sign(w)) == -1 ?
+						rb_num_uminus(pi) : pi;
+				}
+				else if (CLASS_OF(real_x) == rb_cBigDecimal)
+					w = NUM2INT(rb_BigDecimal_sign(real_x)) == -1 ?
+						rb_num_uminus(pi) : pi;
+				else
+					w = pi;
+				break;
+			case 1:
+				w = pi;
+				break;
+			}
+		}
+	}
+	// The poles of +x+ axis
+        else if ((x_sgn = rb_num_infinite_p(x)) != 0 &&
+	         rb_num_finite_p(y))
+	{
+		pi = rb_bigmath_const_pi(prec);
+		switch (x_sgn) {
+		case 1: // 90-Deg
+			w = rb_funcall(pi, div, 2, INT2FIX(2), prec);
+			break;
+		case -1: // 270-Deg
+			w = rb_funcall(pi, div, 2, INT2FIX(-2), prec);
+			break;
+		}
+	}
+	// Diagonals +x+ and +y+
+	else if (x_sgn != 0 && y_sgn != 0)
+	{
+		pi = rb_bigmath_const_pi(prec);
+		if (x_sgn == 1 && y_sgn == 1) // 45-Deg
+			w = rb_funcall(pi, div, 2, INT2FIX(4), prec);
+		else if (x_sgn == 1 && y_sgn == -1) // 135-Deg
+			w = rb_funcall(pi, div, 2, INT2FIX(-4), prec);
+		else if (x_sgn == -1 && y_sgn == -1) // 225-Deg
+			w = rb_funcall(pi, mult, 2,
+				rb_Rational(INT2FIX(-3), INT2FIX(4)), prec);
+		else if (x_sgn == -1 && y_sgn == 1) // 315-Deg
+                        w = rb_funcall(pi, mult, 2,
+                                rb_Rational(INT2FIX(3), INT2FIX(4)), prec);
+	}
+	else
+	{
+elsewise:
+		if (!rb_num_real_p(x) || !rb_num_real_p(y))
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		else
+			w = BIG_NAN;
+	}
+	return w;
+}
+
+static inline VALUE
+quadrant_argument(VALUE x, VALUE y, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	const ID div = rb_intern("div");
+	VALUE w = Qundef, pi = Qundef;
+	bool nucomp = (!rb_num_real_p(x) || !rb_num_real_p(y)) ? true : false;
+	if (rb_num_zero_p(y))
+	{
+
+		x = rb_funcall(BIG_ZERO, mult, 2, rb_num_real(x), prec);
+		y = rb_funcall(BIG_ZERO, mult, 2, rb_num_real(y), prec);
+		switch (NUM2INT(rb_BigDecimal_sign(x))) {
+		case 1: // 0-Deg
+			switch (NUM2INT(rb_BigDecimal_sign(y))) {
+			case 1:
+				w = BIG_ZERO;
+				break;
+			case -1:
+				w = BIG_MINUS_ZERO;
+				break;
+			}
+			break;
+		case -1: // 180-Deg
+			pi = rb_bigmath_const_pi(prec);
+			switch (NUM2INT(rb_BigDecimal_sign(y))) {
+			case 1:
+				w = pi;
+				break;
+			case -1:
+				w = rb_num_uminus(pi);
+				break;
+			}
+			break;
+		}
+	}
+	else // 90-Deg
+	{
+		pi = rb_bigmath_const_pi(prec);
+		y = rb_funcall(BIG_ZERO, mult, 2, rb_num_real(y), prec);
+		switch (NUM2INT(rb_BigDecimal_sign(y))) {
+		case 1:
+			w = rb_funcall(pi, div, 2, INT2FIX(2), prec);
+			break;
+		case -1:
+			w = rb_funcall(pi, div, 2, INT2FIX(-2), prec);
+			break;
+		}
+	}
+	if (nucomp)
+		w = rb_Complex1(w);
+	return w;
+}
+
+static inline bool
+quadrant_diagonal_check(VALUE x, VALUE y)
+{
+	const ID abs = rb_intern("abs");
+	VALUE real_cmp = rb_num_cmpeql(
+		rb_funcall(rb_num_real(x), abs, 0),
+		rb_funcall(rb_num_real(y), abs, 0));
+        VALUE imag_cmp = rb_num_cmpeql(
+		rb_funcall(rb_num_imag(x), abs, 0),
+		rb_funcall(rb_num_imag(y), abs, 0));
+	return (FIX2INT(real_cmp) == 0 && FIX2INT(imag_cmp) == 0);
+}
+
+static inline VALUE
+quadrant_diagonal(VALUE x, VALUE y, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE w = Qundef, pi = Qundef;
+	VALUE x_real = rb_num_real(x), x_imag = rb_num_imag(x),
+	      y_real = rb_num_real(y), y_imag = rb_num_imag(y);
+	// quadrant(ix, iy), |x| == |y|
+	if (rb_num_zero_p(x_real) && rb_num_zero_p(y_real))
+	{
+		pi = rb_bigmath_const_pi(prec);
+		if (rb_num_positive_p(x_imag)) // 45-Deg
+		{
+			if (rb_num_positive_p(y_imag))
+				w = rb_funcall(pi, div, 2, INT2FIX(4), prec);
+			else // if (rb_num_negative_p(y_imag))
+				w = rb_funcall(pi, div, 2, INT2FIX(-4), prec);
+		}
+		else // if rb_num_negative_p(y_imag) // 135-Deg
+		{
+                        if (rb_num_positive_p(y_imag))
+                                w = rb_funcall(pi, mult, 2,
+                                	rb_Rational(INT2FIX(3), INT2FIX(4)), prec);
+                        else // if (rb_num_negative_p(y_imag))
+                                w = rb_funcall(pi, mult, 2,
+                                	rb_Rational(INT2FIX(-3), INT2FIX(4)), prec);
+		}
+		w = rb_Complex1(w);
+	}
+	// quadrant(x+iy, x+iy)
+	else if (NUM2INT(rb_num_cmpeql(x_real, y_real)) == 0 &&
+	         NUM2INT(rb_num_cmpeql(x_imag, y_imag)) == 0)
+	{
+		pi = rb_bigmath_const_pi(prec);
+		if (rb_num_positive_p(x_real))
+			w = rb_funcall(pi, div, 2, INT2FIX(4), prec);
+		else
+			w = rb_funcall(pi, mult, 2,
+				rb_Rational(INT2FIX(-3), INT2FIX(4)), prec);
+		if (!rb_num_real_p(x) || ! rb_num_real_p(y))
+			w = rb_Complex1(w);
+	}
+	// quadrant(x-iy, -x+iy) or quadrant(-x+iy, x-iy)
+        else if (NUM2INT(rb_num_cmpeql(x_real, y_real)) != 0 &&
+                 NUM2INT(rb_num_cmpeql(x_imag, y_imag)) != 0)
+        {
+		pi = rb_bigmath_const_pi(prec);
+ 		if (rb_num_positive_p(x_real))
+			w = rb_funcall(pi, div, 2, INT2FIX(-4), prec);
+		else
+			w = rb_funcall(pi, mult, 2,
+				rb_Rational(INT2FIX(3), INT2FIX(4)), prec);
+		w = rb_Complex1(w);
+        }
+	return w;
+}
+
+
+static inline VALUE
+quadrant_csqrt_iter(RB_BLOCK_CALL_FUNC_ARGLIST(y, c))
+{
+	return rb_funcall(y, '*', 1, y);
+}
+
+
+static inline VALUE
+quadrant_finite(VALUE x, VALUE y, VALUE prec)
+{
+	const ID sub = rb_intern("sub");
+	const ID div = rb_intern("div");
+	VALUE w = Qundef, ct = Qundef, t = Qundef, pi = Qundef;
+	VALUE x_real = rb_num_real(x), x_imag = rb_num_imag(x),
+	      y_real = rb_num_real(y), y_imag = rb_num_imag(y);
+	int coordinate = 1;
+	// Real solution:
+	if (rb_num_zero_p(x_imag) && rb_num_zero_p(y_imag))
+	{
+		x_real = rb_num_canonicalize(x_real, prec, ARG_REAL, ARG_RAWVALUE);
+		y_real = rb_num_canonicalize(y_real, prec, ARG_REAL, ARG_RAWVALUE);
+		     if (rb_num_positive_p(x_real) && rb_num_negative_p(y_real))
+			coordinate = 4;
+		else if (rb_num_negative_p(x_real) && rb_num_negative_p(y_real))
+			coordinate = 3;
+		else if (rb_num_negative_p(x_real) && rb_num_positive_p(y_real))
+			coordinate = 2;
+		// BUG-FIX: BigDecimal to Rational drops significant digits
+#if 0
+		w = rb_Rational(y_real, x_real);
+#else
+		w = rb_funcall(y_real, div, 2, x_real, prec);
+#endif
+		if (rb_num_negative_p(w))  w = rb_num_uminus(w); // abs()
+#if 0
+		t = rb_BigDecimal(w, prec);
+#else
+		t = w;
+#endif
+	}
+	// Complex solution: -i log( (x+iy) / sqrt(x^2+y^2) )
+	else
+	{
+		const ID sum = rb_intern("sum");
+		w = rb_block_call(rb_assoc_new(x, y), sum, 0, NULL,
+			quadrant_csqrt_iter, Qnil);
+		w = rb_bigmath_csqrt(w, prec);
+		ct = rb_funcall1(rb_Complex(x, y), '/', w);
+		     if (rb_num_positive_p(rb_num_real(ct)) &&
+		         rb_num_negative_p(rb_num_imag(ct)))
+			coordinate = 4;
+		else if (rb_num_negative_p(rb_num_real(ct)) &&
+		         rb_num_negative_p(rb_num_imag(ct)))
+			coordinate = 3;
+		else if (rb_num_negative_p(rb_num_real(ct)) &&
+		         rb_num_positive_p(rb_num_imag(ct)))
+			coordinate = 2;
+		t = rb_funcall(rb_num_imag(ct), div, 2, rb_num_real(ct), prec);
+		if (rb_num_negative_p(t))
+			t = rb_num_uminus(t);
+	}
+
+	// Calculate tan^{-1}(y/x)
+	w = rb_bigmath_atan(t, prec);
+	switch (coordinate) {
+	case 4:
+		w = rb_num_uminus(w);
+		break;
+	case 3:
+		pi = rb_bigmath_const_pi(prec);
+		w = rb_funcall(w, sub, 2, pi, prec);
+		break;
+	case 2:
+		pi = rb_bigmath_const_pi(prec);
+		w = rb_funcall(pi, sub, 2, w, prec);
+		break;
+	}
+
+	// For Complex solutions
+	if (rb_num_nonzero_p(x_imag) || rb_num_nonzero_p(y_imag))
+	{
+		VALUE abs = rb_bigmath_cabs(ct, prec);
+		w = rb_ImaginaryZ(rb_Complex(rb_bigmath_log(abs, prec), w), 
+			SIGN_MINUS);
+	}
+
+	if (!rb_num_real_p(x) || ! rb_num_real_p(y))
+		w = rb_Complex1(w);
+
+	return w;
+}
+
+VALUE
+quadrant_formula(VALUE x, VALUE y, VALUE prec)
+{
+	VALUE w = Qundef;
+	rb_check_precise(prec);
+	if (!rb_num_finite_p(x) || !rb_num_finite_p(y))
+	{
+		w = quadrant_nonfinite(x, y, prec);
+	}
+	else // if (rb_num_finite_p(x) && rb_num_finite_p(y))
+	{
+		if (rb_num_zero_p(x) || rb_num_zero_p(y))
+		{
+			w = quadrant_argument(x, y, prec);
+		}
+		else
+		{
+			if (quadrant_diagonal_check(x, y))
+			{
+				w = quadrant_diagonal(x, y, prec);
+			}
+			if (w == Qundef)
+			{
+				w = quadrant_finite(x, y, prec);
+			}
+		}
+	}
+	if (w == Qundef)
+		rb_raise(rb_eRuntimeError, "no solution");
+	return rb_num_round(w, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/rcm10/edf.h

@@ -0,0 +1,34 @@
+VALUE
+rcm10_edf(VALUE x, VALUE *reso)
+{
+	VALUE fra = x; *reso = INT2FIX(0);
+	if (rb_num_nonzero_p(fra) && rb_num_finite_p(fra))
+	{
+		long resov = 0;
+		bool has_sign = RTEST(rb_num_coerce_cmp(x, INT2FIX(0), '<'));
+		VALUE rat_ten = rb_rational_new1(INT2FIX(10));
+		fra = rb_Rational1(fra);
+		if (rb_num_negative_p(fra))
+			fra = rb_num_uminus(fra);
+		if (RTEST(rb_num_coerce_cmp(fra, INT2FIX(10), rb_intern(">="))))
+		{
+			while (RTEST(rb_num_coerce_cmp(fra, INT2FIX(10), rb_intern(">="))))
+			{
+				fra = rb_funcall1(fra, '/', rat_ten);
+				resov++;
+			}
+		}
+		else if (RTEST(rb_num_coerce_cmp(fra, INT2FIX(1), '<')))
+		{
+			while (RTEST(rb_num_coerce_cmp(fra, INT2FIX(1), '<')))
+			{
+				fra = rb_funcall1(fra, '*', rat_ten);
+				resov--;
+			}
+		}
+		if (has_sign)
+			fra = rb_num_uminus(fra);
+		*reso = LONG2FIX(resov);
+	}
+	return fra;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/rcm2/edf.h

@@ -0,0 +1,34 @@
+VALUE
+rcm2_edf(VALUE x, VALUE *reso)
+{
+	VALUE fra = x; *reso = INT2FIX(0);
+	if (rb_num_nonzero_p(fra) && rb_num_finite_p(fra))
+	{
+		long resov = 0;
+		bool has_sign = RTEST(rb_num_coerce_cmp(x, INT2FIX(0), '<'));
+		VALUE rat_two = rb_rational_new1(INT2FIX(2));
+		fra = rb_Rational1(fra);
+		if (rb_num_negative_p(fra))
+			fra = rb_num_uminus(fra);
+		if (RTEST(rb_num_coerce_cmp(fra, INT2FIX(1), rb_intern(">="))))
+		{
+			while (RTEST(rb_num_coerce_cmp(INT2FIX(2), fra, rb_intern("<="))))
+			{
+				fra = rb_funcall1(fra, '/', rat_two);
+				resov++;
+			}
+		}
+		else
+		{
+			while (RTEST(rb_num_coerce_cmp(INT2FIX(1), fra, '>')))
+			{
+				fra = rb_funcall1(fra, '*', rat_two);
+				resov--;
+			}
+		}
+		if (has_sign)
+			fra = rb_num_uminus(fra);
+		*reso = LONG2FIX(resov);
+	}
+	return fra;
+}

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

@@ -0,0 +1,27 @@
+VALUE
+sec_branch(VALUE x, VALUE prec, bigmath_func1 sec_cb)
+{
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		w = BIG_NAN;
+	else if (rb_num_infinite_p(x) != 0)
+	{
+		w = BIG_ONE;
+	}
+	else
+	{
+		VALUE t = Qundef;
+		VALUE v_cos = Qundef;
+		x = rb_bigmath_to_rad(x, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, NULL, &v_cos))
+		{
+			w = rb_num_canonicalize(v_cos, prec, ARG_REAL, ARG_RECIPROCAL);
+		}
+		else
+			w = sec_cb(x, prec);
+	}
+	return w;
+}