bigdecimal-math_r 0.2.0 → 0.2.2

data/ext/bigdecimal/math_r/internal/algo/bigmath/E/{ser.h → napier.h}

@@ -1,5 +1,5 @@
 VALUE
-E_ser(VALUE prec)
+E_napier(VALUE prec)
 {
 	const ID div = rb_intern("div");
 	VALUE n, m, a, e;

data/ext/bigdecimal/math_r/internal/algo/bigmath/EulerGamma/borwein_bailey.h

@@ -0,0 +1,37 @@
+VALUE
+EulerGamma_borwein_bailey(VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID div = rb_intern("div");
+	VALUE zero, one, m, n, nn, a, b, u, v, k;
+	rb_check_precise(prec);
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	n = rb_numdiff_make_n(prec);
+	nn = rb_BigDecimal1(n);
+	a = u = rb_num_uminus(rb_bigmath_log(n, n));
+	b = v = one;
+	k = zero;
+	while (rb_numdiff_condition_p(u, a, n, &m))
+	{
+		k = rb_funcall1(k, '+', one);
+		b = rb_funcall(rb_funcall1(b, '*', rb_funcall1(nn, '*', nn)), 
+			div, 2, rb_funcall1(k, '*', k), m);
+		a = rb_funcall1(
+			rb_funcall(one, div, 2, k, m), '*', 
+			rb_funcall(rb_funcall(rb_funcall1(a, '*', rb_funcall1(nn, '*', nn)), 
+			div, 2, k, m),
+			add, 2, b, m));
+		u = rb_funcall1(u, '+', a);
+		v = rb_funcall1(v, '+', b);
+	}
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(nn);
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(b);
+	RB_GC_GUARD(u);
+	RB_GC_GUARD(v);
+	RB_GC_GUARD(k);
+	return rb_funcall(u, div, 2, v, prec);
+}

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

@@ -1,6 +1,8 @@
 VALUE
 LOG10_ser(VALUE prec)
 {
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
 #if 0
 	VALUE x = rb_Rational(INT2FIX(-9), INT2FIX(10));
 	x = log_ser_mercator(x, prec);
@@ -8,8 +10,8 @@ LOG10_ser(VALUE prec)
 #else
 	const ID add = rb_intern("add");
 	VALUE x = rb_Rational(INT2FIX(1), INT2FIX(4)), log2;
-	x = log1p_p_adic(x, prec);
-	log2 = LOG2_BBP2002(prec);
+	x = log1p_p_adic(x, n);
+	log2 = LOG2_BBP2002(n);
 	return rb_funcall(rb_funcall1(log2, '*', INT2FIX(3)), add, 2, x, prec);
 #endif
 }

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

@@ -1,7 +1,9 @@
 VALUE
 LOG_PI_builtin(VALUE prec)
 {
-	VALUE log_pi = rb_bigmath_const_pi(prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE log_pi = rb_bigmath_const_pi(n);
 	return log_builtin(log_pi, prec);
 }
 

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

@@ -1,5 +1,8 @@
 VALUE
 SQRT2_builtin(VALUE prec)
 {
-	return rb_bigmath_sqrt(INT2FIX(2), prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE x = rb_bigmath_sqrt(INT2FIX(2), n);
+	return rb_num_round(x, prec);
 }

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

@@ -1,5 +1,8 @@
 VALUE
 SQRT3_builtin(VALUE prec)
 {
-	return rb_bigmath_sqrt(INT2FIX(3), prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE x = rb_bigmath_sqrt(INT2FIX(3), n);
+	return rb_num_round(x, prec);
 }

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

@@ -2,21 +2,28 @@ VALUE
 acos_branch(VALUE x, VALUE prec, bigmath_func1 acos_cb)
 {
 	const ID leq = rb_intern("<=");
-	VALUE y = Qundef, p001 = rb_BigDecimal1(rb_str_new_cstr("0.001"));
+	VALUE y = Qundef;
+	VALUE p001 = rb_BigDecimal1(rb_str_new_cstr("0.001"));
+	VALUE domain = rb_range_new(INT2FIX(0), INT2FIX(1), true);
+
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
 	if (!rb_num_finite_p(x))
 		y = x;
 	else
 	{
-		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		VALUE absx = rb_num_abs(x);
 		if (RTEST(rb_num_coerce_cmp(absx, p001, leq)))
 		{
 			y = acos_ser(x, prec);
 		}
-		else if (RTEST(rb_num_coerce_cmp(absx, BIG_ONE, leq)))
+		else if (rb_num_domain_p(domain, absx))
 		{
-			y = acos_cb(x, prec);
+			if (rb_num_equal_p(absx, INT2FIX(1)))
+				y = rb_num_negative_p(x) ? 
+					rb_bigmath_const_pi(prec) : BIG_ZERO;
+			else
+				y = acos_cb(x, prec);
 		}
 		else
 			y = BIG_NAN;

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

@@ -1,15 +1,15 @@
 VALUE
 acosh_branch(VALUE x, VALUE prec, bigmath_func1 acosh_cb)
 {
-	const ID geq = rb_intern(">=");
 	VALUE y = Qundef;
+	VALUE domain = rb_range_new(INT2FIX(1), DBL2NUM(HUGE_VAL), false);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 	if (rb_num_positive_p(x))
 	{
 		if (rb_num_infinite_p(x) == 1)
 			y = BIG_INF;
-		else if (RTEST(rb_num_coerce_cmp(x, BIG_ONE, geq)))
+		else if (rb_num_domain_p(domain, x))
 			y = acosh_cb(x, prec);
 	}
 	if (y == Qundef)

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

@@ -3,15 +3,17 @@ acosh_edom(VALUE x, VALUE prec)
 {
 	const ID add = rb_intern("add");
 	const ID div = rb_intern("div");
-	VALUE t, w, y;
+	VALUE t, w, y, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
 	t = rb_funcall1(BIG_MINUS_ONE, '+', rb_funcall1(x, '*', x));
-	w = rb_funcall(rb_bigmath_sqrt(rb_num_uminus(t), prec), div, 2, x, prec);
-	y = rb_bigmath_atan(w, prec);
+	w = rb_funcall(rb_bigmath_sqrt(rb_num_uminus(t), prec), div, 2, x, n);
+	y = rb_bigmath_atan(w, n);
 	if (rb_num_negative_p(x))
-		y = rb_funcall(rb_bigmath_const_pi(prec), add, 2, y, prec);
+		y = rb_funcall(rb_bigmath_const_pi(n), add, 2, y, n);
+	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/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/branch.h

@@ -1,8 +1,9 @@
 VALUE
 acoth_branch(VALUE x, VALUE prec, bigmath_func1 acoth_cb)
 {
-	VALUE y;
-	const ID leq = rb_intern("<=");
+	VALUE y = Qundef;
+	VALUE p_domain = rb_range_new(INT2FIX(1), DBL2NUM(HUGE_VAL), false);
+	VALUE m_domain = rb_range_new(DBL2NUM(-HUGE_VAL), INT2FIX(-1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
@@ -10,8 +11,7 @@ acoth_branch(VALUE x, VALUE prec, bigmath_func1 acoth_cb)
 		y = BIG_INF;
 	else if (rb_num_equal_p(x, BIG_MINUS_ONE))
 		y = BIG_MINUS_INF;
-	else if (RTEST(rb_num_coerce_cmp(x, BIG_MINUS_ONE, leq)) ||
-	         RTEST(rb_num_coerce_cmp(BIG_ONE, x, leq)))
+	else if (rb_num_domain_p(p_domain, x) || rb_num_domain_p(m_domain, x))
 		y = acoth_cb(x, prec);
 	else
 		y = BIG_NAN;

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/branch.h

@@ -1,9 +1,9 @@
 VALUE
 acsc_branch(VALUE x, VALUE prec, bigmath_func1 acsc_cb)
 {
-	const ID leq = rb_intern("<=");
-	const ID geq = rb_intern(">=");
 	VALUE y = Qundef;
+	VALUE p_domain = rb_range_new(INT2FIX(1), DBL2NUM(HUGE_VAL), false);
+	VALUE m_domain = rb_range_new(DBL2NUM(-HUGE_VAL), INT2FIX(-1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
@@ -11,8 +11,7 @@ acsc_branch(VALUE x, VALUE prec, bigmath_func1 acsc_cb)
 		y = BIG_NAN;
 	else if (rb_num_infinite_p(x) != 0)
 		y = BIG_ONE;
-	else if (RTEST(rb_num_coerce_bin(x, INT2FIX(-1), leq)) ||
-	         RTEST(rb_num_coerce_bin(x, INT2FIX( 1), geq)))
+	else if (rb_num_domain_p(p_domain, x) || rb_num_domain_p(m_domain, x))
 		y = acsc_cb(x, prec);
 	else
 		y = BIG_NAN;

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/branch.h

@@ -1,7 +1,6 @@
 VALUE
 acsch_branch(VALUE x, VALUE prec, bigmath_func1 acsch_cb)
 {
-	const ID leq = rb_intern("<=");
 	VALUE y = Qundef;
 	int sign;
 
@@ -10,16 +9,11 @@ acsch_branch(VALUE x, VALUE prec, bigmath_func1 acsch_cb)
 	if (rb_num_nan_p(x))
 		y = BIG_NAN;
 	else if ((sign = rb_num_infinite_p(x)) != 0)
-	{
 		y = sign == 1 ? BIG_ZERO : BIG_MINUS_ZERO;
-	}
-	else if (RTEST(rb_num_coerce_bin(x, BIG_MINUS_ONE, leq)) ||
-	         RTEST(rb_num_coerce_bin(BIG_ONE, x, leq)))
-	{
+	else if (rb_num_zero_p(x))
+		y = BIG_INF;
+	else 
 		y = acsch_cb(x, prec);
-	}
-	else
-		y = BIG_NAN;
 
 	return y;
 }

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/branch.h

@@ -1,10 +1,10 @@
 VALUE
 asec_branch(VALUE x, VALUE prec, bigmath_func1 asec_cb)
 {
-	const ID leq = rb_intern("<=");
-	const ID geq = rb_intern(">=");
 	const ID div = rb_intern("div");
 	VALUE y = Qundef;
+	VALUE p_domain = rb_range_new(INT2FIX(1), DBL2NUM(HUGE_VAL), false);
+	VALUE m_domain = rb_range_new(DBL2NUM(-HUGE_VAL), INT2FIX(-1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
@@ -12,8 +12,11 @@ asec_branch(VALUE x, VALUE prec, bigmath_func1 asec_cb)
 		y = BIG_NAN;
 	else if (rb_num_infinite_p(x) != 0)
 		y = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
-	else if (RTEST(rb_num_coerce_bin(x, INT2FIX(-1), leq)) ||
-	         RTEST(rb_num_coerce_bin(x, INT2FIX(1), geq)))
+	else if (rb_num_equal_p(x, INT2FIX(-1)))
+		y = rb_bigmath_const_pi(prec);
+	else if (rb_num_equal_p(x, INT2FIX(0)))
+		y = BIG_ZERO;
+	else if (rb_num_domain_p(p_domain, x) || rb_num_domain_p(m_domain, x))
 		y = asec_cb(x, prec);
 	else
 		y = BIG_NAN;

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/branch.h

@@ -1,16 +1,13 @@
 VALUE
 asech_branch(VALUE x, VALUE prec, bigmath_func1 asech_cb)
 {
-	const ID leq = rb_intern("<=");
 	VALUE y;
+	VALUE domain = rb_range_new(INT2FIX(0), INT2FIX(1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
-	if (RTEST(rb_num_coerce_cmp(BIG_ZERO, x, leq)) &&
-	    RTEST(rb_num_coerce_cmp(x, BIG_ONE, leq)))
-	{
+	if (rb_num_domain_p(domain, x))
 		y = asech_cb(x, prec);
-	}
 	else
 		y = BIG_NAN;
 

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/branch.h

@@ -2,7 +2,9 @@ VALUE
 asin_branch(VALUE x, VALUE prec, bigmath_func1 asin_cb)
 {
 	const ID leq = rb_intern("<=");
-	VALUE y = Qundef, p001 = rb_BigDecimal1(rb_str_new_cstr("0.001"));
+	VALUE y = Qundef;
+	VALUE p001 = rb_BigDecimal1(rb_str_new_cstr("0.001"));
+	VALUE domain = rb_range_new(INT2FIX(-1), INT2FIX(1), true);
 
 	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
 
@@ -13,7 +15,7 @@ asin_branch(VALUE x, VALUE prec, bigmath_func1 asin_cb)
 		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
 		if (RTEST(rb_num_coerce_cmp(absx, p001, leq)))
 			y = asin_ser(x, prec);
-		else if (RTEST(rb_num_coerce_cmp(absx, BIG_ONE, leq)))
+		else if (rb_num_domain_p(domain, x))
 			y = asin_cb(x, prec);
 		else
 			y = BIG_NAN;

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;