rational_type Number::to_r() const
{
switch (type())
{
case Number::INTEGER:
return i_to_r();
case Number::FLOATING:
return f_to_r();
case Number::RATIONAL:
return get_r();
#ifndef PMP_DISABLE_VECTOR
case Number::VECTOR:
if (empty())
return 0;
else
return get_v()[0].to_r();
#endif
default:
assert(0);
return 0;
}
}
/*
* call-seq:
* cmp.to_r -> rational
*
* Returns the value as a rational if possible (the imaginary part
* should be exactly zero).
*
* Complex(1, 0).to_r #=> (1/1)
* Complex(1, 0.0).to_r # RangeError
* Complex(1, 2).to_r # RangeError
*
* See rationalize.
*/
static VALUE
nucomp_to_r(VALUE self)
{
get_dat1(self);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
self);
}
return f_to_r(dat->real);
}
/*
* call-seq:
* cmp.to_r -> rational
*
* Returns the value as a rational if possible.
*/
static VALUE
nucomp_to_r(VALUE self)
{
get_dat1(self);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
VALUE s = f_to_s(self);
rb_raise(rb_eRangeError, "can't convert %s into Rational",
StringValuePtr(s));
}
return f_to_r(dat->real);
}
/*
* call-seq:
* flt.to_r -> rational
*
* Returns the value as a rational.
*
* NOTE: 0.3.to_r isn't the same as '0.3'.to_r. The latter is
* equivalent to '3/10'.to_r, but the former isn't so.
*
* For example:
*
* 2.0.to_r #=> (2/1)
* 2.5.to_r #=> (5/2)
* -0.75.to_r #=> (-3/4)
* 0.0.to_r #=> (0/1)
*/
static VALUE
float_to_r(VALUE self, SEL sel)
{
VALUE f, n;
float_decode_internal(self, &f, &n);
#if FLT_RADIX == 2
{
long ln = FIX2LONG(n);
if (ln == 0)
return f_to_r(f);
if (ln > 0)
return f_to_r(f_lshift(f, n));
ln = -ln;
return rb_rational_new2(f, f_lshift(ONE, INT2FIX(ln)));
}
#else
return f_to_r(f_mul(f, f_expt(INT2FIX(FLT_RADIX), n)));
#endif
}
static VALUE
string_to_c_internal(VALUE self)
{
VALUE s;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
{
VALUE m, sr, si, re, r, i;
int po;
m = f_match(comp_pat0, s);
if (!NIL_P(m)) {
sr = rb_reg_nth_match(1, m);
si = rb_reg_nth_match(2, m);
re = rb_reg_match_post(m);
po = 1;
}
if (NIL_P(m)) {
m = f_match(comp_pat1, s);
if (!NIL_P(m)) {
sr = Qnil;
si = rb_reg_nth_match(1, m);
if (NIL_P(si))
si = rb_usascii_str_new2("");
{
VALUE t;
t = rb_reg_nth_match(2, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
}
if (NIL_P(m)) {
m = f_match(comp_pat2, s);
if (NIL_P(m))
return rb_assoc_new(Qnil, self);
sr = rb_reg_nth_match(1, m);
if (NIL_P(rb_reg_nth_match(2, m)))
si = Qnil;
else {
VALUE t;
si = rb_reg_nth_match(3, m);
t = rb_reg_nth_match(4, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
r = INT2FIX(0);
i = INT2FIX(0);
if (!NIL_P(sr)) {
if (strchr(RSTRING_PTR(sr), '/'))
r = f_to_r(sr);
else if (strpbrk(RSTRING_PTR(sr), ".eE"))
r = f_to_f(sr);
else
r = f_to_i(sr);
}
if (!NIL_P(si)) {
if (strchr(RSTRING_PTR(si), '/'))
i = f_to_r(si);
else if (strpbrk(RSTRING_PTR(si), ".eE"))
i = f_to_f(si);
else
i = f_to_i(si);
}
if (po)
return rb_assoc_new(rb_complex_polar(r, i), re);
else
return rb_assoc_new(rb_complex_new2(r, i), re);
}
}
static VALUE
nurat_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv)
{
VALUE a1, a2, backref;
rb_scan_args(argc, argv, "11", &a1, &a2);
if (NIL_P(a1) || (argc == 2 && NIL_P(a2)))
rb_raise(rb_eTypeError, "can't convert nil into Rational");
switch (TYPE(a1)) {
case T_COMPLEX:
if (k_exact_zero_p(RCOMPLEX(a1)->imag))
a1 = RCOMPLEX(a1)->real;
}
switch (TYPE(a2)) {
case T_COMPLEX:
if (k_exact_zero_p(RCOMPLEX(a2)->imag))
a2 = RCOMPLEX(a2)->real;
}
backref = rb_backref_get();
rb_match_busy(backref);
switch (TYPE(a1)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a1 = f_to_r(a1);
break;
case T_STRING:
a1 = string_to_r_strict(a1);
break;
}
switch (TYPE(a2)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a2 = f_to_r(a2);
break;
case T_STRING:
a2 = string_to_r_strict(a2);
break;
}
rb_backref_set(backref);
switch (TYPE(a1)) {
case T_RATIONAL:
if (argc == 1 || (k_exact_one_p(a2)))
return a1;
}
if (argc == 1) {
if (!(k_numeric_p(a1) && k_integer_p(a1)))
return rb_convert_type(a1, T_RATIONAL, "Rational", "to_r");
}
else {
if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
(!f_integer_p(a1) || !f_integer_p(a2)))
return f_div(a1, a2);
}
{
VALUE argv2[2];
argv2[0] = a1;
argv2[1] = a2;
return nurat_s_new(argc, argv2, klass);
}
}
/*
* call-seq:
* num.denominator -> integer
*
* Returns the denominator (always positive).
*/
static VALUE
numeric_denominator(VALUE self, SEL sel)
{
return f_denominator(f_to_r(self));
}
/*
* call-seq:
* num.numerator -> integer
*
* Returns the numerator.
*/
static VALUE
numeric_numerator(VALUE self, SEL sel)
{
return f_numerator(f_to_r(self));
}
static VALUE
nurat_s_induced_from(VALUE klass, VALUE n)
{
return f_to_r(n);
}
static VALUE
nurat_s_convert(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2;
if (rb_scan_args(argc, argv, "02", &a1, &a2) == 1) {
a2 = ONE;
}
switch (TYPE(a1)) {
case T_COMPLEX:
if (k_float_p(RCOMPLEX(a1)->image) || !f_zero_p(RCOMPLEX(a1)->image)) {
VALUE s = f_to_s(a1);
rb_raise(rb_eRangeError, "can't accept %s",
StringValuePtr(s));
}
a1 = RCOMPLEX(a1)->real;
}
switch (TYPE(a2)) {
case T_COMPLEX:
if (k_float_p(RCOMPLEX(a2)->image) || !f_zero_p(RCOMPLEX(a2)->image)) {
VALUE s = f_to_s(a2);
rb_raise(rb_eRangeError, "can't accept %s",
StringValuePtr(s));
}
a2 = RCOMPLEX(a2)->real;
}
switch (TYPE(a1)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a1 = f_to_r(a1);
break;
case T_STRING:
a1 = string_to_r_strict(a1);
break;
}
switch (TYPE(a2)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a2 = f_to_r(a2);
break;
case T_STRING:
a2 = string_to_r_strict(a2);
break;
}
switch (TYPE(a1)) {
case T_RATIONAL:
if (NIL_P(a2) || f_zero_p(a2))
return a1;
else
return f_div(a1, a2);
}
switch (TYPE(a2)) {
case T_RATIONAL:
return f_div(a1, a2);
}
return nurat_s_new(klass, a1, a2);
}
static VALUE
nurat_s_convert(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2, backref;
rb_scan_args(argc, argv, "11", &a1, &a2);
switch (TYPE(a1)) {
case T_COMPLEX:
if (k_exact_p(RCOMPLEX(a1)->imag) && f_zero_p(RCOMPLEX(a1)->imag))
a1 = RCOMPLEX(a1)->real;
}
switch (TYPE(a2)) {
case T_COMPLEX:
if (k_exact_p(RCOMPLEX(a2)->imag) && f_zero_p(RCOMPLEX(a2)->imag))
a2 = RCOMPLEX(a2)->real;
}
backref = rb_backref_get();
rb_match_busy(backref);
switch (TYPE(a1)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a1 = f_to_r(a1);
break;
case T_STRING:
a1 = string_to_r_strict(a1);
break;
}
switch (TYPE(a2)) {
case T_FIXNUM:
case T_BIGNUM:
break;
case T_FLOAT:
a2 = f_to_r(a2);
break;
case T_STRING:
a2 = string_to_r_strict(a2);
break;
}
rb_backref_set(backref);
switch (TYPE(a1)) {
case T_RATIONAL:
if (argc == 1 || (k_exact_p(a2) && f_one_p(a2)))
return a1;
}
if (argc == 1) {
if (k_numeric_p(a1) && !f_integer_p(a1))
return a1;
}
else {
if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
(!f_integer_p(a1) || !f_integer_p(a2)))
return f_div(a1, a2);
}
{
VALUE argv2[2];
argv2[0] = a1;
argv2[1] = a2;
return nurat_s_new(argc, argv2, klass);
}
}
static VALUE
nucomp_expt(VALUE self, VALUE other)
{
if (k_exact_p(other) && f_zero_p(other))
return f_complex_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other) && f_one_p(f_denominator(other)))
other = f_numerator(other); /* good? */
if (k_complex_p(other)) {
VALUE a, r, theta, ore, oim, nr, ntheta;
get_dat1(other);
a = f_polar(self);
r = RARRAY_PTR(a)[0];
theta = RARRAY_PTR(a)[1];
ore = dat->real;
oim = dat->imag;
nr = m_exp_bang(f_sub(f_mul(ore, m_log_bang(r)),
f_mul(oim, theta)));
ntheta = f_add(f_mul(theta, ore), f_mul(oim, m_log_bang(r)));
return f_complex_polar(CLASS_OF(self), nr, ntheta);
}
if (k_integer_p(other)) {
if (f_gt_p(other, ZERO)) {
VALUE x, z, n;
x = self;
z = x;
n = f_sub(other, ONE);
while (f_nonzero_p(n)) {
VALUE a;
while (a = f_divmod(n, TWO),
f_zero_p(RARRAY_PTR(a)[1])) {
get_dat1(x);
x = f_complex_new2(CLASS_OF(self),
f_sub(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag)),
f_mul(f_mul(TWO, dat->real), dat->imag));
n = RARRAY_PTR(a)[0];
}
z = f_mul(z, x);
n = f_sub(n, ONE);
}
return z;
}
return f_expt(f_div(f_to_r(ONE), self), f_negate(other));
}
if (k_numeric_p(other) && f_real_p(other)) {
VALUE a, r, theta;
a = f_polar(self);
r = RARRAY_PTR(a)[0];
theta = RARRAY_PTR(a)[1];
return f_complex_polar(CLASS_OF(self), f_expt(r, other),
f_mul(theta, other));
}
return rb_num_coerce_bin(self, other, id_expt);
}
static VALUE
string_to_c_internal(VALUE self)
{
VALUE s;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
{
VALUE m, sr, si, re, r, i;
int po;
m = f_match(comp_pat0, s);
if (!NIL_P(m)) {
sr = f_aref(m, INT2FIX(1));
si = f_aref(m, INT2FIX(2));
re = f_post_match(m);
po = 1;
}
if (NIL_P(m)) {
m = f_match(comp_pat1, s);
if (!NIL_P(m)) {
sr = Qnil;
si = f_aref(m, INT2FIX(1));
if (NIL_P(si))
si = rb_usascii_str_new2("");
{
VALUE t;
t = f_aref(m, INT2FIX(2));
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = f_post_match(m);
po = 0;
}
}
if (NIL_P(m)) {
m = f_match(comp_pat2, s);
if (NIL_P(m))
return rb_assoc_new(Qnil, self);
sr = f_aref(m, INT2FIX(1));
if (NIL_P(f_aref(m, INT2FIX(2))))
si = Qnil;
else {
VALUE t;
si = f_aref(m, INT2FIX(3));
t = f_aref(m, INT2FIX(4));
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = f_post_match(m);
po = 0;
}
r = INT2FIX(0);
i = INT2FIX(0);
if (!NIL_P(sr)) {
if (f_include_p(sr, a_slash))
r = f_to_r(sr);
else if (f_gt_p(f_count(sr, a_dot_and_an_e), INT2FIX(0)))
r = f_to_f(sr);
else
r = f_to_i(sr);
}
if (!NIL_P(si)) {
if (f_include_p(si, a_slash))
i = f_to_r(si);
else if (f_gt_p(f_count(si, a_dot_and_an_e), INT2FIX(0)))
i = f_to_f(si);
else
i = f_to_i(si);
}
if (po)
return rb_assoc_new(rb_complex_polar(r, i), re);
else
return rb_assoc_new(rb_complex_new2(r, i), re);
}
}
