bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,6 @@
+bool
+rb_num_finite_p(VALUE z)
+{
+	const ID finite_p = rb_intern("finite?");
+	return RTEST(rb_funcall(z, finite_p, 0));
+}

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

@@ -0,0 +1,6 @@
+VALUE
+rb_num_imag(VALUE z)
+{
+	const ID imag = rb_intern("imag");
+	return rb_funcall(z, imag, 0);
+}

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

@@ -0,0 +1,7 @@
+int
+rb_num_infinite_p(VALUE z)
+{
+	const ID infinite_p = rb_intern("infinite?");
+	VALUE y = rb_funcall(z, infinite_p, 0);
+	return NIL_P(y) ? 0 : NUM2INT(y);
+}

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

@@ -0,0 +1,5 @@
+bool
+rb_num_nan_p(VALUE z)
+{
+	return rb_num_notequal_p(z, z);
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_negative_p(VALUE z)
+{
+	const ID negative_p = rb_intern("negative?");
+	return RTEST(rb_funcall(z, negative_p, 0));
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_nonzero_p(VALUE z)
+{
+	const ID nonzero_p = rb_intern("nonzero?");
+	return RTEST(rb_funcall(z, nonzero_p, 0));
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_notequal_p(VALUE lhs, VALUE rhs)
+{
+	const ID notequal = rb_intern("!=");
+	return RTEST(rb_num_coerce_cmp(lhs, rhs, notequal));
+}

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

@@ -0,0 +1,5 @@
+bool
+rb_num_numeric_p(VALUE self)
+{
+	return rb_class_superclass(CLASS_OF(self)) == rb_cNumeric;
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_positive_p(VALUE z)
+{
+	const ID positive_p = rb_intern("positive?");
+	return RTEST(rb_funcall(z, positive_p, 0));
+}

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

@@ -0,0 +1,6 @@
+VALUE
+rb_num_real(VALUE z)
+{
+	const ID real = rb_intern("real");
+	return rb_funcall(z, real, 0);
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_real_p(VALUE z)
+{
+	const ID real_p = rb_intern("real?");
+	return RTEST(rb_funcall(z, real_p, 0));
+}

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

@@ -0,0 +1,56 @@
+static inline VALUE
+decimal_round_iter(RB_BLOCK_CALL_FUNC_ARGLIST(val, prec))
+{
+	const ID exponent = rb_intern("exponent");
+	const ID round = rb_intern("round");
+	VALUE exp;
+	if (TYPE(val) == T_FIXNUM || TYPE(val) == T_BIGNUM)
+		return val;
+	RUBY_ASSERT(CLASS_OF(val) != rb_cBigDecimal);
+	switch (NUM2INT(rb_BigDecimal_sign(val))) {
+	case 0: case 1: case -1: case 3: case -3:
+		goto retval;
+		break;
+	default:
+		break;
+	}
+	exp = rb_funcall(val, exponent, 0);
+	switch (FIX2INT(rb_dbl_cmp(NUM2DBL(exp), 0.))) {
+	case 1: // up to integer-part
+		val = rb_funcall(val, round, 1,
+			LONG2NUM(NUM2LONG(prec)-NUM2LONG(exp)));
+		break;
+	case 0:
+	case -1: // down to fraction-part
+		val = rb_funcall(val, round, 1, prec);
+		break;
+	}
+retval:
+	return val;
+}
+
+VALUE
+rb_num_round(VALUE x, VALUE prec)
+{
+	const ID map = rb_intern("map");
+	VALUE arglist = rb_ary_new();
+	if (rb_num_real_p(x))
+	{
+		rb_ary_store(arglist, 0, rb_num_real(x));
+		arglist = rb_block_call(arglist, map, 0, NULL,
+			decimal_round_iter, prec);
+
+		x = rb_ary_entry(arglist, 0);
+	}
+	else
+	{
+		rb_ary_store(arglist, 0, rb_num_real(x));
+		rb_ary_store(arglist, 1, rb_num_imag(x));
+		arglist = rb_block_call(arglist, map, 0, NULL,
+			decimal_round_iter, prec);
+		x = rb_Complex(
+			rb_ary_entry(arglist, 0),
+			rb_ary_entry(arglist, 1));
+	}
+	return x;
+}

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

@@ -0,0 +1,6 @@
+VALUE
+rb_num_uminus(VALUE x)
+{
+	const ID uminus = rb_intern("-@");
+	return rb_funcall(x, uminus, 0);
+}

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

@@ -0,0 +1,6 @@
+bool
+rb_num_zero_p(VALUE z)
+{
+	const ID zero_p = rb_intern("zero?");
+	return RTEST(rb_funcall(z, zero_p, 0));
+}

data/ext/bigdecimal/math_r/api.c

@@ -0,0 +1,13 @@
+/*******************************************************************************
+	api.c -- API for BigMathR
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+
+#include "decl.h"
+#include "api.h"
+#include "algofunc.h"

data/ext/bigdecimal/math_r/api.h

@@ -0,0 +1,69 @@
+#ifndef BIGMATH_API_H
+#define BIGMATH_API_H
+
+#include "api/bigdecimal/check_precise.h"
+#include "api/bigdecimal/infinity.h"
+#include "api/bigdecimal/minus_infinity.h"
+#include "api/bigdecimal/minus_one.h"
+#include "api/bigdecimal/minus_zero.h"
+#include "api/bigdecimal/nan.h"
+#include "api/bigdecimal/one.h"
+#include "api/bigdecimal/sign.h"
+#include "api/bigdecimal/zero.h"
+#include "api/bigmath/api_call1.h"
+#include "api/bigmath/api_call2.h"
+#include "api/bigmath/atan.h"
+#include "api/bigmath/atan_adopt.h"
+#include "api/bigmath/cabs.h"
+#include "api/bigmath/carg.h"
+#include "api/bigmath/cexp.h"
+#include "api/bigmath/clog.h"
+#include "api/bigmath/const.h"
+#include "api/bigmath/const_e.h"
+#include "api/bigmath/const_log10.h"
+#include "api/bigmath/const_log2.h"
+#include "api/bigmath/const_log_pi.h"
+#include "api/bigmath/const_pi.h"
+#include "api/bigmath/const_sqrt2.h"
+#include "api/bigmath/const_sqrt3.h"
+#include "api/bigmath/cpow.h"
+#include "api/bigmath/csqrt.h"
+#include "api/bigmath/degree_sparg.h"
+#include "api/bigmath/escalb.h"
+#include "api/bigmath/exp.h"
+#include "api/bigmath/expxt.h"
+#include "api/bigmath/hypot.h"
+#include "api/bigmath/ipow.h"
+#include "api/bigmath/l2norm.h"
+#include "api/bigmath/log.h"
+#include "api/bigmath/pow.h"
+#include "api/bigmath/quadrant.h"
+#include "api/bigmath/sincos.h"
+#include "api/bigmath/sqrt.h"
+#include "api/bigmath/to_rad.h"
+#include "api/kernel/rb_BigDecimal.h"
+#include "api/kernel/rb_BigDecimal1.h"
+#include "api/kernel/rb_BigDecimal_flo.h"
+#include "api/kernel/rb_ImaginaryZ.h"
+#include "api/numanalysis/condition_p.h"
+#include "api/numanalysis/make_n.h"
+#include "api/numeric/abs.h"
+#include "api/numeric/canonicalize.h"
+#include "api/numeric/cmpeql.h"
+#include "api/numeric/equal_p.h"
+#include "api/numeric/finite_p.h"
+#include "api/numeric/imag.h"
+#include "api/numeric/infinite_p.h"
+#include "api/numeric/nan_p.h"
+#include "api/numeric/negative_p.h"
+#include "api/numeric/nonzero_p.h"
+#include "api/numeric/notequal_p.h"
+#include "api/numeric/numeric_p.h"
+#include "api/numeric/positive_p.h"
+#include "api/numeric/real.h"
+#include "api/numeric/real_p.h"
+#include "api/numeric/round.h"
+#include "api/numeric/uminus.h"
+#include "api/numeric/zero_p.h"
+
+#endif /* BIGMATH_API_H */

data/ext/bigdecimal/math_r/const.c

@@ -0,0 +1,186 @@
+/*******************************************************************************
+	constant.c -- Mathematical constants
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+/**
+ * The constant pi.
+ * @example
+ *  BigMathR.PI(20) #=> 0.314159265358979323846e1
+ * @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_pi(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_pi(prec);
+}
+
+/**
+ * The natural logarithm of pi.
+ * @example
+ *  BigMathR.LOG_PI(20) #=> 0.11447298858494001741e1
+ * @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_log_pi(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_log_pi(prec);
+}
+
+/**
+ * The constant e.
+ * @example
+ *  BigMathR.E(20) #=> 0.27182818284590452354e1
+ * @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_e(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_e(prec);
+}
+
+/**
+ * The natural logarithm of 2.
+ * @example
+ *  BigMathR.LOG2(20) #=> 0.69314718055994530942e0
+ * @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_log2(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_log2(prec);
+}
+
+/**
+ * The natural logarithm of 10.
+ * @example
+ *  BigMathR.LOG10(20) #=> 0.2302585092994045684e1
+ * @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_log10(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_log10(prec);
+}
+
+/**
+ * The square root of 2.
+ * @example
+ *  BigMathR.SQRT2(20) #=> 0.14142135623730950488e1
+ * @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_sqrt2(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_sqrt2(prec);
+}
+
+/**
+ * The square root of 3.
+ * @example
+ *  BigMathR.SQRT3(20) #=> 0.17320508075688772935e1
+ * @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_sqrt3(VALUE unused_obj, VALUE prec)
+{
+	return rb_bigmath_const_sqrt3(prec);
+}
+
+/**
+ * Implement by Machin's formula.
+ * 
+ * @example
+ *  BigMathR::Const::PI.machin(20)
+ *  #=> 0.31415926535897932385e1
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Constant PI
+ * @raise [TypeError] not an Integer
+ * @raise [RangeError] Zero or negative precision
+ */
+static VALUE
+__impl_const_pi_machin(VALUE unused_obj, VALUE prec)
+{
+	return PI_machin(prec);
+}
+
+/**
+ * Implement by series expansion: sum_(n=0)^infty 1/n!
+ * 
+ * @example
+ *  BigMathR::Const::E.ser(20)
+ *  #=> 0.27182818284590452354e1
+ * @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_e_ser(VALUE unused_obj, VALUE prec)
+{
+	return E_ser(prec);
+}
+
+/**
+ * Implement by BBP's formula (Borwein and Bailey 2002)
+ * 
+ * @example
+ *  BigMathR::Const::LOG2.bbp2002(20)
+ *  #=> 0.69314718055994530942e0
+ * @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_log2_bbp2002(VALUE unused_obj, VALUE prec)
+{
+	return LOG2_BBP2002(prec);
+}
+
+
+/* :nodoc: */
+void
+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, "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);
+	rb_define_module_function(rb_mBigMathR, "SQRT2", __impl_const_sqrt2, 1);
+	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_mConstLOG2, "bbp2002", __impl_const_log2_bbp2002, 1);
+
+}
+

data/ext/bigdecimal/math_r/decl.h

@@ -0,0 +1,203 @@
+#ifndef BIGMATH_MATHFUNC_H
+#define BIGMATH_MATHFUNC_H
+
+VALUE E_ser(VALUE prec);
+VALUE LOG10_ser(VALUE prec);
+VALUE LOG2_BBP2002(VALUE prec);
+VALUE LOG_PI_builtin(VALUE prec);
+VALUE PI_machin(VALUE prec);
+VALUE SQRT2_builtin(VALUE prec);
+VALUE SQRT3_builtin(VALUE prec);
+VALUE acos_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acos_edom(VALUE x, VALUE prec);
+VALUE acos_logrep(VALUE x, VALUE prec);
+VALUE acos_ser(VALUE x, VALUE prec);
+VALUE acosh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acosh_edom(VALUE x, VALUE prec);
+VALUE acosh_logrep(VALUE x, VALUE prec);
+VALUE acot_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acot_logrep(VALUE x, VALUE prec);
+VALUE acoth_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acoth_edom(VALUE x, VALUE prec);
+VALUE acoth_logrep(VALUE x, VALUE prec);
+VALUE acsc_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acsc_edom(VALUE x, VALUE prec);
+VALUE acsc_logrep(VALUE x, VALUE prec);
+VALUE acsch_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE acsch_logrep(VALUE x, VALUE prec);
+VALUE asec_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE asec_edom(VALUE x, VALUE prec);
+VALUE asec_logrep(VALUE x, VALUE prec);
+VALUE asech_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE asech_edom(VALUE x, VALUE prec);
+VALUE asech_logrep(VALUE x, VALUE prec);
+VALUE asin_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE asin_edom(VALUE x, VALUE prec);
+VALUE asin_logrep(VALUE x, VALUE prec);
+VALUE asin_ser(VALUE x, VALUE prec);
+VALUE asinh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE asinh_logrep(VALUE x, VALUE prec);
+VALUE asinh_ser(VALUE x, VALUE prec);
+VALUE atan_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE atan_logrep(VALUE x, VALUE prec);
+VALUE atan_ser_euler(VALUE x, VALUE prec);
+VALUE atan_ser_usual(VALUE x, VALUE prec);
+VALUE atanh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE atanh_edom(VALUE x, VALUE prec);
+VALUE atanh_logrep(VALUE x, VALUE prec);
+VALUE atanh_ser(VALUE x, VALUE prec);
+VALUE cabs_formula(VALUE x, VALUE prec);
+VALUE cacos_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacos_logrep(VALUE x, VALUE prec);
+VALUE cacosh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacosh_logrep(VALUE x, VALUE prec);
+VALUE cacot_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacot_logrep(VALUE x, VALUE prec);
+VALUE cacoth_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacoth_logrep(VALUE x, VALUE prec);
+VALUE cacsc_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacsc_logrep(VALUE x, VALUE prec);
+VALUE cacsch_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cacsch_logrep(VALUE x, VALUE prec);
+VALUE carg_formula(VALUE x, VALUE prec);
+VALUE casec_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE casec_logrep(VALUE x, VALUE prec);
+VALUE casech_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE casech_logrep(VALUE x, VALUE prec);
+VALUE casin_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE casin_logrep(VALUE x, VALUE prec);
+VALUE casinh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE casinh_logrep(VALUE x, VALUE prec);
+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_formula(VALUE x, VALUE prec);
+VALUE ccos_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccos_eulerf(VALUE x, VALUE prec);
+VALUE ccosh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccosh_eulerf(VALUE x, VALUE prec);
+VALUE ccot_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccot_eulerf(VALUE x, VALUE prec);
+VALUE ccoth_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccoth_eulerf(VALUE x, VALUE prec);
+VALUE ccsc_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccsc_eulerf(VALUE x, VALUE prec);
+VALUE ccsch_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE ccsch_eulerf(VALUE x, VALUE prec);
+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 clog_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE clog_formula(VALUE x, VALUE prec);
+VALUE clog10_formula(VALUE x, VALUE prec);
+VALUE clog1p_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);
+VALUE cos_ser(VALUE x, VALUE prec);
+VALUE cosh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cosh_eulerf(VALUE x, VALUE prec);
+VALUE cosh_formula(VALUE x, VALUE prec);
+VALUE cosh_ser(VALUE x, VALUE prec);
+VALUE cot_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE cot_eulerf(VALUE x, VALUE prec);
+VALUE cot_ser(VALUE x, VALUE prec);
+VALUE coth_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE coth_eulerf(VALUE x, VALUE prec);
+VALUE coth_formula(VALUE x, VALUE prec);
+VALUE coth_ser(VALUE x, VALUE prec);
+VALUE cpow_formula(VALUE x, VALUE y, VALUE prec);
+VALUE csc_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE csc_eulerf(VALUE x, VALUE prec);
+VALUE csc_ser(VALUE x, VALUE prec);
+VALUE csch_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE csch_eulerf(VALUE x, VALUE prec);
+VALUE csch_formula(VALUE x, VALUE prec);
+VALUE csch_ser(VALUE x, VALUE prec);
+VALUE csec_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE csec_eulerf(VALUE x, VALUE prec);
+VALUE csech_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE csech_eulerf(VALUE x, VALUE prec);
+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_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_newton(VALUE x, VALUE prec);
+VALUE erf_algo911(VALUE x, VALUE prec);
+VALUE erf_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE erf_cf(VALUE x, VALUE prec);
+VALUE erf_ser_inf(VALUE x, VALUE prec);
+VALUE erf_ser_zero(VALUE x, VALUE prec);
+VALUE erfc_algo911(VALUE x, VALUE prec);
+VALUE erfc_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE erfc_cf(VALUE x, VALUE prec);
+void escalb_edf(VALUE x, VALUE y, VALUE prec, VALUE *a, VALUE *b);
+VALUE exp_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+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 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);
+VALUE hypot_l2norm(VALUE x, VALUE y, VALUE prec);
+VALUE hypot_mmm(VALUE x, VALUE y, VALUE prec);
+VALUE ipow_edf(VALUE x, VALUE y, VALUE prec);
+VALUE l2norm_formula(VALUE x, VALUE prec);
+VALUE log_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE log_builtin(VALUE x, VALUE prec);
+VALUE log_edf(VALUE x, VALUE prec);
+VALUE log_edom(VALUE x, VALUE prec);
+VALUE log_mercator(VALUE x, VALUE prec);
+VALUE log_ser_okumura(VALUE x, VALUE prec);
+VALUE log10_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE log10_edf(VALUE x, VALUE prec);
+VALUE log10_mercator(VALUE x, VALUE prec);
+VALUE log1p_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE log1p_p_adic(VALUE x, VALUE prec);
+VALUE log1p_ser_mercator(VALUE x, VALUE prec);
+VALUE log2_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE log2_edf(VALUE x, VALUE prec);
+VALUE log2_mercator(VALUE x, VALUE prec);
+VALUE logxt_edf(VALUE x, VALUE y, VALUE prec);
+VALUE pow_formula(VALUE x, VALUE y, VALUE prec);
+VALUE quadrant_formula(VALUE x, VALUE y, VALUE prec);
+VALUE rcm10_edf(VALUE x, VALUE *reso);
+VALUE rcm2_edf(VALUE x, VALUE *reso);
+VALUE sec_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE sec_eulerf(VALUE x, VALUE prec);
+VALUE sec_ser(VALUE x, VALUE prec);
+VALUE sech_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE sech_eulerf(VALUE x, VALUE prec);
+VALUE sech_formula(VALUE x, VALUE prec);
+VALUE sech_ser(VALUE x, VALUE prec);
+VALUE sin_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE sin_eulerf(VALUE x, VALUE prec);
+VALUE sin_ser(VALUE x, VALUE prec);
+void sincos_ser(VALUE x, VALUE prec, VALUE *a, VALUE *b);
+VALUE sinh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE sinh_eulerf(VALUE x, VALUE prec);
+VALUE sinh_formula(VALUE x, VALUE prec);
+VALUE sinh_ser(VALUE x, VALUE prec);
+void sinhcosh_ser(VALUE x, VALUE prec, VALUE *a, VALUE *b);
+VALUE sqrt_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE sqrt_builtin(VALUE x, VALUE prec);
+VALUE sqrt_edom(VALUE x, VALUE prec);
+VALUE sqrt_newton(VALUE x, VALUE prec);
+VALUE tan_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE tan_eulerf(VALUE x, VALUE prec);
+VALUE tan_ser(VALUE x, VALUE prec);
+VALUE tanh_branch(VALUE x, VALUE prec, bigmath_func1 cb);
+VALUE tanh_eulerf(VALUE x, VALUE prec);
+VALUE tanh_formula(VALUE x, VALUE prec);
+VALUE tanh_ser(VALUE x, VALUE prec);
+VALUE trig_f_euler(ID func, VALUE theta, VALUE prec);
+
+#endif /* BIGMATH_MATHFUNC_H */