bigdecimal-math_r 0.2.0 → 0.2.2

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

@@ -3,15 +3,25 @@ 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;
+	VALUE n;
+	VALUE one;
+	VALUE w;
+	VALUE t;
+	VALUE d;
+	VALUE y;
 	int sign = 1;
 	VALUE m = Qundef;
 
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	one = BIG_ONE;
+	t = one;
+	d = BIG_ONE;
+	y = BIG_ZERO;
+
+	w = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
+
 	while (rb_numdiff_condition_p(y, d, n, &m))
 	{
 		d = rb_funcall(w, div, 2, t, m);

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

@@ -29,7 +29,7 @@ log2_branch(VALUE x, VALUE prec, bigmath_func1 log2_cb)
 			VALUE exp, fra;
 			fra = rcm2_edf(x, &exp);
 			exp = rb_BigDecimal1(exp);
-			fra = log2_cb(fra, prec);
+			fra = log2_cb(fra, rb_numdiff_make_n(prec));
 			y = rb_funcall(exp, add, 2, fra, prec);
 		}
 		else

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

@@ -1,11 +1,12 @@
 VALUE
 log2_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(2), prec);
+	y = logxt_edf(x, INT2FIX(2), n);
 
 	return rb_num_round(y, prec);
 }

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

@@ -17,19 +17,19 @@ VALUE
 log2_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 = rcm2_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_log2(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_log2(prec), prec);
+	y = temp;
 
-	y = rb_funcall1(exp, '+', fra);
 	return rb_num_round(y, prec);
 }

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

@@ -4,7 +4,12 @@ logxt_edf(VALUE x, VALUE t, VALUE prec)
 	const ID mult = rb_intern("mult");
 	VALUE a, b, s, one_half, n, m;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
+
+	if (!rb_num_finite_p(x) || !rb_num_finite_p(t))
+		return BIG_NAN;
+
 	a = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
 	b = BIG_ONE;
 	s = BIG_ZERO;
@@ -29,5 +34,5 @@ logxt_edf(VALUE x, VALUE t, VALUE prec)
 	RB_GC_GUARD(s);
 	RB_GC_GUARD(one_half);
 
-	return s;
+	return rb_num_round(s, prec);
 }

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

@@ -1,30 +1,35 @@
 VALUE
 pow_formula(VALUE x, VALUE y, VALUE prec)
 {
-	VALUE a = Qundef;
+	VALUE a = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
 	if (!rb_num_real_p(x))
-		rb_raise(rb_eTypeError, "not a Real");
+		goto not_a_real_error;
 	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);
+			a = ipow_edf(x, y, n);
 		else // if (rb_num_negative_p(rb_num_real(x)))
-			a = rb_num_uminus(ipow_edf(rb_num_abs(x), y, prec));
+			a = rb_num_uminus(ipow_edf(rb_num_abs(x), y, n));
 	}
 	else if (rb_num_real_p(y))
 	{
-		a = rb_bigmath_log(rb_num_abs(x), prec);
+		a = rb_bigmath_log(rb_num_abs(x), n);
 		a = rb_funcall1(y, '*', a);
-		a = rb_bigmath_exp(a, prec);
+		a = rb_bigmath_exp(a, n);
 		if (rb_num_negative_p(x))
 			a = rb_num_uminus(a);
 	}
 	else
-		rb_raise(rb_eTypeError, "not a Real");
+		goto not_a_real_error;
+
+	return rb_num_round(a, prec);
 
-	return a;
+not_a_real_error:
+	rb_raise(rb_eTypeError, "not a Real");
 }

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

@@ -4,7 +4,9 @@ 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;
+		const ID succ = rb_intern("succ");
+		const ID pred = rb_intern("pred");
+		VALUE resov = LONG2FIX(0);
 		bool has_sign = RTEST(rb_num_coerce_cmp(x, INT2FIX(0), '<'));
 		VALUE rat_ten = rb_rational_new1(INT2FIX(10));
 		fra = rb_Rational1(fra);
@@ -15,7 +17,9 @@ rcm10_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(fra, INT2FIX(10), rb_intern(">="))))
 			{
 				fra = rb_funcall1(fra, '/', rat_ten);
-				resov++;
+				resov = TYPE(resov) == T_FIXNUM ? 
+					LONG2FIX(FIX2LONG(resov) + 1) : 
+					rb_funcall(resov, succ, 0);
 			}
 		}
 		else if (RTEST(rb_num_coerce_cmp(fra, INT2FIX(1), '<')))
@@ -23,12 +27,14 @@ rcm10_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(fra, INT2FIX(1), '<')))
 			{
 				fra = rb_funcall1(fra, '*', rat_ten);
-				resov--;
+				resov = TYPE(resov) == T_FIXNUM ? 
+					LONG2FIX(FIX2LONG(resov) - 1) : 
+					rb_funcall(resov, pred, 0);
 			}
 		}
 		if (has_sign)
 			fra = rb_num_uminus(fra);
-		*reso = LONG2FIX(resov);
+		*reso = resov;
 	}
 	return fra;
 }

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

@@ -1,10 +1,14 @@
 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;
+		const ID succ = rb_intern("succ");
+		const ID pred = rb_intern("pred");
+		VALUE resov = LONG2FIX(0);
 		bool has_sign = RTEST(rb_num_coerce_cmp(x, INT2FIX(0), '<'));
 		VALUE rat_two = rb_rational_new1(INT2FIX(2));
 		fra = rb_Rational1(fra);
@@ -15,7 +19,9 @@ rcm2_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(INT2FIX(2), fra, rb_intern("<="))))
 			{
 				fra = rb_funcall1(fra, '/', rat_two);
-				resov++;
+				TYPE(resov) == T_FIXNUM ? 
+					LONG2FIX(FIX2LONG(resov) + 1) : 
+					rb_funcall(resov, succ, 0);
 			}
 		}
 		else
@@ -23,7 +29,9 @@ rcm2_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(INT2FIX(1), fra, '>')))
 			{
 				fra = rb_funcall1(fra, '*', rat_two);
-				resov--;
+				TYPE(resov) == T_FIXNUM ? 
+					LONG2FIX(FIX2LONG(resov) - 1) : 
+					rb_funcall(resov, pred, 0);
 			}
 		}
 		if (has_sign)

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

@@ -1,11 +1,13 @@
 VALUE
 sec_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_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/sec/ser.h

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

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

@@ -1,11 +1,13 @@
 VALUE
 sech_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	y = trig_f_euler(mf_cos, x, prec);
+	y = trig_f_euler(mf_cos, x, n);
+	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/sech/formula.h

@@ -2,9 +2,13 @@ VALUE
 sech_formula(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE n = rb_numdiff_make_n(prec);
-	VALUE t = rb_bigmath_exp(x, n), y = Qundef;
-	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE n, t, two, y = Qundef;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	t = rb_bigmath_exp(x, n);
+	two = rb_BigDecimal1(INT2FIX(2));
 
 	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
 	{
@@ -16,7 +20,7 @@ sech_formula(VALUE x, VALUE prec)
 		y = BIG_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/sech/ser.h

@@ -1,11 +1,13 @@
 VALUE
 sech_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, NULL, &y);
+	sinhcosh_ser(x, n, NULL, &y);
+	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/sin/eulerf.h

@@ -2,10 +2,13 @@ VALUE
 sin_eulerf(VALUE z, VALUE prec)
 {
 	const ID sin = rb_intern("sin");
+	VALUE n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	z = trig_f_euler(sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+	z = trig_f_euler(sin, rb_ImaginaryZ(z, SIGN_PLUS), n);
+	z = rb_num_real(z);
 
-	return rb_num_real(z);
+	return rb_num_round(z, prec);
 }

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

@@ -1,13 +1,12 @@
 VALUE
 sin_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_round(sin, prec);
-
-	return sin;
+	return rb_num_round(sin, prec);
 }

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

@@ -4,23 +4,28 @@ sincos_ser(VALUE x, VALUE prec, VALUE *sin, VALUE *cos)
 	const ID div = rb_intern("div");
 	VALUE n, m, f, w, a, y;
 	long i = 0;
-	
+
 	if (sin == NULL && cos == NULL)
 		return;
-	
+
+
 	if (!rb_num_finite_p(x))
 	{
 		if (sin != NULL)  *sin = BIG_NAN;
 		if (cos != NULL)  *cos = BIG_NAN;
 		return;
 	}
+
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
+
 	f = BIG_ONE;
 	w = BIG_ONE;
 	a = BIG_ONE;
 	y = BIG_ZERO;
 	if (sin != NULL)  *sin = BIG_ZERO;
 	if (cos != NULL)  *cos = BIG_ZERO;
+
 	while (rb_numdiff_condition_p(y, a, n, &m))
 	{
 		a = rb_funcall(w, div, 2, f, m);
@@ -41,10 +46,12 @@ sincos_ser(VALUE x, VALUE prec, VALUE *sin, VALUE *cos)
 		w = rb_funcall1(w, '*', x);
 		f = rb_funcall1(f, '*', LONG2NUM(++i));
 	}
+
 	RB_GC_GUARD(f);
 	RB_GC_GUARD(w);
 	RB_GC_GUARD(a);
 	RB_GC_GUARD(y);
+
 	if (sin != NULL)  RB_GC_GUARD(*sin);
 	if (cos != NULL)  RB_GC_GUARD(*cos);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 sinh_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y = Qundef, 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_real(y);
 
-	return rb_num_real(y);
+	return rb_num_round(y, prec);
 }

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

@@ -2,11 +2,15 @@ VALUE
 sinh_formula(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE n = rb_numdiff_make_n(prec);
-	VALUE t = rb_bigmath_exp(x, n), y = Qundef;
-	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE n, t, y = Qundef, two;
 	int sign;
 
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	t = rb_bigmath_exp(x, n);
+	two = rb_BigDecimal1(INT2FIX(2));
+
 	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
 	{
 		y = rb_Rational(INT2FIX(1), t);
@@ -17,7 +21,7 @@ sinh_formula(VALUE x, VALUE prec)
 		y = sign == 1 ? BIG_INF : BIG_MINUS_INF;
 	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(y, div, 2, two, prec);
 	}

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

@@ -1,11 +1,12 @@
 VALUE
 sinh_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 y;
+	return rb_num_round(y, prec);
 }

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

@@ -10,9 +10,9 @@ sinhcosh_inline(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
 	w = BIG_ONE;
 	a = BIG_ONE;
 	y = BIG_ZERO;
-	
 	if (sinh != NULL)  *sinh = BIG_ZERO;
 	if (cosh != NULL)  *cosh = BIG_ZERO;
+
 	while (rb_numdiff_condition_p(y, a, n, &m))
 	{
 		a = rb_funcall(w, div, 2, f, m);
@@ -27,10 +27,12 @@ sinhcosh_inline(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
 		w = rb_funcall1(w, '*', x);
 		f = rb_funcall1(f, '*', LONG2NUM(++i));
 	}
+
 	RB_GC_GUARD(f);
 	RB_GC_GUARD(w);
 	RB_GC_GUARD(a);
 	RB_GC_GUARD(y);
+
 	if (sinh != NULL)  RB_GC_GUARD(*sinh);
 	if (cosh != NULL)  RB_GC_GUARD(*cosh);
 }
@@ -38,8 +40,13 @@ sinhcosh_inline(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
 void
 sinhcosh_ser(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
 {
+	VALUE n;
 	int sign;
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	rb_check_precise(prec);
+
+	n = rb_numdiff_make_n(prec);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
 	
 	if (sinh == NULL && cosh == NULL)  return;
 	
@@ -63,7 +70,7 @@ sinhcosh_ser(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
 	}
 	else
 	{
-		sinhcosh_inline(x, prec, sinh, cosh);
+		sinhcosh_inline(x, n, sinh, cosh);
 		if (sinh != NULL)  *sinh = rb_num_round(*sinh, prec);
 		if (cosh != NULL)  *cosh = rb_num_round(*cosh, prec);
 	}

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

@@ -2,7 +2,8 @@ VALUE
 sqrt_branch(VALUE x, VALUE prec, bigmath_func1 sqrt_cb)
 {
 #define SWITCH_PRECISION_NUMBER 2253
-	rb_check_precise(prec);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
 	if (rb_num_negative_p(x))
 		return BIG_NAN;
 	else if (!rb_num_finite_p(x))

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

@@ -5,8 +5,8 @@ sqrt_builtin(VALUE x, VALUE prec)
 
 	rb_check_precise(prec);
 
-	if (rb_num_negative_p(x) || rb_num_notequal_p(x, x))
+	if (rb_num_negative_p(x) || rb_num_nan_p(x))
 		return BIG_NAN;
 
-	return rb_funcall(x, sqrt, 1, prec);
+	return rb_num_round(rb_funcall(x, sqrt, 1, prec), prec);
 }

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

@@ -5,5 +5,6 @@ sqrt_edom(VALUE x, VALUE prec)
 	RUBY_ASSERT(rb_num_negative_p(x));
 	x = rb_num_uminus(x);
 	imag = rb_bigmath_sqrt(x, prec);
+
 	return rb_num_round(rb_Complex(BIG_ZERO, imag), prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 tan_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);
+	w = rb_num_real(w);
 
-	return rb_num_real(w);
+	return rb_num_round(w, prec);
 }

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

@@ -2,17 +2,12 @@ VALUE
 tan_ser(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE sin, cos;
+	VALUE sin, cos, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	if (!rb_num_finite_p(x))
-		return BIG_NAN;
-	rb_check_precise(prec);
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
-	rb_bigmath_sincos(x, prec, &sin, &cos);
-	sin = rb_num_round(sin, prec);
-	cos = rb_num_round(cos, prec);
+	rb_bigmath_sincos(x, n, &sin, &cos);
 
 	return rb_funcall(sin, div, 2, cos, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 tanh_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	y = rb_ImaginaryZ(trig_f_euler(mf_tan, x, prec), SIGN_PLUS);
+	y = rb_ImaginaryZ(trig_f_euler(mf_tan, x, n), SIGN_PLUS);
+	y = rb_num_real(y);
 
-	return rb_num_real(y);
+	return rb_num_round(y, prec);
 }

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

@@ -4,11 +4,15 @@ tanh_formula(VALUE x, VALUE prec)
 	const ID pred = rb_intern("pred");
 	const ID succ = rb_intern("succ");
 	const ID div = rb_intern("div");
-	VALUE n = rb_numdiff_make_n(prec);
-	VALUE two = rb_BigDecimal1(INT2FIX(2));
-        VALUE t = rb_bigmath_exp(rb_funcall1(x, '*', two), n), y = Qundef;
+	VALUE n, two, t, y = Qundef;
 	int sign;
 
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	two = rb_BigDecimal1(INT2FIX(2));
+        t = rb_bigmath_exp(rb_funcall1(x, '*', two), n);
+
 	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
 	{
 		y = rb_Rational(rb_funcall(t, pred, 0), rb_funcall(t, succ, 0));

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

@@ -1,13 +1,13 @@
 VALUE
 tanh_ser(VALUE x, VALUE prec)
 {
-	VALUE y = Qundef, sinh = Qundef, cosh = Qundef;
+	VALUE y = Qundef, sinh = Qundef, cosh = Qundef, n;
 	const ID div = rb_intern("div");
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	sinhcosh_ser(x, prec, &sinh, &cosh);
-
+	sinhcosh_ser(x, n, &sinh, &cosh);
 	y = rb_funcall(sinh, div, 2, cosh, prec);
 
 	return y;