bigdecimal-math_r 0.2.0 → 0.2.2

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

@@ -10,7 +10,7 @@ atan_branch(VALUE x, VALUE prec, bigmath_func1 atan_cb)
 	if (rb_num_zero_p(x))
 		y = BIG_ZERO;
 	else
-		y = atan_cb(x, prec);
+		y = rb_bigmath_atan_adopt(x, prec, atan_cb);
 
 	return y;
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/atan/logrep.h

@@ -1,14 +1,15 @@
 VALUE
 atan_logrep(VALUE x, VALUE prec)
 {
-	VALUE n, m, y;
+	VALUE n1, m1, y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	n = rb_Complex(BIG_ONE, x);
-	m = rb_bigmath_sqrt(rb_funcall1(BIG_ONE, '+', rb_funcall1(x, '*', x)), prec);
-	y = rb_funcall1(n, '/', m);
-	y = rb_bigmath_carg(y, prec);
+	n1 = rb_Complex(BIG_ONE, x);
+	m1 = rb_bigmath_sqrt(rb_funcall1(BIG_ONE, '+', rb_funcall1(x, '*', x)), n);
+	y = rb_funcall1(n1, '/', m1);
+	y = rb_bigmath_carg(y, n);
 
-	return y;
+	return rb_num_round(y, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/atan/ser_euler.h

@@ -1,6 +1,5 @@
-#if 1
-static VALUE
-atan_ser_euler_inline(VALUE x, VALUE prec)
+VALUE
+atan_ser_euler(VALUE x, VALUE prec)
 {
 	const ID add = rb_intern("add");
 	const ID mult = rb_intern("mult");
@@ -10,6 +9,8 @@ atan_ser_euler_inline(VALUE x, VALUE prec)
 	VALUE m, y, w, t, s;
 	long n = 1;
 
+	rb_check_precise(prec);
+
 	if (rb_num_zero_p(x))
 		return BIG_ZERO;
 
@@ -35,50 +36,3 @@ atan_ser_euler_inline(VALUE x, VALUE prec)
 	};
 	return rb_funcall(rb_funcall(y, div, 2, x, prec), mult, 2, s, prec);
 }
-#else
-static VALUE
-atan_ser_euler_inline(VALUE x, VALUE prec)
-{
-	const ID add = rb_intern("add");
-	const ID mult = rb_intern("mult");
-	const ID div = rb_intern("div");
-	VALUE n, m, wt, w, r, y, d;
-
-	if (rb_num_zero_p(x))
-		return BIG_ZERO;
-
-	n = rb_numdiff_make_n(prec);
-
-	wt = rb_funcall(
-		rb_funcall(x, mult, 2, x, n), div, 2,
-		rb_funcall(BIG_ONE, add, 2, rb_funcall(x, mult, 2, x, n),
-		n), n);
-	w = BIG_ONE;
-	r = BIG_ONE;
-	y = BIG_ZERO;
-	d = BIG_ONE;
-
-	while (rb_numdiff_condition_p(y, d, n, &m))
-	{
-		d = rb_funcall(r, mult, 2, w, m);
-		y = rb_funcall1(y, '+', d);
-		r = rb_funcall1(r, '*', LONG2NUM(++n));
-		r = rb_funcall1(r, '/', LONG2NUM(++n));
-		w = rb_funcall1(w, '*', wt);
-	}
-
-	RB_GC_GUARD(wt);
-	RB_GC_GUARD(w);
-	RB_GC_GUARD(r);
-	RB_GC_GUARD(y);
-	RB_GC_GUARD(d);
-
-	return rb_funcall(rb_funcall(wt, div, 2, x, prec), mult, 2, y, prec);
-}
-#endif
-
-VALUE
-atan_ser_euler(VALUE x, VALUE prec)
-{
-	return rb_bigmath_atan_adopt(x, prec, atan_ser_euler_inline);
-}

data/ext/bigdecimal/math_r/internal/algo/bigmath/atan/ser_usual.h

@@ -1,5 +1,5 @@
-static VALUE
-atan_ser_usual_inline(VALUE x, VALUE prec)
+VALUE
+atan_ser_usual(VALUE x, VALUE prec)
 {
 	const ID mult = rb_intern("mult");
 	const ID div = rb_intern("div");
@@ -32,10 +32,3 @@ atan_ser_usual_inline(VALUE x, VALUE prec)
 
 	return y;
 }
-
-
-VALUE
-atan_ser_usual(VALUE x, VALUE prec)
-{
-	return rb_bigmath_atan_adopt(x, prec, atan_ser_usual_inline);
-}

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

@@ -2,12 +2,13 @@ VALUE
 atanh_branch(VALUE x, VALUE prec, bigmath_func1 atanh_cb)
 {
 	const ID leq = rb_intern("<=");
-	VALUE y = Qundef, p0999 = rb_BigDecimal1(rb_str_new_cstr("0.999"));
+	VALUE y = Qundef;
+	VALUE p0999 = rb_BigDecimal1(rb_str_new_cstr("0.999"));
+	VALUE domain = rb_range_new(INT2FIX(-1), INT2FIX(1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
-	if (RTEST(rb_num_coerce_cmp(INT2FIX(-1), x, leq)) &&
-	    RTEST(rb_num_coerce_cmp(x, INT2FIX(1), leq)))
+	if (rb_num_domain_p(domain, x))
 	{
 		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
 		if (rb_num_equal_p(absx, INT2FIX(1)))

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

@@ -1,14 +1,17 @@
 VALUE
 atanh_edom(VALUE x, VALUE prec)
 {
-	VALUE t, pi;
+	VALUE t, pi, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	t = rb_funcall1(
 		rb_funcall1(BIG_ONE, '+', x), '/', 
 		rb_funcall1(BIG_ONE, '-', x));
-	pi = rb_bigmath_const_pi(prec);
+	pi = rb_bigmath_const_pi(n);
 	t = rb_Complex(
-		rb_bigmath_log(rb_num_abs(t), prec), 
+		rb_bigmath_log(rb_num_abs(t), n), 
 		rb_num_negative_p(x) ? pi : rb_num_uminus(pi));
 	t = rb_funcall1(rb_Rational(INT2FIX(1), INT2FIX(2)), '*', t);
 

data/ext/bigdecimal/math_r/internal/algo/bigmath/atanh/logrep.h

@@ -5,6 +5,8 @@ atanh_logrep(VALUE x, VALUE prec)
 	const ID mult = rb_intern("mult");
 	VALUE n, half;
 
+	rb_check_precise(prec);
+
 	n = rb_numdiff_make_n(prec);
 	half = rb_BigDecimal1(rb_str_new_cstr("0.5"));
 

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

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

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

@@ -1,8 +1,12 @@
 VALUE
 cabs_formula(VALUE z, VALUE prec)
 {
+	VALUE w, n;
+	
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	return rb_bigmath_l2norm(
-		rb_assoc_new(rb_num_real(z), rb_num_imag(z)), prec);
+	w = rb_bigmath_l2norm(
+		rb_assoc_new(rb_num_real(z), rb_num_imag(z)), n);
+	return rb_num_round(w, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacos/logrep.h

@@ -2,14 +2,17 @@ VALUE
 cacos_logrep(VALUE z, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE c1, c2, c3, c4, c5, c6;
+	VALUE c1, c2, c3, c4, c5, c6, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	c1 = rb_ImaginaryZ(z, SIGN_PLUS);
 	c2 = rb_bigmath_csqrt(rb_funcall1(BIG_ONE, '-', 
-		rb_funcall1(z, '*', z)), prec);
-	c3 = rb_bigmath_clog(rb_funcall1(c1, '+', c2), prec);
+		rb_funcall1(z, '*', z)), n);
+	c3 = rb_bigmath_clog(rb_funcall1(c1, '+', c2), n);
 	c4 = rb_ImaginaryZ(c3, SIGN_PLUS);
-	c5 = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+	c5 = rb_funcall(rb_bigmath_const_pi(n), div, 2, INT2FIX(2), n);
 	c6 = rb_funcall1(c5, '+', c4);
 
 	return rb_num_round(c6, prec);

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacosh/logrep.h

@@ -1,17 +1,18 @@
 VALUE
 cacosh_logrep(VALUE z, VALUE prec)
 {
-	VALUE c1, c2, c3;
+	VALUE c1, c2, c3, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	c2 = rb_funcall1(z, '+', BIG_ONE);
-	c2 = rb_bigmath_csqrt(c2, prec);
+	c2 = rb_bigmath_csqrt(c2, n);
 	c3 = rb_funcall1(z, '-', BIG_ONE);
-	c3 = rb_bigmath_csqrt(c3, prec);
+	c3 = rb_bigmath_csqrt(c3, n);
 	c1 = rb_funcall1(c2, '*', c3);
 	c1 = rb_funcall1(z, '+', c1);
-	c1 = rb_bigmath_clog(c1, prec);
+	c1 = rb_bigmath_clog(c1, n);
 
-	return c1;
+	return rb_num_round(c1, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacot/logrep.h

@@ -1,14 +1,15 @@
 VALUE
 cacot_logrep(VALUE z, VALUE prec)
 {
-	VALUE c1, c2, c3;
+	VALUE c1, c2, c3, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	c1 = rb_ImaginaryZ(z, SIGN_PLUS);
 	c2 = rb_funcall1(rb_funcall1(c1, '-', BIG_ONE), '/', 
 	                 rb_funcall1(c1, '+', BIG_ONE));
-	c3 = rb_bigmath_clog(c2, prec);
+	c3 = rb_bigmath_clog(c2, n);
 
 	c1 = rb_funcall1(rb_Complex(INT2FIX(0), INT2FIX(1)), '/', INT2FIX(2));
 	c2 = rb_funcall1(rb_num_uminus(c1), '*', c3);

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacoth/logrep.h

@@ -1,11 +1,15 @@
 VALUE
 cacoth_logrep(VALUE z, VALUE prec)
 {
+	VALUE n;
+
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	z = rb_num_canonicalize(z, n, ARG_COMPLEX, ARG_RAWVALUE);
 	z = rb_ImaginaryZ(z, SIGN_MINUS);
-	z = cacot_logrep(z, prec);
-
-	return rb_ImaginaryZ(z, SIGN_MINUS);
+	z = cacot_logrep(z, n);
+	z = rb_ImaginaryZ(z, SIGN_MINUS);
+	
+	return rb_num_round(z, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacsc/logrep.h

@@ -1,18 +1,19 @@
 VALUE
 cacsc_logrep(VALUE z, VALUE prec)
 {
-	VALUE y;
+	VALUE y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	y = rb_funcall1(z, '*', z);
 	y = rb_funcall1(BIG_ONE, '/', y);
 	y = rb_funcall1(BIG_ONE, '-', y);
-	y = rb_bigmath_csqrt(y, prec);
+	y = rb_bigmath_csqrt(y, n);
 	y = rb_Complex(y, 
 		rb_num_canonicalize(
-			rb_num_uminus(z), prec, ARG_COMPLEX, ARG_RECIPROCAL));
-	y = rb_bigmath_clog(y, prec);
+			rb_num_uminus(z), n, ARG_COMPLEX, ARG_RECIPROCAL));
+	y = rb_bigmath_clog(y, n);
 	y = rb_ImaginaryZ(y, SIGN_PLUS);
 
 	return rb_num_round(y, prec);

data/ext/bigdecimal/math_r/internal/algo/bigmath/cacsch/logrep.h

@@ -1,11 +1,15 @@
 VALUE
 cacsch_logrep(VALUE z, VALUE prec)
 {
+	VALUE n;
+
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	z = rb_num_canonicalize(z, n, ARG_COMPLEX, ARG_RAWVALUE);
+	z = rb_ImaginaryZ(z, SIGN_PLUS);
+	z = cacsc_logrep(z, n);
 	z = rb_ImaginaryZ(z, SIGN_PLUS);
-	z = cacsc_logrep(z, prec);
 
-	return rb_ImaginaryZ(z, SIGN_PLUS);
+	return rb_num_round(z, prec);
 }

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

@@ -1,8 +1,12 @@
 VALUE
 carg_formula(VALUE z, VALUE prec)
 {
+	VALUE n;
+
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	return rb_bigmath_quadrant(
-		rb_num_real(z), rb_num_imag(z), prec);
+	z = rb_bigmath_quadrant(rb_num_real(z), rb_num_imag(z), n);
+	
+	return rb_num_round(z, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/casec/logrep.h

@@ -1,17 +1,18 @@
 VALUE
 casec_logrep(VALUE z, VALUE prec)
 {
-	VALUE w;
+	VALUE w, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	w = rb_funcall1(z, '*', z);
 	w = rb_funcall1(BIG_ONE, '/', w);
 	w = rb_funcall1(BIG_ONE, '-', w);
-	w = rb_bigmath_csqrt(w, prec);
+	w = rb_bigmath_csqrt(w, n);
 	w = rb_funcall1(rb_ImaginaryZ(w, SIGN_PLUS), '+', 
-		rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RECIPROCAL));
-	w = rb_bigmath_clog(w, prec);
+		rb_num_canonicalize(z, n, ARG_COMPLEX, ARG_RECIPROCAL));
+	w = rb_bigmath_clog(w, n);
 	w = rb_ImaginaryZ(w, SIGN_MINUS);
 
 	return rb_num_round(w, prec);

data/ext/bigdecimal/math_r/internal/algo/bigmath/casech/logrep.h

@@ -1,9 +1,11 @@
 VALUE
 casech_logrep(VALUE z, VALUE prec)
 {
+	VALUE n;
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+	z = rb_num_canonicalize(z, n, ARG_COMPLEX, ARG_RECIPROCAL);
 
 	return cacosh_logrep(z, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/casin/logrep.h

@@ -1,14 +1,16 @@
 VALUE
 casin_logrep(VALUE z, VALUE prec)
 {
-	VALUE c1, c2, c3;
+	VALUE c1, c2, c3, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	c1 = rb_ImaginaryZ(z, SIGN_PLUS);
 	c2 = rb_bigmath_csqrt(
-		rb_funcall1(BIG_ONE, '-', rb_funcall1(z, '*', z)), prec);
-	c3 = rb_bigmath_clog(rb_funcall1(c1, '+', c2), prec);
+		rb_funcall1(BIG_ONE, '-', rb_funcall1(z, '*', z)), n);
+	c3 = rb_bigmath_clog(rb_funcall1(c1, '+', c2), n);
+	z = rb_ImaginaryZ(c3, SIGN_MINUS);
 
-	return rb_ImaginaryZ(c3, SIGN_MINUS);
+	return rb_num_round(z, prec);
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/casinh/logrep.h

@@ -3,6 +3,7 @@ casinh_logrep(VALUE z, VALUE prec)
 {
 	VALUE n, t, y;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	t = rb_funcall1(rb_funcall1(z, '*', z), '+', BIG_ONE);

data/ext/bigdecimal/math_r/internal/algo/bigmath/catan/logrep.h

@@ -1,14 +1,15 @@
 VALUE
 catan_logrep(VALUE z, VALUE prec)
 {
-	VALUE c1, c2, c3;
+	VALUE c1, c2, c3, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	c1 = rb_ImaginaryZ(z, SIGN_PLUS);
 	c2 = rb_funcall1(rb_Complex(BIG_ONE, rb_num_uminus(z)), '/', 
 	                 rb_Complex(BIG_ONE, z));
-	c3 = rb_bigmath_clog(c2, prec);
+	c3 = rb_bigmath_clog(c2, n);
 
 	c1 = rb_Complex(INT2FIX(0), rb_Rational(INT2FIX(1), INT2FIX(2)));
 	c2 = rb_funcall1(c1, '*', c3);

data/ext/bigdecimal/math_r/internal/algo/bigmath/catanh/logrep.h

@@ -1,10 +1,13 @@
 VALUE
 catanh_logrep(VALUE z, VALUE prec)
 {
+	VALUE n;
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	z = rb_ImaginaryZ(z, SIGN_PLUS);
-	z = catan_logrep(z, prec);
+	z = catan_logrep(z, n);
+	z = rb_ImaginaryZ(z, SIGN_MINUS);
 
-	return rb_ImaginaryZ(z, SIGN_MINUS);
+	return rb_num_round(z, prec);
 }

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

@@ -0,0 +1,40 @@
+VALUE
+ccbrt_branch(VALUE z, VALUE prec, bigmath_func1 ccbrt_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 = ccbrt_cb(z, prec);
+	}
+	return w;
+}

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

@@ -1,11 +1,14 @@
 VALUE
 ccbrt_formula(VALUE z, VALUE prec)
 {
-	VALUE one_third;
+	VALUE one_third, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	one_third = rb_Rational(INT2FIX(1), INT2FIX(3));
 
-	return rb_bigmath_cpow(z, one_third, prec);
+	z = rb_bigmath_cpow(z, one_third, n);
+	
+	return rb_num_round(z, prec);
 }

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

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

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

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

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

@@ -1,11 +1,13 @@
 VALUE
 ccot_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_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/ccoth/eulerf.h

@@ -1,11 +1,13 @@
 VALUE
 ccoth_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_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/ccsc/eulerf.h

@@ -1,11 +1,13 @@
 VALUE
 ccsc_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_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/ccsch/eulerf.h

@@ -1,11 +1,13 @@
 VALUE
 ccsch_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);
+	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/cexp/eulerf.h

@@ -2,20 +2,23 @@ VALUE
 cexp_eulerf(VALUE z, VALUE prec)
 {
 	const ID mult = rb_intern("mult");
-	VALUE theta, r;
+	VALUE theta, r, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	if (!rb_num_finite_p(rb_num_imag(z)))
 		return rb_Complex(BIG_NAN, BIG_NAN);
-	r = rb_num_canonicalize(rb_num_real(z), prec, ARG_REAL, ARG_RAWVALUE);
-	r = rb_bigmath_exp(r, prec);
+	r = rb_num_canonicalize(rb_num_real(z), n, ARG_REAL, ARG_RAWVALUE);
+	r = rb_bigmath_exp(r, n);
 	if (rb_num_notequal_p(r, r))
 		return rb_Complex(BIG_NAN, BIG_NAN);
-	theta = f_euler_formula(rb_num_imag(z), prec);
+	theta = f_euler_formula(rb_num_imag(z), n);
 
-	return rb_Complex(
-		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_real(theta), prec),
-		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_imag(theta), prec)
+	z = rb_Complex(
+		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_real(theta), n),
+		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_imag(theta), n)
 	);
+
+	return rb_num_round(z, prec);
 }

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

@@ -1,12 +1,14 @@
 VALUE
 cexp2_eulerf(VALUE z, VALUE prec)
 {
-	VALUE log2 = rb_bigmath_const_log2(prec);
+	VALUE log2, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
+	log2 = rb_bigmath_const_log2(n);
 	z = rb_funcall1(z, '*', log2);
-	z = cexp_eulerf(z, prec);
+	z = cexp_eulerf(z, n);
 
-	return z;
+	return rb_num_round(z, prec);
 }