bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,11 @@
+VALUE
+sec_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_REAL, ARG_RECIPROCAL);
+}

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

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

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

@@ -0,0 +1,21 @@
+VALUE
+sech_branch(VALUE x, VALUE prec, bigmath_func1 sech_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_ZERO;
+	else
+	{
+		VALUE absx = rb_num_negative_p(x) ? rb_num_uminus(x) : x;
+		if (RTEST(rb_num_coerce_cmp(absx, INT2FIX(3), '<')))
+			y = sech_ser(x, prec);
+		else
+			y = sech_cb(x, prec);
+	}
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+sech_eulerf(VALUE x, VALUE prec)
+{
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = trig_f_euler(mf_cos, x, prec);
+
+	return rb_num_canonicalize(y, prec, ARG_REAL, ARG_RECIPROCAL);
+}

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

@@ -0,0 +1,25 @@
+VALUE
+sech_formula(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE t = rb_bigmath_exp(x, n), y = Qundef;
+	VALUE 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 (rb_num_infinite_p(t) != 0)
+		y = BIG_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/sech/ser.h

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

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

@@ -0,0 +1,23 @@
+VALUE
+sin_branch(VALUE x, VALUE prec, bigmath_func1 sin_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_sin = Qundef;
+		x = rb_bigmath_to_rad(x, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL))
+			w = v_sin;
+		else
+			w = sin_cb(x, prec);
+	}
+
+	return w;
+}
+

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

@@ -0,0 +1,11 @@
+VALUE
+sin_eulerf(VALUE z, VALUE prec)
+{
+	const ID sin = rb_intern("sin");
+
+	rb_check_precise(prec);
+
+	z = trig_f_euler(sin, rb_ImaginaryZ(z, SIGN_PLUS), prec);
+
+	return rb_num_real(z);
+}

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

@@ -0,0 +1,13 @@
+VALUE
+sin_ser(VALUE x, VALUE prec)
+{
+	VALUE sin;
+
+	rb_check_precise(prec);
+
+	rb_bigmath_sincos(x, prec, &sin, NULL);
+
+	sin = rb_num_round(sin, prec);
+
+	return sin;
+}

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

@@ -0,0 +1,50 @@
+void
+sincos_ser(VALUE x, VALUE prec, VALUE *sin, VALUE *cos)
+{
+	const ID div = rb_intern("div");
+	VALUE n, m, f, w, a, y;
+	long i = 0;
+	
+	if (sin == NULL && cos == NULL)
+		return;
+	
+	if (!rb_num_finite_p(x))
+	{
+		if (sin != NULL)  *sin = BIG_NAN;
+		if (cos != NULL)  *cos = BIG_NAN;
+		return;
+	}
+	n = rb_numdiff_make_n(prec);
+	f = BIG_ONE;
+	w = BIG_ONE;
+	a = BIG_ONE;
+	y = BIG_ZERO;
+	if (sin != NULL)  *sin = BIG_ZERO;
+	if (cos != NULL)  *cos = BIG_ZERO;
+	while (rb_numdiff_condition_p(y, a, n, &m))
+	{
+		a = rb_funcall(w, div, 2, f, m);
+		switch (i % 4) {
+		case 0:
+			if (cos != NULL) *cos = (y = rb_funcall1(*cos, '+', a));
+			break;
+		case 1:
+			if (sin != NULL) *sin = (y = rb_funcall1(*sin, '+', a));
+			break;
+		case 2:
+                        if (cos != NULL) *cos = (y = rb_funcall1(*cos, '-', a));
+			break;
+		case 3:
+                        if (sin != NULL) *sin = (y = rb_funcall1(*sin, '-', a));
+			break;
+		}
+		w = rb_funcall1(w, '*', x);
+		f = rb_funcall1(f, '*', LONG2NUM(++i));
+	}
+	RB_GC_GUARD(f);
+	RB_GC_GUARD(w);
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(y);
+	if (sin != NULL)  RB_GC_GUARD(*sin);
+	if (cos != NULL)  RB_GC_GUARD(*cos);
+}

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

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

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

@@ -0,0 +1,11 @@
+VALUE
+sinh_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_real(y);
+}

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

@@ -0,0 +1,26 @@
+VALUE
+sinh_formula(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE t = rb_bigmath_exp(x, n), y = Qundef;
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	int sign;
+
+	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 ((sign = rb_num_infinite_p(t)) != 0)
+		y = sign == 1 ? BIG_INF : BIG_MINUS_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/sinh/ser.h

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

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

@@ -0,0 +1,70 @@
+static void
+sinhcosh_inline(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
+{
+	const ID div = rb_intern("div");
+	VALUE n, m, f, w, a, y;
+	long i = 0;
+
+	n = rb_numdiff_make_n(prec);
+	f = BIG_ONE;
+	w = BIG_ONE;
+	a = BIG_ONE;
+	y = BIG_ZERO;
+	
+	if (sinh != NULL)  *sinh = BIG_ZERO;
+	if (cosh != NULL)  *cosh = BIG_ZERO;
+	while (rb_numdiff_condition_p(y, a, n, &m))
+	{
+		a = rb_funcall(w, div, 2, f, m);
+		switch (i % 2) {
+		case 0:
+			if (cosh != NULL)  *cosh = (y = rb_funcall1(*cosh, '+', a));
+			break;
+		case 1:
+                        if (sinh != NULL)  *sinh = (y = rb_funcall1(*sinh, '+', a));
+ 			break;
+		}
+		w = rb_funcall1(w, '*', x);
+		f = rb_funcall1(f, '*', LONG2NUM(++i));
+	}
+	RB_GC_GUARD(f);
+	RB_GC_GUARD(w);
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(y);
+	if (sinh != NULL)  RB_GC_GUARD(*sinh);
+	if (cosh != NULL)  RB_GC_GUARD(*cosh);
+}
+
+void
+sinhcosh_ser(VALUE x, VALUE prec, VALUE *sinh, VALUE *cosh)
+{
+	int sign;
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	
+	if (sinh == NULL && cosh == NULL)  return;
+	
+	if (rb_num_nan_p(x))
+	{
+		if (sinh != NULL)  *sinh = BIG_NAN;
+		if (cosh != NULL)  *cosh = BIG_NAN;
+	}
+	else if ((sign = rb_num_infinite_p(x)) != 0)
+	{
+		switch (sign) {
+		case 1:
+			if (sinh != NULL)  *sinh = BIG_INF;
+			if (cosh != NULL)  *cosh = BIG_INF;
+			break;
+		case -1:
+			if (sinh != NULL)  *sinh = BIG_MINUS_INF;
+			if (cosh != NULL)  *cosh = BIG_INF;
+			break;
+		}
+	}
+	else
+	{
+		sinhcosh_inline(x, prec, sinh, cosh);
+		if (sinh != NULL)  *sinh = rb_num_round(*sinh, prec);
+		if (cosh != NULL)  *cosh = rb_num_round(*cosh, prec);
+	}
+}

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

@@ -0,0 +1,16 @@
+VALUE
+sqrt_branch(VALUE x, VALUE prec, bigmath_func1 sqrt_cb)
+{
+#define SWITCH_PRECISION_NUMBER 2253
+	rb_check_precise(prec);
+	if (rb_num_negative_p(x))
+		return BIG_NAN;
+	else if (!rb_num_finite_p(x))
+		return rb_BigDecimal1(x);
+	if (TYPE(prec) == T_FIXNUM &&
+	    NUM2LONG(prec) < SWITCH_PRECISION_NUMBER)
+		return sqrt_builtin(x, prec);
+	else
+		return sqrt_cb(x, prec);
+#undef SWITCH_PRECISION_NUMBER
+}

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

@@ -0,0 +1,12 @@
+VALUE
+sqrt_builtin(VALUE x, VALUE prec)
+{
+	const ID sqrt = rb_intern("sqrt");
+
+	rb_check_precise(prec);
+
+	if (rb_num_negative_p(x) || rb_num_notequal_p(x, x))
+		return BIG_NAN;
+
+	return rb_funcall(x, sqrt, 1, prec);
+}

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

@@ -0,0 +1,9 @@
+VALUE
+sqrt_edom(VALUE x, VALUE prec)
+{
+	VALUE imag;
+	RUBY_ASSERT(rb_num_negative_p(x));
+	x = rb_num_uminus(x);
+	imag = rb_bigmath_sqrt(x, prec);
+	return rb_num_round(rb_Complex(BIG_ZERO, imag), prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/sqrt/newton.h

@@ -0,0 +1,36 @@
+// Reference: C-gengo ni yoru hyoujun algorithm jiten - Haruhiko Okumura
+VALUE
+sqrt_newton(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE s = Qundef, t = Qundef, last = Qundef, n;
+	VALUE two;
+
+	rb_check_precise(prec);
+
+	if (rb_num_zero_p(x))
+		return BIG_ZERO;
+	else if (rb_num_positive_p(x))
+	{
+		if (rb_num_infinite_p(x))
+			return BIG_INF;
+		n = rb_numdiff_make_n(prec);
+		s = RTEST(rb_num_coerce_cmp(x, INT2FIX(1), '>')) ? x : BIG_ONE;
+		two = rb_BigDecimal1(INT2FIX(2));
+		do {
+			last = s;
+			t = rb_funcall1(x, '/', s);
+			t = rb_funcall1(t, '+', s);
+			s = rb_funcall(t, div, 2, two, n);
+		} while (rb_num_coerce_cmp(s, last, '<'));
+
+		RB_GC_GUARD(s);
+		RB_GC_GUARD(t);
+		RB_GC_GUARD(last);
+		RB_GC_GUARD(two);
+
+		return rb_num_round(last, prec);
+	}
+	else
+		return BIG_NAN;
+}

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

@@ -0,0 +1,26 @@
+VALUE
+tan_branch(VALUE x, VALUE prec, bigmath_func1 tan_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_sin = Qundef, v_cos;
+		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_sin, div, 2, v_cos, prec);
+		}
+		else
+			w = tan_cb(x, prec);
+	}
+
+	return w;
+}
+

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

@@ -0,0 +1,11 @@
+VALUE
+tan_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_real(w);
+}

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

@@ -0,0 +1,18 @@
+VALUE
+tan_ser(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE sin, cos;
+
+	rb_check_precise(prec);
+
+	if (!rb_num_finite_p(x))
+		return BIG_NAN;
+	rb_check_precise(prec);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	rb_bigmath_sincos(x, prec, &sin, &cos);
+	sin = rb_num_round(sin, prec);
+	cos = rb_num_round(cos, prec);
+
+	return rb_funcall(sin, div, 2, cos, prec);
+}

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

@@ -0,0 +1,23 @@
+VALUE
+tanh_branch(VALUE x, VALUE prec, bigmath_func1 tanh_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 = tanh_ser(x, prec);
+		else
+			y = tanh_cb(x, prec);
+	}
+
+	return y;
+}

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

@@ -0,0 +1,11 @@
+VALUE
+tanh_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_real(y);
+}

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

@@ -0,0 +1,27 @@
+VALUE
+tanh_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 = rb_numdiff_make_n(prec);
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+        VALUE t = rb_bigmath_exp(rb_funcall1(x, '*', two), n), y = Qundef;
+	int sign;
+
+	if (TYPE(t) == T_FIXNUM || TYPE(t) == T_BIGNUM)
+	{
+		y = rb_Rational(rb_funcall(t, pred, 0), rb_funcall(t, succ, 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/tanh/ser.h

@@ -0,0 +1,14 @@
+VALUE
+tanh_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(sinh, div, 2, cosh, prec);
+
+	return y;
+}