bigdecimal-math_r 0.2.1 → 0.2.3

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

@@ -1,21 +1,22 @@
 VALUE
 cpow_formula(VALUE z, VALUE w, VALUE prec)
 {
-	VALUE a = Qundef;
+	VALUE a = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	if (rb_num_positive_p(rb_num_real(z)) &&
 	    rb_num_zero_p(rb_num_imag(z)) && rb_num_zero_p(rb_num_imag(w)))
 	{
-		a = pow_formula(rb_num_real(z), rb_num_real(w), prec);
-		a = rb_num_canonicalize(a, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		a = pow_formula(rb_num_real(z), rb_num_real(w), n);
+		a = rb_num_canonicalize(a, n, ARG_COMPLEX, ARG_RAWVALUE);
 	}
 	else
 	{
-		a = rb_bigmath_clog(z, prec);
+		a = rb_bigmath_clog(z, n);
 		a = rb_funcall1(w, '*', a);
-		a = rb_bigmath_cexp(a, prec);
+		a = rb_bigmath_cexp(a, n);
 	}
-	return a;
+	return rb_num_round(a, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 csc_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_sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+	w = rb_num_canonicalize(w, n, ARG_REAL, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(w, prec, ARG_REAL, ARG_RECIPROCAL);
+	return rb_num_round(w, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/csc/ser.h

@@ -1,11 +1,13 @@
 VALUE
 csc_ser(VALUE x, VALUE prec)
 {
-	VALUE sin;
+	VALUE sin, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	rb_bigmath_sincos(x, prec, &sin, NULL);
+	rb_bigmath_sincos(x, n, &sin, NULL);
+	sin = rb_num_canonicalize(sin, n, ARG_REAL, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(sin, prec, ARG_REAL, ARG_RECIPROCAL);
+	return rb_num_round(sin, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 csch_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	y = rb_ImaginaryZ(trig_f_euler(mf_sin, x, prec), SIGN_PLUS);
+	y = rb_ImaginaryZ(trig_f_euler(mf_sin, x, n), SIGN_PLUS);
+	y = rb_num_canonicalize(y, n, ARG_REAL, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+	return rb_num_round(y, prec);
 }

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

@@ -6,8 +6,8 @@ csch_formula(VALUE x, VALUE prec)
 	int sign;
 
 	rb_check_precise(prec);
-
 	n = rb_numdiff_make_n(prec);
+
 	t = rb_bigmath_exp(x, n);
 	y = Qundef;
 	two = rb_BigDecimal1(INT2FIX(2));
@@ -22,7 +22,7 @@ csch_formula(VALUE x, VALUE prec)
 		y = sign == 1 ? BIG_ZERO : BIG_MINUS_ZERO;
 	else
 	{
-		y = rb_num_canonicalize(t, prec, ARG_REAL, ARG_RECIPROCAL);
+		y = rb_num_canonicalize(t, n, ARG_REAL, ARG_RECIPROCAL);
 		y = rb_funcall1(t, '-', y);
 		y = rb_funcall(two, div, 2, y, prec);
 	}

data/ext/bigdecimal/math_r/internal/algo/bigmath/csch/ser.h

@@ -1,11 +1,14 @@
 VALUE
 csch_ser(VALUE x, VALUE prec)
 {
-	VALUE y = Qundef;
+	VALUE y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	sinhcosh_ser(x, prec, &y, NULL);
+	sinhcosh_ser(x, n, &y, NULL);
 
-	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+	y = rb_num_canonicalize(y, n, ARG_REAL, ARG_RECIPROCAL);
+
+	return rb_num_round(y, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 csec_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_cos, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+	w = trig_f_euler(mf_cos, rb_ImaginaryZ(z, SIGN_PLUS), n);
+	w = rb_num_canonicalize(w, n, ARG_COMPLEX, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(w, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+	return rb_num_round(w, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 csech_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_cos, z, prec);
+	w = trig_f_euler(mf_cos, z, n);
+	w = rb_num_canonicalize(w, n, ARG_COMPLEX, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(w, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+	return rb_num_round(w, prec);
 }

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

@@ -1,11 +1,12 @@
 VALUE
 csin_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_sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+	w = trig_f_euler(mf_sin, rb_ImaginaryZ(z, SIGN_PLUS), n);
 
-	return w;
+	return rb_num_round(w, prec);
 }

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

@@ -1,11 +1,12 @@
 VALUE
 csinh_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_sin, z, prec), SIGN_PLUS);
+	w = rb_ImaginaryZ(trig_f_euler(mf_sin, z, n), SIGN_PLUS);
 
-	return w;
+	return rb_num_round(w, prec);
 }

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

@@ -0,0 +1,40 @@
+VALUE
+csqrt_branch(VALUE z, VALUE prec, bigmath_func1 csqrt_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(z))
+	{
+		w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (!rb_num_finite_p(z))
+	{
+		int re_sgn = rb_num_infinite_p(rb_num_real(z));
+		int im_sgn = rb_num_infinite_p(rb_num_imag(z));
+		if (re_sgn != 0 && im_sgn == 0)
+		{
+			switch (re_sgn) {
+			case 1:
+				w = rb_Complex1(BIG_INF);
+				break;
+			case -1:
+				w = rb_Complex(BIG_ZERO, BIG_INF);
+				break;
+			}
+		}
+		else
+		{
+			w = rb_Complex(
+				BIG_INF,
+				rb_num_coerce_bin(im_sgn, BIG_INF, '*')
+			);
+		}
+	}
+	if (w == Qundef)
+	{
+		w = csqrt_cb(z, prec);
+	}
+	return w;
+}

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));