bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,38 @@
+VALUE
+casech_branch(VALUE z, VALUE prec, bigmath_func1 casech_cb)
+{
+	VALUE w = Qundef;
+	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))
+		w = rb_Complex(BIG_NAN, BIG_NAN);
+	else if (z_re_inf || z_im_inf)
+	{
+		const ID div = rb_intern("div");
+		if (z_re_inf != 0 && z_im_inf == 0)
+		{
+			VALUE imag = rb_funcall(rb_bigmath_const_pi(prec), div, 
+				2, INT2FIX(2), prec);
+			w = rb_Complex(BIG_ZERO, imag);
+		}
+		else if (z_re_inf == 0 && z_im_inf != 0)
+		{
+			VALUE imag = rb_funcall(rb_bigmath_const_pi(prec), div, 
+				2, INT2FIX(-2 * z_im_inf), prec);
+			w = rb_Complex(BIG_ZERO, imag);
+		}
+		else if (z_re_inf == -1 && z_im_inf == 1)
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		else
+			w = rb_Complex(BIG_ZERO, BIG_ZERO);
+	}
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		w = casech_cb(z, prec);
+	}
+
+	return w;
+}
+

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

@@ -0,0 +1,9 @@
+VALUE
+casech_logrep(VALUE z, VALUE prec)
+{
+	rb_check_precise(prec);
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+
+	return cacosh_logrep(z, prec);
+}

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

@@ -0,0 +1,35 @@
+VALUE
+casin_branch(VALUE z, VALUE prec, bigmath_func1 casin_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)
+	{
+		const ID div = rb_intern("div");
+		if (z_re_inf != 0 && z_im_inf == 0)
+		{
+			VALUE real = rb_num_zero_p(rb_num_imag(z)) ?
+				rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
+					INT2FIX(z_re_inf * 2), prec) :
+				BIG_ZERO;
+			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 casin_cb(z, prec);
+	}
+}

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

@@ -0,0 +1,14 @@
+VALUE
+casin_logrep(VALUE z, VALUE prec)
+{
+	VALUE c1, c2, c3;
+
+	rb_check_precise(prec);
+
+	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);
+
+	return rb_ImaginaryZ(c3, SIGN_MINUS);
+}

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

@@ -0,0 +1,59 @@
+VALUE
+casinh_branch(VALUE z, VALUE prec, bigmath_func1 casinh_cb)
+{
+	VALUE y = Qundef;
+
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(rb_num_imag(z)) == 0)
+		{
+			switch (rb_num_infinite_p(rb_num_real(z))) {
+			case 1:
+				y = rb_Complex(BIG_INF, BIG_ZERO);
+				break;
+			case -1:
+				y = rb_Complex(BIG_MINUS_INF, BIG_ZERO);
+				break;
+			}
+		}
+		else if (rb_num_infinite_p(rb_num_real(z)) == 0)
+		{
+			if (rb_num_zero_p(rb_num_real(z)))
+			{
+				switch (rb_num_infinite_p(rb_num_imag(z))) {
+				case 1:
+					y = rb_Complex(BIG_INF, rb_bigmath_const_pi(prec));
+					break;
+				case -1:
+					y = rb_Complex(BIG_ZERO, BIG_ZERO);
+					break;
+				}
+			}
+			else
+			{
+				const ID div = rb_intern("div");
+				VALUE pi_2 = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+				switch (rb_num_infinite_p(rb_num_imag(z))) {
+				case 1:
+					y = rb_Complex(BIG_INF, pi_2);
+					break;
+				case -1:
+					pi_2 = rb_num_uminus(pi_2);
+					y = rb_Complex(BIG_ZERO, pi_2);
+					break;
+				}
+			}
+		}
+		else
+		{
+			y = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+	}
+	if (y == Qundef)
+	{
+		y = casinh_cb(z, prec);
+	}
+	return y;
+}

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

@@ -0,0 +1,13 @@
+VALUE
+casinh_logrep(VALUE z, VALUE prec)
+{
+	VALUE n, t, y;
+
+	n = rb_numdiff_make_n(prec);
+
+	t = rb_funcall1(rb_funcall1(z, '*', z), '+', BIG_ONE);
+	t = rb_bigmath_csqrt(t, n);
+	y = rb_bigmath_clog(rb_funcall1(z, '+', t), n);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,46 @@
+VALUE
+catan_branch(VALUE z, VALUE prec, bigmath_func1 catan_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)
+	{
+		const ID div = rb_intern("div");
+		if (z_re_inf != 0 && z_im_inf == 0)
+		{
+			VALUE real = 
+				rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
+				INT2FIX(z_re_inf * 2), prec);
+			VALUE imag = BIG_ZERO;
+			return rb_Complex(real, imag);
+		}
+		else if (z_re_inf == 0 && z_im_inf != 0)
+		{
+			VALUE real = 
+				rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
+				INT2FIX(z_im_inf * 2), prec);
+			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 if (rb_num_equal_p(z, rb_Complex_I))
+		return rb_Complex(BIG_ZERO, BIG_INF);
+	else if (rb_num_equal_p(z, rb_Complex_mI))
+		return rb_Complex(BIG_ZERO, BIG_MINUS_INF);
+	else
+	{
+		z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+		return catan_cb(z, prec);
+	}
+#undef rb_Complex_I
+#undef rb_Complex_mI
+}

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

@@ -0,0 +1,17 @@
+VALUE
+catan_logrep(VALUE z, VALUE prec)
+{
+	VALUE c1, c2, c3;
+
+	rb_check_precise(prec);
+
+	c1 = rb_ImaginaryZ(z, SIGN_PLUS);
+	c2 = rb_funcall1(rb_Complex(BIG_ONE, rb_num_uminus(z)), '/', 
+	                 rb_Complex(BIG_ONE, z));
+	c3 = rb_bigmath_clog(c2, prec);
+
+	c1 = rb_Complex(INT2FIX(0), rb_Rational(INT2FIX(1), INT2FIX(2)));
+	c2 = rb_funcall1(c1, '*', c3);
+
+	return rb_num_round(c2, prec);
+}

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

@@ -0,0 +1,26 @@
+VALUE
+catanh_branch(VALUE z, VALUE prec, bigmath_func1 catanh_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)
+	{
+		const ID div = rb_intern("div");
+		VALUE pi_2 = rb_funcall(
+			rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+		if (rb_num_negative_p(rb_num_imag(z)))
+			pi_2 = rb_num_uminus(pi_2);
+		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/catanh/logrep.h

@@ -0,0 +1,10 @@
+VALUE
+catanh_logrep(VALUE z, VALUE prec)
+{
+	rb_check_precise(prec);
+
+	z = rb_ImaginaryZ(z, SIGN_PLUS);
+	z = catan_logrep(z, prec);
+
+	return rb_ImaginaryZ(z, SIGN_MINUS);
+}

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

@@ -0,0 +1,11 @@
+VALUE
+ccbrt_formula(VALUE z, VALUE prec)
+{
+	VALUE one_third;
+
+	rb_check_precise(prec);
+
+	one_third = rb_Rational(INT2FIX(1), INT2FIX(3));
+
+	return rb_bigmath_cpow(z, one_third, prec);
+}

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

@@ -0,0 +1,41 @@
+VALUE
+ccos_branch(VALUE z, VALUE prec, bigmath_func1 ccos_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_INF, 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))
+		{
+			w = rb_Complex(v_cos, BIG_ZERO);
+		}
+		else
+		{
+			w = ccos_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,37 @@
+VALUE
+ccosh_branch(VALUE z, VALUE prec, bigmath_func1 ccosh_cb)
+{
+	VALUE w = Qundef;
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_Complex(BIG_INF, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_cos = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, NULL, &v_cos) &&
+		    rb_num_zero_p(real))
+		{
+			w = rb_Complex(BIG_ZERO, v_cos);
+		}
+		else
+		{
+			w = ccosh_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,46 @@
+VALUE
+ccot_branch(VALUE z, VALUE prec, bigmath_func1 ccot_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)))
+		{
+			if (rb_num_negative_p(rb_num_imag(z)))
+				w = rb_Complex(BIG_ZERO, BIG_ONE);
+			else
+				w = rb_Complex(BIG_ZERO, BIG_MINUS_ONE);
+		}
+		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_sin = Qundef, v_cos = Qundef;
+		real = rb_bigmath_to_rad(real, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, &v_cos) &&
+		    rb_num_zero_p(imag))
+		{
+			const ID div = rb_intern("div");
+			w = rb_funcall(v_cos, div, 2, v_sin, prec);
+			w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			w = ccot_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,43 @@
+VALUE
+ccoth_branch(VALUE z, VALUE prec, bigmath_func1 ccoth_cb)
+{
+	VALUE w = Qundef;
+	
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_num_negative_p(rb_num_real(z)) ? BIG_MINUS_ONE : BIG_ONE;
+			w = rb_Complex(w, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef, v_cos = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, &v_cos) &&
+		    rb_num_zero_p(real))
+		{
+			const ID div = rb_intern("div");
+			w = rb_funcall(v_cos, div, 2, v_sin, prec);
+			w = rb_Complex(BIG_ZERO, w);
+		}
+		else
+		{
+			w = ccoth_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,42 @@
+VALUE
+ccsc_branch(VALUE z, VALUE prec, bigmath_func1 ccsc_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_sin = Qundef;
+		real = rb_bigmath_to_rad(real, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL) &&
+		    rb_num_zero_p(imag))
+		{
+			v_sin = rb_num_canonicalize(v_sin, prec, ARG_REAL, ARG_RECIPROCAL);
+			w = rb_Complex(v_sin, BIG_ZERO);
+		}
+		else
+		{
+			w = ccsc_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,38 @@
+VALUE
+ccsch_branch(VALUE z, VALUE prec, bigmath_func1 ccsch_cb)
+{
+	VALUE w = Qundef;
+	if (!rb_num_finite_p(z))
+	{
+		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
+		{
+			w = rb_Complex(BIG_ZERO, BIG_ZERO);
+		}
+		else
+		{
+			w = BIG_NAN;
+			if (rb_num_nan_p(rb_num_real(w)) && rb_num_zero_p(rb_num_imag(z)))
+				w = rb_Complex(w, BIG_ZERO);
+			else
+				w = rb_Complex(w, BIG_NAN);
+		}
+	}
+	if (w == Qundef)
+	{
+		VALUE real = rb_num_real(z), imag = rb_num_imag(z);
+		VALUE t = Qundef;
+		VALUE v_sin = Qundef;
+		imag = rb_bigmath_to_rad(imag, prec, &t);
+		if (-1 != rb_bigmath_degree_sparg(t, prec, &v_sin, NULL) &&
+		    rb_num_zero_p(real))
+		{
+			v_sin = rb_num_canonicalize(v_sin, prec, ARG_REAL, ARG_RECIPROCAL);
+			w = rb_Complex(BIG_ZERO, v_sin);
+		}
+		else
+		{
+			w = ccsch_cb(rb_Complex(real, imag), prec);
+		}
+	}
+	return w;
+}

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

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

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

@@ -0,0 +1,42 @@
+VALUE
+cexp_branch(VALUE z, VALUE prec, bigmath_func1 cexp_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 = cexp_cb(rb_Complex(real, imag), prec);
+	}
+	return w;
+}

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

@@ -0,0 +1,21 @@
+VALUE
+cexp_eulerf(VALUE z, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE theta, r;
+
+	rb_check_precise(prec);
+
+	if (!rb_num_finite_p(rb_num_imag(z)))
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	r = rb_num_canonicalize(rb_num_real(z), prec, ARG_REAL, ARG_RAWVALUE);
+	r = rb_bigmath_exp(r, prec);
+	if (rb_num_notequal_p(r, r))
+		return rb_Complex(BIG_NAN, BIG_NAN);
+	theta = f_euler_formula(rb_num_imag(z), prec);
+
+	return rb_Complex(
+		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_real(theta), prec),
+		rb_funcall(rb_BigDecimal1(r), mult, 2, rb_num_imag(theta), prec)
+	);
+}