bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,24 @@
+VALUE
+asinh_logrep(VALUE x, VALUE prec)
+{
+	VALUE t, y;
+
+	rb_check_precise(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);
+	}
+	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);
+		y = rb_num_uminus(t);
+	}
+	else 
+		y = BIG_ZERO;
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,48 @@
+VALUE
+asinh_ser(VALUE x, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE n, m;
+	VALUE one, two, x2, c, t, f_n, f_m, d, y, i;
+
+	n = rb_numdiff_make_n(prec);
+
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+	x2 = rb_funcall1(x, '*', x);
+	y = BIG_ZERO;
+	i = BIG_ZERO;
+	c = one;
+	t = one;
+	f_n = one;
+	f_m = one;
+	d = one;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall1(
+			rb_funcall1(c, '*', f_n), '/', 
+			rb_funcall1(t, '*', f_m));
+		d = rb_funcall(d, mult, 2, x, m);
+		y = rb_funcall1(y, '+', d);
+		c = rb_num_uminus(c);
+		t = rb_funcall1(t, '+', two);
+		i = rb_funcall1(i, '+', one);
+		f_n = rb_funcall1(f_n, '*', i);
+		i = rb_funcall1(i, '+', one);
+		f_m = rb_funcall1(f_m, '*', i);
+		x = rb_funcall(x, mult, 2, x2, m);
+	}
+
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(x2);
+	RB_GC_GUARD(c);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(f_n);
+	RB_GC_GUARD(f_m);
+	RB_GC_GUARD(y);
+	RB_GC_GUARD(i);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,16 @@
+VALUE
+atan_branch(VALUE x, VALUE prec, bigmath_func1 atan_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		y = BIG_NAN;
+	if (rb_num_zero_p(x))
+		y = BIG_ZERO;
+	else
+		y = atan_cb(x, prec);
+
+	return y;
+}

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

@@ -0,0 +1,14 @@
+VALUE
+atan_logrep(VALUE x, VALUE prec)
+{
+	VALUE n, m, y;
+
+	rb_check_precise(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);
+
+	return y;
+}

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

@@ -0,0 +1,84 @@
+#if 1
+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");
+	const ID exponent = rb_intern("exponent");
+	const ID double_fig = rb_intern("double_fig");
+	VALUE m, y, w, t, s;
+	long n = 1;
+
+	if (rb_num_zero_p(x))
+		return BIG_ZERO;
+
+	m = rb_funcall1(rb_funcall(rb_cBigDecimal, double_fig, 0), '+', prec);
+	y = rb_funcall(
+		rb_funcall(x, mult, 2, x, m), div, 2,
+		rb_funcall(BIG_ONE, add, 2, rb_funcall(x, mult, 2, x, m),
+		m), m);
+	w = BIG_ONE;
+	t = BIG_ONE;
+	s = BIG_ZERO;
+
+	for ( ; ; )
+	{
+		VALUE a = rb_funcall(t, mult, 2, w, m);
+
+		if (rb_num_negative_p(rb_funcall1(m, '+', rb_funcall(a, exponent, 0))))
+			break;
+		s = rb_funcall(s, add, 2, a, m);
+		t = rb_funcall(t, mult, 2, LONG2NUM(++n), m);
+		t = rb_funcall(t, div, 2, LONG2NUM(++n), m);
+		w = rb_funcall(w, mult, 2, y, m);
+	};
+	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

@@ -0,0 +1,41 @@
+static VALUE
+atan_ser_usual_inline(VALUE x, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	const ID div = rb_intern("div");
+	VALUE y, d, r, t, x2, n, m, two;
+
+	rb_check_precise(prec);
+
+	two = rb_BigDecimal1(INT2FIX(2));
+	n = rb_numdiff_make_n(prec);
+	y = x;
+	d = y;
+	t = x;
+	r = rb_BigDecimal1(INT2FIX(3));
+	x2 = rb_funcall(x, mult, 2, x, n);
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		t = rb_funcall(rb_num_uminus(t), mult, 2, x2, n);
+		d = rb_funcall(t, div, 2, r, m);
+		y = rb_funcall1(y, '+', d);
+		r = rb_funcall1(r, '+', two);
+	}
+
+	RB_GC_GUARD(y);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(r);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(x2);
+	RB_GC_GUARD(two);
+
+	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

@@ -0,0 +1,24 @@
+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"));
+
+	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)))
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (rb_num_equal_p(absx, INT2FIX(1)))
+			y = rb_num_negative_p(x) ? BIG_MINUS_INF : BIG_INF;
+		else if (RTEST(rb_num_coerce_cmp(absx, p0999, leq)))
+			y = atanh_ser(x, prec);
+		else
+			y = atanh_cb(x, prec);
+	}
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,16 @@
+VALUE
+atanh_edom(VALUE x, VALUE prec)
+{
+	VALUE t, pi;
+
+	t = rb_funcall1(
+		rb_funcall1(BIG_ONE, '+', x), '/', 
+		rb_funcall1(BIG_ONE, '-', x));
+	pi = rb_bigmath_const_pi(prec);
+	t = rb_Complex(
+		rb_bigmath_log(rb_num_abs(t), prec), 
+		rb_num_negative_p(x) ? pi : rb_num_uminus(pi));
+	t = rb_funcall1(rb_Rational(INT2FIX(1), INT2FIX(2)), '*', t);
+
+	return rb_num_round(t, prec);
+}

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

@@ -0,0 +1,16 @@
+VALUE
+atanh_logrep(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE n, half;
+
+	n = rb_numdiff_make_n(prec);
+	half = rb_BigDecimal1(rb_str_new_cstr("0.5"));
+
+	x = rb_funcall(
+		rb_funcall1(BIG_ONE, '+', x), div, 2, 
+		rb_funcall1(BIG_ONE, '-', x), n);
+
+	return rb_funcall(half, mult, 2, rb_bigmath_log(x, n), prec);
+}

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

@@ -0,0 +1,33 @@
+VALUE
+atanh_ser(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	VALUE one, two, i, d, y, x2, n, m;
+
+	n = rb_numdiff_make_n(prec);
+
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+	i = one;
+	x2 = rb_funcall1(x, '*', x);
+	d = one;
+	y = BIG_ZERO;
+
+	while (rb_numdiff_condition_p(y, d, n, &m))
+	{
+		d = rb_funcall(x, div, 2, i, m);
+		y = rb_funcall1(y, '+', d);
+		x = rb_funcall(x, mult, 2, x2, m);
+		i = rb_funcall1(i, '+', two);
+	}
+
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(y);
+	RB_GC_GUARD(x2);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,8 @@
+VALUE
+cabs_formula(VALUE z, VALUE prec)
+{
+	rb_check_precise(prec);
+
+	return rb_bigmath_l2norm(
+		rb_assoc_new(rb_num_real(z), rb_num_imag(z)), prec);
+}

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

@@ -0,0 +1,38 @@
+VALUE
+cacos_branch(VALUE z, VALUE prec, bigmath_func1 cacos_cb)
+{
+	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
+	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
+
+	if (rb_num_nan_p(z))
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	else if (z_re_inf || z_im_inf)
+	{
+		if (z_re_inf != 0 && z_im_inf == 0)
+		{
+			VALUE real = 
+				(rb_num_zero_p(rb_num_imag(z)) &&
+			         z_re_inf == 1) ?
+				BIG_ZERO : rb_bigmath_const_pi(prec);
+			VALUE imag = z_re_inf == 1 ? BIG_MINUS_INF : BIG_INF;
+			return rb_Complex(real, imag);
+		}
+		else if (z_re_inf == 0 && z_im_inf != 0)
+		{
+			return rb_Complex(BIG_ZERO, rb_num_imag(z));
+		}
+		else if (z_re_inf == -1 && z_im_inf == 1)
+		{
+			return rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else
+		{
+			return rb_Complex(BIG_ZERO, BIG_ZERO);
+		}
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return cacos_cb(z, prec);
+	}
+}

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

@@ -0,0 +1,16 @@
+VALUE
+cacos_logrep(VALUE z, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE c1, c2, c3, c4, c5, c6;
+
+	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);
+	c4 = rb_ImaginaryZ(c3, SIGN_PLUS);
+	c5 = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+	c6 = rb_funcall1(c5, '+', c4);
+
+	return rb_num_round(c6, prec);
+}

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

@@ -0,0 +1,34 @@
+VALUE
+cacosh_branch(VALUE z, VALUE prec, bigmath_func1 cacosh_cb)
+{
+	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
+	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
+
+	if (rb_num_nan_p(z))
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	else if (z_re_inf || z_im_inf)
+	{
+		if (z_re_inf != 0 && z_im_inf == 0)
+		{
+			VALUE real = BIG_INF;
+			VALUE imag = (z_re_inf == -1 && rb_num_zero_p(rb_num_imag(z))) ? 
+				rb_bigmath_const_pi(prec) : BIG_ZERO;
+			return rb_Complex(real, imag);
+		}
+		else if (z_re_inf == 0 && z_im_inf != 0)
+		{
+			VALUE real = BIG_INF;
+			VALUE imag = BIG_ZERO;
+			return rb_Complex(real, imag);
+		}
+		else if (z_re_inf == -1 && z_im_inf == 1)
+			return rb_Complex(BIG_NAN, BIG_NAN);
+		else
+			return rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return cacosh_cb(z, prec);
+	}
+}

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

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

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

@@ -0,0 +1,39 @@
+VALUE
+cacot_branch(VALUE z, VALUE prec, bigmath_func1 cacot_cb)
+{
+#define rb_Complex_I rb_Complex(INT2FIX(0), INT2FIX(1))
+#define rb_Complex_mI rb_Complex(INT2FIX(0), INT2FIX(-1))
+	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
+	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
+
+	if (rb_num_nan_p(z))
+	{
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (z_re_inf || z_im_inf)
+	{
+		return rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else if (rb_num_equal_p(z, rb_Complex_I))
+	{
+		return rb_Complex(BIG_ZERO, BIG_MINUS_INF);
+	}
+	else if (rb_num_equal_p(z, rb_Complex_mI))
+	{
+		return rb_Complex(BIG_ZERO, BIG_INF);
+	}
+	else if (rb_num_zero_p(z))
+	{
+		const ID div = rb_intern("div");
+		VALUE real = 
+			rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+		return rb_Complex(real, BIG_ZERO);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return cacot_cb(z, prec);
+	}
+#undef rb_Complex_I
+#undef rb_Complex_mI
+}

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

@@ -0,0 +1,17 @@
+VALUE
+cacot_logrep(VALUE z, VALUE prec)
+{
+	VALUE c1, c2, c3;
+
+	rb_check_precise(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);
+
+	c1 = rb_funcall1(rb_Complex(INT2FIX(0), INT2FIX(1)), '/', INT2FIX(2));
+	c2 = rb_funcall1(rb_num_uminus(c1), '*', c3);
+
+	return rb_num_round(c2, prec);
+}

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

@@ -0,0 +1,29 @@
+VALUE
+cacoth_branch(VALUE z, VALUE prec, bigmath_func1 catanh_cb)
+{
+	VALUE w = Qundef;
+
+	if (rb_num_nan_p(z))
+	{
+		w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (rb_num_infinite_p(z) != 0)
+	{
+		w = rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else if (rb_num_zero_p(z))
+	{
+		const ID div = rb_intern("div");
+		VALUE pi_2 = rb_funcall(
+			rb_bigmath_const_pi(prec), div, 2, 
+			INT2FIX(2), prec);
+		w = rb_Complex(BIG_ZERO, pi_2);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		w = catanh_cb(z, prec);
+	}
+
+	return w;
+}

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

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

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

@@ -0,0 +1,28 @@
+VALUE
+cacsc_branch(VALUE z, VALUE prec, bigmath_func1 cacsc_cb)
+{
+	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
+	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
+
+	if (rb_num_nan_p(z))
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	else if (z_re_inf || z_im_inf)
+	{
+		return rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else if (rb_num_zero_p(z))
+	{
+		const ID div = rb_intern("div");
+		int zero_sign = NUM2INT(rb_BigDecimal_sign(rb_num_real(z)));
+		VALUE real = rb_num_nonzero_p(rb_num_imag(z)) ?
+			BIG_ZERO : rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
+			INT2FIX(zero_sign * 2), prec);
+		VALUE imag = 1 == zero_sign ? BIG_MINUS_INF : BIG_INF;
+		return rb_Complex(real, imag);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return cacsc_cb(z, prec);
+	}
+}

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

@@ -0,0 +1,19 @@
+VALUE
+cacsc_logrep(VALUE z, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(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_Complex(y, 
+		rb_num_canonicalize(
+			rb_num_uminus(z), prec, ARG_COMPLEX, ARG_RECIPROCAL));
+	y = rb_bigmath_clog(y, prec);
+	y = rb_ImaginaryZ(y, SIGN_PLUS);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,18 @@
+VALUE
+cacsch_branch(VALUE z, VALUE prec, bigmath_func1 cacsch_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_infinite_p(z) != 0)
+		w = rb_Complex(BIG_ZERO, BIG_ZERO);
+	else if (rb_num_zero_p(z))
+		w = rb_Complex(BIG_INF, BIG_INF);
+	else
+		w = cacsch_cb(z, prec);
+
+	return w;
+}

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

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

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

@@ -0,0 +1,8 @@
+VALUE
+carg_formula(VALUE z, VALUE prec)
+{
+	rb_check_precise(prec);
+
+	return rb_bigmath_quadrant(
+		rb_num_real(z), rb_num_imag(z), prec);
+}

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

@@ -0,0 +1,29 @@
+VALUE
+casec_branch(VALUE z, VALUE prec, bigmath_func1 casec_cb)
+{
+	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
+	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
+
+	if (rb_num_nan_p(z))
+	{
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (z_re_inf || z_im_inf)
+	{
+		return rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else if (rb_num_zero_p(z))
+	{
+		int zero_sign = NUM2INT(rb_BigDecimal_sign(rb_num_real(z)));
+		VALUE real = 
+			(rb_num_nonzero_p(rb_num_imag(z)) || zero_sign == -1) ?
+			BIG_ZERO : rb_bigmath_const_pi(prec);
+		VALUE imag = 1 == zero_sign ? BIG_MINUS_INF : BIG_INF;
+		return rb_Complex(real, imag);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return casec_cb(z, prec);
+	}
+}

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

@@ -0,0 +1,18 @@
+VALUE
+casec_logrep(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(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_funcall1(rb_ImaginaryZ(w, SIGN_PLUS), '+', 
+		rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RECIPROCAL));
+	w = rb_bigmath_clog(w, prec);
+	w = rb_ImaginaryZ(w, SIGN_MINUS);
+
+	return rb_num_round(w, prec);
+}