bigdecimal-math_r 0.2.0

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

@@ -0,0 +1,39 @@
+static VALUE
+init_prec(VALUE prec)
+{
+	const ID double_fig = rb_intern("double_fig");
+	VALUE fig, retval = Qnil;
+
+	rb_check_precise(prec);
+
+	fig = rb_funcall(rb_cBigDecimal, double_fig, 0);
+
+	switch (NUM2INT(rb_dbl_cmp(NUM2DBL(prec), NUM2DBL(fig)))) {
+	case -1:
+		retval = fig;
+		break;
+	case 0:
+	case 1:
+		retval = prec;
+	}
+
+	return retval;
+}
+
+VALUE
+rb_bigmath_const(const char *gv, VALUE (*func)(VALUE prec), VALUE prec)
+{
+	static long def_prec = DEF_PREC;
+	VALUE x;
+
+	x = rb_gv_get(gv);
+	prec = init_prec(prec);
+	if (def_prec < NUM2LONG(prec) || NIL_P(x))
+	{
+		if (def_prec < NUM2LONG(prec))
+			def_prec = NUM2LONG(prec);
+		x = func(LONG2FIX(def_prec));
+		rb_gv_set(gv, x);
+	}
+        return rb_num_round(x, prec);
+}

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

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

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_log10(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_LOG10, LOG10_ser, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_log2(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_LOG2, LOG2_BBP2002, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_log_pi(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_LOG_PI, LOG_PI_builtin, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_pi(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_PI, PI_machin, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_sqrt2(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_SQRT2, SQRT2_builtin, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_const_sqrt3(VALUE prec)
+{
+	return rb_bigmath_const(BIGMATH_SQRT3, SQRT3_builtin, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_cpow(VALUE z, VALUE w, VALUE prec)
+{
+	return cpow_formula(z, w, prec);
+}

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

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

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

@@ -0,0 +1,199 @@
+
+
+/**
+ *  Degree  | Rational | $P(x, y) = (\cos\theta, \sin\theta)$
+ *  360-deg |      0/1 | $(1, 0)$
+ *   30-deg |      1/6 | $(\frac{\sqrt{3}}{2}, \frac{1}{2})$
+ *   45-deg |      1/4 | $(\frac{\sqrt{2}}{2}, \frac{\sqrt{2}}{2})$
+ *   60-deg |      1/3 | $(\frac{1}{2}, \frac{\sqrt{3}}{2})$
+ *   90-deg |      1/2 | $(0, 1)$
+ *  120-deg |      2/3 | $(-\frac{1}{2}, \frac{\sqrt{3}}{2})$
+ *  135-deg |      3/4 | $(-\frac{\sqrt{2}}{2}, \frac{\sqrt{2}}{2})$
+ *  150-deg |      5/6 | $(-\frac{\sqrt{3}}{2}, \frac{1}{2})$
+ *  180-deg |      1/1 | $(-1, 0)$
+ *  210-deg |      7/6 | $(-\frac{\sqrt{3}}{2}, -\frac{1}{2})$
+ *  225-deg |      5/4 | $(-\frac{\sqrt{2}}{2}, -\frac{\sqrt{2}}{2})$
+ *  240-deg |      4/3 | $(-\frac{1}{2}, -\frac{\sqrt{3}}{2})$
+ *  270-deg |      3/2 | $(0, -1)$
+ *  300-deg |      5/3 | $(\frac{1}{2}, -\frac{\sqrt{3}}{2})$
+ *  315-deg |      7/4 | $(\frac{\sqrt{2}}{2}, -\frac{\sqrt{2}}{2})$
+ *  330-deg |     11/6 | $(\frac{\sqrt{3}}{2}, -\frac{1}{2})$
+ *
+ *  ```Ruby
+ *  def sparg_list(prec)
+ *    funcs = [:sin, :cos, :tan, :csc, :sec, :cot]
+ *    degrees = [
+ *      0/1r, 1/6r, 1/4r, 1/3r, 1/2r, 2/3r, 3/4r, 5/6r,
+ *        1r, 7/6r, 5/4r, 4/3r, 3/2r, 5/3r, 7/4r, 11/6r
+ *    ]
+ *    degree_num = [
+ *      360,  30,  45,  60,  90, 120, 135, 150,
+ *      180, 210, 225, 240, 270, 300, 315, 330
+ *    ]
+ *    pi = BigMath.PI(prec)
+ *  
+ *    puts (["Degree"] + funcs).map{|func| (" " + func.to_s).ljust(prec+5, " ")}.join("  ")
+ *  
+ *    degree_num.zip(degrees).each do |deg, rat|
+ *      list = [deg]
+ *      funcs.each do |func|
+ *        meth = BigMathR::Trigonometric.method(func)
+ *        y = meth.call(rat * pi, prec)
+ *        list << y
+ *      end
+ *      puts list.map{|x| ((x = x.to_s)[0] == '-' ? x : " " + x.to_s).ljust(prec+5, " ")}.join("  ")
+ *    end
+ *  end
+ *  ```
+ *  
+ *  ```
+ *  $ sparg_list(8)
+ *   Degree         sin            cos            tan            csc            sec            cot         
+ *   360            0.0            0.1e1          0.0            Infinity       0.1e1          Infinity    
+ *   30             0.5e0          0.8660254e0    0.57735027e0   0.2e1          0.11547005e1   0.17320508e1
+ *   45             0.70710678e0   0.70710678e0   0.1e1          0.14142136e1   0.14142136e1   0.1e1       
+ *   60             0.8660254e0    0.5e0          0.17320508e1   0.11547005e1   0.2e1          0.57735027e0
+ *   90             0.1e1          0.0            Infinity       0.1e1          Infinity       0.0         
+ *   120            0.8660254e0   -0.5e0         -0.17320508e1   0.11547005e1  -0.2e1         -0.57735027e0
+ *   135            0.70710678e0  -0.70710678e0  -0.1e1          0.14142136e1  -0.14142136e1  -0.1e1       
+ *   150            0.5e0         -0.8660254e0   -0.57735027e0   0.2e1         -0.11547005e1  -0.17320508e1
+ *   180            0.0           -0.1e1         -0.0            Infinity      -0.1e1         -Infinity    
+ *   210           -0.5e0         -0.8660254e0    0.57735027e0  -0.2e1         -0.11547005e1   0.17320508e1
+ *   225           -0.70710678e0  -0.70710678e0   0.1e1         -0.14142136e1  -0.14142136e1   0.1e1       
+ *   240           -0.8660254e0   -0.5e0          0.17320508e1  -0.11547005e1  -0.2e1          0.57735027e0
+ *   270           -0.1e1          0.0           -Infinity      -0.1e1          Infinity      -0.0         
+ *   300           -0.8660254e0    0.5e0         -0.17320508e1  -0.11547005e1   0.2e1         -0.57735027e0
+ *   315           -0.70710678e0   0.70710678e0  -0.1e1         -0.14142136e1   0.14142136e1  -0.1e1       
+ *   330           -0.5e0          0.8660254e0   -0.57735027e0  -0.2e1          0.11547005e1  -0.17320508e1
+ *  ```
+ * --------------------------------- SYNOPSIS ---------------------------------
+ */
+
+int
+rb_bigmath_degree_sparg(VALUE t, VALUE prec, VALUE *sin, VALUE *cos)
+{
+	const ID div = rb_intern("div");
+#define angle_equal_p(d) \
+	rb_num_equal_p(t, INT2FIX(d))
+#define HALF \
+	rb_funcall(BIG_ONE, div, 2, INT2FIX(2), prec)
+#define HALF_M \
+	rb_funcall(BIG_ONE, div, 2, INT2FIX(-2), prec)
+#define SQRT2_2 \
+	rb_funcall(rb_bigmath_const_sqrt2(prec), div, 2, INT2FIX(2), prec)
+#define SQRT2_2_M \
+	rb_funcall(rb_bigmath_const_sqrt2(prec), div, 2, INT2FIX(-2), prec)
+#define SQRT3_2 \
+	rb_funcall(rb_bigmath_const_sqrt3(prec), div, 2, INT2FIX(2), prec)
+#define SQRT3_2_M \
+	rb_funcall(rb_bigmath_const_sqrt3(prec), div, 2, INT2FIX(-2), prec)
+
+	if (angle_equal_p(0))
+	{
+		if (cos != NULL)  *cos = BIG_ONE;
+		if (sin != NULL)  *sin = BIG_ZERO;
+		return 1;
+	}
+	else if (angle_equal_p(30))
+	{
+		if (cos != NULL)  *cos = SQRT3_2;
+		if (sin != NULL)  *sin = HALF;
+		return 1;
+	}
+	else if (angle_equal_p(45))
+	{
+		if (cos != NULL)  *cos = SQRT2_2;
+		if (sin != NULL)  *sin = SQRT2_2;
+		return 1;
+	}
+	else if (angle_equal_p(60))
+	{
+		if (cos != NULL)  *cos = HALF;
+		if (sin != NULL)  *sin = SQRT3_2;
+
+		return 1;
+	}
+	else if (angle_equal_p(90))
+	{
+		if (cos != NULL)  *cos = BIG_ZERO;
+		if (sin != NULL)  *sin = BIG_ONE;
+		return 1;
+	}
+	else if (angle_equal_p(120))
+	{
+		if (cos != NULL)  *cos = HALF_M;
+		if (sin != NULL)  *sin = SQRT3_2;
+		return 1;
+	}
+	else if (angle_equal_p(135))
+	{
+		if (cos != NULL)  *cos = SQRT2_2_M;
+		if (sin != NULL)  *sin = SQRT2_2; 
+		return 1;
+	}
+	else if (angle_equal_p(150))
+	{
+		if (cos != NULL)  *cos = SQRT3_2_M;
+		if (sin != NULL)  *sin = HALF;
+		return 1;
+	}
+	else if (angle_equal_p(180))
+	{
+		if (cos != NULL)  *cos = BIG_MINUS_ONE;
+		if (sin != NULL)  *sin = BIG_ZERO;
+		return 1;
+	}
+	else if (angle_equal_p(210))
+	{
+		if (cos != NULL)  *cos = SQRT3_2_M;
+		if (sin != NULL)  *sin = HALF_M;
+		return 1;
+	}
+	else if (angle_equal_p(225))
+	{
+		if (cos != NULL)  *cos = SQRT2_2_M;
+		if (sin != NULL)  *sin = SQRT2_2_M;
+		return 1;
+	}
+	else if (angle_equal_p(240))
+	{
+		if (cos != NULL)  *cos = HALF_M;
+		if (sin != NULL)  *sin = SQRT3_2_M;
+		return 1;
+	}
+	else if (angle_equal_p(270))
+	{
+		if (cos != NULL)  *cos = BIG_ZERO;
+		if (sin != NULL)  *sin = BIG_MINUS_ONE;
+		return 1;
+	}
+	else if (angle_equal_p(300))
+	{
+		if (cos != NULL)  *cos = HALF;
+		if (sin != NULL)  *sin = SQRT3_2_M;
+		return 1;
+	}
+	else if (angle_equal_p(315))
+	{
+		if (cos != NULL)  *cos = SQRT2_2;
+		if (sin != NULL)  *sin = SQRT2_2_M;
+		return 1;
+	}
+	else if (angle_equal_p(330))
+	{
+		if (cos != NULL)  *cos = SQRT3_2;
+		if (sin != NULL)  *sin = HALF_M;
+		return 1;
+	}
+#undef angle_equal_p
+#undef HALF
+#undef HALF_M
+#undef SQRT2_2
+#undef SQRT2_2_M
+#undef SQRT3_2
+#undef SQRT3_2_M
+	else
+	{
+		return -1;
+	}
+}

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

@@ -0,0 +1,5 @@
+void
+rb_bigmath_escalb(VALUE a, VALUE x, VALUE prec, VALUE *exp, VALUE *fra)
+{
+	return escalb_edf(a, x, prec, exp, fra);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_exp(VALUE x, VALUE prec)
+{
+	return exp_edf(x, prec);
+}

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

@@ -0,0 +1,18 @@
+VALUE
+rb_bigmath_expxt(VALUE x, VALUE t, VALUE prec)
+{
+	rb_check_precise(prec);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	if (rb_num_notequal_p(x, x) ||
+	    rb_num_negative_p(x) || 
+	    NUM2INT(rb_num_cmpeql(x, INT2FIX(1))) == 1)
+		rb_raise(rb_eRangeError, "Argument x is out of range: (0 <= x <= 1)");
+	t = rb_num_canonicalize(t, prec, ARG_REAL, ARG_RAWVALUE);
+	if (rb_num_notequal_p(t, t) ||
+	    rb_num_negative_p(t) ||
+	    NUM2INT(rb_num_cmpeql(t, INT2FIX(1))) == 1)
+		rb_raise(rb_eRangeError, "Argument t is out of range: (0 <= t <= 1)");
+	if (!rb_num_finite_p(x) || !rb_num_finite_p(t))
+		rb_raise(rb_eFloatDomainError, "not a finite");
+	return expxt_edf(x, t, prec);
+}

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

@@ -0,0 +1,10 @@
+VALUE
+rb_bigmath_hypot(VALUE a, VALUE b, VALUE prec)
+{
+	if (rb_num_zero_p(rb_num_imag(a)) &&
+	    rb_num_zero_p(rb_num_imag(b)))
+		return hypot_branch(a, b, prec, hypot_mmm);
+	else
+		return hypot_branch(a, b, prec, hypot_l2norm);
+}
+

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

@@ -0,0 +1,14 @@
+VALUE
+rb_bigmath_ipow(VALUE x, VALUE n, VALUE exp)
+{
+	VALUE y;
+	
+	rb_check_precise(exp);
+	x = rb_num_canonicalize(x, exp, ARG_REAL, ARG_RAWVALUE);
+	if (!(TYPE(n) == T_FIXNUM || TYPE(n) == T_BIGNUM))
+		rb_raise(rb_eTypeError, "right-hand side must be an Integer");
+	
+	y = ipow_edf(x, n, exp);
+	
+	return y;
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_l2norm(VALUE vec, VALUE prec)
+{
+	return l2norm_formula(vec, prec);
+}

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

@@ -0,0 +1,7 @@
+
+
+VALUE
+rb_bigmath_log(VALUE x, VALUE prec)
+{
+	return log_branch(x, prec, log_builtin);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_pow(VALUE z, VALUE w, VALUE prec)
+{
+	return pow_formula(z, w, prec);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_quadrant(VALUE x, VALUE y, VALUE prec)
+{
+	return quadrant_formula(x, y, prec);
+}

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

@@ -0,0 +1,5 @@
+void
+rb_bigmath_sincos(VALUE x, VALUE prec, VALUE *sin, VALUE *cos)
+{
+	sincos_ser(x, prec, sin, cos);
+}

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

@@ -0,0 +1,5 @@
+VALUE
+rb_bigmath_sqrt(VALUE x, VALUE prec)
+{
+	return sqrt_branch(x, prec, sqrt_newton);
+}

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

@@ -0,0 +1,41 @@
+VALUE
+rb_bigmath_to_rad(VALUE x, VALUE prec, VALUE *t)
+{
+	const ID mult = rb_intern("mult");
+	VALUE n = rb_numdiff_make_n(prec);
+	VALUE twopi = rb_bigmath_const_pi(n); twopi = rb_funcall1(twopi, '*', INT2FIX(2));
+	bool neg = false;
+	if (NUM2INT(rb_num_cmpeql(x, rb_num_uminus(twopi))) == -1 ||
+	    NUM2INT(rb_num_cmpeql(twopi, x)) == -1)
+	{
+		neg = rb_num_negative_p(x);
+		if (neg)
+			x = rb_num_uminus(x);
+		if (rb_num_cmpeql(x, INT2FIX(30)) == 1)
+			x = rb_funcall1(x, '%', twopi);
+		else
+			while (RTEST(rb_num_coerce_cmp(x, twopi, '>')))
+				x = rb_funcall1(x, '-', twopi);
+		if (neg)
+			x = rb_num_uminus(x);
+	}
+	else
+	{
+		x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	}
+	if (t != NULL)
+	{
+		*t = rb_num_round(
+			rb_funcall1(x, '/', twopi), prec);
+		if (rb_num_negative_p(*t))
+			rb_funcall1(x, '+', INT2FIX(1));
+		*t = rb_funcall(*t, mult, 2, INT2FIX(360), prec);
+	}
+#if 0
+	if (NUM2INT(rb_num_cmpeql(x, rb_num_uminus(pi))) == -1)
+		x = rb_funcall1(x, '+', twopi);
+	else if   (NUM2INT(rb_num_cmpeql(pi, x)) == -1)
+		x = rb_funcall1(x, '-', twopi);
+#endif
+	return x;
+}

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

@@ -0,0 +1,6 @@
+VALUE
+rb_BigDecimal(VALUE x, VALUE prec)
+{
+	const ID BigDecimal = rb_intern("BigDecimal");
+	return rb_funcall(rb_cObject, BigDecimal, 2, x, prec);
+}

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

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

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

@@ -0,0 +1,9 @@
+VALUE
+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);
+	return y;
+}

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

@@ -0,0 +1,8 @@
+VALUE
+rb_ImaginaryZ(VALUE z, bool signbit)
+{
+	VALUE real, imag;
+	real = signbit ? rb_num_imag(z) : rb_num_uminus(rb_num_imag(z));
+	imag = signbit ? rb_num_uminus(rb_num_real(z)) : rb_num_real(z);
+	return rb_Complex(real, imag);
+}

data/ext/bigdecimal/math_r/api/numanalysis/condition_p.h

@@ -0,0 +1,26 @@
+static inline void
+rb_numdiff_keep_fig(VALUE *m)
+{
+	const ID double_fig = rb_intern("double_fig");
+	VALUE dbl_fig = rb_funcall(rb_cBigDecimal, double_fig, 0);
+	if (RTEST(rb_num_coerce_cmp(*m, dbl_fig, '<')))
+		*m = dbl_fig;
+}
+
+bool
+rb_numdiff_condition_p(VALUE y, VALUE d, VALUE n, VALUE *m)
+{
+	const ID exponent = rb_intern("exponent");
+	const ID abs = rb_intern("abs");
+	*m = rb_funcall(n, '-', 1, 
+	       rb_funcall(
+	         rb_funcall(
+	           rb_funcall(y, exponent, 0), '-', 1, 
+	           rb_funcall(d, exponent, 0)
+	         ), abs, 0
+	       )
+	     );
+	if (rb_num_positive_p(*m))
+		rb_numdiff_keep_fig(m);
+	return rb_num_nonzero_p(d) && rb_num_positive_p(*m);
+}

data/ext/bigdecimal/math_r/api/numanalysis/make_n.h

@@ -0,0 +1,9 @@
+VALUE
+rb_numdiff_make_n(VALUE prec)
+{
+	const ID double_fig = rb_intern("double_fig");
+	VALUE n;
+	rb_check_precise(prec);
+	n = rb_funcall(rb_funcall(rb_cBigDecimal, double_fig, 0), '+', 1, prec);
+	return n;
+}

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

@@ -0,0 +1,7 @@
+VALUE
+rb_num_abs(VALUE x)
+{
+	const ID _abs = rb_intern("abs");
+	x = rb_funcall(x, _abs, 0);
+	return x;
+}

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

@@ -0,0 +1,140 @@
+static VALUE
+canonicalize_decimalize(VALUE x, VALUE prec)
+{
+	switch (TYPE(x)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		x = rb_BigDecimal1(x);
+		break;
+	case T_FLOAT:
+		x = rb_BigDecimal_flo(x);
+		break;
+	case T_RATIONAL:
+		x = rb_BigDecimal(x, prec);
+		break;
+	default:
+		break;
+	}
+	return x;
+}
+
+static inline VALUE
+canonicalize_iter(RB_BLOCK_CALL_FUNC_ARGLIST(val, _))
+{
+	const ID abs2 = rb_intern("abs2");
+	return rb_funcall(val, abs2, 0);
+}
+
+VALUE
+rb_num_canonicalize(VALUE x, VALUE prec, bool complex_form, bool inversion)
+{
+	const ID sum = rb_intern("sum");
+	const ID div = rb_intern("div");
+retry:
+	switch (TYPE(x)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		if (inversion)
+		{
+			if (rb_num_zero_p(x))
+				x = BIG_INF;
+			else
+			{
+				x = rb_Rational(INT2FIX(1), x);
+				x = rb_BigDecimal(x, prec);
+			}
+		}
+		else
+			x = rb_BigDecimal1(x);
+		if (complex_form)
+			x = rb_Complex(x, BIG_ZERO);
+		break;
+	case T_FLOAT:
+		if (inversion)
+			x = DBL2NUM(1 / NUM2DBL(x));
+		x = rb_BigDecimal_flo(x);
+		if (complex_form)
+			x = rb_Complex(x, BIG_ZERO);
+		break;
+	case T_RATIONAL:
+		if (inversion)
+			x = rb_funcall1(INT2FIX(1), '/', x);
+		x = rb_BigDecimal(x, prec);
+		if (complex_form)
+			x = rb_Complex(x, BIG_ZERO);
+		break;
+	case T_COMPLEX:
+		if (rb_num_zero_p(rb_num_imag(x)))
+		{
+			x = rb_num_real(x);
+			goto retry;
+		}
+		else if (!complex_form && rb_num_nonzero_p(rb_num_imag(x)))
+			rb_raise(rb_eTypeError, "not a Real");
+		else if (
+		    (!complex_form &&
+		      rb_num_zero_p(rb_num_imag(x))) ||
+		     (complex_form &&
+		      rb_num_infinite_p(rb_num_real(x)) &&
+		      rb_num_finite_p(rb_num_imag(x))))
+		{
+			x = rb_num_real(x);
+			goto retry;
+		}
+		else if (complex_form && inversion && rb_num_infinite_p(rb_num_imag(x)))
+		{
+			if (rb_num_finite_p(rb_num_real(x)))
+				x = rb_Complex(BIG_ZERO, BIG_ZERO);
+			else
+				x = rb_Complex(BIG_NAN, BIG_NAN);
+		}
+		else if (complex_form)
+		{
+			VALUE norm, real, imag, n = rb_numdiff_make_n(prec);
+;
+			real = canonicalize_decimalize(rb_num_real(x), n);
+			imag = canonicalize_decimalize(rb_num_imag(x), n);
+			if (inversion)
+			{
+				norm = rb_block_call(
+					rb_assoc_new(
+					  rb_num_real(x), 
+					  rb_num_imag(x)), 
+					sum, 0, NULL,
+					canonicalize_iter, n);
+				real = rb_funcall(real, div, 2, norm, prec);
+				imag = rb_funcall(imag, div, 2, norm, prec);
+				x = rb_Complex(real, rb_num_uminus(imag));
+			}
+			else
+			{
+				x = rb_Complex(real, imag);
+			}
+		}
+		else
+			x = rb_Complex(BIG_NAN, BIG_NAN);
+		break;
+	case T_NIL: case T_TRUE: case T_FALSE:
+		rb_raise(rb_eTypeError,
+			"can't convert %"PRIsVALUE" into Numeric", rb_inspect(x));
+		break;
+	default:
+		if (rb_class_superclass(CLASS_OF(x)) != rb_cNumeric)
+			rb_raise(rb_eTypeError,
+				"can't convert %"PRIsVALUE" into Numeric", CLASS_OF(x));
+		else if (CLASS_OF(x) == rb_cBigDecimal)
+		{
+			if (inversion)
+			{
+				x = rb_funcall(BIG_ONE, div, 2, x, prec);
+				x = rb_num_round(x, prec);
+			}
+			if (complex_form)
+				x = rb_Complex(x, BIG_ZERO);
+		}
+		break;
+	}
+	if (complex_form && rb_num_real_p(x))
+		x = rb_Complex(x, BIG_ZERO);
+	return x;
+}

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

@@ -0,0 +1,6 @@
+VALUE
+rb_num_cmpeql(VALUE lhs, VALUE rhs)
+{
+	const ID cmpeql = rb_intern("<=>");
+	return rb_num_coerce_cmp(lhs, rhs, cmpeql);
+}

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

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