bigdecimal-math_r 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 719ac1d5b1b20031ea157c824a660307e45adf15bf00edd6f906eaef31e8ef47
-  data.tar.gz: 4340bfae2018a9c332991f5c5e0ab4833f0ad914a15a05729ae68e07833a25fd
+  metadata.gz: 518812b6a73ac402e7e68bbab7063ccda4cf1f65dc52bd7267894252e56308b7
+  data.tar.gz: a16aa529cbf7f3da0f9aec0699ee447cfff6925c7a6d2b30cfff2693dc346310
 SHA512:
-  metadata.gz: 7eb916c9ab6c4f2288c7b8a5c9d36dfe5879bf547082fba2be2e4ea01925e97fd5de4f7445d0d28dee03faa457502d8a86107ac71d5c417d1508cf8a2e4a44dd
-  data.tar.gz: 2fcc65443645680121c138272d4825d9707fa9296936b114ab2e630f49213f0710ada866c3c080bc9c38a332a7e9f5cdefb24bac2e0c528efec910cbc35cb6ef
+  metadata.gz: 473370ffad4f28e5679d52ff5b164270fba4cc39bb83befbcc108a168449d52b6383952dddd1c00edf885bc4ffab0eff95ede1e356a09f59ec16389fc2bfc08e
+  data.tar.gz: 9976dcd853ca1209736a19d65f4b184d7d01a6d8d05c744c0415d0da15d4c423b94ec6c82a6d770928b317d4f72dd289a0c04f32836cd088ba07cc6fe3760bb9

data/changelog.md

@@ -7,6 +7,22 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.2.2] - 2025-10-XX
+
+### Changed
+- The names of mathematical constants were unified by the discoverer
+- Renamed `BigMathR::Const::E.ser` to `BigMathR::Const::E.napier`
+- Renamed `BigMathR::GammaR` to `BigMathR::GammaBeta`
+
+### Added
+- `BigMathR::Const::E#euler`. Continued fraction type constant $e$ .
+- `BigMathR::Const::E#euler_number`. It is an alias of `napier`.
+- `BigMathR::Const::EulerGamma#borwein_bailey`. Brent-McMillan type constant $\gamma$ .
+- `BigMathR::Const::EulerGamma#brent_mcmillan`. It is an alias of `borwein_bailey`.
+- `BigMathR#EulerGamma`.
+- Branches for the logarithmic functions.
+- `expm1` Function.
+
 ## [0.2.1] - 2025-05-XX
 
 ### Changed

data/ext/bigdecimal/math_r/algofunc.h

@@ -1,7 +1,8 @@
 #ifndef BIGMATH_ALGOFUNC_H
 #define BIGMATH_ALGOFUNC_H
 
-#include "internal/algo/bigmath/E/ser.h"
+#include "internal/algo/bigmath/E/napier.h"
+#include "internal/algo/bigmath/EulerGamma/borwein_bailey.h"
 #include "internal/algo/bigmath/LOG10/ser.h"
 #include "internal/algo/bigmath/LOG2/BBP2002.h"
 #include "internal/algo/bigmath/LOG_PI/builtin.h"
@@ -72,6 +73,7 @@
 #include "internal/algo/bigmath/catan/logrep.h"
 #include "internal/algo/bigmath/catanh/branch.h"
 #include "internal/algo/bigmath/catanh/logrep.h"
+#include "internal/algo/bigmath/ccbrt/branch.h"
 #include "internal/algo/bigmath/ccbrt/formula.h"
 #include "internal/algo/bigmath/ccos/branch.h"
 #include "internal/algo/bigmath/ccos/eulerf.h"
@@ -89,10 +91,14 @@
 #include "internal/algo/bigmath/cexp/eulerf.h"
 #include "internal/algo/bigmath/cexp2/branch.h"
 #include "internal/algo/bigmath/cexp2/eulerf.h"
+#include "internal/algo/bigmath/cexpm1/branch.h"
+#include "internal/algo/bigmath/cexpm1/identity.h"
 #include "internal/algo/bigmath/clog/branch.h"
 #include "internal/algo/bigmath/clog/formula.h"
+#include "internal/algo/bigmath/clog10/branch.h"
 #include "internal/algo/bigmath/clog10/formula.h"
 #include "internal/algo/bigmath/clog1p/branch.h"
+#include "internal/algo/bigmath/clog2/branch.h"
 #include "internal/algo/bigmath/clog2/formula.h"
 #include "internal/algo/bigmath/cos/branch.h"
 #include "internal/algo/bigmath/cos/eulerf.h"
@@ -124,11 +130,13 @@
 #include "internal/algo/bigmath/csin/eulerf.h"
 #include "internal/algo/bigmath/csinh/branch.h"
 #include "internal/algo/bigmath/csinh/eulerf.h"
+#include "internal/algo/bigmath/csqrt/branch.h"
 #include "internal/algo/bigmath/csqrt/formula.h"
 #include "internal/algo/bigmath/ctan/branch.h"
 #include "internal/algo/bigmath/ctan/eulerf.h"
 #include "internal/algo/bigmath/ctanh/branch.h"
 #include "internal/algo/bigmath/ctanh/eulerf.h"
+#include "internal/algo/bigmath/cuberoot/branch.h"
 #include "internal/algo/bigmath/cuberoot/newton.h"
 #include "internal/algo/bigmath/erf/algo911.h"
 #include "internal/algo/bigmath/erf/branch.h"
@@ -144,6 +152,8 @@
 #include "internal/algo/bigmath/exp/edf.h"
 #include "internal/algo/bigmath/exp2/branch.h"
 #include "internal/algo/bigmath/exp2/edf.h"
+#include "internal/algo/bigmath/expm1/branch.h"
+#include "internal/algo/bigmath/expm1/identity.h"
 #include "internal/algo/bigmath/expxt/edf.h"
 #include "internal/algo/bigmath/f_euler/formula.h"
 #include "internal/algo/bigmath/hypot/branch.h"

data/ext/bigdecimal/math_r/api/bigmath/const_e.h

@@ -1,5 +1,5 @@
 VALUE
 rb_bigmath_const_e(VALUE prec)
 {
-	return rb_bigmath_const(BIGMATH_E, E_ser, prec);
+	return rb_bigmath_const(BIGMATH_E, E_napier, prec);
 }

data/ext/bigdecimal/math_r/api/bigmath/const_euler_gamma.h

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_euler_gamma(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_EulerGamma, EulerGamma_borwein_bailey, prec);
+}

data/ext/bigdecimal/math_r/api/bigmath/csqrt.h

@@ -1,5 +1,5 @@
 VALUE
 rb_bigmath_csqrt(VALUE z, VALUE prec)
 {
-	return csqrt_formula(z, prec);
+	return csqrt_branch(z, prec, csqrt_formula);
 }

data/ext/bigdecimal/math_r/api/kernel/rb_BigDecimal_flo.h

@@ -3,7 +3,13 @@ rb_BigDecimal_flo(VALUE x)
 {
 	const ID BigDecimal = rb_intern("BigDecimal");
 	const ID DIG = rb_intern("DIG");
-	VALUE FLOAT_DIG = rb_const_get_at(rb_cFloat, DIG);
-	VALUE y = rb_funcall(rb_cObject, BigDecimal, 2, x, FLOAT_DIG);
+	VALUE FLOAT_DIG, y;
+	if (rb_num_nan_p(x))
+		y = BIG_NAN;
+	else
+	{
+		FLOAT_DIG = rb_const_get_at(rb_cFloat, DIG);
+		y = rb_funcall(rb_cObject, BigDecimal, 2, x, FLOAT_DIG);
+	}
 	return y;
 }

data/ext/bigdecimal/math_r/api/numeric/nan_p.h

@@ -1,5 +1,8 @@
 bool
 rb_num_nan_p(VALUE z)
 {
-	return rb_num_notequal_p(z, z);
+	if (rb_num_real_p(z))
+		return rb_num_notequal_p(z, z);
+	else
+		return !rb_num_finite_p(z) && !rb_num_infinite_p(z);
 }

data/ext/bigdecimal/math_r/api.h

@@ -20,6 +20,7 @@
 #include "api/bigmath/clog.h"
 #include "api/bigmath/const.h"
 #include "api/bigmath/const_e.h"
+#include "api/bigmath/const_euler_gamma.h"
 #include "api/bigmath/const_log10.h"
 #include "api/bigmath/const_log2.h"
 #include "api/bigmath/const_log_pi.h"
@@ -50,6 +51,7 @@
 #include "api/numeric/abs.h"
 #include "api/numeric/canonicalize.h"
 #include "api/numeric/cmpeql.h"
+#include "api/numeric/domain_p.h"
 #include "api/numeric/equal_p.h"
 #include "api/numeric/finite_p.h"
 #include "api/numeric/imag.h"

data/ext/bigdecimal/math_r/const.c

@@ -54,6 +54,21 @@ __impl_const_e(VALUE unused_obj, VALUE prec)
 	return rb_bigmath_const_e(prec);
 }
 
+/**
+ * The Euler-Mascheroni constant gamma.
+ * @example
+ *  BigMathR.EulerGamma(20) #=> 
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_const_euler_gamma(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_euler_gamma(prec);
+}
+
 /**
  * The natural logarithm of 2.
  * @example
@@ -135,7 +150,7 @@ __impl_const_pi_machin(VALUE unused_obj, VALUE prec)
  * Implement by series expansion: sum_(n=0)^infty 1/n!
  * 
  * @example
- *  BigMathR::Const::E.ser(20)
+ *  BigMathR::Const::E.napier(20)
  *  #=> 0.27182818284590452354e1
  * @param prec [Integer] Arbitrary precision
  * @return [BigDecimal] Natural logarithm of 2
@@ -143,9 +158,26 @@ __impl_const_pi_machin(VALUE unused_obj, VALUE prec)
  * @raise [RangeError] Zero or negative precision
  */
 static VALUE
-__impl_const_e_ser(VALUE unused_obj, VALUE prec)
+__impl_const_e_napier(VALUE unused_obj, VALUE prec)
+{
+	return E_napier(prec);
+}
+
+/**
+ * Implement by Borwein-Bailey's formula (Brent-McMillan type formula)
+ * 
+ * @example
+ *  BigMathR::Const::EulerGamma.borwein_bailey(20)
+ *  #=> 
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Natural logarithm of 2
+ * @raise [TypeError] not an Integer
+ * @raise [RangeError] Zero or negative precision
+ */
+static VALUE
+__impl_const_euler_gamma_borwein_bailey(VALUE unused_obj, VALUE prec)
 {
-	return E_ser(prec);
+	return EulerGamma_borwein_bailey(prec);
 }
 
 /**
@@ -172,6 +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);
+	rb_define_module_function(rb_mBigMathR, "EulerGamma", __impl_const_euler_gamma, 1);
 	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);
@@ -179,8 +212,12 @@ InitVM_Const(void)
 	rb_define_module_function(rb_mBigMathR, "SQRT3", __impl_const_sqrt3, 1);
 
 	rb_define_module_function(rb_mConstPI, "machin", __impl_const_pi_machin, 1);
-	rb_define_module_function(rb_mConstE, "ser", __impl_const_e_ser, 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);
+	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);
 	rb_define_module_function(rb_mConstLOG2, "bbp2002", __impl_const_log2_bbp2002, 1);
-
 }
 

data/ext/bigdecimal/math_r/decl.h

@@ -1,7 +1,8 @@
 #ifndef BIGMATH_MATHFUNC_H
 #define BIGMATH_MATHFUNC_H
 
-VALUE E_ser(VALUE prec);
+VALUE E_napier(VALUE prec);
+VALUE EulerGamma_borwein_bailey(VALUE prec);
 VALUE LOG10_ser(VALUE prec);
 VALUE LOG2_BBP2002(VALUE prec);
 VALUE LOG_PI_builtin(VALUE prec);
@@ -72,6 +73,7 @@ VALUE catan_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE catan_logrep(VALUE x, VALUE prec);
 VALUE catanh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE catanh_logrep(VALUE x, VALUE prec);
+VALUE ccbrt_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE ccbrt_formula(VALUE x, VALUE prec);
 VALUE ccos_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE ccos_eulerf(VALUE x, VALUE prec);
@@ -89,10 +91,14 @@ VALUE cexp_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE cexp_eulerf(VALUE x, VALUE prec);
 VALUE cexp2_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE cexp2_eulerf(VALUE x, VALUE prec);
+VALUE cexpm1_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cexpm1_identity(VALUE x, VALUE prec);
 VALUE clog_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE clog_formula(VALUE x, VALUE prec);
+VALUE clog10_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE clog10_formula(VALUE x, VALUE prec);
 VALUE clog1p_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE clog2_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE clog2_formula(VALUE x, VALUE prec);
 VALUE cos_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE cos_eulerf(VALUE x, VALUE prec);
@@ -124,11 +130,13 @@ VALUE csin_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE csin_eulerf(VALUE x, VALUE prec);
 VALUE csinh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE csinh_eulerf(VALUE x, VALUE prec);
+VALUE csqrt_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE csqrt_formula(VALUE x, VALUE prec);
 VALUE ctan_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE ctan_eulerf(VALUE x, VALUE prec);
 VALUE ctanh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE ctanh_eulerf(VALUE x, VALUE prec);
+VALUE cuberoot_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE cuberoot_newton(VALUE x, VALUE prec);
 VALUE erf_algo911(VALUE x, VALUE prec);
 VALUE erf_branch(VALUE x, VALUE prec, bigmath_func1 cb);
@@ -144,6 +152,8 @@ VALUE exp_builtin(VALUE x, VALUE prec);
 VALUE exp_edf(VALUE x, VALUE prec);
 VALUE exp2_branch(VALUE x, VALUE prec, bigmath_func1 cb);
 VALUE exp2_edf(VALUE x, VALUE prec);
+VALUE expm1_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE expm1_identity(VALUE x, VALUE prec);
 VALUE expxt_edf(VALUE x, VALUE y, VALUE prec);
 VALUE f_euler_formula(VALUE x, VALUE prec);
 VALUE hypot_branch(VALUE x, VALUE y, VALUE prec, bigmath_func2 cb);

data/ext/bigdecimal/math_r/exp.c

@@ -18,7 +18,7 @@
  * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
  * @raise [TypeError] Occurs when +x+ is not a numeric class.
  * @example
- *  BigMathR::EDF.exp(1, 20)
+ *  BigMathR::Exp.exp_edf(1, 20)
  *  #=> 0.27182818284590452354e1
  * @since 0.1.0
  */
@@ -38,7 +38,7 @@ __impl_exp_edf(VALUE unused_obj, VALUE x, VALUE prec)
  * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
  * @raise [TypeError] Occurs when +x+ is not a numeric class.
  * @example
- *  BigMathR::EDF.exp2(1/2r, 20)
+ *  BigMathR::Exp.exp2_edf(1/2r, 20)
  *  #=> 0.14142135623730950488e1
  * @since 0.1.0
  */
@@ -48,6 +48,46 @@ __impl_exp2_edf(VALUE unused_obj, VALUE x, VALUE prec)
 	return exp2_branch(x, prec, exp2_edf);
 }
 
+/**
+ * Computes the subtracted 1 from x of the exponential function.
+ * <br>
+ * The calculation is more accurate than +exp(x)-1+ when the argument is near zero.
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::Exp.expm1_identity(BigDecimal(1), 20)
+ *  #=> 0.17182818284590452354e1
+ * @since 0.2.2
+ */
+static VALUE
+__impl_expm1_identity(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return expm1_branch(x, prec, expm1_identity);
+}
+
+/**
+ * Computes the subtracted 1 from +z+ of the exponential function.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::Exp.cexpm1_identity(1+1i, 20)
+ *  # => (0.46869393991588515714e0+0.22873552871788423912e1i)
+ * @since 0.2.2
+ */
+static VALUE
+__impl_cexpm1_identity(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return cexpm1_branch(z, prec, cexpm1_identity);
+}
+
+
 
 /**
  *  Document-module:  BigMathR::Exp
@@ -62,11 +102,13 @@ __impl_exp2_edf(VALUE unused_obj, VALUE x, VALUE prec)
  *  <br>
  *  Exponential function:     +exp()+ <br>
  *  Base-2 (binary) exponent: +exp2()+ <br>
- *  
+ *  expm1 function:           +expm1()+ <br>
  */
 void
 InitVM_Exp(void)
 {
 	rb_define_module_function(rb_mExp, "exp_edf", __impl_exp_edf, 2);
 	rb_define_module_function(rb_mExp, "exp2_edf", __impl_exp2_edf, 2);
+	rb_define_module_function(rb_mExp, "expm1_identity", __impl_expm1_identity, 2);
+	rb_define_module_function(rb_mExp, "cexpm1_identity", __impl_cexpm1_identity, 2);
 }

data/ext/bigdecimal/math_r/extconf.rb

@@ -16,6 +16,7 @@ VOID = "void"
 MATHFUNCS = {
   "exp" => [VALUE, ARG1], "cexp" => [VALUE, ARG1],
   "exp2" => [VALUE, ARG1], "cexp2" => [VALUE, ARG1],
+  "expm1" => [VALUE, ARG1], "cexpm1" => [VALUE, ARG1],
   "expxt" => [VALUE, ARG2],
   "log" => [VALUE, ARG1], "clog" => [VALUE, ARG1], 
   "log1p" => [VALUE, ARG1], "clog1p" => [VALUE, ARG1], 
@@ -64,6 +65,7 @@ MATHFUNCS = {
   "f_euler" => [VALUE, ARG1],
   "PI"=>[VALUE, ARG_PREC],
   "E"=>[VALUE, ARG_PREC],
+  "EulerGamma"=>[VALUE, ARG_PREC],
   "LOG2"=>[VALUE, ARG_PREC],
   "LOG10"=>[VALUE, ARG_PREC],
   "LOG_PI"=>[VALUE, ARG_PREC],
@@ -74,11 +76,13 @@ MATHFUNCS = {
 CB_TYPE = {
   "exp" => "bigmath_func1", "cexp" => "bigmath_func1",
   "exp2" => "bigmath_func1", "cexp2" => "bigmath_func1",
+  "expm1" => "bigmath_func1", "cexpm1" => "bigmath_func1",
   "log" => "bigmath_func1", "clog" => "bigmath_func1",
   "log2" => "bigmath_func1", "clog2" => "bigmath_func1",
   "log10" => "bigmath_func1", "clog10" => "bigmath_func1",
   "log1p" => "bigmath_func1", "clog1p" => "bigmath_func1",
-  "sqrt" => "bigmath_func1",
+  "sqrt" => "bigmath_func1", "csqrt" => "bigmath_func1",
+  "cuberoot" => "bigmath_func1", "ccbrt" => "bigmath_func1",
   "sin" => "bigmath_func1", "csin" => "bigmath_func1",
   "cos" => "bigmath_func1", "ccos" => "bigmath_func1",
   "tan" => "bigmath_func1", "ctan" => "bigmath_func1",

data/ext/bigdecimal/math_r/{gamma_r.c → gamma_beta.c}

@@ -1,5 +1,5 @@
 /*******************************************************************************
-	gamma_r.c -- Regularized Incomplete Gamma Function
+	gamma_beta.c -- Gamma and Beta Functions
 
 	Author: tribusonz
 	Lisence: MIT
@@ -82,20 +82,20 @@ gammar_q(VALUE a, VALUE x, VALUE loggamma_a, VALUE prec)
 	n = rb_numdiff_make_n(prec);
 	la = one; lb = rb_funcall1(one, '+', rb_funcall1(x, '-', a)); // Laguerreの多項式
 	// w = exp(a * log(x, prec) - x - loggamma_a, n);
-	w = rb_funcall1(a, '*', rb_bigmath_log(x, prec));
+	w = rb_funcall1(a, '*', rb_bigmath_log(x, n));
 	w = rb_funcall1(w, '-', x);
 	w = rb_funcall1(w, '-', loggamma_a);
-	w = rb_bigmath_exp(w, prec);
+	w = rb_bigmath_exp(w, n);
 	result = rb_funcall1(w, '/', lb);
 	big_k = two;
+
 	for (int k = 2; k <= 1000; k++)
 	{
 		// temp = ((k - one - a) * (lb - la) + (k + x) * lb).div(k, n);
-		temp = rb_funcall1(k, '-', rb_funcall1(one, '-', a));
+		temp = rb_funcall1(big_k, '-', rb_funcall1(one, '-', a));
 		temp = rb_funcall1(temp, '*', rb_funcall1(lb, '-', la));
-		temp = rb_funcall1(temp, '+', rb_funcall1(rb_funcall1(k, '+', x), '*', lb));
+		temp = rb_funcall1(temp, '+', rb_funcall1(rb_funcall1(big_k, '+', x), '*', lb));
 		temp = rb_funcall(temp, div, 2, big_k, n);
-
 		la = lb; lb = temp;
 		// w *= (k - one - a) / k;
 		temp = rb_funcall1(rb_funcall1(big_k, '-', one), '-', a);
@@ -126,7 +126,6 @@ retval:
 	return result;
 }
 
-// TODO: -1 <= x <= 1 以外はエラーが出る: `erf': undefined method `-' for nil (NoMethodError)
 VALUE
 erf_gammar(VALUE x, VALUE prec)
 {
@@ -140,35 +139,6 @@ erf_gammar(VALUE x, VALUE prec)
 	return rb_num_round(y, prec);
 }
 
-VALUE
-erf_branch(VALUE x, VALUE prec, bigmath_func1 erf_cb)
-{
-	VALUE y = Qundef;
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
-	if (erf_cb == NULL)
-		return BIG_NAN;
-	if (!rb_num_finite_p(x))
-	{
-		if (rb_num_nan_p(x))
-			y = BIG_NAN;
-		else
-		{
-			switch (rb_num_infinite_p(x)) {
-			case -1:
-				y = BIG_MINUS_ONE;
-				break;
-			case 1:
-				y = BIG_ONE;
-				break;
-			}
-		}
-	}
-	if (y == Qundef)
-		y = erf_cb(x, prec);
-	return y;
-}
-
-// TODO: -1 <= x <= 1 以外はエラーが出る: `erf': undefined method `-' for nil (NoMethodError)
 VALUE
 erfc_gammar(VALUE x, VALUE prec)
 {
@@ -188,64 +158,27 @@ erfc_gammar(VALUE x, VALUE prec)
 	return rb_num_round(y, prec);
 }
 
-VALUE
-erfc_branch(VALUE x, VALUE prec, bigmath_func1 erfc_cb)
-{
-	VALUE y = Qundef;
-	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
-	if (erfc_cb == NULL)
-		return BIG_NAN;
-	if (!rb_num_finite_p(x))
-	{
-		if (rb_num_nan_p(x))
-			y = BIG_NAN;
-		else
-		{
-			switch (rb_num_infinite_p(x)) {
-			case -1:
-				y = rb_BigDecimal1(INT2FIX(2));
-				break;
-			case 1:
-				y = BIG_ZERO;
-				break;
-			}
-		}
-	}
-	if (y == Qundef)
-		y = erfc_cb(x, prec);
-	return y;
-}
-
-
 
 
 static VALUE
-__impl_gammar_erf(VALUE unused_obj, VALUE x, VALUE prec)
+__impl_gammabeta_erf(VALUE unused_obj, VALUE x, VALUE prec)
 {
 	return erf_branch(x, prec, erf_gammar);
 }
 
 
 static VALUE
-__impl_gammar_erfc(VALUE unused_obj, VALUE x, VALUE prec)
+__impl_gammabeta_erfc(VALUE unused_obj, VALUE x, VALUE prec)
 {
 	return erfc_branch(x, prec, erfc_gammar);
 }
-
-
-// TODO: eps-16の誤差がある。
-// |erf(1) - 0.84270079294971474562456763838456194738845892814039e0|
-// 結果: 1.237166529966980473119076080698259... × 10^-16
-// |erfc(1) - 0.15729920705028525437543236161543805261154107185961e0|
-// 結果: 1.2371665299669804731190760806982591... × 10^-16
-
 #endif
 
 void
-InitVM_GammaR(void)
+InitVM_GammaBeta(void)
 {
 #if 0
-	rb_define_module_function(rb_mGammaR, "erf", __impl_gammar_erf, 2);
-	rb_define_module_function(rb_mGammaR, "erfc", __impl_gammar_erfc, 2);
+	rb_define_module_function(rb_mGammaBeta, "erf", __impl_gammabeta_erf, 2);
+	rb_define_module_function(rb_mGammaBeta, "erfc", __impl_gammabeta_erfc, 2);
 #endif
 }

data/ext/bigdecimal/math_r/internal/algo/bigmath/E/{ser.h → napier.h}

@@ -1,5 +1,5 @@
 VALUE
-E_ser(VALUE prec)
+E_napier(VALUE prec)
 {
 	const ID div = rb_intern("div");
 	VALUE n, m, a, e;

data/ext/bigdecimal/math_r/internal/algo/bigmath/EulerGamma/borwein_bailey.h

@@ -0,0 +1,37 @@
+VALUE
+EulerGamma_borwein_bailey(VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID div = rb_intern("div");
+	VALUE zero, one, m, n, nn, a, b, u, v, k;
+	rb_check_precise(prec);
+	zero = BIG_ZERO;
+	one = BIG_ONE;
+	n = rb_numdiff_make_n(prec);
+	nn = rb_BigDecimal1(n);
+	a = u = rb_num_uminus(rb_bigmath_log(n, n));
+	b = v = one;
+	k = zero;
+	while (rb_numdiff_condition_p(u, a, n, &m))
+	{
+		k = rb_funcall1(k, '+', one);
+		b = rb_funcall(rb_funcall1(b, '*', rb_funcall1(nn, '*', nn)), 
+			div, 2, rb_funcall1(k, '*', k), m);
+		a = rb_funcall1(
+			rb_funcall(one, div, 2, k, m), '*', 
+			rb_funcall(rb_funcall(rb_funcall1(a, '*', rb_funcall1(nn, '*', nn)), 
+			div, 2, k, m),
+			add, 2, b, m));
+		u = rb_funcall1(u, '+', a);
+		v = rb_funcall1(v, '+', b);
+	}
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(nn);
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(b);
+	RB_GC_GUARD(u);
+	RB_GC_GUARD(v);
+	RB_GC_GUARD(k);
+	return rb_funcall(u, div, 2, v, prec);
+}

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

@@ -1,6 +1,8 @@
 VALUE
 LOG10_ser(VALUE prec)
 {
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
 #if 0
 	VALUE x = rb_Rational(INT2FIX(-9), INT2FIX(10));
 	x = log_ser_mercator(x, prec);
@@ -8,8 +10,8 @@ LOG10_ser(VALUE prec)
 #else
 	const ID add = rb_intern("add");
 	VALUE x = rb_Rational(INT2FIX(1), INT2FIX(4)), log2;
-	x = log1p_p_adic(x, prec);
-	log2 = LOG2_BBP2002(prec);
+	x = log1p_p_adic(x, n);
+	log2 = LOG2_BBP2002(n);
 	return rb_funcall(rb_funcall1(log2, '*', INT2FIX(3)), add, 2, x, prec);
 #endif
 }

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

@@ -1,7 +1,9 @@
 VALUE
 LOG_PI_builtin(VALUE prec)
 {
-	VALUE log_pi = rb_bigmath_const_pi(prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE log_pi = rb_bigmath_const_pi(n);
 	return log_builtin(log_pi, prec);
 }
 

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

@@ -1,5 +1,8 @@
 VALUE
 SQRT2_builtin(VALUE prec)
 {
-	return rb_bigmath_sqrt(INT2FIX(2), prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE x = rb_bigmath_sqrt(INT2FIX(2), n);
+	return rb_num_round(x, prec);
 }

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

@@ -1,5 +1,8 @@
 VALUE
 SQRT3_builtin(VALUE prec)
 {
-	return rb_bigmath_sqrt(INT2FIX(3), prec);
+	rb_check_precise(prec);
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE x = rb_bigmath_sqrt(INT2FIX(3), n);
+	return rb_num_round(x, prec);
 }