bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,87 @@
+void
+escalb_edf(VALUE a, VALUE x, VALUE prec, VALUE *exp, VALUE *fra)
+{
+	const ID fix = rb_intern("fix");
+	const ID frac = rb_intern("frac");
+	const ID floor = rb_intern("floor");
+	const ID pred = rb_intern("pred");
+	const ID MAX_10_EXP = rb_intern("MAX_10_EXP");
+	VALUE max_10_exp = rb_const_get_at(rb_cFloat, MAX_10_EXP);
+
+	if (!rb_num_finite_p(a) && !rb_num_positive_p(a))
+		rb_raise(rb_eRangeError, "parameter a must be positive finite");
+	switch (TYPE(x)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		*exp = x; *fra = BIG_ZERO;
+		break;
+	case T_FLOAT:
+		if (isinf(NUM2DBL(x)) || isnan(NUM2DBL(x)))
+		{
+			*exp = rb_BigDecimal_flo(x); *fra = BIG_ZERO;
+		}
+		else
+		{
+			*exp = rb_funcall(x, floor, 0);
+			*fra = rb_BigDecimal_flo(rb_funcall1(x, '%', INT2FIX(1)));
+		}
+		break;
+	case T_RATIONAL:
+		*exp = rb_funcall(x, floor, 0);
+		*fra = rb_BigDecimal(rb_funcall1(x, '%', INT2FIX(1)), prec);
+		break;
+	case T_COMPLEX:
+		rb_raise(rb_eTypeError, "no solution for Complex");
+		break;
+	default:
+		if (rb_class_superclass(CLASS_OF(x)) == rb_cNumeric)
+		{
+			if (CLASS_OF(x) == rb_cBigDecimal)
+			{
+				if (!rb_num_finite_p(x))
+				{
+					*exp = x; *fra = BIG_ZERO;
+				}
+				else
+				{
+					*exp = rb_Integer(rb_funcall(x, fix, 0));
+					if (rb_num_negative_p(x) &&
+					    rb_num_notequal_p(*exp, x))
+						*exp = rb_funcall(*exp, pred, 0);
+					if (rb_num_notequal_p(*exp, x))
+					{
+						*fra = rb_funcall(x, frac, 0);
+						if (rb_num_negative_p(*fra))
+							*fra = rb_funcall1(BIG_ONE, '+', *fra);
+					}
+					else
+						*fra = BIG_ZERO;
+				}
+			}
+			else
+				rb_raise(rb_eTypeError, "unknown numeric type");
+		}
+		rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+		break;
+	}
+	if (!rb_num_finite_p(x))
+	{
+		switch (rb_num_infinite_p(x)) {
+		case 1:
+			*exp = x;
+			break;
+		case -1:
+			*exp = BIG_ZERO;
+			break;
+		default:
+			*exp = BIG_NAN;
+			break;
+		}
+		*fra = BIG_ZERO;
+		return;
+	}
+	*exp = rb_bigmath_ipow(a, *exp,
+		NUM2INT(rb_num_cmpeql(prec, max_10_exp)) == 1 ? prec : max_10_exp);
+	*exp = rb_num_round(*exp,
+		NUM2INT(rb_num_cmpeql(prec, max_10_exp)) == 1 ? prec : max_10_exp);
+}

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

@@ -0,0 +1,29 @@
+VALUE
+exp_branch(VALUE x, VALUE prec, bigmath_func1 exp_cb)
+{
+	const ID mult = rb_intern("mult");
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		w = BIG_NAN;
+	else
+	{
+	        VALUE exp = Qundef, fra = Qundef;
+		rb_bigmath_escalb(
+			rb_bigmath_const_e(prec), x, prec, &exp, &fra);
+		if (exp == Qundef || fra == Qundef)
+			rb_raise(rb_eRuntimeError, "no solution");
+		else if (rb_num_infinite_p(exp) || rb_num_zero_p(exp) || rb_num_zero_p(fra))
+			w = rb_num_round(exp, prec);
+		else
+		{
+			fra = exp_cb(fra, prec);
+			if (CLASS_OF(exp) != rb_cBigDecimal)
+				exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+			w = rb_funcall(exp, mult, 2, fra, prec);
+		}
+	}
+	return w;
+}

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

@@ -0,0 +1,6 @@
+VALUE
+exp_builtin(VALUE x, VALUE prec)
+{
+	VALUE y = rb_funcall(rb_mBigMath, mf_exp, 2, x, prec);
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,23 @@
+VALUE
+exp_edf(VALUE x, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE exp = Qundef, fra = Qundef;
+
+	rb_check_precise(prec);
+
+	if (rb_num_notequal_p(x, x))
+		return BIG_NAN;
+	rb_bigmath_escalb(rb_bigmath_const_e(prec), x, prec, &exp, &fra);
+	if (exp == Qundef || fra == Qundef)
+		rb_raise(rb_eRuntimeError, "no solution");
+	if (rb_num_infinite_p(exp) ||
+	    rb_num_zero_p(exp) ||
+	    rb_num_zero_p(fra))
+		return rb_num_round(exp, prec);
+	fra = rb_bigmath_expxt(fra, BIG_ONE, prec);
+	if (CLASS_OF(exp) != rb_cBigDecimal)
+		exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+
+	return rb_funcall(exp, mult, 2, fra, prec);
+}

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

@@ -0,0 +1,29 @@
+VALUE
+exp2_branch(VALUE x, VALUE prec, bigmath_func1 exp2_cb)
+{
+	const ID mult = rb_intern("mult");
+	VALUE w = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (rb_num_nan_p(x))
+		w = BIG_NAN;
+	else
+	{
+	        VALUE exp = Qundef, fra = Qundef;
+		rb_bigmath_escalb(
+			rb_BigDecimal1(INT2FIX(2)), x, prec, &exp, &fra);
+		if (exp == Qundef || fra == Qundef)
+			rb_raise(rb_eRuntimeError, "no solution");
+		else if (rb_num_infinite_p(exp) || rb_num_zero_p(exp) || rb_num_zero_p(fra))
+			w = rb_num_round(exp, prec);
+		else
+		{
+			fra = exp2_cb(fra, prec);
+			if (CLASS_OF(exp) != rb_cBigDecimal)
+				exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+			w = rb_funcall(exp, mult, 2, fra, prec);
+		}
+	}
+	return w;
+}

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

@@ -0,0 +1,19 @@
+VALUE
+exp2_edf(VALUE x, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	VALUE exp = Qundef, fra = Qundef;
+	if (rb_num_notequal_p(x, x))
+		return BIG_NAN;
+	rb_bigmath_escalb(INT2FIX(2), x, prec, &exp, &fra);
+	if (exp == Qundef || fra == Qundef)
+		rb_raise(rb_eRuntimeError, "no solution");
+	if (rb_num_infinite_p(exp) ||
+	    rb_num_zero_p(exp) ||
+	    rb_num_zero_p(fra))
+		return rb_num_round(exp, prec);
+	fra = rb_bigmath_expxt(fra, rb_bigmath_const_log2(prec), prec);
+	if (CLASS_OF(exp) != rb_cBigDecimal)
+		exp = rb_num_canonicalize(exp, prec, ARG_REAL, ARG_RAWVALUE);
+	return rb_funcall(exp, mult, 2, fra, prec);
+}

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

@@ -0,0 +1,31 @@
+VALUE
+expxt_edf(VALUE x, VALUE t, VALUE prec)
+{
+	const ID mult = rb_intern("mult");
+	const ID div = rb_intern("div");
+	VALUE n, m, a, xt, e;
+	long i = 0;
+
+	rb_check_precise(prec);
+
+	n = rb_numdiff_make_n(prec), m;
+	a = BIG_ONE;
+	xt = rb_funcall1(x, '*', t);
+	e = BIG_ZERO;
+
+	if (rb_num_zero_p(xt))
+		return e;
+
+	while (rb_numdiff_condition_p(e, a, n, &m))
+	{
+		e = rb_funcall1(e, '+', a);
+		a = rb_funcall(a, div, 2, LONG2NUM(++i), m);
+		a = rb_funcall(a, mult, 2, xt, m);
+	}
+
+	RB_GC_GUARD(a);
+	RB_GC_GUARD(xt);
+	RB_GC_GUARD(e);
+
+	return rb_num_round(e, prec);
+}

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

@@ -0,0 +1,11 @@
+VALUE
+f_euler_formula(VALUE theta, VALUE prec)
+{
+	VALUE sin, cos;
+
+	rb_check_precise(prec);
+
+	rb_bigmath_sincos(theta, prec, &sin, &cos);
+
+	return rb_Complex(cos, sin);
+}

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

@@ -0,0 +1,25 @@
+VALUE
+hypot_branch(VALUE a, VALUE b, VALUE prec, bigmath_func2 hypot_cb)
+{
+	VALUE c = Qundef;
+
+	a = rb_num_real_p(a) ?
+		rb_num_canonicalize(a, prec, ARG_REAL, ARG_RAWVALUE) :
+		rb_num_canonicalize(a, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	b = rb_num_real_p(b) ?
+		rb_num_canonicalize(b, prec, ARG_REAL, ARG_RAWVALUE) :
+		rb_num_canonicalize(b, prec, ARG_COMPLEX, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(a) || !rb_num_finite_p(b))
+	{
+		if (rb_num_nan_p(a) || rb_num_nan_p(b))
+			c = BIG_NAN;
+		else if (rb_num_infinite_p(a) || rb_num_infinite_p(b))
+			c = BIG_INF;
+	}
+	if (c == Qundef)
+		c = hypot_cb(a, b, prec);
+
+	return c;
+}
+

data/ext/bigdecimal/math_r/internal/algo/bigmath/hypot/l2norm.h

@@ -0,0 +1,11 @@
+VALUE
+hypot_l2norm(VALUE a, VALUE b, VALUE prec)
+{
+	VALUE w;
+	
+	rb_check_precise(prec);
+	
+	w = rb_bigmath_l2norm(rb_assoc_new(a, b), prec);
+	
+	return w;
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/hypot/mmm.h

@@ -0,0 +1,38 @@
+// Reference: C-gengo no yoru hyoujun algorithm jiten - Haruhiko Okumura
+VALUE
+hypot_mmm(VALUE a, VALUE b, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE n, m, two, four, t;
+
+	rb_check_precise(prec);
+
+	n = rb_numdiff_make_n(prec);
+	m = Qundef;
+        two = rb_BigDecimal1(INT2FIX(2));
+	four = rb_BigDecimal1(INT2FIX(4));
+	t = BIG_ONE;
+
+	if (rb_num_negative_p(a))  a = rb_num_uminus(a);
+	if (rb_num_negative_p(b))  b = rb_num_uminus(b);
+	if (rb_num_coerce_cmp(a, b, '<'))
+	{
+		t = a; a = b; b = t;
+	}
+	if (rb_num_zero_p(b))  return a;
+	while (rb_numdiff_condition_p(a, t, n, &m))
+	{
+		t = rb_funcall1(b, '/', a);
+		t = rb_funcall1(t, '*', t);
+		t = rb_funcall(t, div, 2, rb_funcall1(four, '+', t), m);
+		a = rb_funcall1(a, '+', 
+			rb_funcall1(rb_funcall1(two, '*', a), '*', t));
+		b = rb_funcall1(b, '*', t);
+	}
+
+	RB_GC_GUARD(two);
+	RB_GC_GUARD(four);
+	RB_GC_GUARD(t);
+
+	return rb_num_round(a, prec);
+}

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

@@ -0,0 +1,33 @@
+VALUE
+ipow_edf(VALUE x, VALUE n, VALUE exp)
+{
+	const ID mult = rb_intern("mult");
+	const ID exponent = rb_intern("exponent");
+	const ID r_shift = rb_intern(">>");
+	const ID geq = rb_intern(">=");
+	VALUE abs_n = Qundef, r = Qundef;
+
+	if (!rb_num_finite_p(x))
+		return BIG_NAN;
+	x = rb_num_canonicalize(x, exp, ARG_REAL, ARG_RAWVALUE);
+	abs_n = n;
+	if (rb_num_negative_p(n))  abs_n = rb_num_uminus(abs_n); // abs()
+	r = BIG_ONE;
+	while (rb_num_nonzero_p(abs_n))
+	{
+		if (RTEST(NUM2INT(rb_num_coerce_bit(abs_n, INT2FIX(1), '&'))))
+		{
+			r = rb_funcall(r, mult, 2, x, exp);
+			if (RTEST(rb_num_coerce_cmp(rb_funcall(
+			r, exponent, 0), exp, '>')))
+				r = BIG_INF;
+		}
+		if (rb_num_infinite_p(r))
+			break;
+		x = rb_funcall(x, mult, 2, x, exp);
+		abs_n = rb_num_coerce_bit(abs_n, INT2FIX(1), r_shift);
+	}
+
+	return RTEST(rb_num_coerce_cmp(n, INT2FIX(0), geq)) ?
+		r : rb_funcall1(INT2FIX(1), '/', r);
+}

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

@@ -0,0 +1,48 @@
+
+static VALUE
+l2norm_iter(RB_BLOCK_CALL_FUNC_ARGLIST(y, c))
+{
+	const ID abs2 = rb_intern("abs2");
+	return rb_funcall(y, abs2, 0);
+}
+
+static VALUE
+l2norm_sum(VALUE self)
+{
+	const ID sum = rb_intern("sum");
+	return rb_block_call(self, sum, 0, NULL, l2norm_iter, Qnil);
+}
+
+static VALUE
+bigmath_l2norm(VALUE vec, VALUE prec)
+{
+	VALUE sum;
+	if (CLASS_OF(vec) != rb_cArray)
+		rb_raise(rb_eTypeError, "vec must be an Array");
+
+	sum = l2norm_sum(vec);
+
+	switch (TYPE(sum)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		sum = rb_BigDecimal1(sum);
+		break;
+	case T_FLOAT:
+		sum = rb_BigDecimal_flo(sum);
+		break;
+	case T_RATIONAL:
+		sum = rb_BigDecimal(sum, prec);
+		break;
+	default:
+		break;
+	}
+	return rb_bigmath_sqrt(sum, prec);
+}
+
+VALUE
+l2norm_formula(VALUE vec, VALUE prec)
+{
+	rb_check_precise(prec);
+
+	return bigmath_l2norm(vec, prec);
+}

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

@@ -0,0 +1,40 @@
+VALUE
+log_branch(VALUE x, VALUE prec, bigmath_func1 log_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+	{
+		switch (rb_num_infinite_p(x)) {
+		case 1:
+			y = BIG_INF;
+			break;
+		case -1: case 0:
+		default:
+			y = BIG_NAN;
+			break;
+		}
+	}
+	else if (rb_num_zero_p(x))
+	{
+		y = BIG_MINUS_INF;
+	}
+        else
+        {
+		if (rb_num_positive_p(x))
+		{
+			const ID add = rb_intern("add");
+			VALUE exp, fra;
+			fra = rcm2_edf(x, &exp);
+			exp = rb_funcall1(rb_bigmath_const_log2(prec), '*', exp);
+			fra = log_cb(fra, prec);
+			y = rb_funcall(exp, add, 2, fra, prec);
+		}
+		else
+			y = BIG_NAN;
+	}
+	return y;
+}
+

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

@@ -0,0 +1,12 @@
+VALUE
+log_builtin(VALUE x, VALUE prec)
+{
+	const ID log = rb_intern("log");
+	VALUE y;
+
+	rb_check_precise(prec);
+
+	y = rb_funcall(rb_mBigMath, log, 2, x, prec);
+
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,10 @@
+VALUE
+log_edf(VALUE x, VALUE prec)
+{
+	VALUE fra = Qundef, exp = Qundef, y = Qundef;
+	fra = rcm2_edf(x, &exp);
+	fra = logxt_edf(fra, INT2FIX(2), prec);
+	y = rb_funcall1(exp, '+', fra);
+	y = rb_funcall1(y, '*', rb_bigmath_const_log2(prec));
+	return rb_num_round(y, prec);
+}

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

@@ -0,0 +1,10 @@
+VALUE
+log_edom(VALUE x, VALUE prec)
+{
+	VALUE y, pi = rb_bigmath_const_pi(prec);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	RUBY_ASSERT (rb_num_negative_p(x));
+	x = rb_num_uminus(x);
+	y = rb_bigmath_log(x, prec);
+	return rb_Complex(y, pi);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log/mercator.h

@@ -0,0 +1,34 @@
+
+#if 0
+static VALUE
+log_ser_mercator_x(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE y;
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	y = rb_funcall1(x, '-', INT2FIX(1));
+	y = rb_funcall(y, div, 2, x, prec);
+	y = rb_num_uminus(y);
+	return y;
+}
+#endif
+
+VALUE
+log_mercator(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE fra = Qundef, exp = Qundef, y = Qundef;
+	fra = rcm2_edf(x, &exp);
+
+	rb_check_precise(prec);
+
+	y = rb_funcall1(fra, '-', INT2FIX(1));
+        fra = rb_funcall(y, div, 2, fra, prec);
+	fra = rb_num_uminus(fra);
+	fra = log1p_ser_mercator(fra, prec);
+	fra = rb_num_uminus(fra);
+
+	exp = rb_funcall1(exp, '*', rb_bigmath_const_log2(prec));
+	y = rb_funcall1(exp, '+', fra);
+	return rb_num_round(y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log/ser_okumura.h

@@ -0,0 +1,57 @@
+VALUE
+log_ser_okumura(VALUE x, VALUE prec)
+{
+	const ID add = rb_intern("add");
+	const ID div = rb_intern("div");
+	const ID mult = rb_intern("mult");
+	const ID pow = rb_intern("**");
+	const ID succ = rb_intern("succ");
+	bool inv;
+	VALUE one = BIG_ONE;
+	VALUE two = rb_BigDecimal1(INT2FIX(2));
+	VALUE n = rb_numdiff_make_n(prec), m;
+	VALUE k, x2, i, s, d, y;
+	
+	inv = RTEST(rb_num_coerce_cmp(x, INT2FIX(1), '>'));
+	if (inv)
+		x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RECIPROCAL);
+	else
+		x = rb_num_canonicalize(x, n, ARG_REAL, ARG_RAWVALUE);
+	
+	rcm2_edf(rb_funcall1(x, '/', rb_bigmath_const_sqrt2(n)), &k);
+	k = rb_funcall(k, succ, 0);
+	k = rb_BigDecimal1(k);
+	x = rb_funcall1(x, '/', rb_funcall1(two, pow, k));
+	x = rb_funcall(
+		rb_funcall1(x, '-', one), div, 2,
+		rb_funcall1(x, '+', one), n);
+#if 0
+	x2 = rb_funcall1(x, '*', x);
+#else
+	x2 = rb_funcall(x, mult, 2, x, n);
+#endif
+	i = one;
+	s = x;
+	d = one;
+	while (rb_numdiff_condition_p(s, d, n, &m))
+	{
+		x = rb_funcall(x, mult, 2, x2, m);
+		i = rb_funcall1(i, '+', two);
+		d = rb_funcall(x, div, 2, i, m);
+		s = rb_funcall1(s, '+', d);
+	}
+
+	y = rb_funcall(
+		rb_funcall1(rb_bigmath_const_log2(n), '*', k),
+		add, 2, rb_funcall1(two, '*', s), prec);
+
+	RB_GC_GUARD(x);
+	RB_GC_GUARD(x2);
+	RB_GC_GUARD(i);
+	RB_GC_GUARD(s);
+	RB_GC_GUARD(d);
+	RB_GC_GUARD(one);
+	RB_GC_GUARD(two);
+
+	return inv ? rb_num_uminus(y) : y;
+}

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

@@ -0,0 +1,40 @@
+VALUE
+log10_branch(VALUE x, VALUE prec, bigmath_func1 log10_cb)
+{
+	VALUE y = Qundef;
+
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+
+	if (!rb_num_finite_p(x))
+	{
+		switch (rb_num_infinite_p(x)) {
+		case 1:
+			y = BIG_INF;
+			break;
+		case -1: case 0:
+		default:
+			y = BIG_NAN;
+			break;
+		}
+	}
+	else if (rb_num_zero_p(x))
+	{
+		y = BIG_MINUS_INF;
+	}
+        else
+        {
+		if (rb_num_positive_p(x))
+		{
+			const ID add = rb_intern("add");
+			VALUE exp, fra;
+			fra = rcm10_edf(x, &exp);
+			exp = rb_BigDecimal1(exp);
+			fra = log10_cb(fra, prec);
+			y = rb_funcall(exp, add, 2, fra, prec);
+		}
+		else
+			y = BIG_NAN;
+	}
+	return y;
+}
+

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

@@ -0,0 +1,11 @@
+VALUE
+log10_edf(VALUE x, VALUE prec)
+{
+	VALUE y = Qundef;
+
+	rb_check_precise(prec);
+
+	y = logxt_edf(x, INT2FIX(10), prec);
+
+	return rb_num_round(y, prec);
+}

data/ext/bigdecimal/math_r/internal/algo/bigmath/log10/mercator.h

@@ -0,0 +1,35 @@
+
+#if 0
+static VALUE
+log_ser_mercator_x(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE y;
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	y = rb_funcall1(x, '-', INT2FIX(1));
+	y = rb_funcall(y, div, 2, x, prec);
+	y = rb_num_uminus(y);
+	return y;
+}
+#endif
+
+VALUE
+log10_mercator(VALUE x, VALUE prec)
+{
+	const ID div = rb_intern("div");
+	VALUE fra = Qundef, exp = Qundef, y = Qundef;
+
+	rb_check_precise(prec);
+
+	fra = rcm10_edf(x, &exp);
+
+	y = rb_funcall1(fra, '-', INT2FIX(1));
+        fra = rb_funcall(y, div, 2, fra, prec);
+	fra = rb_num_uminus(fra);
+	fra = log1p_ser_mercator(fra, prec);
+	fra = rb_num_uminus(fra);
+	fra = rb_funcall(fra, div, 2, rb_bigmath_const_log10(prec), prec);
+
+	y = rb_funcall1(exp, '+', fra);
+	return rb_num_round(y, prec);
+}