bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,42 @@
+VALUE
+cexp2_branch(VALUE z, VALUE prec, bigmath_func1 cexp2_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		int real_sign;
+		if (rb_num_nan_p(z))
+		{
+			if (rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_NAN, BIG_ZERO);
+			else
+				w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else if ((real_sign = rb_num_infinite_p(rb_num_real(z))) != 0 &&
+		          rb_num_finite_p(rb_num_imag(z)))
+		{
+			switch (real_sign) {
+			case -1:
+				w = rb_Complex(BIG_ZERO, BIG_ZERO);
+				break;
+			case 1:
+				w = rb_Complex(BIG_INF, BIG_ZERO);
+				break;
+			}
+		}
+                else
+		{
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		imag = rb_bigmath_to_rad(imag, prec, NULL);
+		w = cexp2_cb(rb_Complex(real, imag), prec);
+	}
+	return w;
+}

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

@@ -0,0 +1,12 @@
+VALUE
+cexp2_eulerf(VALUE z, VALUE prec)
+{
+	VALUE log2 = rb_bigmath_const_log2(prec);
+
+	rb_check_precise(prec);
+
+	z = rb_funcall1(z, '*', log2);
+	z = cexp_eulerf(z, prec);
+
+	return z;
+}

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

@@ -0,0 +1,54 @@
+VALUE
+clog_branch(VALUE z, VALUE prec, bigmath_func1 clog_cb)
+{
+	VALUE w = Qundef, arg = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_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)))
+		{
+			switch (rb_num_infinite_p(rb_num_real(z))) {
+			case -1:
+				arg = rb_num_imag(clog_cb(BIG_MINUS_ONE, prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				w = rb_Complex(BIG_INF, BIG_ZERO);
+				break;
+			}
+		}
+		else if (rb_num_finite_p(rb_num_real(z)))
+		{
+			switch (rb_num_infinite_p(rb_num_imag(z))) {
+			case -1:
+				arg = rb_num_imag(
+					clog_cb(rb_Complex(BIG_ZERO, BIG_MINUS_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			case 1:
+				arg = rb_num_imag(
+					clog_cb(rb_Complex(BIG_ZERO, BIG_ONE), prec));
+				w = rb_Complex(BIG_INF, arg);
+				break;
+			}
+		}
+		else /* log(INF +i INF) */
+		{
+			w = rb_Complex(
+				rb_BigDecimal1(rb_num_real(z)),
+				rb_BigDecimal1(rb_num_imag(z))
+			);
+		}
+	}
+	if (w == Qundef)
+	{
+		w = clog_cb(z, prec);
+	}
+	return w;
+}

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

@@ -0,0 +1,13 @@
+VALUE
+clog_formula(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	w = rb_Complex(
+		rb_bigmath_log(rb_bigmath_cabs(z, prec), prec),
+		rb_bigmath_carg(z, prec)
+	);
+
+
+	return rb_num_round(w, prec);
+}

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

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

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

@@ -0,0 +1,34 @@
+VALUE
+clog1p_branch(VALUE z, VALUE prec, bigmath_func1 clog1p_cb)
+{
+	VALUE w = Qundef;
+	VALUE one_thousand = rb_Rational(INT2FIX(1), INT2FIX(1000));
+	const ID geq = rb_intern_const(">=");
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_nan_p(z))
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		else
+			w = clog_branch(z, prec, clog1p_cb);
+	}
+	if (w == Qundef)
+	{
+		if (rb_num_zero_p(z))
+			w = rb_Complex(BIG_ZERO, BIG_ZERO);
+		else if (RTEST(rb_num_coerce_cmp(one_thousand, rb_bigmath_cabs(z, prec), geq)))
+		{
+			w = clog1p_cb(z, prec);
+			if (rb_num_real_p(w))
+				w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			z = rb_funcall1(z, '+', BIG_ONE);
+			w = rb_bigmath_clog(z, prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,21 @@
+VALUE
+cos_branch(VALUE x, VALUE prec, bigmath_func1 cos_cb)
+{
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+		w = BIG_NAN;
+	else
+	{
+		VALUE t = Qundef;
+		VALUE v_cos = Qundef;
+		x = rb_bigmath_to_rad(x, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, NULL, &v_cos))
+			w = v_cos;
+		else
+			w = cos_cb(x, prec);
+	}
+	return w;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+cos_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_cos, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return rb_num_real(w);
+}

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

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

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

@@ -0,0 +1,22 @@
+VALUE
+cosh_branch(VALUE x, VALUE prec, bigmath_func1 cosh_cb)
+{
+	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_INF;
+	else
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (RTEST(rb_num_coerce_cmp(absx, INT2FIX(3), '<')))
+			y = cosh_ser(x, prec);
+		else
+			y = cosh_cb(x, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+cosh_eulerf(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = trig_f_euler(mf_cos, x, prec);
+
+	return rb_num_real(y);
+}

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

@@ -0,0 +1,30 @@
+VALUE
+cosh_formula(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	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));
+
+	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
+	{
+		y = rb_Rational(INT2FIX(1), t);
+	        y = rb_funcall1(t, '+', y);
+	        y = rb_funcall(rb_BigDecimal(y, n), div, 2, two, prec);
+	}
+	else if (rb_num_infinite_p(t) != 0)
+		y = BIG_INF;
+	else
+	{
+		y = rb_num_canonicalize(t, prec, ARG_REAL, ARG_RECIPROCAL);
+		y = rb_funcall1(t, '+', y);
+		y = rb_funcall(y, div, 2, two, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+cosh_ser(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef;
+
+	rb_check_precise(prec);
+
+	sinhcosh_ser(x, prec, NULL, &y);
+
+	return y;
+}

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

@@ -0,0 +1,28 @@
+VALUE
+cot_branch(VALUE x, VALUE prec, bigmath_func1 cot_cb)
+{
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+		w = BIG_NAN;
+	else if (rb_num_infinite_p(x) != 0)
+		w = rb_num_infinite_p(x) ? BIG_MINUS_ZERO : BIG_ZERO;
+	else
+	{
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef, v_cos = Qundef;
+		x = rb_bigmath_to_rad(x, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, &v_cos))
+		{
+			const ID div = rb_intern("div");
+			w = rb_funcall(v_cos, div, 2, v_sin, prec);
+		}
+		else
+			w = cot_cb(x, prec);
+	}
+
+	return w;
+}
+

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

@@ -0,0 +1,11 @@
+VALUE
+cot_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_tan, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return rb_num_canonicalize(w, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,12 @@
+VALUE
+cot_ser(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE sin, cos;
+
+	rb_check_precise(prec);
+
+	rb_bigmath_sincos(x, prec, &sin, &cos);
+
+	return rb_funcall(cos, div, 2, sin, prec);
+}

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

@@ -0,0 +1,23 @@
+VALUE
+coth_branch(VALUE x, VALUE prec, bigmath_func1 coth_cb)
+{
+	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_ONE : BIG_MINUS_ONE;
+	else
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (RTEST(rb_num_coerce_cmp(absx, INT2FIX(3), '<')))
+			y = coth_ser(x, prec);
+		else
+			y = coth_cb(x, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+coth_eulerf(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = rb_ImaginaryZ(trig_f_euler(mf_tan, x, prec), SIGN_PLUS);
+
+	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,30 @@
+VALUE
+coth_formula(VALUE x, VALUE prec)
+{
+	const ID pred = rb_intern("pred");
+	const ID succ = rb_intern("succ");
+	const ID div = rb_intern("div");
+	VALUE n, two, t, y = Qundef;
+	int sign;
+
+	n = rb_numdiff_make_n(prec);
+
+	two = rb_BigDecimal1(INT2FIX(2));
+        t = rb_bigmath_exp(rb_funcall1(x, '*', two), n);
+
+	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
+	{
+		y = rb_Rational(rb_funcall(t, succ, 0), rb_funcall(t, pred, 0));
+	        y = rb_BigDecimal(y, prec);
+	}
+	else if ((sign = rb_num_infinite_p(t)) != 0)
+		y = sign == 1 ? BIG_ONE : BIG_MINUS_ONE;
+	else
+	{
+		y = rb_funcall(
+			rb_funcall1(t, '+', BIG_ONE), div, 2, 
+			rb_funcall1(t, '-', BIG_ONE), prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,13 @@
+VALUE
+coth_ser(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef, sinh = Qundef, cosh = Qundef;
+	const ID div = rb_intern("div");
+
+	rb_check_precise(prec);
+
+	sinhcosh_ser(x, prec, &sinh, &cosh);
+	y = rb_funcall(cosh, div, 2, sinh, prec);
+
+	return y;
+}

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

@@ -0,0 +1,20 @@
+VALUE
+cpow_formula(VALUE z, VALUE w, VALUE prec)
+{
+	VALUE a = Qundef;
+
+	rb_check_precise(prec);
+
+	if (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);
+	}
+	else
+	{
+		a = rb_bigmath_clog(z, prec);
+		a = rb_funcall1(w, '*', a);
+		a = rb_bigmath_cexp(a, prec);
+	}
+	return a;
+}

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

@@ -0,0 +1,28 @@
+VALUE
+csc_branch(VALUE x, VALUE prec, bigmath_func1 csc_cb)
+{
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		w = BIG_NAN;
+	else if (rb_num_infinite_p(x) != 0)
+	{
+		w = rb_num_negative_p(x) ? BIG_MINUS_ZERO : BIG_ZERO;
+	}
+	else
+	{
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef;
+		x = rb_bigmath_to_rad(x, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL))
+		{
+			w = rb_num_canonicalize(v_sin, prec, ARG_REAL, ARG_RECIPROCAL);
+		}
+		else
+			w = csc_cb(x, prec);
+	}
+
+	return w;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+csc_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return rb_num_canonicalize(w, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,11 @@
+VALUE
+csc_ser(VALUE x, VALUE prec)
+{
+	VALUE sin;
+
+	rb_check_precise(prec);
+
+	rb_bigmath_sincos(x, prec, &sin, NULL);
+
+	return rb_num_canonicalize(sin, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,23 @@
+VALUE
+csch_branch(VALUE x, VALUE prec, bigmath_func1 csch_cb)
+{
+	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
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (RTEST(rb_num_coerce_cmp(absx, INT2FIX(3), '<')))
+			y = csch_ser(x, prec);
+		else
+			y = csch_cb(x, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+csch_eulerf(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = rb_ImaginaryZ(trig_f_euler(mf_sin, x, prec), SIGN_PLUS);
+
+	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,31 @@
+VALUE
+csch_formula(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, t, y, two;
+	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));
+
+	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
+	{
+		y = rb_Rational(INT2FIX(1), t);
+	        y = rb_funcall1(t, '-', y);
+	        y = rb_funcall(two, div, 2, rb_BigDecimal(y, n), prec);
+	}
+	else if ((sign = rb_num_infinite_p(t)) != 0)
+		y = sign == 1 ? BIG_ZERO : BIG_MINUS_ZERO;
+	else
+	{
+		y = rb_num_canonicalize(t, prec, ARG_REAL, ARG_RECIPROCAL);
+		y = rb_funcall1(t, '-', y);
+		y = rb_funcall(two, div, 2, y, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+csch_ser(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef;
+
+	rb_check_precise(prec);
+
+	sinhcosh_ser(x, prec, &y, NULL);
+
+	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,42 @@
+VALUE
+csec_branch(VALUE z, VALUE prec, bigmath_func1 csec_cb)
+{
+	VALUE w = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_nan_p(z) || rb_num_finite_p(rb_num_imag(z)))
+		{
+			if (rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_NAN, BIG_ZERO);
+			else
+				w = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else if (rb_num_finite_p(rb_num_real(z)))
+		{
+			w = rb_Complex(BIG_ZERO, BIG_ZERO);
+		}
+		else
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_cos = Qundef;
+		real = rb_bigmath_to_rad(real, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, NULL, &v_cos) &&
+		    rb_num_zero_p(imag))
+		{
+			v_cos = rb_num_canonicalize(v_cos, prec, ARG_REAL, ARG_RECIPROCAL);
+			w = rb_Complex(v_cos, BIG_ZERO);
+		}
+		else
+		{
+			w = csec_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+csec_eulerf(VALUE z, VALUE prec)
+{
+	VALUE w;
+
+	rb_check_precise(prec);
+
+	w = trig_f_euler(mf_cos, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return rb_num_canonicalize(w, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+}