bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/internal/algo/bigmath/PI/machin.h

@@ -0,0 +1,48 @@
+
+VALUE
+PI_machin(VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE m, n, one, two, m25, m57121, pi, k, t, d;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	one = BIG_ONE;
+	two = rb_BigDecimal1(INT2FIX(2));
+	m25 = rb_BigDecimal1(rb_str_new_cstr("-0.04"));
+	m57121 = rb_BigDecimal1(rb_str_new_cstr("-57121"));
+	pi = BIG_ZERO;
+	k = BIG_ONE;
+	t = rb_BigDecimal(rb_Rational(INT2FIX(16), INT2FIX(5)), n);
+	d = one;
+
+	while (rb_numdiff_condition_p(pi, d, n, &m))
+	{
+		d = rb_funcall(t, div, 2, k, m);
+		pi = rb_funcall1(pi, '+', d);
+		t = rb_funcall1(t, '*', m25);
+		k = rb_funcall1(k, '+', two);
+	}
+	k = BIG_ONE;
+	t = rb_BigDecimal(rb_Rational(INT2FIX(4), INT2FIX(239)), n);
+	d = one;
+	while (rb_numdiff_condition_p(pi, d, n, &m))
+	{
+		d = rb_funcall(t, div, 2, k, m);
+		pi = rb_funcall1(pi, '-', d);
+		t = rb_funcall(t, div, 2, m57121, n);
+		k = rb_funcall1(k, '+', two);
+	}
+
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(m25);
+	RB_GC_GUARD(m57121);
+	RB_GC_GUARD(pi);
+	RB_GC_GUARD(k);
+	RB_GC_GUARD(t);
+	RB_GC_GUARD(d);
+
+	return rb_num_round(pi, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+SQRT2_builtin(VALUE prec)
+{
+	return rb_bigmath_sqrt(INT2FIX(2), prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+SQRT3_builtin(VALUE prec)
+{
+	return rb_bigmath_sqrt(INT2FIX(3), prec);
+}

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

@@ -0,0 +1,25 @@
+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"));
+	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;
+		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)))
+		{
+			y = acos_cb(x, prec);
+		}
+		else
+			y = BIG_NAN;
+	}
+	return y;
+}

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

@@ -0,0 +1,15 @@
+VALUE
+acos_edom(VALUE x, VALUE prec)
+{
+	VALUE imag, y, arg, t;
+
+	rb_check_precise(prec);
+
+	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);
+	y = rb_Complex(arg, imag);
+
+	return y;
+}

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

@@ -0,0 +1,19 @@
+VALUE
+acos_logrep(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	const ID sub = rb_intern("sub");
+	VALUE t, pi_2;
+
+	rb_check_precise(prec);
+
+	t = rb_funcall1(x, '*', x);
+	t = rb_funcall1(INT2FIX(1), '-', t);
+	t = rb_bigmath_sqrt(t, prec);
+	t = rb_funcall1(x, '/', t);
+	t = rb_bigmath_atan(t, prec);
+	pi_2 = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+	t = rb_funcall(pi_2, sub, 2, t, prec);
+
+	return t;
+}

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

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

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

@@ -0,0 +1,19 @@
+VALUE
+acosh_branch(VALUE x, VALUE prec, bigmath_func1 acosh_cb)
+{
+	const ID geq = rb_intern(">=");
+	VALUE y = Qundef;
+
+	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)))
+			y = acosh_cb(x, prec);
+	}
+	if (y == Qundef)
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,17 @@
+VALUE
+acosh_edom(VALUE x, VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID div = rb_intern("div");
+	VALUE t, w, y;
+
+	rb_check_precise(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);
+	if (rb_num_negative_p(x))
+		y = rb_funcall(rb_bigmath_const_pi(prec), add, 2, y, prec);
+
+	return rb_Complex(BIG_ZERO, y);
+}

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

@@ -0,0 +1,14 @@
+VALUE
+acosh_logrep(VALUE x, VALUE prec)
+{
+	VALUE n, t, y;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	t = rb_funcall1(rb_funcall1(x, '*', x), '-', BIG_ONE);
+	t = rb_bigmath_sqrt(t, n);
+	y = rb_bigmath_log(rb_funcall1(x, '+', t), n);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,16 @@
+VALUE
+acot_branch(VALUE x, VALUE prec, bigmath_func1 acot_cb)
+{
+	VALUE y;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		y = BIG_NAN;
+	else if (rb_num_infinite_p(x) != 0)
+		y = rb_num_negative_p(x) ? BIG_MINUS_ZERO : BIG_ZERO;
+	else
+		y = acot_cb(x, prec);
+
+	return y;
+}

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

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

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

@@ -0,0 +1,20 @@
+VALUE
+acoth_branch(VALUE x, VALUE prec, bigmath_func1 acoth_cb)
+{
+	VALUE y;
+	const ID leq = rb_intern("<=");
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_equal_p(x, BIG_ONE))
+		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)))
+		y = acoth_cb(x, prec);
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,18 @@
+VALUE
+acoth_edom(VALUE x, VALUE prec)
+{
+	VALUE t, pi;
+
+	rb_check_precise(prec);
+
+	t = rb_funcall1(
+		rb_funcall1(x, '+', BIG_ONE), '/', 
+		rb_funcall1(x, '-', BIG_ONE));
+	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/acoth/logrep.h

@@ -0,0 +1,33 @@
+VALUE
+acoth_logrep(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	y = rb_funcall1(
+		rb_funcall1(x, '+', BIG_ONE), '/', 
+		rb_funcall1(x, '-', BIG_ONE));
+	y = rb_bigmath_log(y, prec);
+	y = rb_funcall1(rb_Rational(INT2FIX(1), INT2FIX(2)), '*', y);
+	y = rb_num_round(y, prec);
+
+	return y;
+}
+
+
+#if 0
+VALUE
+acoth_logrep(VALUE x, VALUE prec)
+{
+	VALUE r1, r2, r3, r4;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RECIPROCAL);
+	r1 = rb_funcall1(BIG_ONE, '+', x);
+	r2 = rb_bigmath_sqrt(r1, prec);
+	r1 = rb_funcall1(BIG_ONE, '-', x);
+	r3 = rb_bigmath_sqrt(r1, prec);
+	r4 = rb_funcall1(r2, '/', r3);
+	r4 = rb_bigmath_log(r4, prec);
+
+	return rb_num_round(r4, prec);
+}
+#endif

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

@@ -0,0 +1,21 @@
+VALUE
+acsc_branch(VALUE x, VALUE prec, bigmath_func1 acsc_cb)
+{
+	const ID leq = rb_intern("<=");
+	const ID geq = rb_intern(">=");
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		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)))
+		y = acsc_cb(x, prec);
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,20 @@
+VALUE
+acsc_edom(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE imag, y, arg, t;
+
+	rb_check_precise(prec);
+
+	x = rb_num_canonicalize(x, prec, 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);
+	if (!rb_num_negative_p(x))
+		arg = rb_num_uminus(arg);
+	imag = rb_bigmath_log(rb_num_abs(t), prec);
+	y = rb_Complex(arg, imag);
+	y = rb_num_uminus(y);
+
+	return y;
+}

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

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

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

@@ -0,0 +1,25 @@
+VALUE
+acsch_branch(VALUE x, VALUE prec, bigmath_func1 acsch_cb)
+{
+	const ID leq = rb_intern("<=");
+	VALUE y = Qundef;
+	int sign;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	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)))
+	{
+		y = acsch_cb(x, prec);
+	}
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,25 @@
+VALUE
+acsch_logrep(VALUE x, VALUE prec)
+{
+	VALUE t, y;
+
+	rb_check_precise(prec);
+
+	x = rb_num_canonicalize(x, prec, 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);
+	}
+	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/asec/branch.h

@@ -0,0 +1,22 @@
+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;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		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)))
+		y = asec_cb(x, prec);
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,16 @@
+VALUE
+asec_edom(VALUE x, VALUE prec)
+{
+	VALUE imag, y, arg, t;
+
+	rb_check_precise(prec);
+
+	x = rb_num_canonicalize(x, prec, 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);
+	y = rb_Complex(arg, imag);
+
+	return y;
+}

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

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

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

@@ -0,0 +1,18 @@
+VALUE
+asech_branch(VALUE x, VALUE prec, bigmath_func1 asech_cb)
+{
+	const ID leq = rb_intern("<=");
+	VALUE y;
+
+	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)))
+	{
+		y = asech_cb(x, prec);
+	}
+	else
+		y = BIG_NAN;
+
+	return y;
+}

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

@@ -0,0 +1,19 @@
+VALUE
+asech_edom(VALUE x, VALUE prec)
+{
+	VALUE absx, recip_x, sqr, w, y;
+
+	absx = rb_num_abs(x);
+	recip_x = rb_num_canonicalize(absx, prec, 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_funcall1(w, '*', rb_funcall1(recip_x, '+', BIG_ONE));
+	w = rb_funcall1(w, '+', recip_x);
+	y = rb_bigmath_carg(w, prec);
+	if (rb_num_negative_p(x))
+		y =rb_funcall1(rb_bigmath_const_pi(prec), '-', y);
+
+	return rb_Complex(BIG_ZERO, y);
+}

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

@@ -0,0 +1,16 @@
+VALUE
+asech_logrep(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = rb_funcall1(x, '*', x);
+	y = rb_funcall1(BIG_ONE, '-', y);
+	y = rb_bigmath_sqrt(y, prec);
+	y = rb_funcall1(y, '+', BIG_ONE);
+	y = rb_funcall1(y, '/', x);
+	y = rb_bigmath_log(y, prec);
+
+	return y;
+}

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

@@ -0,0 +1,22 @@
+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"));
+
+	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;
+		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)))
+			y = asin_cb(x, prec);
+		else
+			y = BIG_NAN;
+	}
+	return y;
+}

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

@@ -0,0 +1,20 @@
+VALUE
+asin_edom(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE imag, y, arg, t;
+
+	rb_check_precise(prec);
+
+	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);
+	if (!rb_num_negative_p(x))
+		arg = rb_num_uminus(arg);
+	imag = rb_bigmath_log(rb_num_abs(t), prec);
+	y = rb_Complex(arg, imag);
+	y = rb_num_uminus(y);
+
+	return y;
+}

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

@@ -0,0 +1,15 @@
+VALUE
+asin_logrep(VALUE x, VALUE prec)
+{
+	VALUE t;
+
+	rb_check_precise(prec);
+
+	t = rb_funcall1(x, '*', x);
+	t = rb_funcall1(INT2FIX(1), '-', t);
+	t = rb_bigmath_sqrt(t, prec);
+	t = rb_funcall1(x, '/', t);
+	t = rb_bigmath_atan(t, prec);
+
+	return t;
+}

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

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

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

@@ -0,0 +1,26 @@
+VALUE
+asinh_branch(VALUE x, VALUE prec, bigmath_func1 asinh_cb)
+{
+	VALUE y = Qundef, eps5 = rb_BigDecimal1(rb_str_new_cstr("0.001"));
+	int sign;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		y = BIG_NAN;
+	else if ((sign = rb_num_infinite_p(x)) != 0)
+	{
+		y = sign == 1 ? BIG_INF : BIG_MINUS_INF;
+	}
+	else if (rb_num_zero_p(x))
+		y = BIG_ZERO;
+	else
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (RTEST(rb_num_coerce_cmp(absx, eps5, '<')))
+			y = asinh_ser(x, prec);
+		else
+			y = asinh_cb(x, prec);
+	 }
+	return y;
+}