bigdecimal-math_r 0.2.0 → 0.2.2

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

@@ -16,51 +16,21 @@ csqrt_term(VALUE abs, VALUE a, VALUE prec, ID ops)
 VALUE
 csqrt_formula(VALUE z, VALUE prec)
 {
-	VALUE w = Qundef;
+	const ID add = rb_intern("add"), sub = rb_intern("sub");
+	VALUE w = Qundef, abs, re, im, sgn, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(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");
+	abs = rb_bigmath_cabs(z, n);
+	re = csqrt_term(abs, rb_num_real(z), n, add);
+	im = csqrt_term(abs, rb_num_real(z), n, sub);
+	sgn = rb_num_cmpeql(rb_num_imag(z), INT2NUM(0));
 
-	return w;
+	if (rb_num_nonzero_p(sgn))
+		w = rb_Complex(re, rb_num_coerce_bin(sgn, im, '*'));
+	else
+		w = rb_Complex(re, im);
+
+	return rb_num_round(w, prec);
 }

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

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

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

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

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

@@ -0,0 +1,18 @@
+VALUE
+cuberoot_branch(VALUE x, VALUE prec, bigmath_func1 cuberoot_cb)
+{
+	bool positive;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	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);
+
+	x = cuberoot_cb(x, prec);
+
+	return positive ? x : rb_num_uminus(x);
+}

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

@@ -2,19 +2,11 @@ VALUE
 cuberoot_newton(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE s = Qundef, t = Qundef, prev = Qundef;
+	VALUE s = Qundef, t = Qundef, prev = Qundef, n;
 	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);
+	n = rb_numdiff_make_n(prec);
 
 	if (RTEST(rb_num_coerce_cmp(x, INT2FIX(1), '>')))
 		s = x;
@@ -29,7 +21,7 @@ cuberoot_newton(VALUE x, VALUE prec)
 		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);
+		s = rb_funcall(t, div, 2, three, n);
 	} while (RTEST(rb_num_coerce_cmp(s, prev, '<')));
 
 	RB_GC_GUARD(s);
@@ -38,5 +30,5 @@ cuberoot_newton(VALUE x, VALUE prec)
 	RB_GC_GUARD(two);
 	RB_GC_GUARD(three);
 
-	return positive ? prev : rb_num_uminus(prev);
+	return rb_num_round(prev, prec);
 }

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

@@ -4,15 +4,18 @@ 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 absx, bc, log10, 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"));
 
+	rb_check_precise(prec);
 	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));
+	log10 = rb_bigmath_const_log10(n);
+
+	bc = rb_BigDecimal1(rb_funcall1(n, '+', INT2FIX(21)));
+	bc = rb_funcall1(bc, '*', log10);
 	bc = rb_bigmath_sqrt(bc, n);
 	bc = rb_funcall(bc, div, 2, INT2FIX(5), n);
 	if (rb_num_coerce_cmp(absx, bc, leq))
@@ -21,7 +24,7 @@ erf_algo911(VALUE x, VALUE prec)
 		goto retval;
 	}
 	bc = rb_funcall1(prec, '+', INT2FIX(6));
-	bc = rb_funcall1(bc, '*', rb_bigmath_log(INT2FIX(10), n));
+	bc = rb_funcall1(bc, '*', log10);
 	bc = rb_funcall1(bc, pow, zero_six);
 	bc = rb_funcall(bc, div, 2, four_one, n);
        if (rb_num_coerce_cmp(absx, bc, leq))

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

@@ -4,6 +4,7 @@ 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;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	zero = BIG_ZERO;

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

@@ -5,6 +5,7 @@ erf_ser_inf(VALUE x, VALUE prec)
 	const ID mult = rb_intern("mult");
 	VALUE n, m, s, zero, one, two, x2, f, r, i, i2, d, y;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	s = rb_bigmath_exp(rb_funcall1(rb_num_uminus(x), '*', x), n);

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

@@ -5,6 +5,7 @@ erf_ser_zero(VALUE x, VALUE prec)
 	const ID mult = rb_intern("mult");
 	VALUE n, m, zero, one, two, x2, f, r, i, d, y;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	zero = BIG_ZERO;

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

@@ -4,14 +4,17 @@ 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 bc, n, log10, y = Qundef;
 	VALUE zero_seven = rb_BigDecimal1(rb_str_new_cstr("0.7"));
 	VALUE nine = rb_BigDecimal1(INT2FIX(9));
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
+	log10 = rb_bigmath_const_log10(n);
+
 	bc = rb_funcall1(prec, '+', INT2FIX(6));
-	bc = rb_funcall1(bc, '*', rb_bigmath_log(INT2FIX(10), n));
+	bc = rb_funcall1(bc, '*', log10);
 	bc = rb_funcall1(bc, pow, zero_seven);
 	bc = rb_funcall(bc, div, 2, nine, n);
 	if (rb_num_coerce_cmp(x, bc, leq))

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

@@ -4,6 +4,7 @@ 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;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	zero = BIG_ZERO;

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

@@ -8,6 +8,8 @@ escalb_edf(VALUE a, VALUE x, VALUE prec, VALUE *exp, VALUE *fra)
 	const ID MAX_10_EXP = rb_intern("MAX_10_EXP");
 	VALUE max_10_exp = rb_const_get_at(rb_cFloat, MAX_10_EXP);
 
+	rb_check_precise(prec);
+
 	if (!rb_num_finite_p(a) && !rb_num_positive_p(a))
 		rb_raise(rb_eRangeError, "parameter a must be positive finite");
 	switch (TYPE(x)) {

data/ext/bigdecimal/math_r/internal/algo/bigmath/exp/builtin.h

@@ -1,6 +1,12 @@
 VALUE
 exp_builtin(VALUE x, VALUE prec)
 {
-	VALUE y = rb_funcall(rb_mBigMath, mf_exp, 2, x, prec);
+	VALUE y, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	y = rb_funcall(rb_mBigMath, mf_exp, 2, x, n);
+
 	return rb_num_round(y, prec);
 }

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

@@ -2,22 +2,23 @@ VALUE
 exp_edf(VALUE x, VALUE prec)
 {
 	const ID mult = rb_intern("mult");
-	VALUE exp = Qundef, fra = Qundef;
+	VALUE exp = Qundef, fra = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	if (rb_num_notequal_p(x, x))
 		return BIG_NAN;
-	rb_bigmath_escalb(rb_bigmath_const_e(prec), x, prec, &exp, &fra);
+	rb_bigmath_escalb(rb_bigmath_const_e(n), x, n, &exp, &fra);
 	if (exp == Qundef || fra == Qundef)
 		rb_raise(rb_eRuntimeError, "no solution");
 	if (rb_num_infinite_p(exp) ||
 	    rb_num_zero_p(exp) ||
 	    rb_num_zero_p(fra))
-		return rb_num_round(exp, prec);
-	fra = rb_bigmath_expxt(fra, BIG_ONE, prec);
+		return rb_num_round(exp, n);
+	fra = rb_bigmath_expxt(fra, BIG_ONE, n);
 	if (CLASS_OF(exp) != rb_cBigDecimal)
-		exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+		exp = rb_num_canonicalize(exp, n, ARG_REAL, ARG_RAWVALUE);
 
 	return rb_funcall(exp, mult, 2, fra, prec);
 }

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

@@ -2,18 +2,22 @@ VALUE
 exp2_edf(VALUE x, VALUE prec)
 {
 	const ID mult = rb_intern("mult");
-	VALUE exp = Qundef, fra = Qundef;
+	VALUE exp = Qundef, fra = Qundef, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
 	if (rb_num_notequal_p(x, x))
 		return BIG_NAN;
-	rb_bigmath_escalb(INT2FIX(2), x, prec, &exp, &fra);
+	rb_bigmath_escalb(INT2FIX(2), x, n, &exp, &fra);
 	if (exp == Qundef || fra == Qundef)
 		rb_raise(rb_eRuntimeError, "no solution");
 	if (rb_num_infinite_p(exp) ||
 	    rb_num_zero_p(exp) ||
 	    rb_num_zero_p(fra))
-		return rb_num_round(exp, prec);
-	fra = rb_bigmath_expxt(fra, rb_bigmath_const_log2(prec), prec);
+		return rb_num_round(exp, n);
+	fra = rb_bigmath_expxt(fra, rb_bigmath_const_log2(n), n);
 	if (CLASS_OF(exp) != rb_cBigDecimal)
-		exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+		exp = rb_num_canonicalize(exp, n, ARG_REAL, ARG_RAWVALUE);
 	return rb_funcall(exp, mult, 2, fra, prec);
 }

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

@@ -0,0 +1,13 @@
+VALUE
+expm1_branch(VALUE x, VALUE prec, bigmath_func1 expm1_cb)
+{
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		w = BIG_NAN;
+	else
+		w = expm1_cb(x, prec);
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/expm1/identity.h

@@ -0,0 +1,18 @@
+VALUE
+expm1_identity(VALUE x, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE y = Qundef;
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	x = rb_funcall1(x, '/', two);
+
+	y = rb_funcall1(rb_bigmath_exp(x, n), '*', sinh_branch(x, n, sinh_formula));
+	y = rb_funcall(two, mult, 2, y, prec);
+
+	return y;
+}

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

@@ -7,8 +7,8 @@ expxt_edf(VALUE x, VALUE t, VALUE prec)
 	long i = 0;
 
 	rb_check_precise(prec);
-
 	n = rb_numdiff_make_n(prec), m;
+
 	a = BIG_ONE;
 	xt = rb_funcall1(x, '*', t);
 	e = BIG_ZERO;

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

@@ -1,11 +1,12 @@
 VALUE
 f_euler_formula(VALUE theta, VALUE prec)
 {
-	VALUE sin, cos;
+	VALUE sin, cos, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	rb_bigmath_sincos(theta, prec, &sin, &cos);
+	rb_bigmath_sincos(theta, n, &sin, &cos);
 
 	return rb_Complex(cos, sin);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/hypot/l2norm.h

@@ -1,11 +1,12 @@
 VALUE
 hypot_l2norm(VALUE a, VALUE b, VALUE prec)
 {
-	VALUE w;
+	VALUE w, n;
 	
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	w = rb_bigmath_l2norm(rb_assoc_new(a, b), n);
 	
-	w = rb_bigmath_l2norm(rb_assoc_new(a, b), prec);
-	
-	return w;
+	return rb_num_round(w, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/hypot/mmm.h

@@ -6,8 +6,8 @@ hypot_mmm(VALUE a, VALUE b, VALUE prec)
 	VALUE n, m, two, four, t;
 
 	rb_check_precise(prec);
-
 	n = rb_numdiff_make_n(prec);
+
 	m = Qundef;
         two = rb_BigDecimal1(INT2FIX(2));
 	four = rb_BigDecimal1(INT2FIX(4));

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

@@ -7,11 +7,12 @@ ipow_edf(VALUE x, VALUE n, VALUE exp)
 	const ID geq = rb_intern(">=");
 	VALUE abs_n = Qundef, r = Qundef;
 
+	rb_check_precise(exp);
+
 	if (!rb_num_finite_p(x))
 		return BIG_NAN;
 	x = rb_num_canonicalize(x, exp, ARG_REAL, ARG_RAWVALUE);
-	abs_n = n;
-	if (rb_num_negative_p(n))  abs_n = rb_num_uminus(abs_n); // abs()
+	abs_n = rb_num_abs(n);
 	r = BIG_ONE;
 	while (rb_num_nonzero_p(abs_n))
 	{
@@ -28,6 +29,7 @@ ipow_edf(VALUE x, VALUE n, VALUE exp)
 		abs_n = rb_num_coerce_bit(abs_n, INT2FIX(1), r_shift);
 	}
 
-	return RTEST(rb_num_coerce_cmp(n, INT2FIX(0), geq)) ?
-		r : rb_funcall1(INT2FIX(1), '/', r);
+	if (!RTEST(rb_num_coerce_cmp(n, INT2FIX(0), geq)))
+		r = rb_funcall1(BIG_ONE, '/', r);
+	return r;
 }

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

@@ -42,7 +42,12 @@ bigmath_l2norm(VALUE vec, VALUE prec)
 VALUE
 l2norm_formula(VALUE vec, VALUE prec)
 {
+	VALUE y, n;
+
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	y = bigmath_l2norm(vec, n);
 
-	return bigmath_l2norm(vec, prec);
+	return rb_num_round(y, prec);
 }

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

@@ -1,7 +1,7 @@
 VALUE
 log_branch(VALUE x, VALUE prec, bigmath_func1 log_cb)
 {
-	VALUE y = Qundef;
+	VALUE y = Qundef, n;
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
@@ -27,8 +27,12 @@ log_branch(VALUE x, VALUE prec, bigmath_func1 log_cb)
 		{
 			const ID add = rb_intern("add");
 			VALUE exp, fra;
+
+			rb_check_precise(prec);
+			n = rb_numdiff_make_n(prec);
+
 			fra = rcm2_edf(x, &exp);
-			exp = rb_funcall1(rb_bigmath_const_log2(prec), '*', exp);
+			exp = rb_funcall1(rb_bigmath_const_log2(n), '*', exp);
 			fra = log_cb(fra, prec);
 			y = rb_funcall(exp, add, 2, fra, prec);
 		}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log/builtin.h

@@ -2,11 +2,12 @@ VALUE
 log_builtin(VALUE x, VALUE prec)
 {
 	const ID log = rb_intern("log");
-	VALUE y;
+	VALUE y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	y = rb_funcall(rb_mBigMath, log, 2, x, prec);
+	y = rb_funcall(rb_mBigMath, log, 2, x, n);
 
 	return rb_num_round(y, prec);
 }

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

@@ -1,10 +1,13 @@
 VALUE
 log_edf(VALUE x, VALUE prec)
 {
-	VALUE fra = Qundef, exp = Qundef, y = Qundef;
-	fra = rcm2_edf(x, &exp);
-	fra = logxt_edf(fra, INT2FIX(2), prec);
-	y = rb_funcall1(exp, '+', fra);
-	y = rb_funcall1(y, '*', rb_bigmath_const_log2(prec));
+	VALUE y = Qundef, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	y = logxt_edf(x, INT2FIX(2), n);
+	y = rb_funcall1(y, '*', rb_bigmath_const_log2(n));
+
 	return rb_num_round(y, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/log/edom.h

@@ -1,10 +1,16 @@
 VALUE
 log_edom(VALUE x, VALUE prec)
 {
-	VALUE y, pi = rb_bigmath_const_pi(prec);
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	VALUE y, pi = rb_bigmath_const_pi(prec), n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
 	RUBY_ASSERT (rb_num_negative_p(x));
 	x = rb_num_uminus(x);
-	y = rb_bigmath_log(x, prec);
-	return rb_Complex(y, pi);
+	y = rb_bigmath_log(x, n);
+	y = rb_Complex(y, pi);
+
+	return rb_num_round(y, prec);
 }

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

@@ -17,18 +17,16 @@ VALUE
 log_mercator(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE fra = Qundef, exp = Qundef, y = Qundef;
-	fra = rcm2_edf(x, &exp);
+	VALUE temp = Qundef, y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	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);
+	y = rb_funcall1(temp, '-', INT2FIX(1));
+        temp = rb_funcall(y, div, 2, temp, n);
+	temp = rb_num_uminus(temp);
+	temp = log1p_ser_mercator(temp, n);
+	y = rb_num_uminus(temp);
 
-	exp = rb_funcall1(exp, '*', rb_bigmath_const_log2(prec));
-	y = rb_funcall1(exp, '+', fra);
 	return rb_num_round(y, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/log/ser_okumura.h

@@ -9,8 +9,11 @@ log_ser_okumura(VALUE x, VALUE prec)
 	bool inv;
 	VALUE one = BIG_ONE;
 	VALUE two = rb_BigDecimal1(INT2FIX(2));
-	VALUE n = rb_numdiff_make_n(prec), m;
+	VALUE n, m;
 	VALUE k, x2, i, s, d, y;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 	
 	inv = RTEST(rb_num_coerce_cmp(x, INT2FIX(1), '>'));
 	if (inv)

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

@@ -1,11 +1,12 @@
 VALUE
 log10_edf(VALUE x, VALUE prec)
 {
-	VALUE y = Qundef;
+	VALUE y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	y = logxt_edf(x, INT2FIX(10), prec);
+	y = logxt_edf(x, INT2FIX(10), n);
 
 	return rb_num_round(y, prec);
 }

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

@@ -17,19 +17,19 @@ VALUE
 log10_mercator(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE fra = Qundef, exp = Qundef, y = Qundef;
+	VALUE temp = Qundef, y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	fra = rcm10_edf(x, &exp);
+	y = rb_funcall1(x, '-', INT2FIX(1));
+        temp = rb_funcall(y, div, 2, temp, n);
+	temp = rb_num_uminus(temp);
+	temp = log1p_ser_mercator(temp, n);
+	temp = rb_num_uminus(temp);
+	temp = rb_funcall(temp, div, 2, rb_bigmath_const_log10(n), n);
 
-	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_log10(prec), prec);
+	y = temp;
 
-	y = rb_funcall1(exp, '+', fra);
 	return rb_num_round(y, prec);
 }

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

@@ -1,8 +1,8 @@
 VALUE
-log1p_branch(VALUE x, VALUE prec, bigmath_func1 cb)
+log1p_branch(VALUE x, VALUE prec, bigmath_func1 log1p_cb)
 {
 	VALUE y = Qundef;
-	VALUE one_thousand = rb_Rational(INT2FIX(1), INT2FIX(1000));
+	VALUE one_thousand = rb_Rational(INT2FIX(1), INT2FIX(1000)), n;
 	const ID geq = rb_intern_const(">=");
 	const ID gt = rb_intern_const(">");
 
@@ -13,20 +13,23 @@ log1p_branch(VALUE x, VALUE prec, bigmath_func1 cb)
 		if (rb_num_nan_p(x))
 			y = BIG_NAN;
 		else
-			y = log_branch(x, prec, cb);
+			y = log_branch(x, prec, log1p_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);
+			y = log1p_cb(x, prec);
 		else if (RTEST(rb_num_coerce_cmp(INT2FIX(-1), x, gt)))
 			y = BIG_NAN;
 		else
 		{
+			rb_check_precise(prec);
+			n = rb_numdiff_make_n(prec);
+
 			x = rb_funcall1(x, '+', BIG_ONE);
-			y = rb_bigmath_log(x, prec);
+			y = rb_bigmath_log(x, n);
 			y = rb_num_round(y, prec);
 		}
 	}