bigdecimal-math_r 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b95587ca4276311022b70f43467ee93dd4dc91008b0c2b6209773fa44020d608
-  data.tar.gz: 0b0bbcc52b980817ae252104f4da298b80295f2513c8f2659141f4606456bb8b
+  metadata.gz: e81ef8bf762b9147ddb484f578dff41f43fbede81f4b8e875b554528540dc299
+  data.tar.gz: bc13ee261dc7a056eef1eb231f1059190bdf97c8cde0ede2e2206f6c335ede09
 SHA512:
-  metadata.gz: cc27d828aca7556dd0719f04794632ed8a6ed7d855a6bf840c4835e4b56eede56174f4b4f3a81cde94763231cd50306954e729687d41035d762a317ce1e222aa
-  data.tar.gz: 1ad28add251a800315f045a0057cfaf71949e060afa7bf2b2ecc244399df878c27607eaa9385a20b029d40aacd2426f03b47358a1d14c89d092f0d9c573d0c5e
+  metadata.gz: 1ce5aadd6303fea558e215f3a1a9b51953246fe192f0370958c67e247f59483f537944b56a135537c11b6791a2fe495163771c35159b75a230a705991a9d4a61
+  data.tar.gz: ef35daded47e2bf1d127fffe99f0ecb00b0c7fe814cf85b9fa39ac083a50fe396ac3de6c48585cfd428edffe0acc4436cb8aef1ed9ce6d809e2b8068ec65c7fc

data/README.md

@@ -23,7 +23,8 @@ Mathematical functions are compatible with both real and complex solutions.
 
 Constants:  
 ```
-:E (Constant e), 
+:E (Constant e)
+:EulerGamma (Euler-Mascheroni Constant)
 :LOG2 (Natural logarithm of 2)
 :LOG_PI (Natural logarithm of pi)
 :LOG10 (Natural logarithm of 10)

data/changelog.md

@@ -7,6 +7,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.2.7] - 2025-10-XX
+
+### Fix
+- rcm2_edf(): Ignore Increase/Declease for exponent
+
+### Added
+- BigMathR#EulerGamma
+- BigMathR::Const::EulerGamma#borwein_bailey
+
 ## [0.2.6] - 2025-10-XX
 
 ### Fix

data/ext/bigdecimal/math_r/const.c

@@ -54,7 +54,6 @@ __impl_const_e(VALUE unused_obj, VALUE prec)
 	return rb_bigmath_const_e(prec);
 }
 
-#if 0
 /**
  * The Euler-Mascheroni constant gamma.
  * @example
@@ -69,7 +68,6 @@ __impl_const_euler_gamma(VALUE unused_obj, VALUE prec)
 {
 	return rb_bigmath_const_euler_gamma(prec);
 }
-#endif
 
 /**
  * The natural logarithm of 2.
@@ -165,7 +163,6 @@ __impl_const_e_napier(VALUE unused_obj, VALUE prec)
 	return E_napier(prec);
 }
 
-#if 0
 /**
  * Implement by Borwein-Bailey's formula (Brent-McMillan type formula)
  * 
@@ -182,7 +179,6 @@ __impl_const_euler_gamma_borwein_bailey(VALUE unused_obj, VALUE prec)
 {
 	return EulerGamma_borwein_bailey(prec);
 }
-#endif
 
 /**
  * Implement by BBP's formula (Borwein and Bailey 2002)
@@ -208,9 +204,7 @@ InitVM_Const(void)
 {
 	rb_define_module_function(rb_mBigMathR, "PI", __impl_const_pi, 1);
 	rb_define_module_function(rb_mBigMathR, "E", __impl_const_e, 1);
-#if 0
 	rb_define_module_function(rb_mBigMathR, "EulerGamma", __impl_const_euler_gamma, 1);
-#endif
 	rb_define_module_function(rb_mBigMathR, "LOG2", __impl_const_log2, 1);
 	rb_define_module_function(rb_mBigMathR, "LOG_PI", __impl_const_log_pi, 1);
 	rb_define_module_function(rb_mBigMathR, "LOG10", __impl_const_log10, 1);
@@ -220,12 +214,10 @@ InitVM_Const(void)
 	rb_define_module_function(rb_mConstPI, "machin", __impl_const_pi_machin, 1);
 	rb_define_module_function(rb_mConstE, "napier", __impl_const_e_napier, 1);
 	rb_define_module_function(rb_mConstE, "euler_number", __impl_const_e_napier, 1);
-#if 0
 	rb_define_module_function(rb_mConstEulerGamma, "borwein_bailey",
 		__impl_const_euler_gamma_borwein_bailey, 1);
 	rb_define_module_function(rb_mConstEulerGamma, "brent_mcmillan",
 		__impl_const_euler_gamma_borwein_bailey, 1);
-#endif
 	rb_define_module_function(rb_mConstLOG2, "bbp2002", __impl_const_log2_bbp2002, 1);
 }
 

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

@@ -14,7 +14,7 @@ asec_branch(VALUE x, VALUE prec, bigmath_func1 asec_cb)
 		y = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
 	else if (rb_num_equal_p(x, INT2FIX(-1)))
 		y = rb_bigmath_const_pi(prec);
-	else if (rb_num_equal_p(x, INT2FIX(0)))
+	else if (rb_num_equal_p(x, INT2FIX(1)))
 		y = BIG_ZERO;
 	else if (rb_num_domain_p(p_domain, x) || rb_num_domain_p(m_domain, x))
 		y = asec_cb(x, prec);

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

@@ -8,9 +8,13 @@ asec_edom(VALUE x, VALUE prec)
 
 	x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
 	t = rb_funcall1(BIG_ONE, '-', rb_funcall1(x, '*', x));
+	// Bug-fix: Below, if the argument is -0.0, the calculation is Infinity-Infinity, resulting in NaN.
 	t = rb_funcall1(rb_bigmath_sqrt(rb_num_uminus(t), n), '+', x);
 	arg = rb_num_negative_p(x) ? rb_bigmath_const_pi(n) : BIG_ZERO;
 	imag = rb_bigmath_log(rb_num_abs(t), n);
+	// Bug-Fix: Set to -Infinity if NaN
+	if (rb_num_nan_p(imag))
+		imag = BIG_MINUS_INF;
 	y = rb_Complex(arg, imag);
 
 	return rb_num_round(y, prec);

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

@@ -1,6 +1,8 @@
 VALUE
 cacos_branch(VALUE z, VALUE prec, bigmath_func1 cacos_cb)
 {
+	const ID mult = rb_intern("mult");
+	const ID div = rb_intern("div");
 	int z_re_inf = rb_num_infinite_p(rb_num_real(z));
 	int z_im_inf = rb_num_infinite_p(rb_num_imag(z));
 
@@ -14,20 +16,26 @@ cacos_branch(VALUE z, VALUE prec, bigmath_func1 cacos_cb)
 				(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;
+			VALUE imag = BIG_MINUS_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);
+			VALUE real = rb_bigmath_const_pi(prec);
+			VALUE imag = z_im_inf == 1 ? BIG_MINUS_INF : BIG_INF;
+			if (!rb_num_negative_p(rb_num_real(z)))
+				real = rb_funcall(real, div, 2, INT2FIX(2), prec);
+			return rb_Complex(real, imag);
 		}
 		else
 		{
-			return rb_Complex(BIG_ZERO, BIG_ZERO);
+			VALUE real = rb_bigmath_const_pi(prec);
+			VALUE imag = z_im_inf == -1 ? BIG_INF : BIG_MINUS_INF;
+			real = z_re_inf == -1 ?
+				rb_funcall(real, mult, 2, 
+					rb_rational_new(INT2FIX(3), INT2FIX(4)), prec) :
+				rb_funcall(real, div, 2, INT2FIX(4), prec);
+			return rb_Complex(real, imag);
 		}
 	}
 	else

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

@@ -17,14 +17,16 @@ cacosh_branch(VALUE z, VALUE prec, bigmath_func1 cacosh_cb)
 		}
 		else if (z_re_inf == 0 && z_im_inf != 0)
 		{
+			const ID div = rb_intern("div");
 			VALUE real = BIG_INF;
-			VALUE imag = BIG_ZERO;
+			VALUE imag = rb_funcall(rb_bigmath_const_pi(prec), 
+				div, 2, INT2FIX(2), prec);
+			if (z_im_inf == -1)
+				imag = rb_num_uminus(imag);
 			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);
+			return rb_Complex(BIG_INF, BIG_NAN);
 	}
 	else
 	{

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

@@ -2,9 +2,7 @@ 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)

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

@@ -4,26 +4,30 @@ 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));
 
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
 	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);
+		const ID div = rb_intern("div");
+		VALUE real = rb_bigmath_const_pi(prec);
+		real = rb_funcall(real, div, 2, INT2FIX(2), prec);
+		return rb_Complex(real, 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) ?
+			(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;
+		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/casech/branch.h

@@ -10,20 +10,13 @@ casech_branch(VALUE z, VALUE prec, bigmath_func1 casech_cb)
 	else if (z_re_inf || z_im_inf)
 	{
 		const ID div = rb_intern("div");
-		if (z_re_inf != 0 && z_im_inf == 0)
+		if ((z_re_inf != 0 && z_im_inf == 0) ||
+		    (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);
 	}
@@ -35,4 +28,3 @@ casech_branch(VALUE z, VALUE prec, bigmath_func1 casech_cb)
 
 	return w;
 }
-

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

@@ -9,23 +9,38 @@ casin_branch(VALUE z, VALUE prec, bigmath_func1 casin_cb)
 	else if (z_re_inf || z_im_inf)
 	{
 		const ID div = rb_intern("div");
+		const ID mult = rb_intern("mult");
+		VALUE real, imag;
 		if (z_re_inf != 0 && z_im_inf == 0)
 		{
-			VALUE real = rb_num_zero_p(rb_num_imag(z)) ?
+			real = 
 				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;
+					INT2FIX(z_re_inf * 2), prec);
+			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));
+			real = rb_bigmath_const_pi(prec);
+			imag = BIG_MINUS_INF;
+			if (z_im_inf == -1)
+				real = rb_funcall(real, div, 2, INT2FIX(2), prec);
+			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);
+		{
+			VALUE rat = Qundef;
+			real = rb_bigmath_const_pi(prec);
+			imag = BIG_MINUS_INF;
+			if (z_re_inf == 1 && z_im_inf == 1)
+				rat = rb_rational_new(INT2FIX(5), INT2FIX(4));
+			else if (z_re_inf == 1 && z_im_inf == -1)
+				rat = rb_rational_new(INT2FIX(3), INT2FIX(4));
+			else
+				rat = rb_rational_new(INT2FIX(1), INT2FIX(4));
+			real = rb_funcall(real, mult, 2, rat, prec);
+			return rb_Complex(real, imag);
+		}
 	}
 	else
 	{

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

@@ -3,13 +3,18 @@ casinh_branch(VALUE z, VALUE prec, bigmath_func1 casinh_cb)
 {
 	VALUE y = 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));
+
 	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
 
-	if (!rb_num_finite_p(z))
+	if (rb_num_nan_p(z))
+		y = rb_Complex(BIG_NAN, BIG_NAN);
+	else if (!rb_num_finite_p(z))
 	{
-		if (rb_num_infinite_p(rb_num_imag(z)) == 0)
+		if (z_re_inf != 0 && z_im_inf == 0)
 		{
-			switch (rb_num_infinite_p(rb_num_real(z))) {
+			switch (z_re_inf) {
 			case 1:
 				y = rb_Complex(BIG_INF, BIG_ZERO);
 				break;
@@ -18,37 +23,27 @@ casinh_branch(VALUE z, VALUE prec, bigmath_func1 casinh_cb)
 				break;
 			}
 		}
-		else if (rb_num_infinite_p(rb_num_real(z)) == 0)
+		else if (z_re_inf == 0 && z_im_inf != 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;
-				}
+			const ID div = rb_intern("div");
+			VALUE pi_2 = rb_funcall(rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+			switch (z_im_inf) {
+			case 1:
+				y = rb_Complex(BIG_INF, pi_2);
+				break;
+			case -1:
+				pi_2 = rb_num_uminus(pi_2);
+				y = rb_Complex(BIG_INF, pi_2);
+				break;
 			}
 		}
 		else
 		{
-			y = rb_Complex(BIG_NAN, BIG_NAN);
+			VALUE real = BIG_INF;
+			VALUE imag = BIG_NAN;
+			if (z_re_inf == -1)
+				real = rb_num_uminus(real);
+			y = rb_Complex(real, imag);
 		}
 	}
 	if (y == Qundef)

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

@@ -10,27 +10,30 @@ catan_branch(VALUE z, VALUE prec, bigmath_func1 catan_cb)
 		return rb_Complex(BIG_NAN, BIG_NAN);
 	else if (z_re_inf || z_im_inf)
 	{
+		const ID mult = rb_intern("mult");
 		const ID div = rb_intern("div");
+		VALUE real, imag;
 		if (z_re_inf != 0 && z_im_inf == 0)
 		{
-			VALUE real = 
-				rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
+			real = rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
 				INT2FIX(z_re_inf * 2), prec);
-			VALUE imag = BIG_ZERO;
+			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, 
+			real = rb_funcall(rb_bigmath_const_pi(prec), div, 2, 
 				INT2FIX(z_im_inf * 2), prec);
-			VALUE imag = BIG_ZERO;
+			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);
+		{
+			real = rb_funcall(rb_bigmath_const_pi(prec), mult, 2, 
+				rb_rational_new(INT2FIX(z_im_inf * 3), INT2FIX(4)), prec);
+			imag = BIG_ZERO;
+			return rb_Complex(real, imag);
+		}
 	}
 	else if (rb_num_equal_p(z, rb_Complex_I))
 		return rb_Complex(BIG_ZERO, BIG_INF);

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

@@ -2,19 +2,26 @@ VALUE
 catanh_branch(VALUE z, VALUE prec, bigmath_func1 catanh_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));
 
 	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)
+	else if (z_re_inf || z_im_inf)
 	{
-		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);
+		if (z_re_inf != 0 && z_im_inf != 0)
+			w = rb_Complex(BIG_NAN, BIG_NAN);
+		else
+		{
+			const ID div = rb_intern("div");
+			VALUE pi_2 = rb_funcall(
+				rb_bigmath_const_pi(prec), div, 2, INT2FIX(2), prec);
+			if (z_re_inf == 1 || z_im_inf == -1)
+				pi_2 = rb_num_uminus(pi_2);
+			w = rb_Complex(BIG_ZERO, pi_2);
+		}
 	}
 	else
 	{

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

@@ -2,7 +2,9 @@ VALUE
 ccosh_branch(VALUE z, VALUE prec, bigmath_func1 ccosh_cb)
 {
 	VALUE w = Qundef;
-	if (!rb_num_finite_p(z))
+	if (rb_num_nan_p(z))
+		w = rb_Complex(BIG_NAN, BIG_NAN);
+	else if (!rb_num_finite_p(z))
 	{
 		if (rb_num_infinite_p(z) != 0 && rb_num_zero_p(rb_num_imag(z)))
 		{

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

@@ -5,8 +5,12 @@ cpow_formula(VALUE z, VALUE w, VALUE prec)
 
 	rb_check_precise(prec);
 	n = rb_numdiff_make_n(prec);
-
-	if (rb_num_positive_p(rb_num_real(z)) &&
+	
+	if (!rb_num_finite_p(z) || !rb_num_finite_p(w))
+	{
+		a = rb_Complex(BIG_NAN, BIG_NAN);
+	}
+	else if (rb_num_positive_p(rb_num_real(z)) &&
 	    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), n);

data/ext/bigdecimal/math_r/internal/algo/bigmath/rcm2/edf.h

@@ -19,7 +19,7 @@ rcm2_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(INT2FIX(2), fra, rb_intern("<="))))
 			{
 				fra = rb_funcall1(fra, '/', rat_two);
-				TYPE(resov) == T_FIXNUM ? 
+				resov = TYPE(resov) == T_FIXNUM ? 
 					LONG2FIX(FIX2LONG(resov) + 1) : 
 					rb_funcall(resov, succ, 0);
 			}
@@ -29,7 +29,7 @@ rcm2_edf(VALUE x, VALUE *reso)
 			while (RTEST(rb_num_coerce_cmp(INT2FIX(1), fra, '>')))
 			{
 				fra = rb_funcall1(fra, '*', rat_two);
-				TYPE(resov) == T_FIXNUM ? 
+				resov = TYPE(resov) == T_FIXNUM ? 
 					LONG2FIX(FIX2LONG(resov) - 1) : 
 					rb_funcall(resov, pred, 0);
 			}

data/ext/bigdecimal/math_r/internal/algo/bigmath/trig/f_euler.h

@@ -1,3 +1,4 @@
+// Make euler's formula, e^i(theta) as *exppz and e^-i(theta) as *expmz
 static inline void
 f_euler2(VALUE theta, VALUE prec, VALUE *exppz, VALUE *expmz)
 {
@@ -6,7 +7,7 @@ f_euler2(VALUE theta, VALUE prec, VALUE *exppz, VALUE *expmz)
 	*expmz = rb_funcall(*exppz, conj, 0);
 }
 
-
+// Make euler's formula of complex exponent, e^(theta) as *exppz and e^-(theta) as *expmz
 static inline void
 f_euler_e2(VALUE theta, VALUE prec, VALUE *exppz, VALUE *expmz)
 {
@@ -33,7 +34,7 @@ f_euler_e2(VALUE theta, VALUE prec, VALUE *exppz, VALUE *expmz)
 	}
 }
 
-
+// Euler's formula for cos()
 static inline VALUE
 f_euler_cos(VALUE exppz, VALUE expmz)
 {
@@ -44,6 +45,7 @@ f_euler_cos(VALUE exppz, VALUE expmz)
 	return y;
 }
 
+// Euler's formula for sin(), when argument is infinite
 static inline VALUE
 f_euler_sin_infinite(VALUE y)
 {
@@ -97,6 +99,7 @@ f_euler_sin_infinite(VALUE y)
 	return w;
 }
 
+// Euler's formula for sin()
 static inline VALUE
 f_euler_sin(VALUE exppz, VALUE expmz)
 {
@@ -112,6 +115,7 @@ f_euler_sin(VALUE exppz, VALUE expmz)
 	return y;
 }
 
+// Euler's formula for tan()
 static inline VALUE
 f_euler_tan(VALUE exppz, VALUE expmz)
 {
@@ -128,6 +132,7 @@ f_euler_tan(VALUE exppz, VALUE expmz)
 	return rb_funcall1(sin, '/', cos);
 }
 
+// Euler's formula for sin and cos
 static inline VALUE
 f_euler_sc(const ID func, VALUE theta, VALUE prec)
 {
@@ -208,7 +213,7 @@ f_euler_t(VALUE theta, VALUE prec)
 	return rb_ImaginaryZ(y, SIGN_MINUS);
 }
 
-
+// For hyperbolic
 static inline VALUE
 f_euler_h(const ID func, VALUE theta, VALUE prec)
 {
@@ -230,6 +235,7 @@ f_euler_h(const ID func, VALUE theta, VALUE prec)
 	return rb_num_round(y, prec);
 }
 
+// Mix Euler's formula of exponent and sincos
 static inline VALUE
 f_euler_esc(const ID func, VALUE z, VALUE prec)
 {

data/lib/bigdecimal/math_r/version.rb

@@ -2,6 +2,6 @@
 
 module BigMathR
   # Module version.
-  VERSION = "0.2.6"
+  VERSION = "0.2.8"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bigdecimal-math_r
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors:
 - tribusonz-2