bigdecimal-math_r 0.2.1 → 0.2.2

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

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