bigdecimal-math_r 0.2.1 → 0.2.2

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

@@ -1,13 +1,16 @@
 VALUE
 acot_logrep(VALUE x, VALUE prec)
 {
-	VALUE n, m, y;
+	VALUE n1, m1, y, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
-	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/acoth/edom.h

@@ -1,16 +1,17 @@
 VALUE
 acoth_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(x, '+', BIG_ONE), '/', 
 		rb_funcall1(x, '-', BIG_ONE));
-	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/acoth/logrep.h

@@ -1,12 +1,15 @@
 VALUE
 acoth_logrep(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	y = rb_funcall1(
 		rb_funcall1(x, '+', BIG_ONE), '/', 
 		rb_funcall1(x, '-', BIG_ONE));
-	y = rb_bigmath_log(y, prec);
+	y = rb_bigmath_log(y, n);
 	y = rb_funcall1(rb_Rational(INT2FIX(1), INT2FIX(2)), '*', y);
 	y = rb_num_round(y, prec);
 

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

@@ -2,19 +2,20 @@ VALUE
 acsc_edom(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE imag, y, arg, t;
+	VALUE imag, y, arg, t, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	t = rb_funcall1(BIG_ONE, '-', rb_funcall1(x, '*', x));
-	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), prec), '+', x);
-	arg = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), n), '+', x);
+	arg = rb_funcall(rb_bigmath_const_pi(n), div, 2, INT2FIX(2), n);
 	if (!rb_num_negative_p(x))
 		arg = rb_num_uminus(arg);
-	imag = rb_bigmath_log(rb_num_abs(t), prec);
+	imag = rb_bigmath_log(rb_num_abs(t), n);
 	y = rb_Complex(arg, imag);
 	y = rb_num_uminus(y);
 
-	return y;
+	return rb_num_round(y, prec);
 }

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

@@ -1,16 +1,17 @@
 VALUE
 acsc_logrep(VALUE x, VALUE prec)
 {
-	VALUE t;
+	VALUE t, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	t = rb_funcall1(x, '*', x);
 	t = rb_funcall1(INT2FIX(1), '-', t);
-	t = rb_bigmath_sqrt(t, prec);
+	t = rb_bigmath_sqrt(t, n);
 	t = rb_funcall1(x, '/', t);
-	t = rb_bigmath_atan(t, prec);
+	t = rb_bigmath_atan(t, n);
 
-	return t;
+	return rb_num_round(t, prec);
 }

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

@@ -1,22 +1,23 @@
 VALUE
 acsch_logrep(VALUE x, VALUE prec)
 {
-	VALUE t, y;
+	VALUE t, y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	if (rb_num_positive_p(x))
 	{
 		t = rb_funcall1(rb_funcall1(x, '*', x), '+', BIG_ONE);
-		t = rb_bigmath_sqrt(t, prec);
-		y = rb_bigmath_log(rb_funcall1(x, '+', t), prec);
+		t = rb_bigmath_sqrt(t, n);
+		y = rb_bigmath_log(rb_funcall1(x, '+', t), n);
 	}
 	else if (rb_num_negative_p(x))
 	{
 		t = rb_funcall1(rb_funcall1(x, '*', x), '+', BIG_ONE);
-		t = rb_bigmath_sqrt(t, prec);
-		t = rb_bigmath_log(rb_funcall1(t, '-', x), prec);
+		t = rb_bigmath_sqrt(t, n);
+		t = rb_bigmath_log(rb_funcall1(t, '-', x), n);
 		y = rb_num_uminus(t);
 	}
 	else 

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

@@ -1,16 +1,17 @@
 VALUE
 asec_edom(VALUE x, VALUE prec)
 {
-	VALUE imag, y, arg, t;
+	VALUE imag, y, arg, t, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	t = rb_funcall1(BIG_ONE, '-', rb_funcall1(x, '*', x));
-	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), prec), '+', x);
-	arg = rb_num_negative_p(x) ? rb_bigmath_const_pi(prec) : BIG_ZERO;
-	imag = rb_bigmath_log(rb_num_abs(t), prec);
+	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), n), '+', x);
+	arg = rb_num_negative_p(x) ? rb_bigmath_const_pi(n) : BIG_ZERO;
+	imag = rb_bigmath_log(rb_num_abs(t), n);
 	y = rb_Complex(arg, imag);
 
-	return y;
+	return rb_num_round(y, prec);
 }

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

@@ -3,19 +3,20 @@ asec_logrep(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
 	const ID sub = rb_intern("sub");
-	VALUE t, pi_2;
+	VALUE t, pi_2, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	t = rb_funcall1(x, '*', x);
 	t = rb_funcall1(INT2FIX(1), '-', t);
-	t = rb_bigmath_sqrt(t, prec);
+	t = rb_bigmath_sqrt(t, n);
 	t = rb_funcall1(x, '/', t);
-	t = rb_bigmath_atan(t, prec);
+	t = rb_bigmath_atan(t, n);
 	pi_2 = rb_funcall(
-		rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
-	t = rb_funcall(pi_2, sub, 2, t, prec);
+		rb_bigmath_const_pi(n), div, 2, INT2FIX(2), n);
+	t = rb_funcall(pi_2, sub, 2, t, n);
 
-	return t;
+	return rb_num_round(t, prec);
 }

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

@@ -1,19 +1,23 @@
 VALUE
 asech_edom(VALUE x, VALUE prec)
 {
-	VALUE absx, recip_x, sqr, w, y;
+	VALUE absx, recip_x, sqr, w, y, n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	absx = rb_num_abs(x);
-	recip_x = rb_num_canonicalize(absx, prec, ARG_REAL, ARG_RECIPROCAL);
+	recip_x = rb_num_canonicalize(absx, n, ARG_REAL, ARG_RECIPROCAL);
 	sqr = rb_funcall1(
 		rb_funcall1(BIG_ONE, '-', absx), '/', 
 		rb_funcall1(absx, '+', BIG_ONE));
-	w = rb_Complex(BIG_ZERO, rb_bigmath_sqrt(sqr, prec));
+	w = rb_Complex(BIG_ZERO, rb_bigmath_sqrt(sqr, n));
 	w = rb_funcall1(w, '*', rb_funcall1(recip_x, '+', BIG_ONE));
 	w = rb_funcall1(w, '+', recip_x);
-	y = rb_bigmath_carg(w, prec);
+	y = rb_bigmath_carg(w, n);
 	if (rb_num_negative_p(x))
-		y =rb_funcall1(rb_bigmath_const_pi(prec), '-', y);
+		y =rb_funcall1(rb_bigmath_const_pi(n), '-', y);
+	y = rb_Complex(BIG_ZERO, y);
 
-	return rb_Complex(BIG_ZERO, y);
+	return rb_num_round(y, prec);
 }

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

@@ -1,13 +1,14 @@
 VALUE
 asech_logrep(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	y = rb_funcall1(x, '*', x);
 	y = rb_funcall1(BIG_ONE, '-', y);
-	y = rb_bigmath_sqrt(y, prec);
+	y = rb_bigmath_sqrt(y, n);
 	y = rb_funcall1(y, '+', BIG_ONE);
 	y = rb_funcall1(y, '/', x);
 	y = rb_bigmath_log(y, prec);

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

@@ -2,19 +2,20 @@ VALUE
 asin_edom(VALUE x, VALUE prec)
 {
 	const ID div = rb_intern("div");
-	VALUE imag, y, arg, t;
+	VALUE imag, y, arg, t, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	t = rb_funcall1(BIG_ONE, '-', rb_funcall1(x, '*', x));
-	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), prec), '+', x);
+	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), n), '+', x);
 	arg = rb_funcall(
-		rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+		rb_bigmath_const_pi(n), div, 2, INT2FIX(2), n);
 	if (!rb_num_negative_p(x))
 		arg = rb_num_uminus(arg);
-	imag = rb_bigmath_log(rb_num_abs(t), prec);
+	imag = rb_bigmath_log(rb_num_abs(t), n);
 	y = rb_Complex(arg, imag);
 	y = rb_num_uminus(y);
 
-	return y;
+	return rb_num_round(y, prec);
 }

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

@@ -1,13 +1,14 @@
 VALUE
 asin_logrep(VALUE x, VALUE prec)
 {
-	VALUE t;
+	VALUE t, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	t = rb_funcall1(x, '*', x);
 	t = rb_funcall1(INT2FIX(1), '-', t);
-	t = rb_bigmath_sqrt(t, prec);
+	t = rb_bigmath_sqrt(t, n);
 	t = rb_funcall1(x, '/', t);
 	t = rb_bigmath_atan(t, prec);
 

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

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

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

@@ -1,21 +1,22 @@
 VALUE
 asinh_logrep(VALUE x, VALUE prec)
 {
-	VALUE t, y;
+	VALUE t, y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	if (rb_num_positive_p(x))
 	{
 		t = rb_funcall1(rb_funcall1(x, '*', x), '+', BIG_ONE);
-		t = rb_bigmath_sqrt(t, prec);
-		y = rb_bigmath_log(rb_funcall1(x, '+', t), prec);
+		t = rb_bigmath_sqrt(t, n);
+		y = rb_bigmath_log(rb_funcall1(x, '+', t), n);
 	}
 	else if (rb_num_negative_p(x))
 	{
 		t = rb_funcall1(rb_funcall1(x, '*', x), '+', BIG_ONE);
-		t = rb_bigmath_sqrt(t, prec);
-		t = rb_bigmath_log(rb_funcall1(t, '-', x), prec);
+		t = rb_bigmath_sqrt(t, n);
+		t = rb_bigmath_log(rb_funcall1(t, '-', x), n);
 		y = rb_num_uminus(t);
 	}
 	else 

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

@@ -5,6 +5,7 @@ asinh_ser(VALUE x, VALUE prec)
 	VALUE n, m;
 	VALUE one, two, x2, c, t, f_n, f_m, d, y, i;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	one = BIG_ONE;

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

@@ -9,6 +9,8 @@ atan_ser_euler(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;
 

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