bigdecimal-math_r 0.2.0 → 0.2.2

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

@@ -0,0 +1,13 @@
+VALUE
+cexpm1_branch(VALUE z, VALUE prec, bigmath_func1 cexpm1_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
+		w = cexpm1_cb(z, prec);
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/cexpm1/identity.h

@@ -0,0 +1,17 @@
+VALUE
+cexpm1_identity(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef;
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE n;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	x = rb_funcall1(x, '/', two);
+
+	y = rb_funcall1(rb_bigmath_cexp(x, n), '*', csinh_branch(x, n, csinh_eulerf));
+	y = rb_funcall1(two, '*', y);
+
+	return rb_num_round(y, prec);
+}

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

@@ -5,15 +5,17 @@ clog_branch(VALUE z, VALUE prec, bigmath_func1 clog_cb)
 
 	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
 
-	if (!rb_num_finite_p(z))
+	if (rb_num_nan_p(z))
 	{
-		if (rb_num_notequal_p(z, z))
-		{
-			w = rb_Complex(BIG_NAN, BIG_NAN);
-		}
-		else if (rb_num_finite_p(rb_num_imag(z)))
+		w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (!rb_num_finite_p(z))
+	{
+		int re_inf_sgn = rb_num_infinite_p(rb_num_real(z));
+		int im_inf_sgn = rb_num_infinite_p(rb_num_imag(z));
+		if (re_inf_sgn != 0 && im_inf_sgn == 0)
 		{
-			switch (rb_num_infinite_p(rb_num_real(z))) {
+			switch (re_inf_sgn) {
 			case -1:
 				arg = rb_num_imag(clog_cb(BIG_MINUS_ONE, prec));
 				w = rb_Complex(BIG_INF, arg);
@@ -23,7 +25,7 @@ clog_branch(VALUE z, VALUE prec, bigmath_func1 clog_cb)
 				break;
 			}
 		}
-		else if (rb_num_finite_p(rb_num_real(z)))
+		else if (re_inf_sgn == 0 && im_inf_sgn != 0)
 		{
 			switch (rb_num_infinite_p(rb_num_imag(z))) {
 			case -1:
@@ -40,10 +42,7 @@ clog_branch(VALUE z, VALUE prec, bigmath_func1 clog_cb)
 		}
 		else /* log(INF +i INF) */
 		{
-			w = rb_Complex(
-				rb_BigDecimal1(rb_num_real(z)),
-				rb_BigDecimal1(rb_num_imag(z))
-			);
+			w = z;
 		}
 	}
 	if (w == Qundef)

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

@@ -0,0 +1,53 @@
+VALUE
+clog10_branch(VALUE z, VALUE prec, bigmath_func1 clog10_cb)
+{
+	VALUE w = Qundef, arg = 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_inf_sgn = rb_num_infinite_p(rb_num_real(z));
+		int im_inf_sgn = rb_num_infinite_p(rb_num_imag(z));
+		if (re_inf_sgn != 0 && im_inf_sgn == 0)
+		{
+			switch (re_inf_sgn) {
+			case -1:
+				arg = rb_num_imag(clog10_cb(BIG_MINUS_ONE, prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				w = rb_Complex(BIG_INF, BIG_ZERO);
+				break;
+			}
+		}
+		else if (re_inf_sgn == 0 && im_inf_sgn != 0)
+		{
+			switch (rb_num_infinite_p(rb_num_imag(z))) {
+			case -1:
+				arg = rb_num_imag(
+					clog10_cb(rb_Complex(BIG_ZERO, BIG_MINUS_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				arg = rb_num_imag(
+					clog10_cb(rb_Complex(BIG_ZERO, BIG_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			}
+		}
+		else /* log(INF +i INF) */
+		{
+			w = z;
+		}
+	}
+	if (w == Qundef)
+	{
+		w = clog10_cb(z, prec);
+	}
+	return w;
+}

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

@@ -1,12 +1,13 @@
 VALUE
 clog10_formula(VALUE z, VALUE prec)
 {
-	VALUE w;
+	VALUE w, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	w = clog_formula(z, prec);
-	w = rb_funcall1(w, '/', rb_bigmath_const_log10(prec));
+	w = rb_bigmath_clog(z, n);
+	w = rb_funcall1(w, '/', rb_bigmath_const_log10(n));
 
 	return rb_num_round(w, prec);
 }

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

@@ -0,0 +1,53 @@
+VALUE
+clog2_branch(VALUE z, VALUE prec, bigmath_func1 clog2_cb)
+{
+	VALUE w = Qundef, arg = 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_inf_sgn = rb_num_infinite_p(rb_num_real(z));
+		int im_inf_sgn = rb_num_infinite_p(rb_num_imag(z));
+		if (re_inf_sgn != 0 && im_inf_sgn == 0)
+		{
+			switch (re_inf_sgn) {
+			case -1:
+				arg = rb_num_imag(clog2_cb(BIG_MINUS_ONE, prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				w = rb_Complex(BIG_INF, BIG_ZERO);
+				break;
+			}
+		}
+		else if (re_inf_sgn == 0 && im_inf_sgn != 0)
+		{
+			switch (rb_num_infinite_p(rb_num_imag(z))) {
+			case -1:
+				arg = rb_num_imag(
+					clog2_cb(rb_Complex(BIG_ZERO, BIG_MINUS_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				arg = rb_num_imag(
+					clog2_cb(rb_Complex(BIG_ZERO, BIG_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			}
+		}
+		else /* log(INF +i INF) */
+		{
+			w = z;
+		}
+	}
+	if (w == Qundef)
+	{
+		w = clog2_cb(z, prec);
+	}
+	return w;
+}

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

@@ -1,12 +1,13 @@
 VALUE
 clog2_formula(VALUE z, VALUE prec)
 {
-	VALUE w;
+	VALUE w, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	w = clog_formula(z, prec);
-	w = rb_funcall1(w, '/', rb_bigmath_const_log2(prec));
+	w = rb_bigmath_clog(z, n);
+	w = rb_funcall1(w, '/', rb_bigmath_const_log2(n));
 
 	return rb_num_round(w, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 cos_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);
-
-	return rb_num_real(w);
+	w = trig_f_euler(mf_cos, rb_ImaginaryZ(z, SIGN_PLUS), n);
+	w = rb_num_real(w);
+	
+	return rb_num_round(w, prec);
 }

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

@@ -1,12 +1,12 @@
 VALUE
 cos_ser(VALUE x, VALUE prec)
 {
-	VALUE cos;
+	VALUE cos, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	rb_bigmath_sincos(x, prec, NULL, &cos);
-	cos = rb_num_round(cos, prec);
+	rb_bigmath_sincos(x, n, NULL, &cos);
 
-	return cos;
+	return rb_num_round(cos, prec);
 }

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

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

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

@@ -5,8 +5,8 @@ cosh_formula(VALUE x, VALUE prec)
 	VALUE n, t, y, two;
 
 	rb_check_precise(prec);
-
 	n = rb_numdiff_make_n(prec);
+
 	t = rb_bigmath_exp(x, n);
 	y = Qundef;
 	two = rb_BigDecimal1(INT2FIX(2));
@@ -15,16 +15,16 @@ cosh_formula(VALUE x, VALUE prec)
 	{
 		y = rb_Rational(INT2FIX(1), t);
 	        y = rb_funcall1(t, '+', y);
-	        y = rb_funcall(rb_BigDecimal(y, n), div, 2, two, prec);
+	        y = rb_funcall(rb_BigDecimal(y, n), div, 2, two, n);
 	}
 	else if (rb_num_infinite_p(t) != 0)
 		y = BIG_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);
+		y = rb_funcall(y, div, 2, two, n);
 	}
 
-	return y;
+	return rb_num_round(y, prec);
 }

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

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

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

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

@@ -2,11 +2,12 @@ VALUE
 cot_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);
 
-	rb_bigmath_sincos(x, prec, &sin, &cos);
+	rb_bigmath_sincos(x, n, &sin, &cos);
 
 	return rb_funcall(cos, div, 2, sin, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 coth_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y, 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_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/coth/formula.h

@@ -7,6 +7,7 @@ coth_formula(VALUE x, VALUE prec)
 	VALUE n, two, t, y = Qundef;
 	int sign;
 
+	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
 
 	two = rb_BigDecimal1(INT2FIX(2));

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

@@ -1,12 +1,13 @@
 VALUE
 coth_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(cosh, div, 2, sinh, prec);
 
 	return y;

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

@@ -1,20 +1,22 @@
 VALUE
 cpow_formula(VALUE z, VALUE w, VALUE prec)
 {
-	VALUE a = Qundef;
+	VALUE a = Qundef, n;
 
 	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
 
-	if (rb_num_zero_p(rb_num_imag(z)) && rb_num_zero_p(rb_num_imag(w)))
+	if (rb_num_positive_p(rb_num_real(z)) &&
+	    rb_num_zero_p(rb_num_imag(z)) && rb_num_zero_p(rb_num_imag(w)))
 	{
-		a = pow_formula(rb_num_real(z), rb_num_real(w), prec);
-		a = rb_num_canonicalize(a, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		a = pow_formula(rb_num_real(z), rb_num_real(w), n);
+		a = rb_num_canonicalize(a, n, ARG_COMPLEX, ARG_RAWVALUE);
 	}
 	else
 	{
-		a = rb_bigmath_clog(z, prec);
+		a = rb_bigmath_clog(z, n);
 		a = rb_funcall1(w, '*', a);
-		a = rb_bigmath_cexp(a, prec);
+		a = rb_bigmath_cexp(a, n);
 	}
-	return a;
+	return rb_num_round(a, prec);
 }

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

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

@@ -1,11 +1,13 @@
 VALUE
 csc_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_canonicalize(sin, n, ARG_REAL, ARG_RECIPROCAL);
 
-	return rb_num_canonicalize(sin, prec, ARG_REAL, ARG_RECIPROCAL);
+	return rb_num_round(sin, prec);
 }

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

@@ -1,11 +1,13 @@
 VALUE
 csch_eulerf(VALUE x, VALUE prec)
 {
-	VALUE y;
+	VALUE y, 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_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/csch/formula.h

@@ -6,8 +6,8 @@ csch_formula(VALUE x, VALUE prec)
 	int sign;
 
 	rb_check_precise(prec);
-
 	n = rb_numdiff_make_n(prec);
+
 	t = rb_bigmath_exp(x, n);
 	y = Qundef;
 	two = rb_BigDecimal1(INT2FIX(2));
@@ -22,7 +22,7 @@ csch_formula(VALUE x, VALUE prec)
 		y = sign == 1 ? BIG_ZERO : BIG_MINUS_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/csch/ser.h

@@ -1,11 +1,14 @@
 VALUE
 csch_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 rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+	y = rb_num_canonicalize(y, n, ARG_REAL, ARG_RECIPROCAL);
+
+	return rb_num_round(y, prec);
 }

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

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

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

@@ -1,11 +1,12 @@
 VALUE
 csin_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 = trig_f_euler(mf_sin, rb_ImaginaryZ(z, SIGN_PLUS), n);
 
-	return w;
+	return rb_num_round(w, prec);
 }

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

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

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

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