bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/extconf.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+ARG1 = {"x"=>"VALUE", "prec"=>"VALUE"}
+ARG2 = {"x"=>"VALUE", "y"=>"VALUE", "prec"=>"VALUE"}
+ARG1SCALAR2 = {"x"=>"VALUE", "prec"=>"VALUE", "*a"=>"VALUE", "*b"=>"VALUE"}
+ARG2SCALAR2 = {"x"=>"VALUE", "y"=>"VALUE", "prec"=>"VALUE", "*a"=>"VALUE", "*b"=>"VALUE"}
+ARG_RCM = {"x"=>"VALUE", "*reso"=>"VALUE"}
+ARG_TRIG = {"func"=>"ID", "theta"=>"VALUE", "prec"=>"VALUE"}
+ARG_PREC = {"prec"=>"VALUE"}
+
+VALUE = "VALUE"
+VOID = "void"
+
+MATHFUNCS = {
+  "exp" => [VALUE, ARG1], "cexp" => [VALUE, ARG1],
+  "exp2" => [VALUE, ARG1], "cexp2" => [VALUE, ARG1],
+  "expxt" => [VALUE, ARG2],
+  "log" => [VALUE, ARG1], "clog" => [VALUE, ARG1], 
+  "log1p" => [VALUE, ARG1], "clog1p" => [VALUE, ARG1], 
+  "log2" => [VALUE, ARG1], "clog2" => [VALUE, ARG1],
+  "log10" => [VALUE, ARG1], "clog10" => [VALUE, ARG1], 
+  "logxt" => [VALUE, ARG2],
+  "rcm2" => [VALUE, ARG_RCM], "rcm10" => [VALUE, ARG_RCM],
+  "sincos" => [VOID, ARG1SCALAR2],
+  "sin" => [VALUE, ARG1],  "csin" => [VALUE, ARG1], 
+  "cos" => [VALUE, ARG1],  "ccos" => [VALUE, ARG1],
+  "tan" => [VALUE, ARG1],  "ctan" => [VALUE, ARG1],
+  "csc" => [VALUE, ARG1],  "ccsc" => [VALUE, ARG1],
+  "sec" => [VALUE, ARG1],  "csec" => [VALUE, ARG1],
+  "cot" => [VALUE, ARG1],  "ccot" => [VALUE, ARG1],
+  "sinhcosh" => [VOID, ARG1SCALAR2],
+  "sinh" => [VALUE, ARG1],  "csinh" => [VALUE, ARG1], 
+  "cosh" => [VALUE, ARG1],  "ccosh" => [VALUE, ARG1],
+  "tanh" => [VALUE, ARG1],  "ctanh" => [VALUE, ARG1],
+  "csch" => [VALUE, ARG1],  "ccsch" => [VALUE, ARG1],
+  "sech" => [VALUE, ARG1],  "csech" => [VALUE, ARG1],
+  "coth" => [VALUE, ARG1],  "ccoth" => [VALUE, ARG1],
+  "asin" => [VALUE, ARG1],  "casin" => [VALUE, ARG1],
+  "acos" => [VALUE, ARG1],  "cacos" => [VALUE, ARG1],
+  "atan" => [VALUE, ARG1],  "catan" => [VALUE, ARG1],
+  "acsc" => [VALUE, ARG1],  "cacsc" => [VALUE, ARG1],
+  "asec" => [VALUE, ARG1],  "casec" => [VALUE, ARG1],
+  "acot" => [VALUE, ARG1],  "cacot" => [VALUE, ARG1],
+  "asinh" => [VALUE, ARG1],  "casinh" => [VALUE, ARG1],
+  "acosh" => [VALUE, ARG1],  "cacosh" => [VALUE, ARG1],
+  "atanh" => [VALUE, ARG1],  "catanh" => [VALUE, ARG1],
+  "acsch" => [VALUE, ARG1],  "cacsch" => [VALUE, ARG1],
+  "asech" => [VALUE, ARG1],  "casech" => [VALUE, ARG1],
+  "acoth" => [VALUE, ARG1],  "cacoth" => [VALUE, ARG1],
+  "trig" => [VALUE, ARG_TRIG],
+  "hypot" => [VALUE, ARG2],
+  "sqrt" => [VALUE, ARG1], "csqrt" => [VALUE, ARG1],
+  "cuberoot" => [VALUE, ARG1], "ccbrt" => [VALUE, ARG1],
+  "pow" => [VALUE, ARG2], "cpow" => [VALUE, ARG2], "ipow" => [VALUE, ARG2],
+  "escalb" => [VOID, ARG2SCALAR2],
+  "cabs" => [VALUE, ARG1],
+  "carg" => [VALUE, ARG1],
+  "l2norm" => [VALUE, ARG1],
+  "quadrant" => [VALUE, ARG2],
+  "erf" => [VALUE, ARG1],
+  "erfc" => [VALUE, ARG1],
+  "f_euler" => [VALUE, ARG1],
+  "PI"=>[VALUE, ARG_PREC],
+  "E"=>[VALUE, ARG_PREC],
+  "LOG2"=>[VALUE, ARG_PREC],
+  "LOG10"=>[VALUE, ARG_PREC],
+  "LOG_PI"=>[VALUE, ARG_PREC],
+  "SQRT2"=>[VALUE, ARG_PREC],
+  "SQRT3"=>[VALUE, ARG_PREC]
+}
+
+CB_TYPE = {
+  "exp" => "bigmath_func1", "cexp" => "bigmath_func1",
+  "exp2" => "bigmath_func1", "cexp2" => "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",
+  "sin" => "bigmath_func1", "csin" => "bigmath_func1",
+  "cos" => "bigmath_func1", "ccos" => "bigmath_func1",
+  "tan" => "bigmath_func1", "ctan" => "bigmath_func1",
+  "csc" => "bigmath_func1", "ccsc" => "bigmath_func1",
+  "sec" => "bigmath_func1", "csec" => "bigmath_func1",
+  "cot" => "bigmath_func1", "ccot" => "bigmath_func1",
+  "sinh" => "bigmath_func1", "csinh" => "bigmath_func1",
+  "cosh" => "bigmath_func1", "ccosh" => "bigmath_func1",
+  "tanh" => "bigmath_func1", "ctanh" => "bigmath_func1",
+  "csch" => "bigmath_func1", "ccsch" => "bigmath_func1",
+  "sech" => "bigmath_func1", "csech" => "bigmath_func1",
+  "coth" => "bigmath_func1", "ccoth" => "bigmath_func1",
+  "asin" => "bigmath_func1", "casin" => "bigmath_func1",
+  "acos" => "bigmath_func1", "cacos" => "bigmath_func1",
+  "atan" => "bigmath_func1", "catan" => "bigmath_func1",
+  "acsc" => "bigmath_func1", "cacsc" => "bigmath_func1",
+  "asec" => "bigmath_func1", "casec" => "bigmath_func1",
+  "acot" => "bigmath_func1", "cacot" => "bigmath_func1",
+  "asinh" => "bigmath_func1", "casinh" => "bigmath_func1",
+  "acosh" => "bigmath_func1", "cacosh" => "bigmath_func1",
+  "atanh" => "bigmath_func1", "catanh" => "bigmath_func1",
+  "acsch" => "bigmath_func1", "cacsch" => "bigmath_func1",
+  "asech" => "bigmath_func1", "casech" => "bigmath_func1",
+  "acoth" => "bigmath_func1", "cacoth" => "bigmath_func1",
+  "hypot" => "bigmath_func2",
+  "erf" => "bigmath_func1",
+  "erfc" => "bigmath_func1"
+}
+
+API_H = 'api.h'
+DECL_H = "decl.h"
+ALGOFUNC_H = 'algofunc.h'
+
+MATHFUNC_DIR_PATH = "internal/algo/bigmath/*/**/*.h"
+BRANCH_DIR_PATH = "internal/algo/branch/*/**/*.h"
+API_DIR_PATH = "api/*/**/*.h"
+
+DECL_INCLG = "BIGMATH_MATHFUNC_H"
+
+def declare_func(retval_type, funcname, args)
+  ary = args.map{|(arg, type)| [type, arg].join(" ")}.join(", ")
+  "%s %s(%s);" % [retval_type, funcname, ary]
+end
+
+def cfile_writer(filename, str)
+  f = IO.read(filename)
+  if f != str
+    IO.write(filename, str)
+  end
+end
+
+def update_header(include_guard, header_filename, target_dir)
+  header_str = String.new
+  Dir.chdir(__dir__) do
+    header_str << "#ifndef #{include_guard}\n"
+    header_str << "#define #{include_guard}\n"
+    header_str << "\n"
+    Dir.glob(target_dir) do |h|
+      header_str << "#include \"#{h}\"\n"
+    end
+    header_str << "\n"
+    header_str << "#endif /* #{include_guard} */\n"
+    cfile_writer(header_filename, header_str)
+  end
+end
+
+def update_decl_mathfunc_header
+  header_filename = DECL_H
+  header_str = String.new
+  Dir.chdir(__dir__) do
+    header_str << "#ifndef #{DECL_INCLG}\n"
+    header_str << "#define #{DECL_INCLG}\n"
+    header_str << "\n"
+    Dir.glob(MATHFUNC_DIR_PATH) do |h|
+      if /\w+\/\w+\/\w+\/\w+\/\w+.h/.match?(h)
+        /(.+)\/(.+)\/(.+)\/(.+)\/(.+).h/ =~ h
+        mathfunc, algo = $4, $5
+        if MATHFUNCS.keys.include?(mathfunc)
+          retval_type, args = MATHFUNCS[mathfunc]
+          if algo == "branch"
+            if CB_TYPE.keys.include?(mathfunc)
+              args = args.merge({"cb" => CB_TYPE[mathfunc]})
+            else
+              raise "The callback function name is not in the list: #{mathfunc}"
+            end
+          end
+          header_str << declare_func(retval_type, "#{mathfunc}_#{algo}", args)
+          header_str << "\n"
+        else
+          raise "The function name is not in the list: #{mathfunc}"
+        end
+      end
+    end
+    header_str << "\n"
+    header_str << "#endif /* #{DECL_INCLG} */"
+    cfile_writer(header_filename, header_str)
+  end
+end
+
+update_header("BIGMATH_ALGOFUNC_H", ALGOFUNC_H, MATHFUNC_DIR_PATH)
+update_header("BIGMATH_API_H", API_H, API_DIR_PATH)
+update_decl_mathfunc_header
+
+create_makefile('bigdecimal/math_r/math_r')

data/ext/bigdecimal/math_r/gamma_r.c

@@ -0,0 +1,251 @@
+/*******************************************************************************
+	gamma_r.c -- Regularized Incomplete Gamma Function
+
+	Author: tribusonz
+	Lisence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+#if 0
+VALUE gammar_q(VALUE, VALUE, VALUE, VALUE);
+
+
+VALUE
+gammar_p(VALUE a, VALUE x, VALUE loggamma_a, VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID geq = rb_intern(">=");
+	VALUE zero = BIG_ZERO, one = BIG_ONE, result, term, previous, big_k;
+	VALUE n;
+	a = rb_num_canonicalize(a, prec, ARG_REAL, ARG_RAWVALUE);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	loggamma_a = rb_num_canonicalize(loggamma_a, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (RTEST(rb_num_coerce_cmp(x, rb_funcall1(one, '+', a), geq)))
+		return rb_funcall1(one, '-', gammar_q(a, x, loggamma_a, prec));
+
+	if (rb_num_zero_p(x))
+		return zero;
+
+	n = rb_numdiff_make_n(prec);
+
+	// result = term = exp(a * log(x, n) - x - loggamma_a, n) / a;
+	term = rb_funcall1(a, '*', rb_bigmath_log(x, n));
+	term = rb_funcall1(term, '-', x);
+	term = rb_funcall1(term, '-', loggamma_a);
+	term = rb_bigmath_exp(term, n);
+	term = rb_funcall1(term, '/', a);
+	result = term;
+
+	big_k = one;
+
+	for (int k = 1; k <= 1000; k++)
+	{
+		VALUE d = rb_funcall1(x, '/', rb_funcall1(a, '+', big_k));
+		term = rb_funcall1(term, '*', d);
+		previous = result; result = rb_funcall(result, add, 2, term, n);
+		if (rb_num_equal_p(result, previous))
+			goto retval;
+		big_k = rb_funcall1(big_k, '+', one);
+	}
+	rb_warn("gammar_p(): can't converge.");
+retval:
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(loggamma_a);
+	RB_GC_GUARD(zero);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(result);
+	RB_GC_GUARD(term);
+	RB_GC_GUARD(previous);
+	return result;
+}
+
+VALUE
+gammar_q(VALUE a, VALUE x, VALUE loggamma_a, VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID div = rb_intern("div");
+	VALUE one = BIG_ONE, two = rb_BigDecimal1(INT2FIX(2)), 
+	      big_k, la, lb, w, result, temp, previous;
+	VALUE n;
+	a = rb_num_canonicalize(a, prec, ARG_REAL, ARG_RAWVALUE);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	loggamma_a = rb_num_canonicalize(loggamma_a, prec, ARG_REAL, ARG_RAWVALUE);
+	
+	if (RTEST(rb_num_coerce_cmp(x, rb_funcall1(one, '+', a), '<')))
+		return rb_funcall1(one, '-', gammar_p(a, x, loggamma_a, 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(w, '-', x);
+	w = rb_funcall1(w, '-', loggamma_a);
+	w = rb_bigmath_exp(w, prec);
+	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(temp, '*', rb_funcall1(lb, '-', la));
+		temp = rb_funcall1(temp, '+', rb_funcall1(rb_funcall1(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);
+		w = rb_funcall1(w, '*', rb_funcall1(temp, '/', big_k));
+
+		// temp = w / (la * lb);
+		temp = rb_funcall1(w, '/', rb_funcall1(la, '*', lb));
+
+		previous = result; result = rb_funcall(result, add, 2, temp, n);
+		if (rb_num_equal_p(result, previous))
+			goto retval;
+		big_k = rb_funcall1(big_k, '+', one);
+	}
+	rb_warn("gammar_q(): can't converge.");
+retval:
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(loggamma_a);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(big_k);
+	RB_GC_GUARD(la);
+	RB_GC_GUARD(lb);
+	RB_GC_GUARD(w);
+	RB_GC_GUARD(result);
+	RB_GC_GUARD(temp);
+	RB_GC_GUARD(previous);
+	return result;
+}
+
+// TODO: -1 <= x <= 1 以外はエラーが出る: `erf': undefined method `-' for nil (NoMethodError)
+VALUE
+erf_gammar(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE half = rb_BigDecimal1(rb_str_new_cstr("0.5"));
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE log_pi_2 = rb_funcall(
+		rb_bigmath_const_log_pi(prec), div, 2, two, prec);
+	VALUE y = gammar_p(half, rb_funcall1(x, '*', x), log_pi_2, prec);
+	if (rb_num_negative_p(x))  y = rb_num_uminus(y);
+	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)
+{
+	const ID div = rb_intern("div");
+	VALUE half = rb_BigDecimal1(rb_str_new_cstr("0.5"));
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE log_pi_2 = rb_funcall(
+		rb_bigmath_const_log_pi(prec), div, 2, two, prec);
+	VALUE y;
+	if (!rb_num_negative_p(x))
+		y = gammar_q(half, rb_funcall1(x, '*', x), log_pi_2, prec);
+	else
+	{
+		y = gammar_p(half, rb_funcall1(x, '*', x), log_pi_2, prec);
+		y = rb_funcall1(BIG_ONE, '+', y);
+	}
+	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)
+{
+	return erf_branch(x, prec, erf_gammar);
+}
+
+
+static VALUE
+__impl_gammar_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)
+{
+#if 0
+	rb_define_module_function(rb_mGammaR, "erf", __impl_gammar_erf, 2);
+	rb_define_module_function(rb_mGammaR, "erfc", __impl_gammar_erfc, 2);
+#endif
+}

data/ext/bigdecimal/math_r/hyperb.c

@@ -0,0 +1,172 @@
+/*******************************************************************************
+	hyperb.c -- Hyperbolic functions
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+/**
+ * Computes hyperbolic sine of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.sinh(1, 20) # Series expansion
+ *  #=> 0.11752011936438014569e1
+ *  BigMathR::Hyperb.sinh(4, 20) # Formula
+ *  #=> 0.27289917197127752449e2
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_sinh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sinh_branch(x, prec, sinh_formula);
+}
+
+
+/**
+ * Computes hyperbolic cosine of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.cosh(1, 20) # Series expansion
+ *  #=> 0.15430806348152437785e1
+ *  BigMathR::Hyperb.cosh(4, 20) # Formula
+ *  #=> 0.27308232836016486629e2
+
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_cosh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cosh_branch(x, prec, cosh_formula);
+}
+
+/**
+ * Computes hyperbolic tangent of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.tanh(1, 20) # Series expansion
+ *  #=> 0.76159415595576488812e0
+ *  BigMathR::Hyperb.tanh(4, 20) # Formula
+ *  #=> 0.99932929973906704379e0
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_tanh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return tanh_branch(x, prec, tanh_formula);
+}
+ 
+/**
+ * Computes hyperbolic cosecant of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.csch(1, 20) # Series expansion
+ *  #=> 0.85091812823932154512e0
+ *  BigMathR::Hyperb.csch(4, 20) # Formula
+ *  #=> 0.36643570325865605966e-1
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_csch(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return csch_branch(x, prec, csch_formula);
+}
+
+/**
+ * Computes hyperbolic secant of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.sech(1, 20) # Series expansion
+ *  #=> 0.64805427366388539957e0
+ *  BigMathR::Hyperb.sech(4, 20) # Formula
+ *  #=> 0.36618993473686532773e-1
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_sech(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sech_branch(x, prec, sech_formula);
+}
+
+/**
+ * Computes hyperbolic cotangent of +x+.
+ * 
+ * @example
+ *  BigMathR::Hyperb.coth(1, 20) # Series expansion
+ *  #=> 0.13130352854993313036e1
+ *  BigMathR::Hyperb.coth(4, 20) # Formula
+ *  #=> 0.10006711504016824899e1
+ * @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.
+ * @since 0.1.0
+ */
+static VALUE
+__impl_hyperb_coth(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return coth_branch(x, prec, coth_formula);
+}
+
+/**
+ * Document-module: BigMathR::Hyperb
+ * 
+ * A module that provides a hyperbolic functions.
+ * It is used internally.
+ * <br>
+ * It handle the real number solutions. 
+ * The algorithm is implemented according to the references, 
+ * when |x| < 3 computes to series expansion, otherwise computes by exponent identity.
+ * == Synopsis
+ * The function names defined are the same as those in the C/C++ standard.
+ * <br>
+ * - Hyperbolic Sine:                +:sinh+ <br>
+ * - Hyperbolic Cosine:              +:cosh+ <br>
+ * - Hyperbolic Tangent:             +:tanh+ <br>
+ * Follow, those reciprocals of not defined in C/C++ standard.
+ * <br>
+ * - Hyperbolic Cosecant:            +:csch+ <br>
+ * - Hyperbolic Secant:              +:sech+ <br>
+ * - Hyperbolic Cotangent:           +:coth+ <br>
+ * Reference::
+ * C-gengo ni yoru hyoujun alkgorithm jiten (Japanese) - Hasruhiko Okumura (Gijutsu hyouron-sha)
+ */
+void
+InitVM_Hyperb(void)
+{
+	rb_define_singleton_method(rb_mHyperb, "sinh", __impl_hyperb_sinh, 2);
+	rb_define_singleton_method(rb_mHyperb, "cosh", __impl_hyperb_cosh, 2);
+	rb_define_singleton_method(rb_mHyperb, "tanh", __impl_hyperb_tanh, 2);
+	rb_define_singleton_method(rb_mHyperb, "csch", __impl_hyperb_csch, 2);
+	rb_define_singleton_method(rb_mHyperb, "sech", __impl_hyperb_sech, 2);
+	rb_define_singleton_method(rb_mHyperb, "coth", __impl_hyperb_coth, 2);
+}

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

@@ -0,0 +1,22 @@
+VALUE
+E_ser(VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, m, a, e;
+	long k = 0; // TODO: should be break when number is exceeded to LONG_MAX?
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	a = BIG_ONE;
+	e = BIG_ZERO;
+
+	while (rb_numdiff_condition_p(e, a, n, &m))
+	{
+		e = rb_funcall1(e, '+', a);
+		a = rb_funcall(a, div, 2, LONG2NUM(++k), m);
+	}
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(e);
+        return rb_num_round(e, prec);
+}

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

@@ -0,0 +1,16 @@
+VALUE
+LOG10_ser(VALUE prec)
+{
+#if 0
+	VALUE x = rb_Rational(INT2FIX(-9), INT2FIX(10));
+	x = log_ser_mercator(x, prec);
+	return rb_num_uminus(x);
+#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);
+	return rb_funcall(rb_funcall1(log2, '*', INT2FIX(3)), add, 2, x, prec);
+#endif
+}
+

data/ext/bigdecimal/math_r/internal/algo/bigmath/LOG2/BBP2002.h

@@ -0,0 +1,36 @@
+VALUE
+LOG2_BBP2002(VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	const ID div = rb_intern("div");
+	VALUE two, nine, a, r, s, d, n, m;
+
+	rb_check_precise(prec);
+	n = rb_numdiff_make_n(prec);
+
+	two = rb_BigDecimal1(INT2FIX(2));
+	nine = rb_BigDecimal1(INT2FIX(9));
+	a = BIG_ONE;
+	r = BIG_ONE;
+	s = BIG_ZERO;
+	d = BIG_ONE;
+
+	while (rb_numdiff_condition_p(s, d, n, &m))
+	{
+		d = rb_funcall(r, div, 2, a, m);
+		s = rb_funcall1(s, '+', d);
+		a = rb_funcall1(a, '+', two);
+		r = rb_funcall(r, div, 2, nine, m);
+	}
+	s = rb_funcall(s, mult, 2,
+		rb_Rational(INT2FIX(2), INT2FIX(3)), prec);
+
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(nine);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(r);
+	RB_GC_GUARD(s);
+
+	return s;
+}

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

@@ -0,0 +1,7 @@
+VALUE
+LOG_PI_builtin(VALUE prec)
+{
+	VALUE log_pi = rb_bigmath_const_pi(prec);
+	return log_builtin(log_pi, prec);
+}
+